deadbyte-mcp 0.15.1 → 0.15.2

package/controller/deadbyte-controller.ps1

@@ -16,6 +16,40 @@ $LogDir = Join-Path $RuntimeDir 'logs'
 $ConfigPath = if ($env:DEADBYTE_CONTROLLER_CONFIG) { $env:DEADBYTE_CONTROLLER_CONFIG } else { Join-Path $Root 'deadbyte-controller.config.psd1' }
 
 function Fail([string]$Message) { throw "DEADBYTE controller: $Message" }
+
+function Get-ControllerMutationMutexName {
+    $normalized = ([System.IO.Path]::GetFullPath($RuntimeDir)).TrimEnd('\\').ToLowerInvariant()
+    $sha = [System.Security.Cryptography.SHA256]::Create()
+    try {
+        $bytes = [System.Text.Encoding]::UTF8.GetBytes($normalized)
+        $digest = $sha.ComputeHash($bytes)
+    } finally {
+        $sha.Dispose()
+    }
+    $hex = ([System.BitConverter]::ToString($digest)).Replace('-', '').ToLowerInvariant().Substring(0, 24)
+    return "Local\DEADBYTE-MCP-Controller-$hex"
+}
+
+function Invoke-WithControllerMutationLock([string]$Name, [scriptblock]$Body) {
+    $mutexName = Get-ControllerMutationMutexName
+    $mutex = New-Object System.Threading.Mutex($false, $mutexName)
+    $held = $false
+    try {
+        try {
+            $held = $mutex.WaitOne([TimeSpan]::FromSeconds(180))
+        } catch [System.Threading.AbandonedMutexException] {
+            $held = $true
+        }
+        if (-not $held) { Fail "controller mutation lock timeout for '$Name'" }
+        & $Body
+    } finally {
+        if ($held) {
+            try { $mutex.ReleaseMutex() } catch {}
+        }
+        $mutex.Dispose()
+    }
+}
+
 function Ensure-Directory([string]$Path) { if (-not (Test-Path -LiteralPath $Path -PathType Container)) { New-Item -ItemType Directory -Path $Path -Force | Out-Null } }
 function Ledger-Path([string]$Name) { Join-Path $RuntimeDir ("{0}.instance.json" -f $Name.ToLowerInvariant()) }
 function Log-Path([string]$Name, [string]$Kind) { Join-Path $LogDir ("{0}.{1}.log" -f $Name.ToLowerInvariant(), $Kind) }
@@ -1275,7 +1309,7 @@ function Clean-Stale {
     }
 }
 
-function Run-Command([string]$Name) {
+function Run-CommandCore([string]$Name) {
     $cfg = Get-Config
     Assert-ControllerRootBound $cfg
     Ensure-Directory $RuntimeDir; Ensure-Directory $LogDir
@@ -1318,6 +1352,20 @@ function Run-Command([string]$Name) {
     }
 }
 
+function Run-Command([string]$Name) {
+    $mutating = $Name -in @(
+        'start','resume','park','stop','restart','toggle','clean',
+        'armhost','disarmhost','armprocess','disarmprocess','armcoding','disarmcoding',
+        'armautonomous','disarmautonomous','armdesktop','disarmdesktop',
+        'supervisorstart','supervisorstop','supervisorrecover'
+    )
+    if (-not $mutating) {
+        Run-CommandCore $Name
+        return
+    }
+    Invoke-WithControllerMutationLock $Name { Run-CommandCore $Name }
+}
+
 if ($Command -ne 'menu') {
     $recordsStartFailure = $Command -in @('start','resume','restart')
     if ($recordsStartFailure) { Remove-Item -LiteralPath (Controller-StartFailurePath) -Force -ErrorAction SilentlyContinue }
@@ -1336,7 +1384,7 @@ while ($true) {
     Clear-Host
     $cfg = Get-Config
     Assert-ControllerRootBound $cfg
-    Write-Host 'DEADBYTE MCP ON-DEMAND CONTROLLER V0.15.1 / R45'
+    Write-Host 'DEADBYTE MCP ON-DEMAND CONTROLLER V0.15.2 / R46'
     Write-Host '======================================'
     Show-State $cfg | Out-Null
     Write-Host ''

package/controller/deadbyte-process-policy.json

@@ -19,7 +19,7 @@
   },
   "profiles": {
     "ping_hold": {
-      "executable": "C:\\Windows\\System32\\cmd.exe",
+      "executable": "C:\\WINDOWS\\System32\\cmd.exe",
       "executable_sha256": "97ac98b1a92c286054cce55239cfccdfc23a5517bd07fe693072c9ca96c7dabb",
       "root_ids": [
         "core"
@@ -42,6 +42,68 @@
       "input_actions": {
         "ping": "echo DEADBYTE_ACTION_PING\r\n"
       }
+    },
+    "powershell": {
+      "executable": "C:\\WINDOWS\\System32\\WindowsPowerShell\\v1.0\\powershell.exe",
+      "executable_sha256": "8bb6fa8c283b4d92120b1ef249a9b311b0f804d4cabbe9981159976c8be76a5e",
+      "root_ids": [
+        "core"
+      ],
+      "prefix_args": [
+        "-NoLogo",
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command"
+      ],
+      "transport": "pipe",
+      "max_args": 1,
+      "max_arg_bytes": 8192,
+      "max_sessions": 4,
+      "max_input_bytes": 65536,
+      "max_retained_output_bytes": 1048576,
+      "env_allow": [
+        "PATH",
+        "TEMP",
+        "TMP",
+        "SystemRoot",
+        "WINDIR",
+        "USERPROFILE",
+        "PSModulePath",
+        "COMSPEC",
+        "PATHEXT"
+      ],
+      "input_actions": {}
+    },
+    "powershell_repl": {
+      "executable": "C:\\WINDOWS\\System32\\WindowsPowerShell\\v1.0\\powershell.exe",
+      "executable_sha256": "8bb6fa8c283b4d92120b1ef249a9b311b0f804d4cabbe9981159976c8be76a5e",
+      "root_ids": [
+        "core"
+      ],
+      "prefix_args": [
+        "-NoLogo",
+        "-NoProfile",
+        "-NonInteractive"
+      ],
+      "transport": "pipe",
+      "allow_raw_input": true,
+      "max_args": 0,
+      "max_arg_bytes": 256,
+      "max_sessions": 2,
+      "max_input_bytes": 65536,
+      "max_retained_output_bytes": 4194304,
+      "env_allow": [
+        "PATH",
+        "TEMP",
+        "TMP",
+        "SystemRoot",
+        "WINDIR",
+        "USERPROFILE",
+        "PSModulePath",
+        "COMSPEC",
+        "PATHEXT"
+      ],
+      "input_actions": {}
     }
   }
 }

package/docs/ARCHITECTURE.md

@@ -1,4 +1,4 @@
-# DEADBYTE MCP V0.15.1 / R45 ARCHITECTURE
+# DEADBYTE MCP V0.15.2 / R46 ARCHITECTURE
 
 ```mermaid
 flowchart TD
@@ -9,7 +9,7 @@ flowchart TD
     D --> MI[Optional Machine 4 Tools]
     D --> F[Optional Host 3 Tools]
     D --> G[Optional Agent 7 Tools]
-    D --> PR[Optional Process 6 Tools]
+    D --> PR[Optional Process 7 Tools]
     D --> V[Optional Coding 22 Tools]
     D --> MF[Optional Machine FS 8 Tools]
     D --> OB[Optional Observation 6 Tools]
@@ -59,8 +59,7 @@ invocation may recover a stale owner only when no live guardian remains.
 ## Exact capability catalogs
 
 Only complete combinations of base plus optional machine, host, agent, process, coding,
-machine-filesystem, observation, and autonomous surfaces are valid at the HTTP bridge. A fully
-enabled R34 runtime exposes exactly 73 tools. Process authority is independently granted;
+machine-filesystem, observation, and autonomous surfaces are valid at the HTTP bridge. The current fully enabled R46 runtime exposes exactly 83 full tools and 43 compact tools. Process authority is independently granted;
 machine-filesystem and observation reuse coding-policy roots; autonomous requires the complete
 coding surface. Partial, dependency-invalid, unknown, or extra catalogs fail closed.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deadbyte-mcp",
-  "version": "0.15.1",
+  "version": "0.15.2",
   "private": false,
   "type": "module",
   "description": "Authenticated MCP agentic runtime with signed skills, persistent model backends, identity-bound remote devices, durable job supervision, immutable release slots, and separately revocable machine authority.",
@@ -16,10 +16,10 @@
     "r42:parent:verify": "node scripts/verify-r42-parent.mjs",
     "r42:eval": "node scripts/agent-eval-r42.mjs",
     "self-update:runtime": "node scripts/runtime-self-update.mjs",
-    "self-update:deferred": "node scripts/deferred-slot-operation-r45.mjs",
-    "release:parity": "node scripts/release-parity-r45.mjs",
-    "release:final:write": "node scripts/final-closure-r45.mjs",
-    "release:final:verify": "node scripts/final-closure-verify-r45.mjs",
+    "self-update:deferred": "node scripts/deferred-slot-operation-r46.mjs",
+    "release:parity": "node scripts/release-parity-r46.mjs",
+    "release:final:write": "node scripts/final-closure-r46.mjs",
+    "release:final:verify": "node scripts/final-closure-verify-r46.mjs",
     "proof": "node src/proof-cli.mjs workspaces/demo input.txt",
     "verify": "node src/verifier-cli.mjs workspaces/demo evidence/latest.json",
     "trust:init": "node src/trust-init.mjs",
@@ -42,7 +42,7 @@
     "contained:run": "node src/contained-cli.mjs workspaces/demo input.txt",
     "contained:smoke": "node src/contained-smoke.mjs",
     "mcp:contained:smoke": "node src/mcp-contained-smoke-client.mjs",
-    "gate:windows": "powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r45.ps1",
+    "gate:windows": "powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r46.ps1",
     "authority:smoke": "node src/authority-smoke.mjs",
     "mcp:remote:smoke": "node src/remote-mcp-smoke-client.mjs",
     "mcp:host:smoke": "node src/mcp-host-smoke-client.mjs",
@@ -63,7 +63,9 @@
     "doctor": "node src/deadbyte-cli.mjs doctor",
     "r45:parent:verify": "node scripts/verify-r45-parent.mjs",
     "r45:full:test": "node scripts/full-regression-r45.mjs",
-    "finalize:r45": "node scripts/finalize-r45.mjs"
+    "finalize:r45": "node scripts/finalize-r45.mjs",
+    "r46:fileless:test": "node --test --test-concurrency=1 test/process-policy.test.mjs test/process-policy-refresh.test.mjs test/release-generation.test.mjs test/process-runtime.test.mjs test/process-mcp-tools.test.mjs test/compact-gateway-r36.test.mjs test/capability-ledger-r36.test.mjs test/remote-device-r44.test.mjs test/observation-runtime.test.mjs test/observation-mcp-tools.test.mjs",
+    "r46:full:test": "node scripts/full-regression-r46.mjs"
   },
   "bundleDependencies": [
     "@modelcontextprotocol/server",

package/scripts/deferred-slot-operation-r46.mjs

@@ -0,0 +1,126 @@
+import { createHash, createPublicKey, randomBytes } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { mkdir, readFile, realpath, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseActivePointer } from '../src/release-slot.mjs';
+import { loadPowerShellDataFile, runSlotUpdateCli, verifySlotUpdateEnvelope } from '../src/runtime-update.mjs';
+
+const HEX64=/^[0-9a-f]{64}$/;
+const RECEIPT_ID=/^r27-[A-Za-z0-9-]+$/;
+const here=path.dirname(fileURLToPath(import.meta.url));
+const packageRoot=path.resolve(here,'..');
+const stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const evidenceRoot=path.join(stateRoot,'evidence','deferred-slot-operations');
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const atomicJson=async(file,value)=>{
+  await mkdir(path.dirname(file),{recursive:true});
+  const temp=`${file}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`;
+  await writeFile(temp,`${JSON.stringify(value,null,2)}\n`,{flag:'wx'});
+  await import('node:fs/promises').then(fs=>fs.rename(temp,file));
+};
+function activationArgs(manifestSha){
+  if(!HEX64.test(manifestSha??'')) throw new Error('activate requires one lowercase manifest SHA-256');
+  return ['--stage',packageRoot,'--development-root',packageRoot,'--expected-version','0.15.2',
+    '--expected-manifest',manifestSha,'--process-policy',path.join(packageRoot,'controller','deadbyte-process-policy.json'),
+    '--process-policy-sha256',null,'--desktop-policy',path.join(packageRoot,'controller','deadbyte-desktop-policy.json'),
+    '--desktop-policy-sha256',null,'--semantic-lsp-config',path.join(packageRoot,'controller','deadbyte-semantic-lsp-config.json'),
+    '--semantic-lsp-config-sha256',null,'--enable-machine-fs','--enable-observation','--enable-desktop','--enable-autonomous-supervisor'];
+}
+async function bridgeBootstrapArgs(explicitBridgeRoot=null,explicitBridgeSha256=null){
+  const hasRoot=typeof explicitBridgeRoot==='string'&&explicitBridgeRoot.length>0;
+  const hasSha=typeof explicitBridgeSha256==='string'&&explicitBridgeSha256.length>0;
+  if(hasRoot!==hasSha) throw new Error('bridge override requires exact root + SHA pair');
+  let bridgeRootRaw,expectedSha256=null;
+  if(hasRoot){
+    if(!path.isAbsolute(explicitBridgeRoot)||!HEX64.test(explicitBridgeSha256)) throw new Error('bridge override requires exact root + SHA pair');
+    bridgeRootRaw=explicitBridgeRoot;expectedSha256=explicitBridgeSha256;
+  }else{
+    const pointer=parseActivePointer(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));
+    const config=await loadPowerShellDataFile(pointer.config_path);
+    bridgeRootRaw=config?.Bridge?.WorkingDirectory;
+    if(typeof bridgeRootRaw!=='string'||!path.isAbsolute(bridgeRootRaw)) throw new Error('active controller Bridge.WorkingDirectory must be absolute');
+  }
+  const bridgeRoot=await realpath(path.resolve(bridgeRootRaw));
+  const packageFile=path.join(bridgeRoot,'package.json');
+  const bridgeScript=path.join(bridgeRoot,'src','bridge.mjs');
+  const pkg=JSON.parse(await readFile(packageFile,'utf8'));
+  if(pkg?.name!=='deadbyte-chatgpt-bridge') throw new Error('active Bridge package identity mismatch');
+  const scriptSha256=sha256(await readFile(bridgeScript));
+  if(expectedSha256&&scriptSha256!==expectedSha256) throw new Error('bridge override SHA-256 mismatch');
+  return ['--bridge-root',bridgeRoot,'--bridge-script-sha256',scriptSha256];
+}
+async function rollbackArgs(receiptPath){
+  const resolved=await realpath(path.resolve(receiptPath));
+  const allowed=path.join(stateRoot,'evidence','updates')+path.sep;
+  if(!resolved.startsWith(allowed)||path.basename(resolved).toLowerCase()!=='receipt.json'||!RECEIPT_ID.test(path.basename(path.dirname(resolved)))) {
+    throw new Error('rollback receipt must be one signed activation receipt under the update evidence store');
+  }
+  const envelope=JSON.parse(await readFile(resolved,'utf8'));
+  const publicKey=createPublicKey(await readFile(path.join(stateRoot,'trust','ed25519-public.pem')));
+  if(!verifySlotUpdateEnvelope(envelope,publicKey)||envelope.body?.rollback_performed!==false) throw new Error('rollback activation receipt verification failed');
+  const pointer=parseActivePointer(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));
+  if(pointer.release_id!==envelope.body?.active_pointer?.release_id||pointer.generation_root!==envelope.body?.active_pointer?.generation_root) {
+    throw new Error('rollback receipt does not identify the active release generation');
+  }
+  return ['--rollback-receipt',resolved];
+}
+async function normalizedArgs(mode,value,{explicitBridgeRoot=null,explicitBridgeSha256=null}={}){
+  if(mode==='activate'){
+    const args=activationArgs(value);
+    args[args.indexOf('--process-policy-sha256')+1]=sha256(await readFile(path.join(packageRoot,'controller','deadbyte-process-policy.json')));
+    args[args.indexOf('--desktop-policy-sha256')+1]=sha256(await readFile(path.join(packageRoot,'controller','deadbyte-desktop-policy.json')));
+    args[args.indexOf('--semantic-lsp-config-sha256')+1]=sha256(await readFile(path.join(packageRoot,'controller','deadbyte-semantic-lsp-config.json')));
+    args.push(...await bridgeBootstrapArgs(explicitBridgeRoot,explicitBridgeSha256));
+    return args;
+  }
+  if(mode==='rollback'){
+    if(explicitBridgeRoot||explicitBridgeSha256) throw new Error('rollback does not accept bridge override');
+    return rollbackArgs(value);
+  }
+  throw new Error("operation must be exactly 'activate' or 'rollback'");
+}
+const rawArgs=process.argv.slice(2);
+const mode=rawArgs[0],value=rawArgs[1];
+if(!value||!['activate','rollback'].includes(mode)) throw new Error('usage: deferred-slot-operation-r46.mjs <activate manifest_sha256|rollback activation_receipt> [--bridge-root ABS --bridge-script-sha256 HEX64]');
+let cursor=2,explicitBridgeRoot=null,explicitBridgeSha256=null;
+if(rawArgs[cursor]==='--bridge-root'){
+  explicitBridgeRoot=rawArgs[cursor+1]??null;
+  if(rawArgs[cursor+2]!=='--bridge-script-sha256') throw new Error('bridge override requires exact root + SHA pair');
+  explicitBridgeSha256=rawArgs[cursor+3]??null;cursor+=4;
+}
+let workerFlag=null,operationIdArg=null;
+if(rawArgs[cursor]==='--worker'){workerFlag='--worker';operationIdArg=rawArgs[cursor+1]??null;cursor+=2;}
+if(cursor!==rawArgs.length) throw new Error('deferred slot operation arguments invalid');
+if((explicitBridgeRoot===null)!==(explicitBridgeSha256===null)) throw new Error('bridge override requires exact root + SHA pair');
+if(mode==='rollback'&&(explicitBridgeRoot||explicitBridgeSha256)) throw new Error('rollback does not accept bridge override');
+if(workerFlag==='--worker'){
+  if(!/^[0-9a-f]{32}$/.test(operationIdArg??'')) throw new Error('deferred worker operation id invalid');
+  const statePath=path.join(evidenceRoot,`${operationIdArg}.json`);
+  await new Promise(resolve=>setTimeout(resolve,4000));
+  await atomicJson(statePath,{schema:'deadbyte.deferred-slot-operation.v1',operation_id:operationIdArg,mode,state:'running',started_at_utc:new Date().toISOString(),bridge_root:explicitBridgeRoot,bridge_script_sha256:explicitBridgeSha256});
+  try{
+    const args=await normalizedArgs(mode,value,{explicitBridgeRoot,explicitBridgeSha256});
+    const result=await runSlotUpdateCli(args,{stateRoot});
+    await atomicJson(statePath,{schema:'deadbyte.deferred-slot-operation.v1',operation_id:operationIdArg,mode,state:'completed',
+      completed_at_utc:new Date().toISOString(),receipt_path:result.receipt_path,receipt_sha256:result.receipt_sha256,
+      active_release:result.pointer.release_id,generation_root:result.pointer.generation_root,bridge_root:explicitBridgeRoot,bridge_script_sha256:explicitBridgeSha256});
+  }catch(error){
+    await atomicJson(statePath,{schema:'deadbyte.deferred-slot-operation.v1',operation_id:operationIdArg,mode,state:'failed',
+      completed_at_utc:new Date().toISOString(),error:String(error?.message??error),bridge_root:explicitBridgeRoot,bridge_script_sha256:explicitBridgeSha256});
+    process.exitCode=1;
+  }
+}else{
+  const operationId=randomBytes(16).toString('hex');
+  const statePath=path.join(evidenceRoot,`${operationId}.json`);
+  await atomicJson(statePath,{schema:'deadbyte.deferred-slot-operation.v1',operation_id:operationId,mode,state:'scheduled',scheduled_at_utc:new Date().toISOString(),bridge_root:explicitBridgeRoot,bridge_script_sha256:explicitBridgeSha256});
+  const workerArgs=[fileURLToPath(import.meta.url),mode,value];
+  if(explicitBridgeRoot) workerArgs.push('--bridge-root',explicitBridgeRoot,'--bridge-script-sha256',explicitBridgeSha256);
+  workerArgs.push('--worker',operationId);
+  const child=spawn(process.execPath,workerArgs,{
+    cwd:packageRoot,detached:true,stdio:'ignore',windowsHide:true,env:{...process.env,DEADBYTE_STATE_ROOT:stateRoot}
+  });
+  child.unref();
+  console.log(JSON.stringify({status:'scheduled',operation_id:operationId,mode,state_path:statePath,execution_provider:'deadbyte_mcp',rdc_operation_count:0,bridge_root:explicitBridgeRoot,bridge_script_sha256:explicitBridgeSha256}));
+}

package/scripts/final-closure-r46.mjs

@@ -0,0 +1,98 @@
+import { createHash, createPrivateKey, createPublicKey, sign as cryptoSign } from 'node:crypto';
+import { mkdir, open, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const DOMAIN=Buffer.from('DEADBYTE-R46-FINAL-CLOSURE-V1\0','utf8');
+const here=path.dirname(fileURLToPath(import.meta.url));
+const packageRoot=path.resolve(here,'..');
+const stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const canonical=value=>Array.isArray(value)?value.map(canonical):value&&typeof value==='object'
+  ?Object.fromEntries(Object.keys(value).sort().map(key=>[key,canonical(value[key])])):value;
+const canonicalJson=value=>JSON.stringify(canonical(value));
+function insist(ok,message){if(!ok)throw new Error(message);}
+async function fileEvidence(file){const bytes=await readFile(file);return {path:path.resolve(file),sha256:sha256(bytes)};}
+
+export async function writeFinalClosure({root=packageRoot,runtimeStateRoot=stateRoot,clock=()=>new Date()}={}){
+  const candidate=path.resolve(root),state=path.resolve(runtimeStateRoot);
+  const manifestBytes=await readFile(path.join(candidate,'MANIFEST.SHA256'));
+  const manifestSha256=sha256(manifestBytes);
+  const pointer=JSON.parse(await readFile(path.join(state,'active-release.json'),'utf8'));
+  insist(pointer.version==='0.15.2'&&pointer.manifest_sha256===manifestSha256,'R46 final closure active candidate mismatch');
+  insist(pointer.release_id===`v0.15.2-${manifestSha256.slice(0,16)}`,'R46 final closure release id mismatch');
+
+  const gatePath=path.join(state,'evidence','release',`r46-windows-gate-${manifestSha256.slice(0,16)}.json`);
+  const parityPath=path.join(state,'evidence','release',`r46-parity-${manifestSha256.slice(0,16)}.json`);
+  const gate=JSON.parse(await readFile(gatePath,'utf8'));
+  const parity=JSON.parse(await readFile(parityPath,'utf8'));
+  insist(gate.schema==='deadbyte.r46-windows-gate.v1'&&gate.status==='passed'&&gate.version==='0.15.2','R46 gate evidence invalid');
+  insist(gate.manifest_sha256===manifestSha256,'R46 gate evidence candidate mismatch');
+  insist(parity.schema==='deadbyte.r46-parity.v1'&&parity.status==='passed'&&parity.version==='0.15.2','R46 parity evidence invalid');
+  insist(parity.candidate?.manifest_sha256===manifestSha256&&parity.candidate?.generation_manifest_sha256===pointer.generation_manifest_sha256,'R46 parity active generation mismatch');
+  insist(parity.process_policy?.target_repin_verified===true,'R46 target-machine process repin proof missing');
+  insist(parity.fileless_powershell?.exit_code===0&&parity.fileless_powershell?.pscommandpath_empty===true&&parity.fileless_powershell?.invocation_path_empty===true&&parity.fileless_powershell?.new_temp_ps1_count===0,'R46 fileless PowerShell proof missing');
+  insist(parity.persistent_powershell_repl?.state_persisted===true&&parity.persistent_powershell_repl?.observed_value===42&&parity.persistent_powershell_repl?.wait_for_verified===true&&parity.persistent_powershell_repl?.tail_read_verified===true&&parity.persistent_powershell_repl?.raw_input_not_journaled===true,'R46 persistent PowerShell REPL proof missing');
+  insist(parity.retained_output_ring?.eviction_verified===true&&parity.retained_output_ring?.tail_marker_verified===true&&parity.retained_output_ring?.earliest_offset>0,'R46 retained-output ring proof missing');
+
+  const completed=clock();
+  insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'R46 final closure clock invalid');
+  const body={
+    schema:'deadbyte.r46-final-closure.v1',
+    version:'0.15.2',
+    train:'R46',
+    release_label:'FILELESS POWERSHELL PRODUCT BASELINE',
+    completed_at_utc:completed.toISOString(),
+    active_pointer:pointer,
+    parent:gate.parent,
+    runtime_predecessor:gate.runtime_predecessor,
+    features:gate.features,
+    process_policy:parity.process_policy,
+    fileless_powershell:parity.fileless_powershell,
+    persistent_powershell_repl:parity.persistent_powershell_repl,
+    retained_output_ring:parity.retained_output_ring,
+    evidence:{
+      windows_gate:await fileEvidence(gatePath),
+      parity:await fileEvidence(parityPath)
+    },
+    execution_provider:'deadbyte_mcp',
+    rdc_operation_count:0
+  };
+
+  const privateKey=createPrivateKey(await readFile(path.join(state,'trust','ed25519-private.pem')));
+  const publicKey=createPublicKey(privateKey);
+  insist(privateKey.asymmetricKeyType==='ed25519'&&publicKey.asymmetricKeyType==='ed25519','R46 closure signing key must be Ed25519');
+  const keyId=sha256(Buffer.from(publicKey.export({type:'spki',format:'der'})));
+  const bodyBytes=Buffer.from(canonicalJson(body),'utf8');
+  const signature=cryptoSign(null,Buffer.concat([DOMAIN,bodyBytes]),privateKey);
+  const envelope={
+    body,
+    body_sha256:sha256(bodyBytes),
+    attestation:{
+      algorithm:'ed25519',
+      domain:'DEADBYTE-R46-FINAL-CLOSURE-V1',
+      key_id:keyId,
+      signature_base64:signature.toString('base64')
+    }
+  };
+  envelope.closure_sha256=sha256(Buffer.from(canonicalJson(envelope),'utf8'));
+  const bytes=Buffer.from(`${JSON.stringify(envelope,null,2)}\n`,'utf8');
+  const dir=path.join(state,'evidence','release');
+  await mkdir(dir,{recursive:true});
+  const file=path.join(dir,`r46-final-${manifestSha256.slice(0,16)}.json`);
+  try{
+    const handle=await open(file,'wx',0o600);
+    try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}
+    return {status:'written',path:file,sha256:sha256(bytes),closure_sha256:envelope.closure_sha256,release_id:pointer.release_id};
+  }catch(error){
+    if(error?.code!=='EEXIST')throw error;
+    const existingBytes=await readFile(file);
+    const existing=JSON.parse(existingBytes.toString('utf8').replace(/^\uFEFF/,''));
+    insist(existing.body?.version==='0.15.2'&&existing.body?.active_pointer?.manifest_sha256===manifestSha256,'existing R46 closure identity mismatch');
+    return {status:'existing',path:file,sha256:sha256(existingBytes),closure_sha256:existing.closure_sha256,release_id:pointer.release_id};
+  }
+}
+
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked)writeFinalClosure().then(value=>console.log(JSON.stringify(value))).catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});

package/scripts/final-closure-verify-r46.mjs

@@ -0,0 +1,119 @@
+import { createHash, createPublicKey, verify as cryptoVerify } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const DOMAIN=Buffer.from('DEADBYTE-R46-FINAL-CLOSURE-V1\0','utf8');
+const here=path.dirname(fileURLToPath(import.meta.url));
+const packageRoot=path.resolve(here,'..');
+const stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const canonical=value=>Array.isArray(value)?value.map(canonical):value&&typeof value==='object'
+  ?Object.fromEntries(Object.keys(value).sort().map(key=>[key,canonical(value[key])])):value;
+const canonicalJson=value=>JSON.stringify(canonical(value));
+function insist(ok,message){if(!ok)throw new Error(message);}
+
+export async function verifyFinalClosureObject(envelope,{root=packageRoot,runtimeStateRoot=stateRoot}={}){
+  const candidate=path.resolve(root),state=path.resolve(runtimeStateRoot);
+  insist(envelope&&typeof envelope==='object'&&!Array.isArray(envelope),'R46 closure envelope invalid');
+  insist(envelope.body?.schema==='deadbyte.r46-final-closure.v1','R46 closure schema mismatch');
+  insist(envelope.body?.version==='0.15.2'&&envelope.body?.train==='R46','R46 closure version/train mismatch');
+  insist(envelope.body?.release_label==='FILELESS POWERSHELL PRODUCT BASELINE','R46 closure label mismatch');
+
+  const bodyBytes=Buffer.from(canonicalJson(envelope.body),'utf8');
+  insist(envelope.body_sha256===sha256(bodyBytes),'R46 closure body SHA-256 mismatch');
+  insist(envelope.attestation?.algorithm==='ed25519'&&envelope.attestation?.domain==='DEADBYTE-R46-FINAL-CLOSURE-V1','R46 closure attestation contract mismatch');
+  const publicKey=createPublicKey(await readFile(path.join(state,'trust','ed25519-public.pem')));
+  insist(publicKey.asymmetricKeyType==='ed25519','R46 closure verify key must be Ed25519');
+  const keyId=sha256(Buffer.from(publicKey.export({type:'spki',format:'der'})));
+  insist(envelope.attestation.key_id===keyId,'R46 closure signer key mismatch');
+  insist(typeof envelope.attestation.signature_base64==='string'&&cryptoVerify(
+    null,Buffer.concat([DOMAIN,bodyBytes]),publicKey,Buffer.from(envelope.attestation.signature_base64,'base64')
+  ),'R46 closure signature invalid');
+
+  const unsigned={body:envelope.body,body_sha256:envelope.body_sha256,attestation:envelope.attestation};
+  const closureSha256=sha256(Buffer.from(canonicalJson(unsigned),'utf8'));
+  insist(envelope.closure_sha256===closureSha256,'R46 closure digest mismatch');
+
+  const manifestBytes=await readFile(path.join(candidate,'MANIFEST.SHA256'));
+  const manifestSha256=sha256(manifestBytes);
+  const pointer=JSON.parse(await readFile(path.join(state,'active-release.json'),'utf8'));
+  insist(pointer.version==='0.15.2'&&pointer.manifest_sha256===manifestSha256,'R46 active pointer/candidate mismatch');
+  insist(pointer.release_id===`v0.15.2-${manifestSha256.slice(0,16)}`,'R46 active release id mismatch');
+  insist(envelope.body.active_pointer?.release_id===pointer.release_id&&
+    envelope.body.active_pointer?.manifest_sha256===pointer.manifest_sha256&&
+    envelope.body.active_pointer?.generation_manifest_sha256===pointer.generation_manifest_sha256,
+    'R46 closure active pointer drift');
+
+  const gateRef=envelope.body.evidence?.windows_gate;
+  const parityRef=envelope.body.evidence?.parity;
+  for(const [label,ref] of [['windows gate',gateRef],['parity',parityRef]]){
+    insist(ref&&typeof ref.path==='string'&&/^[0-9a-f]{64}$/.test(String(ref.sha256??'')),`R46 ${label} evidence reference invalid`);
+    const bytes=await readFile(path.resolve(ref.path));
+    insist(sha256(bytes)===ref.sha256,`R46 ${label} evidence hash mismatch`);
+  }
+  const gate=JSON.parse(await readFile(path.resolve(gateRef.path),'utf8'));
+  const parity=JSON.parse(await readFile(path.resolve(parityRef.path),'utf8'));
+  insist(gate.schema==='deadbyte.r46-windows-gate.v1'&&gate.status==='passed'&&gate.version==='0.15.2','R46 gate evidence invalid');
+  insist(gate.manifest_sha256===manifestSha256,'R46 gate candidate mismatch');
+  insist(gate.parent?.release_id==='v0.15.1-d55f00b5144dc31a'&&gate.parent?.manifest_sha256==='d55f00b5144dc31a7fe39e4dc60d640a94780da6aaeca0918e87636b816d7854','R46 sealed parent identity invalid');
+  insist(gate.runtime_predecessor?.release_id==='v0.15.2-0fb46542f6a4345f'&&gate.runtime_predecessor?.manifest_sha256==='0fb46542f6a4345f1c527565d06bf6e9b8e283260e47bf684fb70a60308fcf34','R46 reopened runtime predecessor identity invalid');
+  insist(envelope.body.runtime_predecessor?.release_id===gate.runtime_predecessor.release_id&&envelope.body.runtime_predecessor?.manifest_sha256===gate.runtime_predecessor.manifest_sha256,'R46 closure runtime predecessor mismatch');
+  insist(parity.schema==='deadbyte.r46-parity.v1'&&parity.status==='passed'&&parity.version==='0.15.2','R46 parity evidence invalid');
+  insist(parity.candidate?.release_id===pointer.release_id&&
+    parity.candidate?.manifest_sha256===pointer.manifest_sha256&&
+    parity.candidate?.generation_manifest_sha256===pointer.generation_manifest_sha256,
+    'R46 parity active generation mismatch');
+  insist(parity.process_policy?.target_repin_verified===true,'R46 target-machine process repin proof missing');
+  insist(parity.fileless_powershell?.exit_code===0&&
+    parity.fileless_powershell?.pscommandpath_empty===true&&
+    parity.fileless_powershell?.invocation_path_empty===true&&
+    parity.fileless_powershell?.new_temp_ps1_count===0,
+    'R46 fileless PowerShell proof invalid');
+  insist(parity.persistent_powershell_repl?.state_persisted===true&&
+    parity.persistent_powershell_repl?.observed_value===42&&
+    parity.persistent_powershell_repl?.wait_for_verified===true&&
+    parity.persistent_powershell_repl?.tail_read_verified===true&&
+    parity.persistent_powershell_repl?.raw_input_not_journaled===true,
+    'R46 persistent PowerShell REPL proof invalid');
+  insist(parity.retained_output_ring?.eviction_verified===true&&
+    parity.retained_output_ring?.tail_marker_verified===true&&
+    parity.retained_output_ring?.earliest_offset>0,
+    'R46 retained-output ring proof invalid');
+  insist(envelope.body.process_policy?.target_repin_verified===true,'R46 closure process repin proof invalid');
+  insist(envelope.body.fileless_powershell?.exit_code===0&&
+    envelope.body.fileless_powershell?.new_temp_ps1_count===0,
+    'R46 closure fileless proof invalid');
+  insist(envelope.body.persistent_powershell_repl?.state_persisted===true&&
+    envelope.body.persistent_powershell_repl?.observed_value===42&&
+    envelope.body.persistent_powershell_repl?.raw_input_not_journaled===true,
+    'R46 closure persistent REPL proof invalid');
+  insist(envelope.body.retained_output_ring?.eviction_verified===true&&
+    envelope.body.retained_output_ring?.tail_marker_verified===true,
+    'R46 closure retained-output ring proof invalid');
+
+  return {
+    ok:true,status:'passed',version:'0.15.2',train:'R46',
+    release_id:pointer.release_id,
+    manifest_sha256:pointer.manifest_sha256,
+    generation_manifest_sha256:pointer.generation_manifest_sha256,
+    closure_sha256:envelope.closure_sha256,
+    signer_key_id:keyId,
+    fileless_powershell:true,
+    target_machine_process_repin:true
+  };
+}
+
+export async function verifyFinalClosure({file=null,root=packageRoot,runtimeStateRoot=stateRoot}={}){
+  const state=path.resolve(runtimeStateRoot),candidate=path.resolve(root);
+  const manifestSha256=sha256(await readFile(path.join(candidate,'MANIFEST.SHA256')));
+  const target=file?path.resolve(file):path.join(state,'evidence','release',`r46-final-${manifestSha256.slice(0,16)}.json`);
+  const envelope=JSON.parse(await readFile(target,'utf8'));
+  return {...await verifyFinalClosureObject(envelope,{root:candidate,runtimeStateRoot:state}),path:target};
+}
+
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked)verifyFinalClosure({file:process.argv[2]??null})
+  .then(value=>console.log(JSON.stringify(value,null,2)))
+  .catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});

package/scripts/full-regression-r46.mjs

@@ -0,0 +1,20 @@
+import { spawnSync } from 'node:child_process';
+import { readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const root=path.resolve(here,'..');
+const testDir=path.join(root,'test');
+const files=(await readdir(testDir,{withFileTypes:true}))
+  .filter(entry=>entry.isFile()&&entry.name.endsWith('.test.mjs')&&!['full-max-catalog-r44.test.mjs','full-max-catalog-r45.test.mjs'].includes(entry.name))
+  .map(entry=>path.join('test',entry.name))
+  .sort((a,b)=>a.localeCompare(b,'en'));
+if(files.length<1) throw new Error('R46 full regression found no test files');
+console.log(`R46-FULL-REGRESSION files=${files.length}`);
+const result=spawnSync(process.execPath,['--test','--test-concurrency=1',...files],{
+  cwd:root,stdio:'inherit',windowsHide:true,shell:false
+});
+if(result.error) throw result.error;
+if(result.signal) throw new Error(`R46 full regression terminated by ${result.signal}`);
+process.exitCode=Number.isInteger(result.status)?result.status:1;