deadbyte-mcp 0.15.55 → 0.15.59

package/scripts/bootstrap-uac-migration-r153.ps1

@@ -0,0 +1,232 @@
+param(
+    [Parameter(Mandatory=$true)][ValidateSet('0.15.59')][string]$ExpectedVersion,
+    [Parameter(Mandatory=$true)][string]$StateRoot,
+    [Parameter(Mandatory=$true)][string]$TarballPath,
+    [Parameter(Mandatory=$true)][ValidatePattern('^[0-9a-f]{64}$')][string]$ExpectedTarballSha256,
+    [Parameter(Mandatory=$true)][ValidatePattern('^[0-9a-f]{64}$')][string]$ExpectedManifestSha256,
+    [Parameter(Mandatory=$true)][ValidatePattern('^[0-9a-f]{64}$')][string]$ExpectedBootstrapSha256,
+    [Parameter(Mandatory=$true)][string]$StdoutPath,
+    [Parameter(Mandatory=$true)][string]$StderrPath,
+    [Parameter(Mandatory=$true)][string]$MarkerReceiptPath,
+    [Parameter(Mandatory=$true)][ValidatePattern('^[0-9a-f]{64}$')][string]$MarkerReceiptSha256,
+    [switch]$Bootstrap
+)
+$ErrorActionPreference = 'Stop'
+Set-StrictMode -Version Latest
+
+function Full([string]$Value) { [IO.Path]::GetFullPath($Value).TrimEnd('\') }
+function Require-Absolute([string]$Value,[string]$Label) {
+    if (-not [IO.Path]::IsPathRooted($Value)) { throw "$Label must be absolute" }
+    return [IO.Path]::GetFullPath($Value)
+}
+function Quote([string]$Value) { '"' + $Value.Replace('"','\"') + '"' }
+
+$StateRoot = Require-Absolute $StateRoot 'State root'
+$TarballPath = Require-Absolute $TarballPath 'Exact tarball'
+$StdoutPath = Require-Absolute $StdoutPath 'Stdout evidence'
+$StderrPath = Require-Absolute $StderrPath 'Stderr evidence'
+$MarkerReceiptPath = Require-Absolute $MarkerReceiptPath 'Marker receipt'
+$expectedStateRoot = Join-Path $env:USERPROFILE '.deadbyte-mcp'
+if ((Full $StateRoot) -ine (Full $expectedStateRoot)) { throw 'R153 bootstrap requires the owning user state root' }
+$evidenceDirectory = Join-Path $StateRoot 'evidence\legacy-migration'
+foreach ($file in @($StdoutPath,$StderrPath,$MarkerReceiptPath)) {
+    if ((Full (Split-Path -Parent $file)) -ine (Full $evidenceDirectory)) {
+        throw 'R153 bootstrap evidence path escapes legacy-migration root'
+    }
+}
+$marker = Get-Item -LiteralPath $MarkerReceiptPath -Force
+if ($marker.PSIsContainer -or (($marker.Attributes -band [IO.FileAttributes]::ReparsePoint) -ne 0)) {
+    throw 'R153 bootstrap marker receipt must be a regular file'
+}
+$tarball = Get-Item -LiteralPath $TarballPath -Force
+if ($tarball.PSIsContainer -or (($tarball.Attributes -band [IO.FileAttributes]::ReparsePoint) -ne 0)) {
+    throw 'R153 bootstrap tarball must be a regular file'
+}
+if ((Get-FileHash -LiteralPath $TarballPath -Algorithm SHA256).Hash.ToLowerInvariant() -cne $ExpectedTarballSha256) {
+    throw 'R153 bootstrap exact tarball digest mismatch'
+}
+if ((Get-FileHash -LiteralPath $PSCommandPath -Algorithm SHA256).Hash.ToLowerInvariant() -cne $ExpectedBootstrapSha256) {
+    throw 'R153 bootstrap script differs from the approved tarball manifest'
+}
+if ((Get-FileHash -LiteralPath $MarkerReceiptPath -Algorithm SHA256).Hash.ToLowerInvariant() -cne $MarkerReceiptSha256) {
+    throw 'R153 bootstrap marker receipt digest mismatch'
+}
+if ((Test-Path -LiteralPath $StdoutPath) -or (Test-Path -LiteralPath $StderrPath)) {
+    throw 'R153 bootstrap evidence files must not pre-exist'
+}
+
+$principal = [Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()
+$isAdmin = $principal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
+if (-not $Bootstrap) {
+    $powershell = Join-Path $env:SystemRoot 'System32\WindowsPowerShell\v1.0\powershell.exe'
+    $arguments = @('-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',(Quote $PSCommandPath),
+        '-Bootstrap','-ExpectedVersion',$ExpectedVersion,'-StateRoot',(Quote $StateRoot),
+        '-TarballPath',(Quote $TarballPath),'-ExpectedTarballSha256',$ExpectedTarballSha256,
+        '-ExpectedManifestSha256',$ExpectedManifestSha256,'-ExpectedBootstrapSha256',$ExpectedBootstrapSha256,
+        '-StdoutPath',(Quote $StdoutPath),'-StderrPath',(Quote $StderrPath),
+        '-MarkerReceiptPath',(Quote $MarkerReceiptPath),'-MarkerReceiptSha256',$MarkerReceiptSha256)
+    $child = Start-Process -FilePath $powershell -ArgumentList $arguments -Verb RunAs -Wait -PassThru -WindowStyle Hidden
+    if (Test-Path -LiteralPath $StdoutPath) { [Console]::Out.Write([IO.File]::ReadAllText($StdoutPath)) }
+    if (Test-Path -LiteralPath $StderrPath) { [Console]::Error.Write([IO.File]::ReadAllText($StderrPath)) }
+    exit $child.ExitCode
+}
+if (-not $isAdmin) { throw 'R153 protected bootstrap requires Windows UAC elevation' }
+
+# The elevated bootstrap has one fixed job: independently fetch the exact npm
+# registry artifact, extract it into a fresh protected Program Files directory,
+# verify every manifest byte with PowerShell/.NET (no candidate JavaScript yet),
+# protect the ACL, obtain the R89 trust verdict, then transfer control to the
+# protected sibling helper. It accepts no package name, registry, executable,
+# command, destination, or authority vector.
+$node = Join-Path $env:ProgramFiles 'nodejs\node.exe'
+$systemTar = Join-Path $env:SystemRoot 'System32\tar.exe'
+foreach ($file in @($node,$systemTar)) {
+    $item = Get-Item -LiteralPath $file -Force
+    if ($item.PSIsContainer -or (($item.Attributes -band [IO.FileAttributes]::ReparsePoint) -ne 0)) {
+        throw 'R153 protected bootstrap executable identity invalid'
+    }
+}
+$stageNonce = [Guid]::NewGuid().ToString('N')
+$prefix = Join-Path $env:ProgramFiles ('DEADBYTE-R153-Stage-' + $stageNonce)
+$candidate = Join-Path $prefix 'package'
+if (Test-Path -LiteralPath $prefix) { throw 'R153 fresh protected staging path collision' }
+$existingStages = @(Get-ChildItem -LiteralPath $env:ProgramFiles -Directory -Force -Filter 'DEADBYTE-R153-Stage-*' -ErrorAction Stop)
+if ($existingStages.Count -ge 4) { throw 'R153 protected staging residue limit reached; operator reconciliation required' }
+New-Item -ItemType Directory -Path $prefix -ErrorAction Stop | Out-Null
+$icacls = Join-Path $env:SystemRoot 'System32\icacls.exe'
+& $icacls $prefix '/inheritance:r' '/grant:r' '*S-1-5-32-544:(OI)(CI)(F)' '*S-1-5-18:(OI)(CI)(F)' '/T' '/C' | Out-Null
+if ($LASTEXITCODE -ne 0) { throw 'R153 protected staging initial ACL normalization failed' }
+& $icacls $prefix '/setowner' '*S-1-5-32-544' '/T' '/C' | Out-Null
+if ($LASTEXITCODE -ne 0) { throw 'R153 protected staging initial owner normalization failed' }
+
+$metadataUri = 'https://registry.npmjs.org/deadbyte-mcp/0.15.59'
+$tagsUri = 'https://registry.npmjs.org/-/package/deadbyte-mcp/dist-tags'
+[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
+$metadata = Invoke-RestMethod -UseBasicParsing -Uri $metadataUri -Method Get -TimeoutSec 30
+$tags = Invoke-RestMethod -UseBasicParsing -Uri $tagsUri -Method Get -TimeoutSec 30
+if ([string]$metadata.name -cne 'deadbyte-mcp' -or [string]$metadata.version -cne $ExpectedVersion) {
+    throw 'R153 npm registry package identity mismatch'
+}
+if ([string]$tags.latest -cne $ExpectedVersion) { throw 'R153 npm latest tag mismatch' }
+$registryTarballUri = [Uri]([string]$metadata.dist.tarball)
+if ($registryTarballUri.Scheme -cne 'https' -or $registryTarballUri.Host -cne 'registry.npmjs.org') {
+    throw 'R153 npm registry tarball origin invalid'
+}
+$registryTarball = Join-Path $prefix 'registry.tgz'
+Invoke-WebRequest -UseBasicParsing -Uri $registryTarballUri.AbsoluteUri -OutFile $registryTarball -TimeoutSec 60
+if ((Get-FileHash -LiteralPath $registryTarball -Algorithm SHA256).Hash.ToLowerInvariant() -cne $ExpectedTarballSha256) {
+    throw 'R153 live npm registry tarball SHA-256 mismatch'
+}
+if ((Get-FileHash -LiteralPath $registryTarball -Algorithm SHA1).Hash.ToLowerInvariant() -cne ([string]$metadata.dist.shasum).ToLowerInvariant()) {
+    throw 'R153 live npm registry tarball shasum mismatch'
+}
+$integrity = [string]$metadata.dist.integrity
+if ($integrity -cnotmatch '^sha512-(.+)$') { throw 'R153 npm registry integrity missing or unsupported' }
+$expectedIntegrityBase64 = $integrity.Substring(7)
+$sha512 = [Security.Cryptography.SHA512]::Create()
+try { $sha512Base64 = [Convert]::ToBase64String($sha512.ComputeHash([IO.File]::ReadAllBytes($registryTarball))) }
+finally { $sha512.Dispose() }
+if ($sha512Base64 -cne $expectedIntegrityBase64) { throw 'R153 live npm registry tarball integrity mismatch' }
+
+$members = @(& $systemTar '-tf' $registryTarball)
+if ($LASTEXITCODE -ne 0 -or $members.Count -lt 1) { throw 'R153 exact tarball inventory failed' }
+foreach ($member in $members) {
+    $normalized = ([string]$member).Replace('\','/')
+    if (-not $normalized.StartsWith('package/') -or $normalized.StartsWith('/') -or
+        $normalized.Contains([char]0) -or $normalized.Split('/') -contains '..') {
+        throw 'R153 exact tarball contains unsafe member path'
+    }
+}
+& $systemTar '-xzf' $registryTarball '-C' $prefix
+if ($LASTEXITCODE -ne 0) { throw "R153 exact tarball extraction failed exit=$LASTEXITCODE" }
+$manifestFile = Join-Path $candidate 'MANIFEST.SHA256'
+$packageFile = Join-Path $candidate 'package.json'
+$manifestItem = Get-Item -LiteralPath $manifestFile -Force
+if (-not $manifestItem.PSIsContainer -and (($manifestItem.Attributes -band [IO.FileAttributes]::ReparsePoint) -eq 0)) {
+    if ((Get-FileHash -LiteralPath $manifestFile -Algorithm SHA256).Hash.ToLowerInvariant() -cne $ExpectedManifestSha256) {
+        throw 'R153 staged manifest identity mismatch'
+    }
+} else { throw 'R153 staged manifest must be a regular file' }
+$package = Get-Content -LiteralPath $packageFile -Raw | ConvertFrom-Json
+if ($package.name -cne 'deadbyte-mcp' -or $package.version -cne $ExpectedVersion) {
+    throw 'R153 staged package identity mismatch'
+}
+foreach ($item in Get-ChildItem -LiteralPath $candidate -Recurse -Force) {
+    if (($item.Attributes -band [IO.FileAttributes]::ReparsePoint) -ne 0) { throw 'R153 staged package contains a reparse point' }
+}
+$expected = New-Object 'System.Collections.Generic.HashSet[string]' ([StringComparer]::Ordinal)
+$null = $expected.Add('MANIFEST.SHA256')
+$lineNumber = 0
+foreach ($line in [IO.File]::ReadAllLines($manifestFile)) {
+    $lineNumber++
+    if ($line.Length -eq 0) { continue }
+    if ($line -cnotmatch '^([0-9a-f]{64})  (.+)$') { throw "R153 staged manifest line $lineNumber malformed" }
+    $digest = $Matches[1]; $relative = $Matches[2]
+    if ($relative.Contains('\') -or $relative.StartsWith('/') -or $relative.Contains([char]0) -or $relative.Split('/') -contains '..') {
+        throw 'R153 staged manifest path unsafe'
+    }
+    if (-not $expected.Add($relative)) { throw 'R153 staged manifest duplicate path' }
+    $file = Join-Path $candidate ($relative.Replace('/','\'))
+    $entry = Get-Item -LiteralPath $file -Force
+    if ($entry.PSIsContainer -or (($entry.Attributes -band [IO.FileAttributes]::ReparsePoint) -ne 0)) {
+        throw 'R153 staged manifest entry is not a regular file'
+    }
+    if ((Get-FileHash -LiteralPath $file -Algorithm SHA256).Hash.ToLowerInvariant() -cne $digest) {
+        throw "R153 staged manifest byte mismatch: $relative"
+    }
+}
+$actual = Get-ChildItem -LiteralPath $candidate -Recurse -Force -File | ForEach-Object {
+    $_.FullName.Substring($candidate.Length + 1).Replace('\','/')
+}
+foreach ($relative in $actual) { if (-not $expected.Contains($relative)) { throw "R153 staged package unexpected file: $relative" } }
+if ($actual.Count -ne $expected.Count) { throw 'R153 staged package file-count mismatch' }
+& $icacls $prefix '/inheritance:r' '/grant:r' '*S-1-5-32-544:(OI)(CI)(F)' '*S-1-5-18:(OI)(CI)(F)' '/T' '/C' | Out-Null
+if ($LASTEXITCODE -ne 0) { throw 'R153 protected staging final ACL normalization failed' }
+& $icacls $prefix '/setowner' '*S-1-5-32-544' '/T' '/C' | Out-Null
+if ($LASTEXITCODE -ne 0) { throw 'R153 protected staging final owner normalization failed' }
+# /inheritance:r with /T strips inherited Allow ACEs from leaf files.
+# The directory OI/CI grant above does not become a direct leaf ACE on Windows.
+# Restore direct access for Administrators and SYSTEM on every existing member;
+# never grant Users/Everyone, and independently re-hash all package files below.
+& $icacls $prefix '/grant' '*S-1-5-32-544:(F)' '*S-1-5-18:(F)' '/T' '/C' | Out-Null
+if ($LASTEXITCODE -ne 0) { throw 'R153 protected staging leaf ACL restoration failed' }
+
+# Re-read every manifest-bound byte after ACL normalization. The first
+# candidate JavaScript below cannot run against bytes changed in the ACL gap.
+foreach ($line in [IO.File]::ReadAllLines($manifestFile)) {
+    if ($line.Length -eq 0) { continue }
+    if ($line -cnotmatch '^([0-9a-f]{64})  (.+)$') { throw 'R153 staged manifest changed after ACL normalization' }
+    $digest = $Matches[1]; $relative = $Matches[2]
+    $file = Join-Path $candidate ($relative.Replace('/','\'))
+    $entry = Get-Item -LiteralPath $file -Force
+    if ($entry.PSIsContainer -or (($entry.Attributes -band [IO.FileAttributes]::ReparsePoint) -ne 0) -or
+        (Get-FileHash -LiteralPath $file -Algorithm SHA256).Hash.ToLowerInvariant() -cne $digest) {
+        throw "R153 staged package post-ACL verification failed: $relative"
+    }
+}
+
+foreach ($name in @('NODE_OPTIONS','NODE_PATH','NODE_REPL_EXTERNAL_MODULE','NPM_CONFIG_USERCONFIG','npm_config_userconfig')) {
+    Remove-Item -LiteralPath ('Env:' + $name) -ErrorAction SilentlyContinue
+}
+$env:DEADBYTE_STATE_ROOT = $StateRoot
+
+$helper = Join-Path $candidate 'scripts\request-uac-migration-r153.ps1'
+$deploy = Join-Path $candidate 'scripts\deploy-r48.mjs'
+$trustVerifier = Join-Path $candidate 'scripts\verify-protected-stage-r153.mjs'
+$trustOutput = & $node $trustVerifier
+if ($LASTEXITCODE -ne 0) { throw 'R153 protected stage R89 trust verification failed' }
+$trust = ($trustOutput -join "`n") | ConvertFrom-Json
+if ($trust.trusted -ne $true) { throw 'R153 protected stage R89 verdict not trusted' }
+$preflightOutput = & $node $deploy '--preflight'
+if ($LASTEXITCODE -ne 0) { throw 'R153 protected activation preflight failed' }
+$preflight = ($preflightOutput -join "`n") | ConvertFrom-Json
+if ($preflight.state -ne 'AUTHORITY_UNVERIFIED' -or $preflight.subject_sha256 -notmatch '^[0-9a-f]{64}$') {
+    throw "R153 protected migration not applicable: $($preflight.state)"
+}
+& $helper -Elevated -NodePath $node -DeployScript $deploy -StateRoot $StateRoot `
+    -StdoutPath $StdoutPath -StderrPath $StderrPath -MarkerReceiptPath $MarkerReceiptPath `
+    -MarkerReceiptSha256 $MarkerReceiptSha256 -PreflightSubjectSha256 $preflight.subject_sha256
+$helperExit = $LASTEXITCODE
+try { Remove-Item -LiteralPath $prefix -Recurse -Force -ErrorAction Stop }
+catch { [Console]::Error.WriteLine('R153_STAGE_CLEANUP_WARNING: protected stage retained for operator reconciliation') }
+exit $helperExit

package/scripts/deploy-r48.mjs

@@ -12,6 +12,9 @@ import {createEpochNativeContinuityEngine} from '../src/activation-continuity-en
 import {createActivationClaimManager} from '../src/activation-lock-r65.mjs';
 import {observeAuthorityEvidence} from '../src/activation-authority-proof-r75.mjs';
 import {proveLegacyOfflineScopeRepair} from '../src/legacy-offline-policy-proof-r146.mjs';
+import {claimWithOneTimeMigration,verifyNarrowedPolicyGeneration} from '../src/clean-activation-recovery-r153.mjs';
+import {verifyUacApproval,uacPointerSha256,protectedUacReceiptPath,requireTrustedUacInstallation} from '../src/uac-approval-contract-r153.mjs';
+import {inspectTrustedInstallation} from '../src/privileged-install-trust-r89.mjs';
 
 const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
 const state=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
@@ -19,10 +22,35 @@ const sha=async f=>createHash('sha256').update(await readFile(f)).digest('hex');
 const sleep=ms=>new Promise(resolve=>setTimeout(resolve,ms));
 
 function parseDeployArgs(argv){
-  const out={preflight:false,approvalPath:null,approvalSha256:null};
+  const out={preflight:false,approvalPath:null,approvalSha256:null,uacLegacyMigration:false,
+    markerReceiptPath:null,markerReceiptSha256:null,migrationNonce:null,migrationIssuedAt:null,
+    migrationExpiresAt:null,uacApprovalPath:null,uacApprovalSha256:null};
   for(let index=0;index<argv.length;index++){
     const arg=argv[index];
     if(arg==='--preflight'){if(out.preflight)throw new Error('duplicate --preflight');out.preflight=true;continue;}
+    if(arg==='--uac-legacy-migration'){if(out.uacLegacyMigration)throw new Error('duplicate --uac-legacy-migration');out.uacLegacyMigration=true;continue;}
+    if(arg==='--marker-reconciliation-receipt'){
+      if(out.markerReceiptPath)throw new Error('duplicate --marker-reconciliation-receipt');
+      const value=argv[++index];if(!value)throw new Error('--marker-reconciliation-receipt requires a path');
+      out.markerReceiptPath=path.resolve(value);continue;
+    }
+    if(arg==='--marker-reconciliation-receipt-sha256'){
+      if(out.markerReceiptSha256)throw new Error('duplicate --marker-reconciliation-receipt-sha256');
+      const value=String(argv[++index]??'').toLowerCase();if(!/^[0-9a-f]{64}$/.test(value))throw new Error('--marker-reconciliation-receipt-sha256 requires lowercase SHA-256');
+      out.markerReceiptSha256=value;continue;
+    }
+    if(arg==='--migration-nonce'){
+      const value=String(argv[++index]??'').toLowerCase();if(!/^[0-9a-f]{64}$/.test(value))throw new Error('--migration-nonce requires lowercase 32-byte hex');
+      out.migrationNonce=value;continue;
+    }
+    if(arg==='--migration-issued-at'){out.migrationIssuedAt=String(argv[++index]??'');continue;}
+    if(arg==='--migration-expires-at'){out.migrationExpiresAt=String(argv[++index]??'');continue;}
+    if(arg==='--uac-approval-receipt'){
+      const value=argv[++index];if(!value)throw new Error('--uac-approval-receipt requires a path');out.uacApprovalPath=path.resolve(value);continue;
+    }
+    if(arg==='--uac-approval-receipt-sha256'){
+      const value=String(argv[++index]??'').toLowerCase();if(!/^[0-9a-f]{64}$/.test(value))throw new Error('--uac-approval-receipt-sha256 requires lowercase SHA-256');out.uacApprovalSha256=value;continue;
+    }
     if(arg==='--policy-migration-approval'){
       if(out.approvalPath)throw new Error('duplicate --policy-migration-approval');
       const value=argv[++index];if(!value)throw new Error('--policy-migration-approval requires a path');
@@ -36,6 +64,12 @@ function parseDeployArgs(argv){
     throw new Error(`unknown deploy argument '${arg}'`);
   }
   if(Boolean(out.approvalPath)!==Boolean(out.approvalSha256))throw new Error('policy migration approval path and SHA-256 are required together');
+  if(out.uacLegacyMigration&&out.approvalPath)throw new Error('UAC and owner-signed migration authorization are mutually exclusive');
+  if(Boolean(out.markerReceiptPath)!==Boolean(out.markerReceiptSha256))throw new Error('marker receipt path and SHA-256 are required together');
+  if(out.uacLegacyMigration!==Boolean(out.markerReceiptPath))throw new Error('UAC migration requires a marker reconciliation receipt');
+  const uacFields=[out.migrationNonce,out.migrationIssuedAt,out.migrationExpiresAt,out.uacApprovalPath,out.uacApprovalSha256];
+  if(out.uacLegacyMigration&&uacFields.some(value=>!value))throw new Error('UAC migration requires nonce, lifetime, and approval receipt');
+  if(!out.uacLegacyMigration&&uacFields.some(value=>value))throw new Error('UAC migration arguments require --uac-legacy-migration');
   return out;
 }
 const deployArgs=parseDeployArgs(process.argv.slice(2));
@@ -49,10 +83,19 @@ async function writeExclusive(file,value){
 const activationClaimManager=createActivationClaimManager({stateRoot:state});
 let activationClaimOperationId=null;
 
+let pendingUacConsumption=null;
 async function claimActivation(subjectSha256){
-  const claim=await activationClaimManager.claim(subjectSha256);
-  activationClaimOperationId=claim.operation_id;
-  return claim.release;
+  const held=await claimWithOneTimeMigration({
+    claim:value=>activationClaimManager.claim(value),subjectSha256,
+    consume:pendingUacConsumption?async()=>{
+      const oneTime=pendingUacConsumption;
+      await mkdir(oneTime.consumeDir,{recursive:true});
+      await writeExclusive(path.join(oneTime.consumeDir,`${oneTime.nonce}.json`),oneTime.receipt);
+      pendingUacConsumption=null;
+    }:null
+  });
+  activationClaimOperationId=held.operation_id;
+  return held.release;
 }
 
 async function activePolicyPaths(){
@@ -95,13 +138,26 @@ function controllerCommand(command){
   if(run.error||run.status!==0)throw new Error(`activation controller ${command} failed exit=${run.status} code=${run.error?.code??'none'}`);
 }
 
-function legacyOfflineRecovery(approvalPath,approvalSha256){
-  if(!approvalPath)return null;
+function isElevatedWindowsProcess(){
+  if(process.platform!=='win32')return false;
+  const powershell=path.join(process.env.SystemRoot||'C:\\Windows','System32','WindowsPowerShell','v1.0','powershell.exe');
+  const command="([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)";
+  const run=spawnSync(powershell,['-NoLogo','-NoProfile','-NonInteractive','-EncodedCommand',Buffer.from(command,'utf16le').toString('base64')],{
+    encoding:'utf8',windowsHide:true,shell:false,timeout:15000,env:windowsPowerShellEnvironment()});
+  return !run.error&&run.status===0&&/^true$/i.test(String(run.stdout).trim());
+}
+
+function legacyOfflineRecovery(approvalPath,approvalSha256,{uacLegacyMigration=false,tarballSha256=null,markerReceipt=null,
+  nonce=null,issuedAt=null,expiresAt=null}={}){
+  if(!approvalPath&&!uacLegacyMigration)return null;
+  const uacAuthorization=uacLegacyMigration?{
+    isElevated:isElevatedWindowsProcess(),nonce,issuedAt,expiresAt,tarballSha256,markerReceipt
+  }:null;
   return async({observation,preflight_subject_sha256,pointer,expectedParent,candidate,expectedCandidate})=>
     proveLegacyOfflineScopeRepair({stateRoot:state,pointer,expectedParent,candidate,expectedCandidate,
       preflightSubjectSha256:preflight_subject_sha256,observation,policyPaths:observation.policy_paths,
       policySha256:observation.policy_sha256,approvalPath,approvalSha256,
-      ownerPublicKeyPath:path.join(state,'trust','r70-owner-public.pem')});
+      ownerPublicKeyPath:path.join(state,'trust','r70-owner-public.pem'),uacAuthorization});
 }
 
 async function activationPreflight(manifest,pkg,pointer,recovery){
@@ -116,9 +172,11 @@ async function activationPreflight(manifest,pkg,pointer,recovery){
       const proof=await recovery({phase:'preflight',observation:observed,preflight_subject_sha256:result.subject_sha256,
         pointer,expectedParent:release.parent,candidate:{version:pkg.version,manifest_sha256:manifest},
         expectedCandidate:{version:release.version,manifest_sha256:manifest}});
-      if(proof?.state==='VERIFIED_OFFLINE_LEGACY_SCOPE_REPAIR'&&proof.owner_approval_verified===true)
+      if(proof?.state==='VERIFIED_OFFLINE_LEGACY_SCOPE_REPAIR'&&proof.migration_authorization_verified===true)
         return {...result,state:'LEGACY_SCOPE_REPAIR_READY',safe_to_activate:true,authority_continuity:'LEGACY_SCOPE_REPAIRED_DISARMED',
-          legacy_scope_proof_sha256:proof.subject_sha256,owner_approval_subject_sha256:proof.owner_approval_subject_sha256,reauth_planes:[]};
+          legacy_scope_proof_sha256:proof.subject_sha256,
+          migration_authorization:proof.migration_authorization,
+          migration_authorization_subject_sha256:proof.migration_authorization_subject_sha256,reauth_planes:[]};
     }catch(error){
       return {...result,state:'LEGACY_SCOPE_REPAIR_UNVERIFIED',safe_to_activate:false,
         reason:String(error?.message??error).slice(0,256),authority_continuity:'UNVERIFIED',reauth_planes:[]};
@@ -178,14 +236,69 @@ async function waitForActivation({handoffPath,expectedVersion,expectedManifest,t
 }
 
 const manifest=await sha(path.join(root,'MANIFEST.SHA256'));
-const pointer=JSON.parse(await readFile(path.join(state,'active-release.json'),'utf8'));
+const pointer=parseActivePointer(await readFile(path.join(state,'active-release.json'),'utf8'));
 const bridgeRoot=path.join(root,'bridge');
 const bridgeScript=path.join(bridgeRoot,'src','bridge.mjs');
 const pkg=JSON.parse(await readFile(path.join(root,'package.json'),'utf8'));
 const expectedVersion=pkg.version;
 const release=JSON.parse(await readFile(path.join(root,'RELEASE.json'),'utf8'));
-const recovery=legacyOfflineRecovery(deployArgs.approvalPath,deployArgs.approvalSha256);
+let localTarballSha256=null;
+let markerReceipt=null;
+let pendingUacApproval=null;
+if(deployArgs.uacLegacyMigration){
+  const localTarball=path.join(state,'evidence','npm-publication',pkg.version,`deadbyte-mcp-${pkg.version}.tgz`);
+  localTarballSha256=await sha(localTarball);
+  const expectedReceiptRoot=path.resolve(state,'evidence','legacy-migration');
+  if(path.resolve(path.dirname(deployArgs.markerReceiptPath)).toLowerCase()!==expectedReceiptRoot.toLowerCase())
+    throw new Error('marker reconciliation receipt outside state evidence root');
+  const receiptInfo=await lstat(deployArgs.markerReceiptPath);
+  if(!receiptInfo.isFile()||receiptInfo.isSymbolicLink())throw new Error('marker reconciliation receipt must be a regular file');
+  const receiptBytes=await readFile(deployArgs.markerReceiptPath);
+  if(createHash('sha256').update(receiptBytes).digest('hex')!==deployArgs.markerReceiptSha256)
+    throw new Error('marker reconciliation receipt hash mismatch');
+  markerReceipt=JSON.parse(receiptBytes.toString('utf8').replace(/^\uFEFF/,''));
+  const expectedApprovalPath=protectedUacReceiptPath(root,deployArgs.migrationNonce);
+  if(path.resolve(deployArgs.uacApprovalPath).toLowerCase()!==path.resolve(expectedApprovalPath).toLowerCase())
+    throw new Error('UAC approval receipt path not exact candidate sidecar');
+  requireTrustedUacInstallation(await inspectTrustedInstallation([expectedApprovalPath]));
+  const approvalInfo=await lstat(deployArgs.uacApprovalPath);
+  if(!approvalInfo.isFile()||approvalInfo.isSymbolicLink())throw new Error('UAC approval receipt must be a regular file');
+  const approvalBytes=await readFile(deployArgs.uacApprovalPath);
+  if(createHash('sha256').update(approvalBytes).digest('hex')!==deployArgs.uacApprovalSha256)
+    throw new Error('UAC approval receipt hash mismatch');
+  const approval=JSON.parse(approvalBytes.toString('utf8').replace(/^\uFEFF/,''));
+  // The full UAC subject is checked AFTER live preflight, since its hash
+  // binds the actual predecessor policies and observed preflight identity.
+  if(approval?.schema!=='deadbyte.r153-uac-approval.v1'||
+    approval.nonce!==deployArgs.migrationNonce||
+    approval.issued_at_utc!==deployArgs.migrationIssuedAt||
+    approval.expires_at_utc!==deployArgs.migrationExpiresAt)
+    throw new Error('UAC approval receipt command-line binding mismatch');
+  pendingUacApproval=approval;
+  pendingUacConsumption={consumeDir:path.join(state,'evidence','legacy-migration','consumed'),
+    nonce:deployArgs.migrationNonce,
+    receipt:{schema:'deadbyte.r153-uac-consumption.v1',nonce:deployArgs.migrationNonce,
+      approval_sha256:deployArgs.uacApprovalSha256,marker_receipt_sha256:deployArgs.markerReceiptSha256,
+      candidate_manifest_sha256:manifest,created_at_utc:new Date().toISOString()}};
+}
+const recovery=legacyOfflineRecovery(deployArgs.approvalPath,deployArgs.approvalSha256,
+  {uacLegacyMigration:deployArgs.uacLegacyMigration,tarballSha256:localTarballSha256,markerReceipt,
+    nonce:deployArgs.migrationNonce,issuedAt:deployArgs.migrationIssuedAt,expiresAt:deployArgs.migrationExpiresAt});
 const preflight=await activationPreflight(manifest,pkg,pointer,recovery);
+if(deployArgs.uacLegacyMigration){
+  verifyUacApproval(pendingUacApproval,{
+    stateRoot:state,candidateRoot:root,candidateVersion:pkg.version,
+    candidateManifestSha256:manifest,tarballSha256:localTarballSha256,
+    markerReceiptSha256:deployArgs.markerReceiptSha256,
+    predecessorPointerSha256:uacPointerSha256(pointer),
+    predecessorPolicySha256:markerReceipt.predecessor_policy_sha256,
+    preflightSubjectSha256:preflight.subject_sha256,nodeSha256:await sha(process.execPath),
+    deployScriptSha256:await sha(fileURLToPath(import.meta.url)),
+    nonce:deployArgs.migrationNonce,issuedAt:deployArgs.migrationIssuedAt,
+    expiresAt:deployArgs.migrationExpiresAt
+  });
+}
+
 if(deployArgs.preflight){
   console.log(JSON.stringify(preflight));
   process.exit(0);
@@ -229,6 +342,15 @@ const outcome=await orchestrateActivation({pointer,expectedParent:release.parent
     result=await runSlotUpdateCli(args,{stateRoot:state});
     if(!result.handed_off)throw new Error('release activation unexpectedly completed inline');
     verification=await waitForActivation({handoffPath:result.handoff_path,expectedVersion,expectedManifest:manifest});
+    if(deployArgs.uacLegacyMigration){
+      const active=parseActivePointer(await readFile(path.join(state,'active-release.json'),'utf8'));
+      if(active.version!==expectedVersion||active.manifest_sha256!==manifest)
+        throw new Error('UAC migration active pointer drift after activation');
+      const codingBytes=await readFile(path.join(active.generation_root,'coding-policy.json'));
+      const autonomousBytes=await readFile(path.join(active.generation_root,'autonomous-policy.json'));
+      verifyNarrowedPolicyGeneration({codingPolicy:JSON.parse(codingBytes.toString('utf8').replace(/^\uFEFF/,'')),codingPolicyBytes:codingBytes,
+        autonomousPolicy:JSON.parse(autonomousBytes.toString('utf8').replace(/^\uFEFF/,''))});
+    }
     return {verified:true,release_id:verification.release_id};
   }});
 if(outcome.state!=='ACTIVATED'){

package/scripts/issue-uac-migration-r153.mjs

@@ -0,0 +1,107 @@
+// Issue a bounded no-grant UAC receipt only from a protected installed candidate.
+// Never activate, change ACLs, remove markers, issue grants or publish artifacts.
+import {createHash,randomBytes} from 'node:crypto';
+import {readFile,lstat,open,access} from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {spawnSync} from 'node:child_process';
+import {parseActivePointer} from '../src/release-slot.mjs';
+import {inspectTrustedInstallation,privilegedEpochInstallFiles} from '../src/privileged-install-trust-r89.mjs';
+import {verifyMarkerReconciliationReceipt} from '../src/clean-activation-recovery-r153.mjs';
+import {createUacApproval,uacPointerSha256,protectedUacReceiptPath} from '../src/uac-approval-contract-r153.mjs';
+
+const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const read=async f=>readFile(f);
+const hash=async f=>sha(await read(f));
+const fail=text=>{throw new Error('R153 UAC issuer rejected: '+text);};
+function args(argv){
+  const expected=['--state-root','--marker-receipt','--marker-receipt-sha256','--preflight-subject-sha256'];
+  if(argv.length!==8||expected.some((key,i)=>argv[2*i]!==key))fail('unexpected arguments');
+  const [state,receipt,receiptHash,preflight]=[argv[1],argv[3],argv[5],argv[7]];
+  if(!path.win32.isAbsolute(state)||!path.win32.isAbsolute(receipt)||
+     !/^[0-9a-f]{64}$/.test(receiptHash)||!/^[0-9a-f]{64}$/.test(preflight))fail('subject arguments invalid');
+  return {state:path.resolve(state),receipt:path.resolve(receipt),receiptHash,preflight};
+}
+async function regular(file,label){const s=await lstat(file);if(!s.isFile()||s.isSymbolicLink())fail(label+' must be regular');return s;}
+async function absent(file,label){try{await lstat(file);fail(label+' present');}catch(e){if(e?.code!=='ENOENT')throw e;}}
+async function main(){
+  if(process.platform!=='win32'||process.arch!=='x64')fail('Windows x64 required');
+  const ps='C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe';
+  const check="([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)";
+  const elevated=spawnSync(ps,['-NoLogo','-NoProfile','-NonInteractive','-EncodedCommand',Buffer.from(check,'utf16le').toString('base64')],
+    {encoding:'utf8',shell:false,windowsHide:true,timeout:12000});
+  if(elevated.error||elevated.status!==0||String(elevated.stdout).trim().toLowerCase()!=='true')
+    fail('explicit Windows UAC elevation required');
+  const {state,receipt,receiptHash,preflight}=args(process.argv.slice(2));
+  if(path.dirname(receipt).toLowerCase()!==path.join(state,'evidence','legacy-migration').toLowerCase())
+    fail('marker receipt path not in state evidence root');
+  const issueFile=fileURLToPath(import.meta.url);
+  const deployFile=path.join(root,'scripts','deploy-r48.mjs');
+  const helperFile=path.join(root,'scripts','request-uac-migration-r153.ps1');
+  const trust=await inspectTrustedInstallation([...privilegedEpochInstallFiles(root,process.execPath),
+    issueFile,deployFile,helperFile,path.join(root,'package.json'),path.join(root,'MANIFEST.SHA256'),path.join(root,'RELEASE.json'),path.join(root,'src','uac-approval-contract-r153.mjs'),
+    path.join(root,'src','clean-activation-recovery-r153.mjs'),path.join(root,'src','legacy-offline-policy-proof-r146.mjs')]);
+  if(trust.trusted!==true)fail('candidate not R89 protected');
+  const pkg=JSON.parse((await read(path.join(root,'package.json'))).toString('utf8'));
+  const rel=JSON.parse((await read(path.join(root,'RELEASE.json'))).toString('utf8'));
+  if(pkg.version!=='0.15.59'||rel.version!==pkg.version)fail('candidate release identity mismatch');
+  const pointer=parseActivePointer((await read(path.join(state,'active-release.json'))).toString('utf8'));
+  if(pointer.version!=='0.15.45'||rel.parent?.release_id!==pointer.release_id||
+    rel.parent?.manifest_sha256!==pointer.manifest_sha256||
+    rel.parent?.generation_manifest_sha256!==pointer.generation_manifest_sha256)
+    fail('predecessor pointer drift');
+  const manifest=await hash(path.join(root,'MANIFEST.SHA256'));
+  const verifyManifest=spawnSync(process.execPath,[path.join(root,'scripts','release-manifest.mjs'),'verify-installed'],
+    {cwd:root,encoding:'utf8',shell:false,windowsHide:true,timeout:30000});
+  if(verifyManifest.error||verifyManifest.status!==0)fail('candidate manifest verification failed');
+  await regular(receipt,'marker receipt');
+  const receiptBytes=await read(receipt);
+  if(sha(receiptBytes)!==receiptHash)fail('marker receipt digest mismatch');
+  const marker=JSON.parse(receiptBytes.toString('utf8').replace(/^\uFEFF/,''));
+  const policies=marker.predecessor_policy_sha256;
+  verifyMarkerReconciliationReceipt(marker,{pointer,policySha256:policies,markerSha256:marker.marker_sha256});
+  await absent(path.join(state,'runtime','remote-session.json'),'foreground owner marker');
+  const grantField={process:'grant_file',coding:'lease_file',autonomous:'lease_file',desktop:'grant_file',host:'arm_file'};
+  for(const plane of Object.keys(grantField)){
+    const filename=path.join(pointer.generation_root,`${plane}-policy.json`);
+    await regular(filename,plane+' policy');
+    const bytes=await read(filename);
+    if(sha(bytes)!==policies?.[plane])fail(plane+' policy drift');
+    const policy=JSON.parse(bytes.toString('utf8').replace(/^\uFEFF/,''));
+    const grant=policy[grantField[plane]];
+    if(typeof grant!=='string'||!path.isAbsolute(grant)||
+       path.dirname(grant).toLowerCase()!==path.join(state,'runtime').toLowerCase())fail(plane+' grant path invalid');
+    await absent(grant,plane+' grant');
+    await absent(path.join(state,'runtime','authority-epochs',plane,'.lock'),plane+' authority lock');
+  }
+  const tarball=path.join(state,'evidence','npm-publication',pkg.version,`deadbyte-mcp-${pkg.version}.tgz`);
+  await regular(tarball,'exact publication tarball');
+  const bytes=await read(tarball);
+  const issuedAt=new Date().toISOString(),expiresAt=new Date(Date.now()+300_000).toISOString();
+  const nonce=randomBytes(32).toString('hex');
+  const approval=createUacApproval({stateRoot:state,candidateRoot:root,candidateVersion:pkg.version,
+    candidateManifestSha256:manifest,tarballSha256:sha(bytes),markerReceiptSha256:receiptHash,
+    predecessorPointerSha256:uacPointerSha256(pointer),
+    predecessorPolicySha256:policies,preflightSubjectSha256:preflight,
+    nodeSha256:await hash(process.execPath),deployScriptSha256:await hash(deployFile),
+    nonce,issuedAt,expiresAt});
+  // The strict installation manifest disallows unmanifested files. A receipt
+  // under root would turn an otherwise valid candidate into an invalid tree.
+  const file=protectedUacReceiptPath(root,nonce);
+  const h=await open(file,'wx',0o600);
+  try{await h.writeFile(JSON.stringify(approval)+'\n','utf8');await h.sync();}finally{await h.close();}
+  // Newly created files can be owned by the interactive administrator's SID.
+  // Normalize the exact sidecar to the built-in Administrators owner and
+  // independently require the R89 ACL verdict. No arbitrary path argument.
+  const ownerFix=spawnSync('C:\\Windows\\System32\\icacls.exe',
+    [file,'/setowner','*S-1-5-32-544'],
+    {encoding:'utf8',shell:false,windowsHide:true,timeout:15000});
+  if(ownerFix.error||ownerFix.status!==0)fail('protected approval owner normalization failed');
+  const receiptTrust=await inspectTrustedInstallation([file]);
+  if(receiptTrust.trusted!==true)fail('approval sidecar not R89 protected');
+  process.stdout.write(JSON.stringify({schema:'deadbyte.r153-uac-issuer-result.v1',
+    receipt_path:file,receipt_sha256:await hash(file),nonce,issued_at_utc:issuedAt,
+    expires_at_utc:expiresAt})+'\n');
+}
+main().catch(error=>{process.stderr.write(String(error?.message||error)+'\n');process.exitCode=2;});

package/scripts/r153-prepublish-identity.mjs

@@ -0,0 +1,57 @@
+// R153 additive release-lineage gate. Read-only: no manifests rewritten, no publish/activation.
+import {readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+const defaultRoot=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+const hex64=/^[0-9a-f]{64}$/;
+const EXPECTED=Object.freeze({
+  candidateVersion:'0.15.59', train:'R153',
+  sourceVersion:'0.15.58',
+  sourceSha256:'4bc53cfa6b3890b5749066cb507e8773b36d6c255192a8973dadb8546a39822e',
+  runtimeVersion:'0.15.45',
+  runtimeReleaseId:'v0.15.45-34aa8d1241cfb8bf',
+  runtimeManifest:'34aa8d1241cfb8bf0b5ba303bf3c06e0e9e1bf01f64457bca659d6dd4d634fdc',
+  runtimeGeneration:'ff2b73410062688651abd7bc2dd7b2b8c87810a28e3808bfe1f4352a25b0e6e4'
+});
+const keys=['version','release_id','manifest_sha256','generation_manifest_sha256'];
+const same=(a,b)=>keys.every(k=>a?.[k]===b?.[k]);
+function requireEqual(actual,expected,label){
+  if(actual!==expected)throw new Error(`R153 identity ${label} mismatch: ${JSON.stringify(actual)}`);
+}
+export function verifyR153Lineage({pkg,release,bridge}){
+  if(pkg?.name!=='deadbyte-mcp'||release?.name!=='deadbyte-mcp')throw new Error('R153 package name mismatch');
+  requireEqual(pkg.version,EXPECTED.candidateVersion,'package version');
+  requireEqual(release.version,EXPECTED.candidateVersion,'release version');
+  requireEqual(release.train,EXPECTED.train,'train');
+  requireEqual(release.schema,'deadbyte.release.v1','release schema');
+  requireEqual(bridge?.name,'deadbyte-chatgpt-bridge','bridge name');
+  requireEqual(bridge.version,pkg.version,'bridge version');
+  requireEqual(release.source_predecessor?.version,EXPECTED.sourceVersion,'source predecessor version');
+  requireEqual(release.source_predecessor?.tarball_sha256,EXPECTED.sourceSha256,'source predecessor tarball');
+  requireEqual(release.source_predecessor?.release_status,'REGISTRY_PUBLISHED','source predecessor registry status');
+  const predecessor=release.runtime_predecessor;
+  requireEqual(predecessor?.version,EXPECTED.runtimeVersion,'runtime predecessor version');
+  requireEqual(predecessor?.release_id,EXPECTED.runtimeReleaseId,'runtime release ID');
+  requireEqual(predecessor?.manifest_sha256,EXPECTED.runtimeManifest,'runtime manifest SHA-256');
+  requireEqual(predecessor?.generation_manifest_sha256,EXPECTED.runtimeGeneration,'runtime generation SHA-256');
+  if(!same(release.parent,predecessor))throw new Error('R153 parent is not exact runtime predecessor');
+  if(release.source_predecessor.version===predecessor.version)throw new Error('R153 predecessor roles collapsed');
+  for(const key of ['tarball_sha256','tarball_integrity','npm_integrity'])
+    if(Object.hasOwn(release,key))throw new Error(`R153 release contains self-referential ${key}`);
+  for(const key of ['manifest_sha256','generation_manifest_sha256'])
+    if(!hex64.test(predecessor[key]))throw new Error(`R153 ${key} malformed`);
+  return Object.freeze({schema:'deadbyte.r153-release-lineage-gate.v1',status:'PASS',
+    candidate_version:pkg.version,source_predecessor:EXPECTED.sourceVersion,
+    source_tarball_sha256:EXPECTED.sourceSha256,runtime_predecessor:EXPECTED.runtimeVersion,
+    runtime_release_id:EXPECTED.runtimeReleaseId,scope:'METADATA_ONLY'});
+}
+export async function verifyR153IdentityTree(root=defaultRoot){
+  const regularJSON=async rel=>JSON.parse(await readFile(path.join(root,rel),'utf8'));
+  return verifyR153Lineage({pkg:await regularJSON('package.json'),
+    release:await regularJSON('RELEASE.json'),bridge:await regularJSON('bridge/package.json')});
+}
+if(process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url)){
+  try{console.log(JSON.stringify(await verifyR153IdentityTree(),null,2));}
+  catch(e){console.error('R153_LINEAGE_FAIL '+String(e?.message??e));process.exitCode=1;}
+}