deadbyte-mcp 0.15.28 → 0.15.30

package/proof/CONTAINMENT-BUILD.txt

@@ -39,7 +39,7 @@ deadbyte-process-host.cpp
 exit_code=0
 ==== probe-dependencies ====
 
-Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-r42-agentic-dev\bin\containment-probe.exe
+Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.30-stabilization\bin\containment-probe.exe
 
 File Type: EXECUTABLE IMAGE
 
@@ -59,7 +59,7 @@ File Type: EXECUTABLE IMAGE
 exit_code=0
 ==== contained-launcher-dependencies ====
 
-Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-r42-agentic-dev\bin\deadbyte-exec.exe
+Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.30-stabilization\bin\deadbyte-exec.exe
 
 File Type: EXECUTABLE IMAGE
 
@@ -83,7 +83,7 @@ File Type: EXECUTABLE IMAGE
 exit_code=0
 ==== contained-worker-dependencies ====
 
-Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-r42-agentic-dev\bin\contained-transform-worker.exe
+Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.30-stabilization\bin\contained-transform-worker.exe
 
 File Type: EXECUTABLE IMAGE
 
@@ -104,7 +104,7 @@ File Type: EXECUTABLE IMAGE
 exit_code=0
 ==== contained-reverse-worker-dependencies ====
 
-Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-r42-agentic-dev\bin\contained-reverse-worker.exe
+Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.30-stabilization\bin\contained-reverse-worker.exe
 
 File Type: EXECUTABLE IMAGE
 
@@ -125,7 +125,7 @@ File Type: EXECUTABLE IMAGE
 exit_code=0
 ==== named-tunnel-host-dependencies ====
 
-Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-r42-agentic-dev\bin\deadbyte-tunnel-host.exe
+Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.30-stabilization\bin\deadbyte-tunnel-host.exe
 
 File Type: EXECUTABLE IMAGE
 
@@ -144,7 +144,7 @@ File Type: EXECUTABLE IMAGE
 exit_code=0
 ==== process-host-dependencies ====
 
-Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-r42-agentic-dev\bin\deadbyte-process-host.exe
+Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.30-stabilization\bin\deadbyte-process-host.exe
 
 File Type: EXECUTABLE IMAGE
 

package/scripts/gate-windows-r52.ps1

@@ -0,0 +1,58 @@
+$ErrorActionPreference = 'Stop'
+Set-StrictMode -Version 3.0
+
+function Invoke-GateStep {
+    param([Parameter(Mandatory)][string]$Name,[Parameter(Mandatory)][string[]]$NpmArgs)
+    Write-Host "==== $Name ===="
+    & npm.cmd @NpmArgs
+    if ($LASTEXITCODE -ne 0) { throw "DEADBYTE 0.15.29 / R52 gate failed at $Name with exit code $LASTEXITCODE" }
+}
+
+function Invoke-NodeTest {
+    param([Parameter(Mandatory)][string]$Name,[Parameter(Mandatory)][string[]]$TestFiles)
+    Write-Host "==== $Name ===="
+    & node.exe --test --test-concurrency=1 @TestFiles
+    if ($LASTEXITCODE -ne 0) { throw "DEADBYTE 0.15.29 / R52 gate failed at $Name with exit code $LASTEXITCODE" }
+}
+
+Invoke-NodeTest 'r52-package-boundary' @('test/package-boundary.test.mjs')
+Invoke-NodeTest 'r52-release-smoke-isolation' @('test/release-smoke-isolation.test.mjs')
+Invoke-GateStep 'r52-focused-contracts' @('run','r52:focused:test')
+Invoke-GateStep 'containment-build' @('run','containment:build')
+Invoke-GateStep 'process-policy-refresh' @('run','process:policy:refresh')
+Write-Host "==== desktop-policy-refresh ===="
+& (Join-Path $PSScriptRoot 'init-desktop-policy-r40.ps1')
+Invoke-GateStep 'hardware-build' @('run','hardware:build')
+
+$hostPolicy = [System.IO.Path]::GetFullPath((Join-Path $PSScriptRoot '..\controller\deadbyte-host-policy.json'))
+Remove-Item -LiteralPath $hostPolicy -Force -ErrorAction SilentlyContinue
+if (Test-Path -LiteralPath $hostPolicy) { throw 'could not establish hermetic Host policy absence' }
+
+Invoke-GateStep 'r52-release-focused' @('run','r48:release:test')
+Invoke-NodeTest 'r49-donor-proof' @('test/r49-remote-control-donors.test.mjs')
+Invoke-NodeTest 'r49-desktop-wait' @('test/desktop-runtime-r40.test.mjs','test/desktop-mcp-tools-r40.test.mjs','test/autonomous-desktop-r40.test.mjs')
+Invoke-GateStep 'r49-catalog' @('run','r48:catalog:test')
+Invoke-GateStep 'commander-hardening' @('run','r47:hardening:test')
+Invoke-GateStep 'full-regression' @('run','r48:full:test')
+Invoke-GateStep 'mcp-smoke' @('run','mcp:smoke')
+Invoke-GateStep 'mcp-agent-smoke' @('run','mcp:agent:smoke')
+Invoke-GateStep 'mcp-coding-smoke' @('run','mcp:coding:smoke')
+Invoke-GateStep 'mcp-machine-fs-smoke' @('run','mcp:machine-fs:smoke')
+Invoke-GateStep 'mcp-observation-smoke' @('run','mcp:observation:smoke')
+Invoke-GateStep 'mcp-process-smoke' @('run','mcp:process:smoke')
+Invoke-GateStep 'mcp-autonomous-smoke' @('run','mcp:autonomous:smoke')
+Invoke-GateStep 'tunnel-stdio-compat-smoke' @('run','mcp:tunnel-compat:smoke')
+Invoke-GateStep 'containment-smoke' @('run','containment:smoke')
+Invoke-GateStep 'contained-smoke' @('run','contained:smoke')
+Invoke-GateStep 'mcp-contained-smoke' @('run','mcp:contained:smoke')
+Invoke-GateStep 'host-policy-refresh' @('run','host:policy:init')
+Invoke-GateStep 'manifest-write' @('run','manifest:write')
+Invoke-GateStep 'manifest-verify' @('run','manifest:verify')
+Invoke-GateStep 'doctor' @('run','doctor')
+Invoke-GateStep 'mcp-host-smoke' @('run','mcp:host:smoke')
+Invoke-GateStep 'authority-smoke' @('run','authority:smoke')
+Invoke-GateStep 'manifest-final-verify' @('run','manifest:verify')
+
+& node.exe (Join-Path $PSScriptRoot 'windows-gate-evidence-r52.mjs')
+if ($LASTEXITCODE -ne 0) { throw "R52 evidence writer failed with exit code $LASTEXITCODE" }
+Write-Host '==== DEADBYTE 0.15.29 / R52 WINDOWS GATE: PASS ===='

package/scripts/gate-windows-r53.ps1

@@ -0,0 +1,58 @@
+$ErrorActionPreference = 'Stop'
+Set-StrictMode -Version 3.0
+
+function Invoke-GateStep {
+    param([Parameter(Mandatory)][string]$Name,[Parameter(Mandatory)][string[]]$NpmArgs)
+    Write-Host "==== $Name ===="
+    & npm.cmd @NpmArgs
+    if ($LASTEXITCODE -ne 0) { throw "DEADBYTE 0.15.30 / R53 gate failed at $Name with exit code $LASTEXITCODE" }
+}
+
+function Invoke-NodeTest {
+    param([Parameter(Mandatory)][string]$Name,[Parameter(Mandatory)][string[]]$TestFiles)
+    Write-Host "==== $Name ===="
+    & node.exe --test --test-concurrency=1 @TestFiles
+    if ($LASTEXITCODE -ne 0) { throw "DEADBYTE 0.15.30 / R53 gate failed at $Name with exit code $LASTEXITCODE" }
+}
+
+Invoke-NodeTest 'r53-package-boundary' @('test/package-boundary.test.mjs')
+Invoke-NodeTest 'r53-release-smoke-isolation' @('test/release-smoke-isolation.test.mjs')
+Invoke-GateStep 'r53-focused-contracts' @('run','r53:focused:test')
+Invoke-GateStep 'containment-build' @('run','containment:build')
+Invoke-GateStep 'process-policy-refresh' @('run','process:policy:refresh')
+Write-Host "==== desktop-policy-refresh ===="
+& (Join-Path $PSScriptRoot 'init-desktop-policy-r40.ps1')
+Invoke-GateStep 'hardware-build' @('run','hardware:build')
+
+$hostPolicy = [System.IO.Path]::GetFullPath((Join-Path $PSScriptRoot '..\controller\deadbyte-host-policy.json'))
+Remove-Item -LiteralPath $hostPolicy -Force -ErrorAction SilentlyContinue
+if (Test-Path -LiteralPath $hostPolicy) { throw 'could not establish hermetic Host policy absence' }
+
+Invoke-GateStep 'r53-release-focused' @('run','r48:release:test')
+Invoke-NodeTest 'r49-donor-proof' @('test/r49-remote-control-donors.test.mjs')
+Invoke-NodeTest 'r49-desktop-wait' @('test/desktop-runtime-r40.test.mjs','test/desktop-mcp-tools-r40.test.mjs','test/autonomous-desktop-r40.test.mjs')
+Invoke-GateStep 'r49-catalog' @('run','r48:catalog:test')
+Invoke-GateStep 'commander-hardening' @('run','r47:hardening:test')
+Invoke-GateStep 'full-regression' @('run','r48:full:test')
+Invoke-GateStep 'mcp-smoke' @('run','mcp:smoke')
+Invoke-GateStep 'mcp-agent-smoke' @('run','mcp:agent:smoke')
+Invoke-GateStep 'mcp-coding-smoke' @('run','mcp:coding:smoke')
+Invoke-GateStep 'mcp-machine-fs-smoke' @('run','mcp:machine-fs:smoke')
+Invoke-GateStep 'mcp-observation-smoke' @('run','mcp:observation:smoke')
+Invoke-GateStep 'mcp-process-smoke' @('run','mcp:process:smoke')
+Invoke-GateStep 'mcp-autonomous-smoke' @('run','mcp:autonomous:smoke')
+Invoke-GateStep 'tunnel-stdio-compat-smoke' @('run','mcp:tunnel-compat:smoke')
+Invoke-GateStep 'containment-smoke' @('run','containment:smoke')
+Invoke-GateStep 'contained-smoke' @('run','contained:smoke')
+Invoke-GateStep 'mcp-contained-smoke' @('run','mcp:contained:smoke')
+Invoke-GateStep 'host-policy-refresh' @('run','host:policy:init')
+Invoke-GateStep 'manifest-write' @('run','manifest:write')
+Invoke-GateStep 'manifest-verify' @('run','manifest:verify')
+Invoke-GateStep 'doctor' @('run','doctor')
+Invoke-GateStep 'mcp-host-smoke' @('run','mcp:host:smoke')
+Invoke-GateStep 'authority-smoke' @('run','authority:smoke')
+Invoke-GateStep 'manifest-final-verify' @('run','manifest:verify')
+
+& node.exe (Join-Path $PSScriptRoot 'windows-gate-evidence-r53.mjs')
+if ($LASTEXITCODE -ne 0) { throw "R53 evidence writer failed with exit code $LASTEXITCODE" }
+Write-Host '==== DEADBYTE 0.15.30 / R53 WINDOWS GATE: PASS ===='

package/scripts/verify-r42-parent.mjs

@@ -82,7 +82,7 @@ export async function verifyR42Parent(file=path.join(root,'R42-PARENT.json')){
   const closureBytes=await readFile(path.resolve(record.parent_final_closure_path));
   insist(sha256(closureBytes)===record.parent_final_closure_sha256,'R41 parent final closure raw hash mismatch');
   const closure=JSON.parse(closureBytes.toString('utf8').replace(/^\uFEFF/,''));
-  const pointer=verifySignedClosure(closure,record,await readFile(path.join(stateRoot,'trust','ed25519-public.pem')));
+  const pointer=verifySignedClosure(closure,record,await readFile(path.resolve(process.env.DEADBYTE_PARENT_VERIFY_KEY||path.join(stateRoot,'trust','ed25519-public.pem'))));
   const generationFiles=await verifyTree(path.resolve(pointer.generation_root),'GENERATION.SHA256',record.parent_generation_manifest_sha256,{exact:true});
 
   const tarball=await readFile(path.resolve(record.parent_public_tarball_path));

package/scripts/verify-r43-parent.mjs

@@ -107,7 +107,7 @@ export async function verifyR43Parent(file=path.join(root,'R43-PARENT.json')){
   const activationBytes=await readFile(path.resolve(record.parent_activation_receipt_path));
   insist(sha256(activationBytes)===record.parent_activation_receipt_file_sha256,'R42 activation raw file hash mismatch');
   const activation=JSON.parse(activationBytes.toString('utf8').replace(/^\uFEFF/,''));
-  const keyInfo=publicKeyInfo(await readFile(path.join(stateRoot,'trust','ed25519-public.pem')));
+  const keyInfo=publicKeyInfo(await readFile(path.resolve(process.env.DEADBYTE_PARENT_VERIFY_KEY||path.join(stateRoot,'trust','ed25519-public.pem'))));
   verifyActivationEnvelope(activation,keyInfo,record);
 
   return {

package/scripts/verify-r44-parent.mjs

@@ -76,7 +76,7 @@ export async function verifyR44Parent(parentFile,{stateRoot=path.join(os.homedir
   insist(envelope.body.version===parent.parent_version,'R44 parent closure version mismatch');
   insist(envelope.body.release_label==='R43 AUTHORITY HARDENING PATCH','R44 parent closure label mismatch');
 
-  const publicKey=createPublicKey(await readFile(path.join(path.resolve(stateRoot),'trust','ed25519-public.pem')));
+  const publicKey=createPublicKey(await readFile(path.resolve(process.env.DEADBYTE_PARENT_VERIFY_KEY||path.join(path.resolve(stateRoot),'trust','ed25519-public.pem'))));
   insist(publicKey.asymmetricKeyType==='ed25519','R44 parent trust key must be Ed25519');
   const keyId=sha256(Buffer.from(publicKey.export({type:'spki',format:'der'})));
   insist(keyId===parent.parent_final_closure_signer_key_id,'R44 parent trust key id mismatch');

package/scripts/verify-r45-parent.mjs

@@ -76,7 +76,7 @@ export async function verifyR45Parent(parentFile,{stateRoot=path.join(os.homedir
   insist(envelope.body.version===parent.parent_version,'R45 parent closure version mismatch');
   insist(envelope.body.release_label==='R44 REMOTE AGENT SKILL BASELINE','R45 parent closure label mismatch');
 
-  const publicKey=createPublicKey(await readFile(path.join(path.resolve(stateRoot),'trust','ed25519-public.pem')));
+  const publicKey=createPublicKey(await readFile(path.resolve(process.env.DEADBYTE_PARENT_VERIFY_KEY||path.join(path.resolve(stateRoot),'trust','ed25519-public.pem'))));
   insist(publicKey.asymmetricKeyType==='ed25519','R45 parent trust key must be Ed25519');
   const keyId=sha256(Buffer.from(publicKey.export({type:'spki',format:'der'})));
   insist(keyId===parent.parent_final_closure_signer_key_id,'R45 parent trust key id mismatch');

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

@@ -0,0 +1,94 @@
+import { createHash } from 'node:crypto';
+import { mkdir, open, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { doctor } from '../src/doctor-r45.mjs';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+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 insist = (ok, message) => { if (!ok) throw new Error(message); };
+const pkg = JSON.parse(await readFile(path.join(root, 'package.json'), 'utf8'));
+const release = JSON.parse(await readFile(path.join(root, 'RELEASE.json'), 'utf8'));
+const provenance = JSON.parse(await readFile(path.join(root, 'PROVENANCE.json'), 'utf8'));
+const active = JSON.parse(await readFile(path.join(stateRoot, 'active-release.json'), 'utf8'));
+const manifestSha256 = sha256(await readFile(path.join(root, 'MANIFEST.SHA256')));
+
+insist(pkg.version === '0.15.29' && release.version === pkg.version && release.train === 'R52', 'R52 candidate identity mismatch');
+insist(
+  active.release_id === release.runtime_predecessor.release_id &&
+  active.manifest_sha256 === release.runtime_predecessor.manifest_sha256 &&
+  active.generation_manifest_sha256 === release.runtime_predecessor.generation_manifest_sha256,
+  'active runtime is not the exact sealed R52 runtime rollback target'
+);
+insist(release.parent.version === '0.15.28' && release.parent.manifest_sha256 === release.source_predecessor.manifest_file_sha256 && release.parent.tarball_sha256 === release.source_predecessor.tarball_sha256, 'R52 published parent binding mismatch');
+insist(release.source_predecessor.version === '0.15.28', 'R52 source predecessor version mismatch');
+insist(release.source_predecessor.tarball_sha256 === '0a74332ba715d80a532dc871ece4826bdb917b8c7a442e71388a06d44698c411', 'R52 source predecessor tarball mismatch');
+insist(provenance.source_predecessor_activation_failure_receipt_sha256 === '090f165c96da0d5a8e9c0815fd389fe94e8fe36c23a6878ee825b8f46bfb0bc2', 'R52 failure receipt binding mismatch');
+
+const health = await doctor();
+insist(health.status === 'ok' && health.package_version === pkg.version && health.manifest?.verified === true, 'R52 doctor evidence invalid');
+insist(health.policy?.host_v2_ready === true, 'R52 Host policy v2 is not ready');
+
+const evidence = {
+  schema: 'deadbyte.r52-windows-gate.v1',
+  status: 'passed',
+  exit_code: 0,
+  version: pkg.version,
+  train: 'R52',
+  completed_at_utc: new Date().toISOString(),
+  manifest_sha256: manifestSha256,
+  parent: release.parent,
+  runtime_predecessor: release.runtime_predecessor,
+  source_predecessor: release.source_predecessor,
+  activation_failure_receipt_sha256: provenance.source_predecessor_activation_failure_receipt_sha256,
+  active_predecessor: {
+    release_id: active.release_id,
+    version: active.version,
+    manifest_sha256: active.manifest_sha256,
+    generation_manifest_sha256: active.generation_manifest_sha256
+  },
+  doctor: { verified_entries: health.manifest.verified_entries, host_v2_ready: true },
+  gates: {
+    offline_predecessor_host_revoke_before_capture: true,
+    package_boundary: true,
+    release_smoke_isolation: true,
+    runtime_coherence: true,
+    coding_command_singleflight: true,
+    foreground_desktop_host_fail_closed: true,
+    livelog_optimizer: true,
+    full_regression: true,
+    commander_hardening: true,
+    donor_proof: true,
+    desktop_wait: true,
+    exact_catalog: true,
+    stdio_smokes: true,
+    manifest_final_verify: true
+  }
+};
+
+const bytes = Buffer.from(`${JSON.stringify(evidence, null, 2)}\n`);
+const dir = path.join(stateRoot, 'evidence', 'release');
+await mkdir(dir, { recursive: true });
+const target = path.join(dir, `r52-windows-gate-${manifestSha256.slice(0, 16)}.json`);
+
+try {
+  const handle = await open(target, 'wx', 0o600);
+  try { await handle.writeFile(bytes); await handle.sync(); }
+  finally { await handle.close(); }
+} catch (error) {
+  if (error?.code !== 'EEXIST') throw error;
+  const prior = JSON.parse(await readFile(target, 'utf8'));
+  insist(
+    prior.schema === evidence.schema &&
+    prior.status === 'passed' &&
+    prior.version === evidence.version &&
+    prior.manifest_sha256 === manifestSha256 &&
+    prior.parent?.release_id === release.parent.release_id &&
+    prior.activation_failure_receipt_sha256 === evidence.activation_failure_receipt_sha256,
+    'conflicting R52 gate evidence identity'
+  );
+}
+
+console.log(JSON.stringify({ status: 'passed', path: target, sha256: sha256(bytes), manifest_sha256: manifestSha256 }));

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

@@ -0,0 +1,102 @@
+import { createHash } from 'node:crypto';
+import { mkdir, open, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { doctor } from '../src/doctor-r45.mjs';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+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 insist = (ok, message) => { if (!ok) throw new Error(message); };
+const pkg = JSON.parse(await readFile(path.join(root, 'package.json'), 'utf8'));
+const release = JSON.parse(await readFile(path.join(root, 'RELEASE.json'), 'utf8'));
+const provenance = JSON.parse(await readFile(path.join(root, 'PROVENANCE.json'), 'utf8'));
+const matrix = JSON.parse(await readFile(path.join(root, 'TEST-MATRIX.json'), 'utf8'));
+const active = JSON.parse(await readFile(path.join(stateRoot, 'active-release.json'), 'utf8'));
+const manifestSha256 = sha256(await readFile(path.join(root, 'MANIFEST.SHA256')));
+
+insist(pkg.version === '0.15.30' && release.version === pkg.version && release.train === 'R53', 'R53 candidate identity mismatch');
+insist(
+  active.release_id === release.runtime_predecessor.release_id &&
+  active.manifest_sha256 === release.runtime_predecessor.manifest_sha256 &&
+  active.generation_manifest_sha256 === release.runtime_predecessor.generation_manifest_sha256,
+  'active runtime is not exact sealed 0.15.29 predecessor'
+);
+insist(release.parent.version === '0.15.29', 'R53 parent version mismatch');
+insist(release.parent.release_id === 'v0.15.29-f74eaa1b3d00e6fb', 'R53 parent release id mismatch');
+insist(release.parent.manifest_sha256 === 'f74eaa1b3d00e6fb5a36b2358efb815e3686c9fe9dbd3b84d25a713ef957748c', 'R53 parent manifest mismatch');
+insist(release.parent.generation_manifest_sha256 === '289b4fc065de0681da6864cc1bbe09aab198ca804945ffc27c786438dad13f5a', 'R53 parent generation mismatch');
+insist(release.parent.tarball_sha256 === 'f535d7121a384bed106d34bc7525afa9d4048c7e290f270699e25136d1e82eeb', 'R53 parent tarball mismatch');
+insist(provenance.parent_release_id === release.parent.release_id, 'R53 provenance parent release mismatch');
+insist(provenance.parent_manifest_sha256 === release.parent.manifest_sha256, 'R53 provenance parent manifest mismatch');
+insist(provenance.parent_generation_manifest_sha256 === release.parent.generation_manifest_sha256, 'R53 provenance parent generation mismatch');
+insist(provenance.operator_override?.four_hour_soak === 'NOT_COMPLETED', 'R53 soak bypass missing');
+insist(provenance.operator_override?.stable_final_claim === false, 'R53 must not claim stable/final');
+insist(matrix.operator_override?.four_hour_soak === 'NOT_COMPLETED', 'R53 matrix soak bypass missing');
+
+const health = await doctor();
+insist(health.status === 'ok' && health.package_version === pkg.version && health.manifest?.verified === true, 'R53 doctor evidence invalid');
+insist(health.policy?.host_v2_ready === true, 'R53 Host policy v2 is not ready');
+
+const evidence = {
+  schema: 'deadbyte.r53-windows-gate.v1',
+  status: 'passed',
+  exit_code: 0,
+  version: pkg.version,
+  train: 'R53',
+  completed_at_utc: new Date().toISOString(),
+  manifest_sha256: manifestSha256,
+  parent: release.parent,
+  runtime_predecessor: release.runtime_predecessor,
+  stabilization: release.stabilization,
+  operator_override: provenance.operator_override,
+  active_predecessor: {
+    release_id: active.release_id,
+    version: active.version,
+    manifest_sha256: active.manifest_sha256,
+    generation_manifest_sha256: active.generation_manifest_sha256
+  },
+  doctor: { verified_entries: health.manifest.verified_entries, host_v2_ready: true },
+  gates: {
+    r53_focused: true,
+    package_boundary: true,
+    release_smoke_isolation: true,
+    runtime_coherence: true,
+    coding_command_singleflight: true,
+    foreground_desktop_host_fail_closed: true,
+    full_regression: true,
+    commander_hardening: true,
+    donor_proof: true,
+    desktop_wait: true,
+    exact_catalog: true,
+    stdio_smokes: true,
+    manifest_final_verify: true,
+    four_hour_soak_completed: false
+  }
+};
+
+const bytes = Buffer.from(`${JSON.stringify(evidence, null, 2)}\n`);
+const dir = path.join(stateRoot, 'evidence', 'release');
+await mkdir(dir, { recursive: true });
+const target = path.join(dir, `r53-windows-gate-${manifestSha256.slice(0, 16)}.json`);
+
+try {
+  const handle = await open(target, 'wx', 0o600);
+  try { await handle.writeFile(bytes); await handle.sync(); }
+  finally { await handle.close(); }
+} catch (error) {
+  if (error?.code !== 'EEXIST') throw error;
+  const prior = JSON.parse(await readFile(target, 'utf8'));
+  insist(
+    prior.schema === evidence.schema &&
+    prior.status === 'passed' &&
+    prior.version === evidence.version &&
+    prior.manifest_sha256 === manifestSha256 &&
+    prior.parent?.release_id === release.parent.release_id &&
+    prior.operator_override?.four_hour_soak === 'NOT_COMPLETED',
+    'conflicting R53 gate evidence identity'
+  );
+}
+
+console.log(JSON.stringify({ status: 'passed', path: target, sha256: sha256(bytes), manifest_sha256: manifestSha256 }));

package/src/authority-smoke.mjs

@@ -60,6 +60,7 @@ const transport = new StdioClientTransport({
   cwd: repoRoot,
   env: {
     ...getDefaultEnvironment(),
+    DEADBYTE_STATE_ROOT: path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(trust,'state')),
     DEADBYTE_WORKSPACE_ROOT: workspaceRoot,
     DEADBYTE_SIGNING_KEY: keys.privateKeyPath,
     DEADBYTE_VERIFY_KEY: keys.publicKeyPath

package/src/coding-plane.mjs

@@ -11,6 +11,7 @@ import { loadPrivateSigningKey, loadPublicVerifyKey } from './trust.mjs';
 import { createCodingSearch } from './coding-search.mjs';
 import { createSearchCursorCodec } from './search-cursor.mjs';
 import { atomicMutation } from './atomic-mutation.mjs';
+import { fileURLToPath } from 'node:url';
 
 export const CODING_POLICY_SCHEMA = 'deadbyte.coding-policy.v1';
 export const CODING_LEASE_SCHEMA = 'deadbyte.coding-lease.v1';
@@ -591,7 +592,7 @@ export function createCodingRuntime({ policy, signingKeyPath, verifyKeyPath }) {
       receipt_sha256: signed.receipt.receipt_sha256, request_sha256: request };
   }
   async function runCommandOnce({ rootId, commandId, scriptPath, scriptSha256, args = [], cwd = '.', timeoutMs = null,
-    executionDeadlineUtc = null, preExecutionCheck = null }) {
+    executionDeadlineUtc = null, preExecutionCheck = null, cancellationCheck = null }) {
     const lease = await assertCodingArmed(policy, rootId);
     if (!ID_RE.test(commandId ?? '')) throw new Error('invalid coding command id');
     const command = policy.commands[commandId];
@@ -633,28 +634,58 @@ export function createCodingRuntime({ policy, signingKeyPath, verifyKeyPath }) {
     if (deadlineBound < 100) throw new Error('coding execution deadline expires too soon to execute command');
     const effectiveTimeout = Math.min(requestedTimeout, command.timeout_ms, grantBound, deadlineBound);
     const argv = [...command.prefix_args, script.resolved, ...args];
+    // The internal Windows host owns a kill-on-close Job Object. Its identity
+    // is package-pinned, never selected by a caller or granted public PID input.
+    let executable=command.executable, launchArgs=argv;
+    if(process.platform==='win32'){
+      const host=fileURLToPath(new URL('../bin/deadbyte-process-host.exe',import.meta.url));
+      const hostPolicy=JSON.parse(await readFile(new URL('../controller/deadbyte-process-policy.json',import.meta.url),'utf8'));
+      if(await sha256File(host)!==hostPolicy.native_host?.sha256) throw new Error('coding process host hash changed');
+      executable=host;
+      launchArgs=[command.executable,cwdResolved,randomBytes(32).toString('hex'),'--deadbyte-transport=pipe-quiet',...argv];
+    }
+    if(cancellationCheck!==null&&typeof cancellationCheck!=='function') throw new Error('cancellation check must be internal function');
+    if(cancellationCheck&&await cancellationCheck()) throw new Error('coding command cancelled before dispatch');
+    await recheckCodingAuthority(policy,activeLease,rootId);
     const startMs = performance.now();
-    const child = spawn(command.executable, argv, {
+    const child = spawn(executable, launchArgs, {
       cwd: cwdResolved, env: codingEnvironment(), shell: false, windowsHide: true,
-      detached: false, stdio: ['ignore', 'pipe', 'pipe']
+      detached: process.platform!=='win32', stdio: ['ignore', 'pipe', 'pipe']
     });
+    const killOwned=()=>{
+      if(child.exitCode!==null||child.signalCode!==null)return;
+      if(process.platform==='win32') child.kill('SIGKILL');
+      else {try{process.kill(-child.pid,'SIGKILL');}catch(error){if(error.code!=='ESRCH')throw error;}}
+    };
     const stdoutState = { chunks: [], bytes: 0, exceeded: null };
     const stderrState = { chunks: [], bytes: 0, exceeded: null };
-    collectBounded(child.stdout, command.max_output_bytes, stdoutState, 'stdout', () => child.kill('SIGKILL'));
-    collectBounded(child.stderr, command.max_output_bytes, stderrState, 'stderr', () => child.kill('SIGKILL'));
+    collectBounded(child.stdout, command.max_output_bytes, stdoutState, 'stdout', killOwned);
+    collectBounded(child.stderr, command.max_output_bytes, stderrState, 'stderr', killOwned);
     let timedOut = false;
     let timer;
+    let cancelTimer,checking=false,cancellationError=null,finished=false;
+    if(cancellationCheck){
+      cancelTimer=setInterval(async()=>{
+        if(checking||finished)return;
+        checking=true;
+        try{if(await cancellationCheck())killOwned();}
+        catch(error){cancellationError=error;killOwned();}
+        finally{checking=false;}
+      },50);
+      cancelTimer.unref?.();
+    }
     const timerDelay = deadlineAtMs === null
       ? effectiveTimeout
       : Math.max(1, Math.min(effectiveTimeout, Math.floor(deadlineAtMs - Date.now())));
     const completion = new Promise((resolve, reject) => {
       child.once('error', reject);
       child.once('close', (code, signal) => resolve({ code, signal }));
-      timer = setTimeout(() => { timedOut = true; child.kill('SIGKILL'); }, timerDelay);
+      timer = setTimeout(() => { timedOut = true; killOwned(); }, timerDelay);
       timer.unref?.();
     });
     let result;
-    try { result = await completion; } finally { if (timer) clearTimeout(timer); }
+    try { result = await completion; } finally { finished=true;if (timer) clearTimeout(timer);if(cancelTimer)clearInterval(cancelTimer); }
+    if(cancellationError)throw cancellationError;
     if (stdoutState.exceeded || stderrState.exceeded) throw new Error(stdoutState.exceeded ?? stderrState.exceeded);
     const stdoutBytes = Buffer.concat(stdoutState.chunks);
     const stderrBytes = Buffer.concat(stderrState.chunks);
@@ -669,7 +700,7 @@ export function createCodingRuntime({ policy, signingKeyPath, verifyKeyPath }) {
   }
 
   async function commandRun({ rootId, commandId, scriptPath, scriptSha256, args = [], cwd = '.', timeoutMs = null,
-    executionDeadlineUtc = null, preExecutionCheck = null, receiptId = null, requestSha256 = null }) {
+    executionDeadlineUtc = null, preExecutionCheck = null, cancellationCheck = null, receiptId = null, requestSha256 = null }) {
     const request = requestSha256 ?? requestSha('coding_command_run', {
       root_id: rootId, command_id: commandId, script_path: scriptPath, script_sha256: scriptSha256,
       args, cwd, timeout_ms: timeoutMs
@@ -704,7 +735,7 @@ export function createCodingRuntime({ policy, signingKeyPath, verifyKeyPath }) {
     }
     const execution = (async () => {
       const started = new Date().toISOString();
-      const result = await runCommandOnce({ rootId, commandId, scriptPath, scriptSha256, args, cwd, timeoutMs, executionDeadlineUtc, preExecutionCheck });
+      const result = await runCommandOnce({ rootId, commandId, scriptPath, scriptSha256, args, cwd, timeoutMs, executionDeadlineUtc, preExecutionCheck, cancellationCheck });
       const signed = await signCodingReceipt(policy, signingKeyPath, result.lease, {
         operation: 'coding_command_run', request_sha256: request, root_id: rootId, command_id: commandId,
         script_path: scriptPath, executable_sha256: result.executable_sha256, script_sha256: result.script_sha256,
@@ -751,7 +782,7 @@ export function createCodingRuntime({ policy, signingKeyPath, verifyKeyPath }) {
 
   async function benchmarkRun({ rootId, commandId, scriptPath, scriptSha256, args = [], cwd = '.', timeoutMs = null,
     executionDeadlineUtc = null, preExecutionCheck = null, warmups = 1, iterations = 5, baselineMedianMs = null, maxRegressionPct = 5,
-    receiptId = null, requestSha256 = null }) {
+    receiptId = null, requestSha256 = null, cancellationCheck = null }) {
     if (!Number.isInteger(warmups) || warmups < 0 || warmups > 3) throw new Error('warmups must be in [0, 3]');
     if (!Number.isInteger(iterations) || iterations < 1 || iterations > 20) throw new Error('iterations must be in [1, 20]');
     if (baselineMedianMs !== null && (!Number.isFinite(baselineMedianMs) || baselineMedianMs <= 0)) throw new Error('baseline_median_ms must be positive or null');
@@ -762,13 +793,13 @@ export function createCodingRuntime({ policy, signingKeyPath, verifyKeyPath }) {
       max_regression_pct: maxRegressionPct
     });
     for (let i = 0; i < warmups; i += 1) {
-      const warm = await runCommandOnce({ rootId, commandId, scriptPath, scriptSha256, args, cwd, timeoutMs, executionDeadlineUtc, preExecutionCheck });
+      const warm = await runCommandOnce({ rootId, commandId, scriptPath, scriptSha256, args, cwd, timeoutMs, executionDeadlineUtc, preExecutionCheck, cancellationCheck });
       if (warm.timed_out || warm.exit_code !== 0) throw new Error(`benchmark warmup failed exit=${String(warm.exit_code)} timed_out=${warm.timed_out}`);
     }
     const samples = [];
     let last = null;
     for (let i = 0; i < iterations; i += 1) {
-      last = await runCommandOnce({ rootId, commandId, scriptPath, scriptSha256, args, cwd, timeoutMs, executionDeadlineUtc, preExecutionCheck });
+      last = await runCommandOnce({ rootId, commandId, scriptPath, scriptSha256, args, cwd, timeoutMs, executionDeadlineUtc, preExecutionCheck, cancellationCheck });
       if (last.timed_out || last.exit_code !== 0) throw new Error(`benchmark iteration ${i + 1} failed exit=${String(last.exit_code)} timed_out=${last.timed_out}`);
       samples.push(last.elapsed_ms);
     }

package/src/coding-task-runtime.mjs

@@ -474,7 +474,7 @@ async function reconcileInterrupted(ctx, plan, events, derived, codingRuntime, s
   return deriveState(plan, events);
 }
 
-async function executeStep(codingRuntime, plan, step, attempt) {
+async function executeStep(codingRuntime, plan, step, attempt, cancellationCheck = null) {
   const receiptId = receiptIdFor(plan.task_id, step.step_id, attempt, plan.plan_sha256);
   const requestSha256 = expectedRequest(codingRuntime, step);
   if (step.kind === 'write') {
@@ -486,12 +486,12 @@ async function executeStep(codingRuntime, plan, step, attempt) {
   } else if (step.kind === 'command') {
     await codingRuntime.commandRun({ rootId: step.root_id, commandId: step.command_id, scriptPath: step.script_path,
       scriptSha256: step.script_sha256, args: step.args, cwd: step.cwd, timeoutMs: step.timeout_ms,
-      receiptId, requestSha256 });
+      receiptId, requestSha256, cancellationCheck });
   } else if (step.kind === 'benchmark') {
     await codingRuntime.benchmarkRun({ rootId: step.root_id, commandId: step.command_id, scriptPath: step.script_path,
       scriptSha256: step.script_sha256, args: step.args, cwd: step.cwd, timeoutMs: step.timeout_ms,
       warmups: step.warmups, iterations: step.iterations, baselineMedianMs: step.baseline_median_ms,
-      maxRegressionPct: step.max_regression_pct, receiptId, requestSha256 });
+      maxRegressionPct: step.max_regression_pct, receiptId, requestSha256, cancellationCheck });
   } else {
     throw new Error(`coding step '${step.step_id}' is not executable`);
   }
@@ -670,7 +670,10 @@ export function createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyK
         try {
           const remainingMs = timeoutMs === null ? null : Math.max(100, Math.floor(deadlineState(deadline).remaining_ms));
           const boundedStep = remainingMs === null ? next : { ...next, timeout_ms: next.timeout_ms === null || next.timeout_ms === undefined ? remainingMs : Math.min(next.timeout_ms, remainingMs) };
-          const executed = await executeStep(codingRuntime, plan, boundedStep, attempt);
+          const executed = await executeStep(codingRuntime, plan, boundedStep, attempt,()=>readCancel(ctx,verifyKeyPath));
+          if(await consumeCancel(ctx,journal,signingKeyPath,verifyKeyPath)){
+            derived=deriveState(plan,journal);return {status:'cancelled',task_id:taskId,...derived};
+          }
           if (!executed.outcome.valid) {
             await appendEvent(ctx, journal, signingKeyPath, 'task_paused', {
               stepId: next.step_id, payload: { reason: 'post_execute_receipt_mismatch', detail: executed.outcome.reason }
@@ -700,6 +703,9 @@ export function createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyK
           }
           derived = deriveState(plan, journal);
         } catch (error) {
+          if(await consumeCancel(ctx,journal,signingKeyPath,verifyKeyPath)){
+            derived=deriveState(plan,journal);return {status:'cancelled',task_id:taskId,...derived};
+          }
           if (deadlineExpired()) {
             derived = await failDeadline(ctx, journal, plan, next.step_id);
             return { status: 'failed', task_id: taskId, ...derived, deadline };

package/src/deadbyte-cli.mjs

@@ -16,6 +16,8 @@ import { printDoctor } from './doctor-r45.mjs';
 import { createLiveTimelineFilter, createLiveTimelineTracker, createLiveTimelineWriter, formatCompactAuditEvent, formatRemoteLifecycle, formatRemoteToolCall, formatRuntimeDiagnosticLine, selectLiveLogNames } from './remote-live-log.mjs';
 import { prepareRemoteConsole, remoteDisplayText } from './remote-console.mjs';
 import { ensureRuntimeCoherence } from './runtime-coherence.mjs';
+import { windowsPowerShellEnvironment } from './runtime-update.mjs';
+import { resolveStateRoot } from './state-root.mjs';
 
 const REMOTE_COMMANDS=new Set([
   'menu','start','resume','park','stop','restart','status','url','test','fulltest','toggle','clean','machinetest',
@@ -42,7 +44,7 @@ const CURRENT_DEPLOY_SCRIPT=path.join(CURRENT_PACKAGE_ROOT,'scripts','deploy-r48
 const REMOTE_UPDATE_TIMEOUT_MS=900000;
 const LIVE_LOG_DISCOVERY_INTERVAL_MS=1000;
 
-function stateRoot(){return path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));}
+function stateRoot(){return resolveStateRoot();}
 async function requireRegular(file,label){const info=await lstat(file);if(!info.isFile()||info.isSymbolicLink()) throw new Error(`${label} must be a regular non-symlink file`);return file;}
 function printHelp(){
   const exact=`deadbyte-mcp@${DEADBYTE_VERSION}`;
@@ -171,7 +173,7 @@ function invokeController(ctx,command,{capture=false,allowFailure=false,echoCapt
       stderrFd=openSync(redirectOutput.stderr_path,'w');
       stdio=['ignore',stdoutFd,stderrFd];
     }else stdio=capture?['ignore','pipe','pipe']:'inherit';
-    const options={stdio,encoding:capture?'utf8':undefined,windowsHide:false,shell:false};
+    const options={stdio,encoding:capture?'utf8':undefined,windowsHide:false,shell:false,env:windowsPowerShellEnvironment()};
     if(Number.isInteger(timeoutMs)&&timeoutMs>0) options.timeout=timeoutMs;
     result=spawnSync(ctx.powershell,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',ctx.launcher,command],options);
   }finally{

package/src/doctor-r45.mjs

@@ -4,9 +4,10 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { DEADBYTE_VERSION, MCP_PROTOCOL_VERSION } from './version.mjs';
+import { resolveStateRoot } from './state-root.mjs';
 
 const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
-const stateRoot=()=>path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const stateRoot=()=>resolveStateRoot();
 const sha256=b=>createHash('sha256').update(b).digest('hex');
 async function jsonOrNull(file){try{return JSON.parse((await readFile(file,'utf8')).replace(/^\uFEFF/,''));}catch(e){if(e?.code==='ENOENT')return null;throw e;}}
 async function fileHash(file){return sha256(await readFile(file));}