deadbyte-mcp 0.15.72 → 0.15.74

package/scripts/r193-owner-keygen.mjs

@@ -0,0 +1,43 @@
+// One-time protected owner key enrollment. No caller-selected paths.
+import {generateKeyPairSync} from 'node:crypto';
+import {lstat,open,readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {canonicalJson} from '../src/canonical-json.mjs';
+import {createR186OwnerAnchor} from '../src/r186-owner-anchor.mjs';
+import {inspectTrustedInstallation} from '../src/privileged-install-trust-r89.mjs';
+import {inspectR193OwnerSecretAcl} from '../src/r193-owner-secret-acl.mjs';
+import {parseManifest,verifyManifestTreeExact} from '../src/release-slot.mjs';
+const THIS=fileURLToPath(import.meta.url),ROOT=path.resolve(path.dirname(THIS),'..');
+const OWNER='C:\\Program Files\\DEADBYTE-OwnerAuthority';
+const PRIVATE=path.win32.join(OWNER,'owner-private.der');
+const PUBLIC=path.win32.join(OWNER,'owner-public.pem');
+const ANCHOR=path.win32.join(OWNER,'owner-anchor.json');
+async function exclusive(file,bytes){
+ const handle=await open(file,'wx',0o600);
+ try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}
+}
+async function main(){
+ if(process.platform!=='win32'||process.arch!=='x64')throw Error('R193 owner keygen requires Windows x64');
+ if(process.argv.length!==2)throw Error('R193 owner keygen accepts no arguments');
+ await inspectTrustedInstallation(['C:\\Program Files\\nodejs\\node.exe',THIS,
+  path.join(ROOT,'MANIFEST.SHA256'),path.join(ROOT,'src','r186-owner-anchor.mjs'),
+  path.join(ROOT,'src','r193-owner-secret-acl.mjs'),
+  path.join(ROOT,'src','privileged-install-trust-r89.mjs'),
+  path.join(ROOT,'src','release-slot.mjs')]);
+ const manifest=await readFile(path.join(ROOT,'MANIFEST.SHA256'),'utf8');
+ await verifyManifestTreeExact(ROOT,parseManifest(manifest));
+ const owner=await lstat(OWNER);
+ if(!owner.isDirectory()||owner.isSymbolicLink())throw Error('R193 owner directory is not a real directory');
+ const pair=generateKeyPairSync('ed25519');
+ const privateDer=pair.privateKey.export({format:'der',type:'pkcs8'});
+ const material=createR186OwnerAnchor(pair.publicKey.export({format:'pem',type:'spki'}).toString());
+ await exclusive(PRIVATE,privateDer);
+ await exclusive(PUBLIC,Buffer.from(material.public_key_pem,'utf8'));
+ await exclusive(ANCHOR,Buffer.from(canonicalJson(material.anchor)+'\n','utf8'));
+ const secret=await inspectR193OwnerSecretAcl([OWNER,PRIVATE]);
+ process.stdout.write(JSON.stringify({status:'R193_OWNER_AUTHORITY_ENROLLED',
+  owner_key_id:material.anchor.owner_key_id,secret_acl:secret.reason,
+  private_key_exported:false,authority_granted:false})+'\n');
+}
+main().catch(error=>{console.error(String(error?.message??error).slice(0,500));process.exitCode=2;});

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

@@ -0,0 +1,50 @@
+// 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';
+import {canonicalJson} from '../src/canonical-json.mjs';
+import {inspectTrustedInstallation} from '../src/privileged-install-trust-r89.mjs';
+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';
+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');
+const PS='C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe';
+const sha=b=>createHash('sha256').update(b).digest('hex');
+async function bounded(file,limit){const s=await lstat(file);if(!s.isFile()||s.isSymbolicLink()||s.size<1||s.size>limit)throw Error('R193 request input unsafe');return readFile(file);}
+async function main(){
+ if(process.platform!=='win32'||process.arch!=='x64'||process.argv.length!==2)throw Error('R193 live request accepts no arguments');
+ 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','privileged-install-trust-r89.mjs')]);
+ const manifestBytes=await bounded(manifestPath,1024*1024);
+ await verifyManifestTreeExact(ROOT,parseManifest(manifestBytes.toString('utf8')));
+ const pointer=JSON.parse((await bounded(path.win32.join(STATE,'active-release.json'),64*1024)).toString('utf8'));
+ if(pointer.manifest_sha256!==sha(manifestBytes))throw Error('R193 request package is not exact active release');
+ const codingBytes=await bounded(path.win32.join(pointer.generation_root,'coding-policy.json'),1024*1024);
+ const autonomousBytes=await bounded(path.win32.join(pointer.generation_root,'autonomous-policy.json'),1024*1024);
+ const coding=JSON.parse(codingBytes),autonomous=JSON.parse(autonomousBytes);
+ 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);
+ 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 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,
+  expires_at_utc:request.subject.expires_at_utc,authority_granted:false})+'\n');
+}
+main().catch(error=>{console.error(String(error?.message??error).slice(0,500));process.exitCode=2;});

package/scripts/r193-owner-uac-approve.ps1

@@ -0,0 +1,42 @@
+#requires -Version 5.1
+#requires -RunAsAdministrator
+[CmdletBinding()]
+param([Parameter(Mandatory=$true)][string]$RequestPath)
+$ErrorActionPreference='Stop';Set-StrictMode -Version Latest
+$root=[IO.Path]::GetFullPath((Join-Path $PSScriptRoot '..'))
+$program=[IO.Path]::GetFullPath($env:ProgramFiles).TrimEnd('\')+'\'
+if(-not ($root.TrimEnd('\')+'\').StartsWith($program,[StringComparison]::OrdinalIgnoreCase)){
+ throw 'R193 owner broker must run from an R89-protected Program Files package'
+}
+if(-not [Environment]::UserInteractive){throw 'R193 owner approval requires an interactive desktop'}
+$node='C:\Program Files\nodejs\node.exe'
+$broker=Join-Path $root 'scripts\r193-owner-uac-broker.mjs'
+$request=[IO.Path]::GetFullPath($RequestPath)
+$raw=@(& $node $broker preflight $request 2>&1) -join [Environment]::NewLine
+if($LASTEXITCODE -ne 0){throw ('R193 preflight blocked: '+$raw.Substring(0,[Math]::Min(500,$raw.Length)))}
+$preview=$raw|ConvertFrom-Json
+if([string]$preview.status -cne 'READY_FOR_OWNER_GESTURE' -or $preview.authority_granted -or $preview.owner_approved){
+ throw 'R193 owner preflight returned an invalid state'
+}
+Write-Host '';Write-Host 'DEADBYTE R193 / OWNER AUTONOMOUS APPROVAL' -ForegroundColor Yellow
+Write-Host 'This signs one short-lived exact request. It does not itself arm Autonomous.'
+Write-Host ('Request SHA-256: '+[string]$preview.request_sha256)
+Write-Host ('Project: '+[string]$preview.project_root)
+Write-Host ('Operation: '+[string]$preview.operation)
+Write-Host ('Duration cap seconds: '+[string]$preview.max_seconds)
+Write-Host ('Expires UTC: '+[string]$preview.expires_at_utc)
+$phrase=[string]$preview.review_phrase
+$entered=Read-Host ('Type '+$phrase+' to approve this exact request')
+if($entered -cne $phrase){throw 'R193 owner rejected request'}
+$owner='C:\Program Files\DEADBYTE-OwnerAuthority'
+if(-not(Test-Path -LiteralPath $owner -PathType Container)){throw 'R193 owner authority is not enrolled'}
+$gesture=[ordered]@{schema='deadbyte.r193-owner-gesture.v1';status='APPROVED';
+ request_sha256=[string]$preview.request_sha256;review_phrase=$phrase;
+ approved_at_utc=[DateTime]::UtcNow.ToString('o')}
+$gesturePath=Join-Path $owner ('gesture-'+[string]$preview.request_sha256+'.json')
+$bytes=(New-Object Text.UTF8Encoding($false)).GetBytes(($gesture|ConvertTo-Json -Compress)+[Environment]::NewLine)
+$stream=[IO.File]::Open($gesturePath,[IO.FileMode]::CreateNew,[IO.FileAccess]::Write,[IO.FileShare]::None)
+try{$stream.Write($bytes,0,$bytes.Length);$stream.Flush($true)}finally{$stream.Dispose()}
+$out=@(& $node $broker approve $request 2>&1) -join [Environment]::NewLine
+if($LASTEXITCODE -ne 0){throw ('R193 signing blocked: '+$out.Substring(0,[Math]::Min(500,$out.Length)))}
+Write-Output $out

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

@@ -0,0 +1,139 @@
+// Protected R193 owner broker. This entrypoint is intentionally fixed to the
+// local DEADBYTE state and owner-authority roots; callers choose only an exact
+// request file. It never issues authority. The R186 transaction remains the
+// sole grant/epoch mutation boundary.
+import {createHash,createPrivateKey,createPublicKey} from 'node:crypto';
+import {execFile} from 'node:child_process';
+import {promisify} from 'node:util';
+import {lstat,mkdir,open,readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {canonicalJson} from '../src/canonical-json.mjs';
+import {inspectTrustedInstallation} from '../src/privileged-install-trust-r89.mjs';
+import {parseManifest,verifyManifestTreeExact} from '../src/release-slot.mjs';
+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';
+
+const execFileAsync=promisify(execFile);
+const THIS=fileURLToPath(import.meta.url),ROOT=path.resolve(path.dirname(THIS),'..');
+const STATE='C:\\Users\\DEADBYTE\\.deadbyte-mcp';
+const RUNTIME=path.win32.join(STATE,'runtime');
+const OWNER='C:\\Program Files\\DEADBYTE-OwnerAuthority';
+const PRIVATE=path.win32.join(OWNER,'owner-private.der');
+const PUBLIC=path.win32.join(OWNER,'owner-public.pem');
+const ANCHOR=path.win32.join(OWNER,'owner-anchor.json');
+const NATIVE=path.join(ROOT,'bin','deadbyte-owner-token-r193.exe');
+const PS='C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe';
+const NODE='C:\\Program Files\\nodejs\\node.exe';
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const block=reason=>{throw new Error('R193_OWNER_UAC_BROKER_BLOCKED: '+reason);};
+async function bounded(file,limit){
+ const stat=await lstat(file);
+ if(!stat.isFile()||stat.isSymbolicLink()||stat.size<1||stat.size>limit)block('unsafe input: '+path.basename(file));
+ return readFile(file);
+}
+async function exclusive(file,bytes){
+ await mkdir(path.dirname(file),{recursive:true});
+ const handle=await open(file,'wx',0o600);
+ try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}
+}
+async function exactOrWrite(file,bytes){
+ try{await exclusive(file,bytes);return 'CREATED';}
+ catch(error){
+  if(error?.code!=='EEXIST')throw error;
+  if(!(await readFile(file)).equals(bytes))block('existing output differs: '+path.basename(file));
+  return 'ALREADY_EXACT';
+ }
+}
+async function jsonExec(file,args,options={}){
+ const {stdout}=await execFileAsync(file,args,{windowsHide:true,timeout:20000,
+  maxBuffer:1024*1024,encoding:'utf8',...options});
+ try{return JSON.parse(stdout);}catch{block('invalid JSON from protected child');}
+}
+async function uacPolicy(){
+ const command=`$p=Get-ItemProperty -LiteralPath 'HKLM:\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\System';[pscustomobject]@{enable_uac=([int]$p.EnableLUA -eq 1);secure_desktop=([int]$p.PromptOnSecureDesktop -eq 1);prompt_mode=$(if([int]$p.ConsentPromptBehaviorAdmin -eq 0){'silent'}else{'explicit_secure_desktop'})}|ConvertTo-Json -Compress`;
+ return jsonExec(PS,['-NoLogo','-NoProfile','-NonInteractive','-Command',command]);
+}
+async function live(request){
+ const manifestPath=path.join(ROOT,'MANIFEST.SHA256');
+ 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','r193-uac-r70-bridge.mjs'),
+  path.join(ROOT,'src','r193-owner-secret-acl.mjs'),
+  path.join(ROOT,'src','r188-owner-uac.mjs'),
+  path.join(ROOT,'src','r70-owner-approval.mjs'),
+  path.join(ROOT,'src','canonical-json.mjs'),
+  path.join(ROOT,'src','privileged-install-trust-r89.mjs'),
+  path.join(ROOT,'src','release-slot.mjs')];
+ const installation=await inspectTrustedInstallation(protectedFiles);
+ const manifestBytes=await bounded(manifestPath,1024*1024);
+ await verifyManifestTreeExact(ROOT,parseManifest(manifestBytes.toString('utf8')));
+ const pointer=JSON.parse((await bounded(path.win32.join(STATE,'active-release.json'),64*1024)).toString('utf8'));
+ if(pointer.manifest_sha256!==sha(manifestBytes))block('protected package is not exact active release');
+ const generation=pointer.generation_root;
+ 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 sources={bridge:observation.bridge,core:observation.core,cloud:observation.cloud,supervisor};
+ const processReports={};
+ for(const component of ['bridge','core','cloud','supervisor'])
+  processReports[component]=await jsonExec(NATIVE,['--inspect-pid',String(sources[component]?.pid)]);
+ const [codingPolicyBytes,autonomousPolicyBytes,uac]=await Promise.all([
+  bounded(codingPath,1024*1024),bounded(autonomousPath,1024*1024),uacPolicy()]);
+ const built=buildR193LiveOwnerBoundary({request,activePointer:pointer,installedManifestBytes:manifestBytes,
+  codingPolicyBytes,autonomousPolicyBytes,controllerObservation:observation,
+  supervisorLedger:supervisor,processReports,brokerR89Trusted:installation.trusted,
+  keyAclTrusted:false,uac,ownerGesture:'pending',now:new Date()});
+ return {...built,pointer,manifestBytes,codingPolicyBytes,autonomousPolicyBytes,uac};
+}
+async function main(){
+ if(process.platform!=='win32'||process.arch!=='x64')block('Windows x64 required');
+ const [mode,requestPath]=process.argv.slice(2);
+ 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 state=await live(request);
+ if(mode==='preflight'){
+  process.stdout.write(JSON.stringify({status:'READY_FOR_OWNER_GESTURE',
+   request_sha256:request.request_sha256,review_phrase:request.review_phrase,
+   project_root:request.subject.project_root,operation:request.subject.operation,
+   max_seconds:request.subject.max_seconds,expires_at_utc:request.subject.expires_at_utc,
+   authority_granted:false,owner_approved:false})+'\n');
+  return;
+ }
+ const gesturePath=path.win32.join(OWNER,'gesture-'+request.request_sha256+'.json');
+ const gesture=JSON.parse((await bounded(gesturePath,16*1024)).toString('utf8'));
+ if(gesture?.schema!=='deadbyte.r193-owner-gesture.v1'||gesture?.status!=='APPROVED'||
+    gesture?.request_sha256!==request.request_sha256||gesture?.review_phrase!==request.review_phrase||
+    typeof gesture?.approved_at_utc!=='string'||Date.now()-Date.parse(gesture.approved_at_utc)<0||
+    Date.now()-Date.parse(gesture.approved_at_utc)>60000)block('owner gesture missing, stale or mismatched');
+ const secret=await inspectR193OwnerSecretAcl([OWNER,PRIVATE]);
+ const [privateKeyDer,publicPem,anchorBytes]=await Promise.all([
+  bounded(PRIVATE,8192),bounded(PUBLIC,8192),bounded(ANCHOR,4096)]);
+ const privateKey=createPrivateKey({key:privateKeyDer,format:'der',type:'pkcs8'});
+ const derived=createR186OwnerAnchor(createPublicKey(privateKey).export({format:'pem',type:'spki'}).toString());
+ const anchor=JSON.parse(anchorBytes.toString('utf8'));
+ if(derived.public_key_pem!==publicPem.toString('utf8')||
+    canonicalJson(derived.anchor)!==canonicalJson(anchor))block('owner key enrollment mismatch');
+ const result=approveR193OwnerRequest({request,expected:state.expected,privateKeyDer,
+  boundary:{...state.boundary,key_acl_trusted:secret.trusted,owner_gesture:'approved'},now:new Date()});
+ const bytes=Buffer.from(canonicalJson(result.approval)+'\n','utf8');
+ const protectedApproval=path.win32.join(OWNER,'approval-'+request.request_sha256+'.json');
+ const runtimeApproval=path.win32.join(RUNTIME,'owner-consent','autonomous-approval.json');
+ const protected_state=await exactOrWrite(protectedApproval,bytes);
+ const runtime_state=await exactOrWrite(runtimeApproval,bytes);
+ process.stdout.write(JSON.stringify({...result,approval:undefined,protected_state,runtime_state,
+  protected_approval_sha256:sha(bytes),protected_approval_path:protectedApproval,
+  runtime_approval_path:runtimeApproval})+'\n');
+}
+main().catch(error=>{console.error(String(error?.message??error).slice(0,600));process.exitCode=2;});

package/scripts/r193-owner-uac-enroll-and-approve.ps1

@@ -0,0 +1,62 @@
+#requires -Version 5.1
+#requires -RunAsAdministrator
+[CmdletBinding()]
+param([Parameter(Mandatory=$true)][string]$RequestPath)
+$ErrorActionPreference='Stop';Set-StrictMode -Version Latest
+$root=[IO.Path]::GetFullPath((Join-Path $PSScriptRoot '..'))
+$program=[IO.Path]::GetFullPath($env:ProgramFiles).TrimEnd('\')+'\'
+if(-not ($root.TrimEnd('\')+'\').StartsWith($program,[StringComparison]::OrdinalIgnoreCase)){
+ throw 'R193 enrollment must run from an R89-protected Program Files package'
+}
+if(-not [Environment]::UserInteractive){throw 'R193 enrollment requires an interactive owner desktop'}
+$node='C:\Program Files\nodejs\node.exe'
+$broker=Join-Path $root 'scripts\r193-owner-uac-broker.mjs'
+$keygen=Join-Path $root 'scripts\r193-owner-keygen.mjs'
+$request=[IO.Path]::GetFullPath($RequestPath)
+$raw=@(& $node $broker preflight $request 2>&1) -join [Environment]::NewLine
+if($LASTEXITCODE -ne 0){throw ('R193 enrollment preflight blocked: '+$raw.Substring(0,[Math]::Min(500,$raw.Length)))}
+$preview=$raw|ConvertFrom-Json
+if([string]$preview.status -cne 'READY_FOR_OWNER_GESTURE' -or $preview.authority_granted -or $preview.owner_approved){
+ throw 'R193 enrollment preflight returned an invalid state'
+}
+Write-Host '';Write-Host 'DEADBYTE R193 / ENROLL OWNER AUTHORITY' -ForegroundColor Yellow
+Write-Host 'A new owner-only Ed25519 identity will be created under Program Files.'
+Write-Host 'Limited DEADBYTE processes will not be able to read or use the private key.'
+Write-Host ('Request SHA-256: '+[string]$preview.request_sha256)
+Write-Host ('Project: '+[string]$preview.project_root)
+Write-Host ('Duration cap seconds: '+[string]$preview.max_seconds)
+$phrase=[string]$preview.review_phrase
+$entered=Read-Host ('Type '+$phrase+' to enroll and approve this exact request')
+if($entered -cne $phrase){throw 'R193 owner rejected enrollment'}
+$owner='C:\Program Files\DEADBYTE-OwnerAuthority'
+if(Test-Path -LiteralPath $owner){throw 'R193 owner authority already exists; use the approval-only workflow'}
+$admins=New-Object Security.Principal.SecurityIdentifier('S-1-5-32-544')
+$system=New-Object Security.Principal.SecurityIdentifier('S-1-5-18')
+$inherit=[Security.AccessControl.InheritanceFlags]'ContainerInherit, ObjectInherit'
+$none=[Security.AccessControl.PropagationFlags]::None
+$allow=[Security.AccessControl.AccessControlType]::Allow
+New-Item -ItemType Directory -Path $owner -ErrorAction Stop | Out-Null
+$acl=New-Object Security.AccessControl.DirectorySecurity
+$acl.SetAccessRuleProtection($true,$false);$acl.SetOwner($admins)
+$acl.AddAccessRule((New-Object Security.AccessControl.FileSystemAccessRule($admins,'FullControl',$inherit,$none,$allow)))
+$acl.AddAccessRule((New-Object Security.AccessControl.FileSystemAccessRule($system,'FullControl',$inherit,$none,$allow)))
+Set-Acl -LiteralPath $owner -AclObject $acl
+# Keygen requires the directory to exist with its final ACL. It never accepts a
+# target path and creates every key file with CreateNew/no-clobber semantics.
+$keyRaw=@(& $node $keygen 2>&1) -join [Environment]::NewLine
+if($LASTEXITCODE -ne 0){throw ('R193 protected key enrollment blocked: '+$keyRaw.Substring(0,[Math]::Min(500,$keyRaw.Length)))}
+$keyResult=$keyRaw|ConvertFrom-Json
+if([string]$keyResult.status -cne 'R193_OWNER_AUTHORITY_ENROLLED' -or $keyResult.private_key_exported -or $keyResult.authority_granted){
+ throw 'R193 key enrollment returned an invalid state'
+}
+Write-Host ('Owner key fingerprint: '+[string]$keyResult.owner_key_id) -ForegroundColor Yellow
+$gesture=[ordered]@{schema='deadbyte.r193-owner-gesture.v1';status='APPROVED';
+ request_sha256=[string]$preview.request_sha256;review_phrase=$phrase;
+ approved_at_utc=[DateTime]::UtcNow.ToString('o')}
+$gesturePath=Join-Path $owner ('gesture-'+[string]$preview.request_sha256+'.json')
+$bytes=(New-Object Text.UTF8Encoding($false)).GetBytes(($gesture|ConvertTo-Json -Compress)+[Environment]::NewLine)
+$stream=[IO.File]::Open($gesturePath,[IO.FileMode]::CreateNew,[IO.FileAccess]::Write,[IO.FileShare]::None)
+try{$stream.Write($bytes,0,$bytes.Length);$stream.Flush($true)}finally{$stream.Dispose()}
+$out=@(& $node $broker approve $request 2>&1) -join [Environment]::NewLine
+if($LASTEXITCODE -ne 0){throw ('R193 signing blocked after protected enrollment: '+$out.Substring(0,[Math]::Min(500,$out.Length)))}
+Write-Output $out

package/scripts/r193-test-limited-token.ps1

@@ -0,0 +1,49 @@
+$ErrorActionPreference='Stop'
+$root=[IO.Path]::GetFullPath((Join-Path $PSScriptRoot '..'))
+$probe=Join-Path $root 'scripts\r193-limited-subject-probe.ps1'
+$expectedSha='16317bffb0765e3856a6f64353ef728754e346636161cf2214ec0d0d3e5c7826'
+if((Get-FileHash $probe).Hash.ToLowerInvariant() -cne $expectedSha){throw 'R193_PROBE_SCRIPT_CHANGED'}
+$output=Join-Path $root 'R193-STANDARD-TOKEN-PROBE.json'
+if(Test-Path $output){throw 'R193_EXISTING_OUTPUT - read before retest'}
+$name='DEADBYTE-R193-Limited-Token-Diagnostic'
+if(Get-ScheduledTask -TaskName $name -TaskPath '\' -ErrorAction SilentlyContinue){throw 'R193_TASK_ALREADY_EXISTS'}
+$identity=[Security.Principal.WindowsIdentity]::GetCurrent()
+$account=$identity.Name
+$ps=Join-Path $env:WINDIR 'System32\WindowsPowerShell\v1.0\powershell.exe'
+$arg='-NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -File "'+$probe+'"'
+$action=New-ScheduledTaskAction -Execute $ps -Argument $arg -WorkingDirectory $root
+$trigger=New-ScheduledTaskTrigger -Once -At ((Get-Date).AddDays(1))
+$principal=New-ScheduledTaskPrincipal -UserId $account -LogonType Interactive -RunLevel Limited
+$settings=New-ScheduledTaskSettingsSet -MultipleInstances IgnoreNew -ExecutionTimeLimit (New-TimeSpan -Minutes 1)
+$registered=$false
+try {
+  $null=Register-ScheduledTask -TaskName $name -Action $action -Trigger $trigger -Principal $principal -Settings $settings -Description 'One-shot R193 native Windows token diagnostic. No grants.' -ErrorAction Stop
+  $registered=$true
+  $task=Get-ScheduledTask -TaskName $name -ErrorAction Stop
+  if([string]$task.Principal.RunLevel -ne 'Limited' -or [string]$task.Principal.LogonType -ne 'Interactive'){throw 'R193_TASK_NOT_LIMITED'}
+  Start-ScheduledTask -TaskName $name -ErrorAction Stop
+  $done=$false
+  for($i=0;$i -lt 28;$i++){
+    Start-Sleep -Milliseconds 700
+    if(Test-Path -LiteralPath $output -PathType Leaf){$done=$true;break}
+  }
+  if(-not $done){throw 'R193_LIMITED_TASK_NO_REPORT'}
+  $report=Get-Content -LiteralPath $output -Raw | ConvertFrom-Json
+  $info=Get-ScheduledTaskInfo -TaskName $name -ErrorAction Stop
+  $pass=($report.expected_standard -eq $true -and $report.process_report.elevated -eq $false -and $report.process_report.admin_enabled -eq $false -and $report.authority_granted -eq $false -and $info.LastTaskResult -eq 0)
+  [pscustomobject]@{
+    schema='deadbyte.r193-limited-token-scheduler-smoke.v1'
+    state=$(if($pass){'PASS'}else{'FAIL'})
+    limited_task=$name
+    scheduled_runlevel=[string]$task.Principal.RunLevel
+    native_subject=$report.process_report
+    task_exit=$info.LastTaskResult
+    source_sha256=$expectedSha
+    no_grant=$true
+    production_untouched=$true
+  }|ConvertTo-Json -Depth 8 -Compress
+  if(-not $pass){throw 'R193_EXPECTED_STANDARD_TOKEN_MISSING'}
+} finally {
+  if($registered){Unregister-ScheduledTask -TaskName $name -TaskPath '\' -Confirm:$false -ErrorAction Stop}
+}
+if(Get-ScheduledTask -TaskName $name -TaskPath '\' -ErrorAction SilentlyContinue){throw 'R193_PROBE_TASK_NOT_REMOVED'}

package/scripts/r193-toolchain-inventory.ps1

@@ -0,0 +1,7 @@
+$ErrorActionPreference='Stop'
+$o=[ordered]@{schema='deadbyte.r193-toolchain.v1';toolchain=@{};disk_free_bytes=[int64](Get-PSDrive D).Free}
+foreach($name in @('cl.exe','clang++.exe','g++.exe','cmake.exe','node.exe','powershell.exe')){
+ $q=Get-Command $name -ErrorAction SilentlyContinue
+ $o.toolchain[$name]=if($null -eq $q){'MISSING'}else{[string]$q.Source}
+}
+$o|ConvertTo-Json -Depth 4 -Compress

package/scripts/r193-uac-bridge-focused.mjs

@@ -0,0 +1,21 @@
+import {spawnSync} from 'node:child_process';
+import {fileURLToPath} from 'node:url';
+const root=fileURLToPath(new URL('..',import.meta.url));
+const files=[
+ 'test/r188-owner-uac.test.mjs',
+ 'test/r188-uac-boundary.test.mjs',
+ 'test/r186-owner-grant-broker.test.mjs',
+ 'test/r193-uac-r70-bridge.test.mjs'
+];
+const r=spawnSync(process.execPath,['--test','--test-concurrency=1',...files],{
+ cwd:root,encoding:'utf8',timeout:150000,maxBuffer:1024*1024,windowsHide:true,shell:false
+});
+const output=(r.stdout??'')+'\n'+(r.stderr??'');
+const get=n=>{const m=[...output.matchAll(new RegExp('(?:^|\\n)[ℹ#]\\s*'+n+'\\s+(\\d+)','g'))];return m.length?Number(m.at(-1)[1]):null;};
+const summary={tests:get('tests'),pass:get('pass'),fail:get('fail'),skipped:get('skipped')};
+const pass=r.status===0&&summary.tests>=12&&summary.fail===0&&summary.pass===summary.tests-summary.skipped;
+console.log(JSON.stringify({schema:'deadbyte.r193-uac-bridge-focused.v1',
+ status:pass?'PASS':'FAIL',exit:r.status,summary,files,
+ no_real_owner_enrollment:true,authority_granted:false,
+ production_untouched:true,tail:pass?null:output.slice(-12000)}));
+if(!pass)process.exitCode=1;

package/src/r188-owner-uac.mjs

@@ -0,0 +1,105 @@
+// R188 - no Windows Hello, no PEM owner key, no grant issuance.
+// Unprivileged challenge creation and read-only owner-review validation.
+// Only an independently launched, R89-protected native elevated broker
+// may record an actual approval. Do not turn this into a grant primitive.
+import {createHash,randomBytes} from 'node:crypto';
+import path from 'node:path';
+import {canonicalJson} from './canonical-json.mjs';
+const SHA=/^[a-f0-9]{64}$/;
+const CHALLENGE=/^[A-Za-z0-9_-]{43}$/;
+const ID=/^[A-Za-z0-9._-]{1,64}$/;
+const digest=x=>createHash('sha256').update(Buffer.from(canonicalJson(x),'utf8')).digest('hex');
+function invalid(msg){throw Error('R188 '+msg);}
+function exact(value,fields,label){
+ if(!value||typeof value!=='object'||Array.isArray(value)||
+   Object.keys(value).length!==fields.length||
+   fields.some(f=>!Object.hasOwn(value,f)))invalid(label+' schema mismatch');
+}
+function project(p){
+ if(typeof p!=='string'||!path.win32.isAbsolute(p)||p.startsWith('\\\\')||
+   path.win32.normalize(p).toLowerCase()===path.win32.parse(p).root.toLowerCase())
+  invalid('project root must be a bounded local Windows path');
+ return path.win32.normalize(p);
+}
+function fields(o){
+ for(const k of ['machineEpoch','releaseManifestSha256','codingPolicySha256','autonomousPolicySha256']){
+  if(typeof o?.[k]!=='string'||!SHA.test(o[k]))invalid('invalid '+k);
+ }
+ if(o.rootId!=='core'||!ID.test(o.rootId))invalid('root scope must be core');
+ const root=project(o.projectRoot);
+ if(!Number.isSafeInteger(o.maxSeconds)||o.maxSeconds<1||o.maxSeconds>3600)
+  invalid('maxSeconds outside owner-reviewed window');
+ return root;
+}
+const scopeKeys=['schema','machine_epoch','release_manifest_sha256',
+ 'coding_policy_sha256','autonomous_policy_sha256','root_id','project_root',
+ 'operation','max_seconds','issued_at_utc','expires_at_utc'];
+const requestKeys=['schema','challenge','subject','request_sha256','review_phrase',
+ 'owner_approved','authority_granted','require_interactive_uac'];
+function iso(v){
+ if(typeof v!=='string'||!/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/.test(v)||
+   !Number.isFinite(Date.parse(v))||new Date(v).toISOString()!==v)
+  invalid('UTC time not canonical');
+ return Date.parse(v);
+}
+function hashFor(challenge,subject){return digest({schema:'deadbyte.r188-owner-uac-request.v1',challenge,subject});}
+function phrase(hash){return 'APPROVE-'+hash.slice(0,12).toUpperCase();}
+export function createR188OwnerUacRequest({
+ machineEpoch,releaseManifestSha256,codingPolicySha256,autonomousPolicySha256,
+ rootId,projectRoot,maxSeconds,now=new Date(),expiresInMs=120000
+}={}){
+ const input={machineEpoch,releaseManifestSha256,codingPolicySha256,
+  autonomousPolicySha256,rootId,projectRoot,maxSeconds};
+ const normalized=fields(input);
+ if(!(now instanceof Date)||!Number.isFinite(now.getTime())||
+   !Number.isSafeInteger(expiresInMs)||expiresInMs<1000||expiresInMs>300000)
+  invalid('request lifetime invalid');
+ const subject=Object.freeze({
+  schema:'deadbyte.r188-owner-uac-subject.v1',machine_epoch:machineEpoch,
+  release_manifest_sha256:releaseManifestSha256,
+  coding_policy_sha256:codingPolicySha256,
+  autonomous_policy_sha256:autonomousPolicySha256,
+  root_id:rootId,project_root:normalized,
+  operation:'autonomous_goal_run',max_seconds:maxSeconds,
+  issued_at_utc:now.toISOString(),
+  expires_at_utc:new Date(now.getTime()+expiresInMs).toISOString()
+ });
+ const challenge=randomBytes(32).toString('base64url');
+ const request_sha256=hashFor(challenge,subject);
+ return Object.freeze({schema:'deadbyte.r188-owner-uac-request.v1',
+  challenge,subject,request_sha256,review_phrase:phrase(request_sha256),
+  owner_approved:false,authority_granted:false,require_interactive_uac:true});
+}
+export function verifyR188OwnerUacRequest({request,expected,now=new Date()}={}){
+ exact(request,requestKeys,'request');exact(request.subject,scopeKeys,'subject');
+ const subject=request.subject;
+ const root=fields(expected);
+ if(request.schema!=='deadbyte.r188-owner-uac-request.v1'||
+    subject.schema!=='deadbyte.r188-owner-uac-subject.v1'||
+    request.owner_approved!==false||request.authority_granted!==false||
+    request.require_interactive_uac!==true||
+    typeof request.challenge!=='string'||!CHALLENGE.test(request.challenge)||
+    Buffer.from(request.challenge,'base64url').length!==32||
+    Buffer.from(request.challenge,'base64url').toString('base64url')!==request.challenge)
+   invalid('request shape or challenge invalid');
+ const expectedBindings={
+  machine_epoch:expected.machineEpoch,release_manifest_sha256:expected.releaseManifestSha256,
+  coding_policy_sha256:expected.codingPolicySha256,
+  autonomous_policy_sha256:expected.autonomousPolicySha256,root_id:expected.rootId,
+  project_root:root,operation:'autonomous_goal_run',max_seconds:expected.maxSeconds
+ };
+ for(const [k,v] of Object.entries(expectedBindings)){
+  if(subject[k]!==v)invalid('request scope mismatch: '+k);
+ }
+ if(!(now instanceof Date)||!Number.isFinite(now.getTime()))invalid('current time invalid');
+ const issued=iso(subject.issued_at_utc),expires=iso(subject.expires_at_utc);
+ if(expires<=issued||expires-issued>300000||
+   now.getTime()<issued||now.getTime()>=expires)invalid('request expired or not yet valid');
+ if(typeof request.request_sha256!=='string'||!SHA.test(request.request_sha256)||
+    request.request_sha256!==hashFor(request.challenge,subject)||
+    request.review_phrase!==phrase(request.request_sha256))
+   invalid('request digest or owner phrase altered');
+ return Object.freeze({status:'VERIFIED_FOR_REVIEW_ONLY',request_sha256:request.request_sha256,
+  review_phrase:request.review_phrase,authority_granted:false,owner_approved:false,
+  next_gate:'PROTECTED_INTERACTIVE_UAC_WITH_EXACT_REQUEST_AND_EPOCH'});
+}

package/src/r188-uac-boundary.mjs

@@ -0,0 +1,21 @@
+// R188: pure fail-closed decision gate, NOT proof of a Windows UAC action.
+// A privileged native broker MUST determine these facts independently using
+// token and ACL inspection. Never accept a caller's self-reported booleans.
+export function assessR188UacBoundary(e={}){
+ const finish=(reason)=>Object.freeze({schema:'deadbyte.r188-uac-boundary.v1',
+  status:'BLOCKED',reason,authority_granted:false,grant_issued:false});
+ if(e.codingElevation!=='standard')return finish('CODING_ALREADY_ELEVATED');
+ if(e.privilegedParentReachable!==false)return finish('ELEVATED_PARENT_STILL_REACHABLE');
+ if(e.ownerElevation!=='elevated')return finish('OWNER_NOT_ELEVATED');
+ if(e.protectedBroker!==true)return finish('BROKER_NOT_PROTECTED');
+ if(e.enableUac!==true||e.secureDesktop!==true||
+   e.promptMode!=='explicit_secure_desktop')
+  return finish('UAC_NOT_INTERACTIVE_AND_SECURE');
+ if(e.nativeEpochPinned!==true||e.releaseAndPoliciesPinned!==true)
+  return finish('AUTHORITY_EPOCH_OR_POLICY_NOT_PINNED');
+ if(e.ownerGesture!=='approved')return finish('OWNER_NOT_APPROVED');
+ return Object.freeze({schema:'deadbyte.r188-uac-boundary.v1',
+  status:'ELIGIBLE_FOR_PROTECTED_OWNER_REVIEW',reason:null,
+  authority_granted:false,grant_issued:false,
+  next_gate:'SIGNED_EPOCH_ONE_TIME_GRANT_TRANSACTION'});
+}