deadbyte-mcp 0.15.72 → 0.15.74

package/scripts/npm-release-r48.mjs

@@ -1,6 +1,7 @@
 import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { reconcileNpmPublication } from './npm-publication-r65.mjs';
+import { classifyNpmPublishFailure } from './npm-interactive-r194.mjs';
 import { mkdtemp, readFile, rm, unlink, mkdir } from 'node:fs/promises';
 import {preserveNpmTarball,assertVacantPackDestination} from './npm-preserve-artifact-r67.mjs';
 import {assertR67NpmPublishReady} from './npm-release-readiness-r67.mjs';
@@ -12,8 +13,10 @@ import {assertR165NpmPublishReady} from './npm-release-readiness-r165.mjs';
 import {assertR166NpmPublishReady} from './npm-release-readiness-r166.mjs';
 import {assertR167NpmPublishReady,assertR167PackedIdentity} from './npm-release-readiness-r167.mjs';
 import {assertR168NpmPublishReady,assertR168PackedIdentity} from './npm-release-readiness-r168.mjs';
+import {assertR193NpmPublishReady,assertR193PackedIdentity} from './npm-release-readiness-r193.mjs';
+import {assertR194NpmPublishReady,assertR194PackedIdentity} from './npm-release-readiness-r194.mjs';
 import {resumePackRecord} from '../src/npm-publication-resume-r168.mjs';
-import { existsSync } from 'node:fs';
+import { existsSync,mkdtempSync,readdirSync,readFileSync,rmSync } from 'node:fs';
 import { resolveStateRoot } from '../src/state-root.mjs';
 import path from 'node:path';
 import os from 'node:os';
@@ -46,18 +49,39 @@ function runNpm(args, options = {}) {
   return run(node, [npmCli, ...args], options);
 }
 
+function verifyNpmOwnerPreflight(){
+  try{
+    const registry=runNpm(['config','get','registry'],{timeout:30000}).trim();
+    if(registry!=='https://registry.npmjs.org/')return false;
+    const name=runNpm(['whoami','--registry=https://registry.npmjs.org/'],{timeout:30000}).trim();
+    if(name!=='deadbytes')return false;
+    const owners=runNpm(['owner','ls','deadbyte-mcp','--registry=https://registry.npmjs.org/'],{timeout:30000});
+    return owners.split(/\r?\n/).some(line=>/^\s*deadbytes(?:\s|$)/.test(line));
+  }catch{return false;}
+}
+
 function runNpmInteractive(args, options = {}) {
   const { cwd = root, timeout = 300000 } = options;
-  const r = spawnSync(node, [npmCli, ...args], {
-    cwd,
-    timeout,
-    stdio: 'inherit',
-    shell: false,
-    windowsHide: false,
-  });
-  if (r.error) throw r.error;
-  if (r.status !== 0) throw new Error('Interactive npm command failed (exit=' + r.status + ', cwd=' + cwd + ')');
-  return '';
+  const logDir=mkdtempSync(path.join(os.tmpdir(),'deadbyte-r194-npm-diagnostic-'));
+  try{
+    // Preserve interactive browser/2FA prompts; classify failures from the
+    // isolated npm debug log without printing or preserving credential data.
+    const r=spawnSync(node,[npmCli,...args,'--logs-dir',logDir],{
+      cwd,timeout,stdio:'inherit',shell:false,windowsHide:false
+    });
+    if(r.error)throw r.error;
+    if(r.status!==0){
+      const debug=readdirSync(logDir).filter(name=>name.endsWith('-debug-0.log')).slice(-3)
+        .map(name=>readFileSync(path.join(logDir,name),'utf8').slice(-16000)).join('\n');
+      const reason=classifyNpmPublishFailure({exitCode:r.status,output:debug});
+      const error=new Error('Interactive npm publish did not complete; classified '+reason);
+      error.code=reason;
+      throw error;
+    }
+    return '';
+  }finally{
+    rmSync(logDir,{recursive:true,force:true});
+  }
 }
 
 function parseJson(text) {
@@ -123,6 +147,16 @@ async function main() {
     if (!publishOnly) throw new Error('PUBLISH_BLOCKED R168 requires --publish-only; activation is separate');
     r168Readiness=await assertR168NpmPublishReady(release,{root});
   }
+  let r193Readiness=null;
+  if (!isVerifyOnly && version==='0.15.73') {
+    if (!publishOnly) throw new Error('PUBLISH_BLOCKED R193 requires --publish-only; owner enrollment, runtime migration, and activation are separate authority boundaries');
+    r193Readiness=await assertR193NpmPublishReady(release,{root});
+  }
+  let r194Readiness=null;
+  if (!isVerifyOnly && version==='0.15.74') {
+    if (!publishOnly) throw new Error('PUBLISH_BLOCKED R194 requires --publish-only; activation remains separately authorized');
+    r194Readiness=await assertR194NpmPublishReady(release,{root});
+  }
   if (release.parent?.release_id !== provenance.parent_release_id ||
       release.parent?.manifest_sha256 !== provenance.parent_manifest_sha256 ||
       release.parent?.generation_manifest_sha256 !== provenance.parent_generation_manifest_sha256) {
@@ -262,10 +296,23 @@ async function main() {
       ...r168Readiness,observedSha256:createHash('sha256').update(localBytes).digest('hex'),
       observedIntegrity:localIntegrity,observedShasum:packRecord.shasum
     });
+    if(r193Readiness)assertR193PackedIdentity({
+      ...r193Readiness,observedSha256:createHash('sha256').update(localBytes).digest('hex'),
+      observedIntegrity:localIntegrity,observedShasum:packRecord.shasum
+    });
+    if(r194Readiness)assertR194PackedIdentity({
+      ...r194Readiness,observedSha256:createHash('sha256').update(localBytes).digest('hex'),
+      observedIntegrity:localIntegrity,observedShasum:packRecord.shasum
+    });
 
     console.log('[6/7] Publishing artifact to npm registry...');
     publishAttempted = true;
+    const ownerAuth=async subject=>
+      subject.version===version&&subject.manifest_sha256===manifestSha256&&
+      subject.tarball_sha256===createHash('sha256').update(localBytes).digest('hex')&&
+      verifyNpmOwnerPreflight();
     const reconciliation=await reconcileNpmPublication({recordPath:publicationDir,version,manifestSha256,localBytes,
+      authorizePublish:ownerAuth,authorizeAuthRetry:ownerAuth,
       publish:async()=>runNpmInteractive(['publish',publishTarball,'--access','public','--auth-type=web'],{timeout:300000}),
       lookup:async()=>{
         try{

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

@@ -0,0 +1,80 @@
+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 R193 ${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 assertR193PackedIdentity({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 assertR193NpmPublishReady(release,{root,closureRoot=process.env.DEADBYTE_R193_CLOSURE_ROOT}={}){
+  required(release?.version==='0.15.73'&&release?.train==='R193'&&
+    release?.r193?.scope==='PROTECTED_OWNER_AUTHORIZATION_AND_LIMITED_RUNTIME_MIGRATION','candidate metadata invalid');
+  required(release?.r193?.public_tool_delta===0&&release?.r193?.authority_scope_delta===0,'public authority surface widened');
+  required(release?.parent?.version==='0.15.72'&&
+    release?.parent?.release_id==='v0.15.72-0a5d9436e06e2d9e'&&
+    release?.parent?.manifest_sha256==='0a5d9436e06e2d9e7cf9179417465955d8ca5ba88655b13dd019190243c1cc90'&&
+    release?.parent?.generation_manifest_sha256==='aec7b998306a3bbbcc59088648e7bc46ca7e203d749d4550b5b5f372032f92b0','lineage mismatch');
+  required(root&&path.isAbsolute(root)&&closureRoot&&path.isAbsolute(closureRoot),'closure root absent');
+  const expected=path.resolve(root,'..','..','testing','r193-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.r193-release-closure.v1'&&closure.status==='RELEASE_READY'&&
+    closure.version==='0.15.73'&&closure.train==='R193','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.limited_runtime_migration==='NOT_RUN'&&
+    closure.production_activation==='NOT_RUN','prepublication closure crossed production 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.73'&&
+    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('R193_STAGE_PASS=focused'),'focused protected gate incomplete');
+  const focusedSummary=tapSummary(focused,'focused');
+  required(focusedSummary.fails===0&&focusedSummary.cancelled===0&&focusedSummary.passes>=60&&focusedSummary.skips<=2,'focused regression count mismatch');
+  required(full.includes('R193_STAGE_PASS=full'),'full protected gate incomplete');
+  const summary=tapSummary(full,'full');
+  required(summary.tests>=2150&&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.73.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:'R193_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-r194.mjs

@@ -0,0 +1,80 @@
+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 R194 ${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 assertR194PackedIdentity({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 assertR194NpmPublishReady(release,{root,closureRoot=process.env.DEADBYTE_R194_CLOSURE_ROOT}={}){
+  required(release?.version==='0.15.74'&&release?.train==='R194'&&
+    release?.r194?.scope==='NPM_AUTH_RECOVERY_AND_OWNER_AUTHORIZATION','candidate metadata invalid');
+  required(release?.r194?.public_tool_delta===0&&release?.r194?.authority_scope_delta===0,'public authority surface widened');
+  required(release?.parent?.version==='0.15.72'&&
+    release?.parent?.release_id==='v0.15.72-0a5d9436e06e2d9e'&&
+    release?.parent?.manifest_sha256==='0a5d9436e06e2d9e7cf9179417465955d8ca5ba88655b13dd019190243c1cc90'&&
+    release?.parent?.generation_manifest_sha256==='aec7b998306a3bbbcc59088648e7bc46ca7e203d749d4550b5b5f372032f92b0','lineage mismatch');
+  required(root&&path.isAbsolute(root)&&closureRoot&&path.isAbsolute(closureRoot),'closure root absent');
+  const expected=path.resolve(root,'..','..','testing','r194-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.r194-release-closure.v1'&&closure.status==='RELEASE_READY'&&
+    closure.version==='0.15.74'&&closure.train==='R194','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.limited_runtime_migration==='NOT_RUN'&&
+    closure.production_activation==='NOT_RUN','prepublication closure crossed production 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.74'&&
+    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('R194_STAGE_PASS=focused'),'focused protected gate incomplete');
+  const focusedSummary=tapSummary(focused,'focused');
+  required(focusedSummary.fails===0&&focusedSummary.cancelled===0&&focusedSummary.passes>=60&&focusedSummary.skips<=2,'focused regression count mismatch');
+  required(full.includes('R194_STAGE_PASS=full'),'full protected gate incomplete');
+  const summary=tapSummary(full,'full');
+  required(summary.tests>=2150&&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.74.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:'R194_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/r188-owner-uac-review.ps1

@@ -0,0 +1,91 @@
+#requires -Version 5.1
+#requires -RunAsAdministrator
+# R188: owner-operated elevated REVIEW receipt only. Never issues an agent grant.
+# Invoke by hand from a trusted interactive desktop; not through an agent or MCP.
+[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 'R188 must run from an installed Program Files release, not a writable development directory'
+}
+$settings=Get-ItemProperty -LiteralPath 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System'
+if([int]$settings.EnableLUA -ne 1 -or [int]$settings.PromptOnSecureDesktop -ne 1 -or
+   [int]$settings.ConsentPromptBehaviorAdmin -eq 0){
+ throw 'R188 UAC secure desktop and nonautomatic admin consent must be enabled'
+}
+if(-not [Environment]::UserInteractive){throw 'R188 requires a local interactive owner session'}
+$node='C:\Program Files\nodejs\node.exe'
+if(-not (Test-Path -LiteralPath $node -PathType Leaf)){throw 'R188 trusted Node executable missing'}
+$request=[IO.Path]::GetFullPath($RequestPath)
+$preflight=Join-Path $root 'scripts\r188-uac-review-preview.mjs'
+$raw=(& $node $preflight $request 2>&1 | Out-String)
+if($LASTEXITCODE -ne 0){throw ('R188 preflight blocked: '+$raw.Substring(0,[Math]::Min(300,$raw.Length)))}
+$preview=$raw|ConvertFrom-Json
+if([string]$preview.status -cne 'R188_PROTECTED_REVIEW_PREVIEW_ONLY' -or
+  [bool]$preview.authority_granted -or [bool]$preview.owner_approved -or
+  [bool]$preview.live_epoch_verified -or [bool]$preview.live_policies_verified){
+ throw 'R188 preview unexpectedly claims grant/authorization'
+}
+$phrase=[string]$preview.review_phrase
+if($phrase -cnotmatch '^APPROVE-[A-F0-9]{12}$'){throw 'R188 owner review phrase invalid'}
+Write-Host ''
+Write-Host 'DEADBYTE R188 / OWNER UAC REVIEW' -ForegroundColor Yellow
+Write-Host 'This is a read-only scope REVIEW. It will NOT arm Autonomous.'
+Write-Host ('Request SHA-256: '+[string]$preview.request_sha256)
+Write-Host ('Project: '+[string]$preview.project_root)
+Write-Host ('Action: '+[string]$preview.operation)
+Write-Host ('Duration cap seconds: '+[string]$preview.max_seconds)
+Write-Host ('Expires UTC: '+[string]$preview.expires_at_utc)
+Write-Host ('Release manifest SHA-256: '+[string]$preview.installed_manifest_sha256)
+Write-Host 'Coding policy and live machine epoch still require an independent trusted runtime read.'
+Write-Host 'Do not approve requests you did not initiate and inspect yourself.'
+$entered=Read-Host ('If you recognize this exact request, type '+$phrase+' (anything else rejects)')
+if($entered -cne $phrase){throw 'R188 owner rejected request'}
+$target='C:\Program Files\DEADBYTE-R188-OwnerReview'
+if(-not (Test-Path -LiteralPath $target -PathType Container)){
+ $admins=New-Object Security.Principal.SecurityIdentifier('S-1-5-32-544')
+ $system=New-Object Security.Principal.SecurityIdentifier('S-1-5-18')
+ $users=New-Object Security.Principal.SecurityIdentifier('S-1-5-32-545')
+ New-Item -ItemType Directory -Path $target -ErrorAction Stop | Out-Null
+ $acl=New-Object Security.AccessControl.DirectorySecurity
+ $acl.SetAccessRuleProtection($true,$false)
+ $acl.SetOwner($admins)
+ $inherit=[Security.AccessControl.InheritanceFlags]'ContainerInherit, ObjectInherit'
+ $none=[Security.AccessControl.PropagationFlags]::None
+ $allow=[Security.AccessControl.AccessControlType]::Allow
+ $acl.AddAccessRule((New-Object Security.AccessControl.FileSystemAccessRule($admins,'FullControl',$inherit,$none,$allow)))
+ $acl.AddAccessRule((New-Object Security.AccessControl.FileSystemAccessRule($system,'FullControl',$inherit,$none,$allow)))
+ $acl.AddAccessRule((New-Object Security.AccessControl.FileSystemAccessRule($users,'ReadAndExecute',$inherit,$none,$allow)))
+ Set-Acl -LiteralPath $target -AclObject $acl
+}
+$receipt=[ordered]@{
+ schema='deadbyte.r188-uac-owner-review.v1'
+ status='REVIEWED_NO_GRANT'
+ request_sha256=[string]$preview.request_sha256
+ release_manifest_sha256=[string]$preview.installed_manifest_sha256
+ reviewed_scope=[string]$preview.operation
+ project_root=[string]$preview.project_root
+ duration_cap_seconds=[int]$preview.max_seconds
+ reviewed_at_utc=[DateTime]::UtcNow.ToString('o')
+ live_epoch_verified=$false
+ live_policies_verified=$false
+ owner_reviewed=$true
+ authority_granted=$false
+ grant_issued=$false
+}
+$name=([string]$preview.request_sha256)+'.review.json'
+$dest=Join-Path $target $name
+$text=$receipt|ConvertTo-Json -Compress
+$utf8=New-Object Text.UTF8Encoding($false)
+$stream=[IO.File]::Open($dest,[IO.FileMode]::CreateNew,[IO.FileAccess]::Write,[IO.FileShare]::None)
+try{
+ $bytes=$utf8.GetBytes($text+[Environment]::NewLine)
+ $stream.Write($bytes,0,$bytes.Length)
+ $stream.Flush($true)
+}finally{$stream.Dispose()}
+Write-Host 'R188_OWNER_REVIEWED_NO_GRANT' -ForegroundColor Yellow
+Write-Host ('Receipt: '+$dest)
+Write-Host 'No PEM, Windows Hello, Autonomous grant, npm publish, or production activation performed.'

package/scripts/r188-uac-review-preview.mjs

@@ -0,0 +1,65 @@
+// Protected owner's manual UAC review: verify a request without granting.
+// Requested policy / epoch hashes are UNTRUSTED previews until a protected
+// runtime reader binds them; never interpret this as an authorization token.
+import {readFile,lstat} from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {inspectTrustedInstallation} from '../src/privileged-install-trust-r89.mjs';
+import {parseManifest,verifyManifestTreeExact} from '../src/release-slot.mjs';
+import {verifyR188OwnerUacRequest} from '../src/r188-owner-uac.mjs';
+const thisFile=fileURLToPath(import.meta.url);
+const root=path.resolve(path.dirname(thisFile),'..');
+const args=process.argv.slice(2);
+function block(reason){throw Error('R188_UAC_REVIEW_BLOCKED '+reason);}
+async function bounded(file,max){
+ const st=await lstat(file);
+ if(!st.isFile()||st.isSymbolicLink()||st.size<1||st.size>max)block('UNSAFE_FILE');
+ return readFile(file);
+}
+async function main(){
+ if(process.platform!=='win32'||process.arch!=='x64')block('WINDOWS_X64_REQUIRED');
+ if(args.length!==1||!path.win32.isAbsolute(args[0]))block('ABSOLUTE_REQUEST_REQUIRED');
+ const os=await inspectTrustedInstallation([
+   process.execPath,thisFile,
+   path.join(root,'MANIFEST.SHA256'),
+   path.join(root,'src','r188-owner-uac.mjs'),
+   path.join(root,'src','canonical-json.mjs'),
+   path.join(root,'src','privileged-install-trust-r89.mjs')
+ ]);
+ if(!os.trusted)block('R89_PROTECTED_INSTALLATION_REQUIRED');
+ const manifestBytes=await bounded(path.join(root,'MANIFEST.SHA256'),512*1024);
+ const manifest=parseManifest(manifestBytes.toString('utf8'));
+ await verifyManifestTreeExact(root,manifest);
+ const request=JSON.parse((await bounded(args[0],64*1024)).toString('utf8'));
+ const subject=request.subject;
+ if(!subject||typeof subject!=='object')block('SUBJECT_MISSING');
+ const expected={
+  machineEpoch:subject.machine_epoch,
+  releaseManifestSha256:subject.release_manifest_sha256,
+  codingPolicySha256:subject.coding_policy_sha256,
+  autonomousPolicySha256:subject.autonomous_policy_sha256,
+  rootId:subject.root_id,projectRoot:subject.project_root,
+  maxSeconds:subject.max_seconds
+ };
+ // Strict self-consistency proof, NOT yet verification of the live epoch/policy.
+ const verified=verifyR188OwnerUacRequest({request,expected,now:new Date()});
+ const {createHash}=await import('node:crypto');
+ const actualManifest=createHash('sha256').update(manifestBytes).digest('hex');
+ if(subject.release_manifest_sha256!==actualManifest)block('INSTALLED_RELEASE_NOT_REVIEWED_RELEASE');
+ process.stdout.write(JSON.stringify({
+   status:'R188_PROTECTED_REVIEW_PREVIEW_ONLY',
+   request_sha256:verified.request_sha256,
+   review_phrase:verified.review_phrase,
+   root_id:subject.root_id,project_root:subject.project_root,
+   max_seconds:subject.max_seconds,operation:subject.operation,
+   expires_at_utc:subject.expires_at_utc,
+   requested_machine_epoch:subject.machine_epoch,
+   requested_coding_policy_sha256:subject.coding_policy_sha256,
+   requested_autonomous_policy_sha256:subject.autonomous_policy_sha256,
+   installed_manifest_sha256:actualManifest,
+   os_acl_trusted:true,
+   live_epoch_verified:false,live_policies_verified:false,
+   authority_granted:false,owner_approved:false
+ })+'\n');
+}
+main().catch(e=>{console.error(String(e?.message||e).slice(0,320));process.exitCode=2;});

package/scripts/r193-compile-token.ps1

@@ -0,0 +1,22 @@
+$ErrorActionPreference='Stop'
+$root=[IO.Path]::GetFullPath((Join-Path $PSScriptRoot '..'))
+$source=Join-Path $root 'native\deadbyte-owner-token-r193.cpp'
+$dest=Join-Path $root 'bin\deadbyte-owner-token-r193.exe'
+$sourceDigest='99d1ec196e3e3242a9d44a6445d60abd1b3fbbd53dc9be126d4cc5bb91074099'
+if ((Get-FileHash $source).Hash.ToLowerInvariant() -cne $sourceDigest) { throw 'R193_SOURCE_DRIFT' }
+$gpp='C:\Users\DEADBYTE\scoop\apps\w64devkit\current\bin\g++.exe'
+if(-not(Test-Path $gpp -PathType Leaf)){throw 'R193_TOOLCHAIN_MISSING'}
+if(Test-Path $dest){throw 'R193_BINARY_EXISTS - do not overwrite without explicit inspection'}
+& $gpp -std=c++17 -O2 -Wall -Wextra -Werror -static -s -o $dest $source -ladvapi32
+if($LASTEXITCODE -ne 0){throw "R193_COMPILER_FAILED exit=$LASTEXITCODE"}
+$raw=@(& $dest --report)
+if($LASTEXITCODE -ne 0){throw "R193_REPORT_FAILED exit=$LASTEXITCODE"}
+$report=($raw -join [Environment]::NewLine)|ConvertFrom-Json
+if($report.schema -cne 'deadbyte.r193-native-token.v1' -or $report.authority_granted -or $report.owner_approved -or $report.parent_independence_verified){throw 'R193_INVALID_TOKEN_REPORT'}
+$strictRaw=@(& $dest --require-standard)
+$strictExit=$LASTEXITCODE
+$strict=($strictRaw -join [Environment]::NewLine) | ConvertFrom-Json
+if($report.status -cne $strict.status){throw 'R193_SUBJECT_STATUS_CHANGED'}
+if($report.status -eq 'BLOCKED' -and $strictExit -ne 3){throw 'R193_FAIL_CLOSED_EXPECTED_EXIT3'}
+if($report.status -eq 'STANDARD_TOKEN_OBSERVED' -and $strictExit -ne 0){throw 'R193_STANDARD_EXPECTED_EXIT0'}
+[pscustomobject]@{schema='deadbyte.r193-native-token-acceptance.v1';status='PASS';source_sha256=$sourceDigest;binary_sha256=(Get-FileHash $dest).Hash.ToLowerInvariant();binary_bytes=(Get-Item $dest).Length;native_report=$report;strict_exit=$strictExit;no_grant=$true}|ConvertTo-Json -Depth 7 -Compress

package/scripts/r193-evidence-relocate.ps1

@@ -0,0 +1,12 @@
+$ErrorActionPreference='Stop'
+$source='D:\Projects\deadbyte-mcp\development\deadbyte-mcp-r193-owner-uac-dev\R193-STANDARD-TOKEN-PROBE.json'
+$folder='D:\Projects\deadbyte-mcp\testing\r193'
+$dest=Join-Path $folder 'R193-STANDARD-TOKEN-PROBE.json'
+$item=Get-Item -LiteralPath $source -Force -ErrorAction Stop
+if($item.PSIsContainer -or (($item.Attributes -band [IO.FileAttributes]::ReparsePoint) -ne 0)){throw 'R193_UNSAFE_EVIDENCE'}
+$before=(Get-FileHash $source).Hash.ToLowerInvariant()
+if(Test-Path $dest){throw 'R193_DEST_EVIDENCE_ALREADY_EXISTS'}
+New-Item -ItemType Directory -Path $folder -Force -ErrorAction Stop | Out-Null
+Move-Item -LiteralPath $source -Destination $dest -ErrorAction Stop
+if((Get-FileHash $dest).Hash.ToLowerInvariant() -cne $before){throw 'R193_EVIDENCE_MOVE_CHANGED'}
+[pscustomobject]@{schema='deadbyte.r193-evidence-relocate.v1';state='VERIFIED';evidence_path=$dest;sha256=$before;source_absent=(-not(Test-Path $source));production_untouched=$true}|ConvertTo-Json -Compress

package/scripts/r193-focused-gate.mjs

@@ -0,0 +1,20 @@
+import {spawnSync} from 'node:child_process';
+import path from 'node:path';
+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/r193-native-token.test.mjs'
+];
+const result=spawnSync(process.execPath,['--test','--test-concurrency=1',...files],{
+ cwd:root,encoding:'utf8',windowsHide:true,timeout:120000,maxBuffer:1024*1024,shell:false
+});
+const output=(result.stdout??'')+'\n'+(result.stderr??'');
+const summary=output.split(/\r?\n/).filter(x=>/^[ℹ#]\s*(tests|pass|fail|skipped)\s+/.test(x)).slice(-6);
+const pass=result.status===0 && summary.some(x=>/pass\s+9\b/.test(x)) && summary.some(x=>/fail\s+0\b/.test(x));
+console.log(JSON.stringify({schema:'deadbyte.r193-focused-gate.v1',
+ state:pass?'PASS':'FAIL',exit:result.status,summary,
+ output_tail:pass?null:output.slice(-11000),
+ runtime_source:'isolated_R193_only',release_activated:false,authority_granted:false}));
+if(!pass)process.exitCode=1;

package/scripts/r193-import-r188-scripts.ps1

@@ -0,0 +1,14 @@
+$ErrorActionPreference='Stop'
+$from='D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.69-r188-uac-consent'
+$into='D:\Projects\deadbyte-mcp\development\deadbyte-mcp-r193-owner-uac-dev'
+$names=@('scripts\r188-owner-uac-review.ps1','scripts\r188-uac-review-preview.mjs')
+foreach($n in $names){
+ $s=Join-Path $from $n
+ $d=Join-Path $into $n
+ if(Test-Path $d){throw "R193_IMPORT_ALREADY_EXISTS $n"}
+ $item=Get-Item -LiteralPath $s
+ if($item.PSIsContainer -or ($item.Attributes -band [IO.FileAttributes]::ReparsePoint)){throw "R193_UNSAFE_SOURCE $n"}
+ Copy-Item -LiteralPath $s -Destination $d -ErrorAction Stop
+ if((Get-FileHash $s).Hash -cne (Get-FileHash $d).Hash){throw "R193_IMPORT_BYTES_MISMATCH $n"}
+}
+[pscustomobject]@{state='R188_SCRIPTS_IMPORTED';scripts=$names;overwrite=$false;production_untouched=$true}|ConvertTo-Json -Compress

package/scripts/r193-limited-subject-probe.ps1

@@ -0,0 +1,25 @@
+$ErrorActionPreference='Stop'
+$root=[IO.Path]::GetFullPath((Join-Path $PSScriptRoot '..'))
+$exe=Join-Path $root 'bin\deadbyte-owner-token-r193.exe'
+$output=Join-Path $root 'R193-STANDARD-TOKEN-PROBE.json'
+$sha='d554d732872f3d671fd2fb63c11fc0dac1f8cae377259c6d64dd0c5b3762f2b8'
+if((Get-FileHash -LiteralPath $exe -Algorithm SHA256).Hash.ToLowerInvariant() -cne $sha){throw 'R193_NATIVE_BINARY_CHANGED'}
+if(Test-Path -LiteralPath $output){throw 'R193_PROBE_OUTPUT_ALREADY_EXISTS'}
+$json=@(& $exe '--require-standard')
+$exit=$LASTEXITCODE
+if($json.Count -ne 1){throw 'R193_PROBE_OUTPUT_INVALID'}
+$body=($json[0]|ConvertFrom-Json)
+$record=[ordered]@{
+ schema='deadbyte.r193-standard-token-probe.v1'
+ process_report=$body
+ probe_exit=$exit
+ native_binary_sha256=$sha
+ expected_standard=($body.status -eq 'STANDARD_TOKEN_OBSERVED' -and $exit -eq 0)
+ authority_granted=$false
+}
+$text=$record|ConvertTo-Json -Depth 6 -Compress
+$utf8=New-Object Text.UTF8Encoding($false)
+$bytes=$utf8.GetBytes($text)
+$stream=[IO.File]::Open($output,[IO.FileMode]::CreateNew,[IO.FileAccess]::Write,[IO.FileShare]::None)
+try{$stream.Write($bytes,0,$bytes.Length);$stream.Flush($true)}finally{$stream.Dispose()}
+if(-not $record.expected_standard){exit 3}

package/scripts/r193-migrate-runtime-limited.ps1

@@ -0,0 +1,103 @@
+#requires -Version 5.1
+#requires -RunAsAdministrator
+[CmdletBinding()]
+param([switch]$Execute)
+$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 Limited migration must run from an R89-protected Program Files package'
+}
+$state='C:\Users\DEADBYTE\.deadbyte-mcp'
+$runtime=Join-Path $state 'runtime'
+$pointer=Get-Content -Raw -LiteralPath (Join-Path $state 'active-release.json')|ConvertFrom-Json
+$manifest=Join-Path $root 'MANIFEST.SHA256'
+if((Get-FileHash $manifest).Hash.ToLowerInvariant() -cne [string]$pointer.manifest_sha256){
+ throw 'R193 Limited migration package is not the exact active release'
+}
+$controller=Join-Path $root 'controller\deadbyte-controller.ps1'
+$native=Join-Path $root 'bin\deadbyte-owner-token-r193.exe'
+$env:DEADBYTE_CONTROLLER_CONFIG=[string]$pointer.config_path
+$env:DEADBYTE_CONTROLLER_RUNTIME_ROOT=$runtime
+function Invoke-Controller([string]$Command,[switch]$Json){
+ $args=@('-NoLogo','-NoProfile','-NonInteractive','-ExecutionPolicy','Bypass','-File',$controller,$Command)
+ if($Json){$args+='-Json'}
+ $raw=@(& 'C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe' @args 2>&1)-join [Environment]::NewLine
+ if($LASTEXITCODE -ne 0){throw "R193 controller $Command failed: $($raw.Substring(0,[Math]::Min(400,$raw.Length)))"}
+ if($Json){return $raw|ConvertFrom-Json}
+ return $raw
+}
+function Token([int]$PidValue){
+ $raw=@(& $native --inspect-pid ([string]$PidValue) 2>&1)-join [Environment]::NewLine
+ if($LASTEXITCODE -ne 0){throw "R193 token inspection failed for PID $PidValue"}
+ return $raw|ConvertFrom-Json
+}
+function AuthorityFingerprint($status,[string]$plane){
+ $p=$status.authority.$plane
+ return '{0}|{1}|{2}|{3}|{4}' -f [bool]$p.configured,[bool]$p.armed,[string]$p.reason,[string]$p.epoch_seq,[string]$p.epoch_sha256
+}
+$before=Invoke-Controller status -Json
+if([string]$before.state -cne 'ONLINE' -or -not $before.supervisor.running){throw 'R193 migration requires ONLINE runtime and verified supervisor'}
+foreach($plane in @('process','coding','autonomous','desktop','host')){
+ if([string]$before.authority.$plane.reason -eq 'unverified'){throw "R193 migration authority $plane is unverified"}
+}
+$plan=[ordered]@{schema='deadbyte.r193-limited-migration-plan.v1';active_release=[string]$pointer.release_id;
+ manifest_sha256=[string]$pointer.manifest_sha256;state='PREFLIGHT_PASS';
+ desktop_will_be_disarmed=$true;other_authority_will_not_be_rearmed=$true;
+ production_mutation_requested=[bool]$Execute}
+if(-not $Execute){$plan|ConvertTo-Json -Depth 5 -Compress;exit 0}
+$transient='DEADBYTE-MCP-R193-Limited-Supervisor'
+$stopped=$false
+try{
+ Invoke-Controller supervisorstop|Out-Null
+ Invoke-Controller stop|Out-Null
+ $stopped=$true
+ $offline=Invoke-Controller status -Json
+ if([string]$offline.state -cne 'OFFLINE'){throw 'R193 migration did not reach OFFLINE'}
+ Start-ScheduledTask -TaskName 'DEADBYTE-MCP-Runtime-Logon'
+ $deadline=[DateTime]::UtcNow.AddSeconds(60)
+ do{
+  Start-Sleep -Milliseconds 500
+  try{$online=Invoke-Controller status -Json}catch{$online=$null}
+ }while(($null -eq $online -or [string]$online.state -cne 'ONLINE') -and [DateTime]::UtcNow -lt $deadline)
+ if($null -eq $online -or [string]$online.state -cne 'ONLINE'){throw 'R193 Limited runtime task did not become ONLINE'}
+ $action=New-ScheduledTaskAction -Execute 'C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe' -Argument ('-NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -File "'+(Join-Path $state 'bin\DEADBYTE-MCP.ps1')+'" supervisorstart')
+ $principal=New-ScheduledTaskPrincipal -UserId ([Security.Principal.WindowsIdentity]::GetCurrent().Name) -LogonType Interactive -RunLevel Limited
+ Register-ScheduledTask -TaskName $transient -Action $action -Principal $principal -Force|Out-Null
+ Start-ScheduledTask -TaskName $transient
+ $deadline=[DateTime]::UtcNow.AddSeconds(30)
+ do{Start-Sleep -Milliseconds 500;$after=Invoke-Controller status -Json}
+ while(-not $after.supervisor.running -and [DateTime]::UtcNow -lt $deadline)
+ if(-not $after.supervisor.running){throw 'R193 Limited supervisor task did not become RUNNING'}
+ $supervisor=Get-Content -Raw -LiteralPath (Join-Path $runtime 'supervisor.instance.json')|ConvertFrom-Json
+ $tokens=@{
+  bridge=(Token ([int]$after.bridge.pid));core=(Token ([int]$after.core.pid));
+  cloud=(Token ([int]$after.cloud.pid));supervisor=(Token ([int]$supervisor.pid))
+ }
+ foreach($name in @('bridge','core','cloud','supervisor')){
+  $t=$tokens[$name]
+  if($t.elevated -or $t.admin_enabled -or [int]$t.integrity_rid -lt 8192 -or [int]$t.integrity_rid -ge 12288 -or [string]$t.token_type -cne 'primary'){
+   throw "R193 $name did not migrate to a Limited primary token"
+  }
+ }
+ foreach($plane in @('process','coding','host')){
+  if((AuthorityFingerprint $before $plane) -cne (AuthorityFingerprint $after $plane)){
+   throw "R193 migration changed $plane authority"
+  }
+ }
+ if($after.authority.autonomous.armed){throw 'R193 migration unexpectedly armed Autonomous'}
+ if($after.authority.desktop.armed -or [string]$after.authority.desktop.reason -cne 'disarmed'){
+  throw 'R193 migration expected supported stop to leave Desktop DISARMED'
+ }
+ [ordered]@{schema='deadbyte.r193-limited-migration-result.v1';state='MIGRATED_LIMITED';
+  active_release=[string]$pointer.release_id;desktop_reapproval_required=$true;
+  process_preserved=$true;coding_preserved=$true;host_preserved=$true;
+  autonomous_armed=$false;tokens=$tokens}|ConvertTo-Json -Depth 8 -Compress
+}catch{
+ if($stopped){
+  try{Invoke-Controller start|Out-Null;Invoke-Controller supervisorstart|Out-Null}catch{}
+ }
+ throw
+}finally{
+ Unregister-ScheduledTask -TaskName $transient -Confirm:$false -ErrorAction SilentlyContinue
+}