deadbyte-mcp 0.15.35 → 0.15.37

package/bridge/src/remote-dispatch-r60.mjs

@@ -0,0 +1,75 @@
+// This function is the one downstream-dispatch boundary used by the Bridge.
+// A published dispatch marker precedes every call that might mutate Core.
+const READ_ONLY_TOOLS=new Set([
+  'agent_task_events','agent_task_status','agent_task_verify',
+  'autonomous_goal_events','autonomous_goal_status','autonomous_goal_verify','autonomous_session_status',
+  'capability_manifest','coding_file_read','coding_files_read','coding_receipt_verify','coding_search',
+  'coding_session_status','coding_stat','coding_symbol_definition','coding_symbol_outline','coding_symbol_references',
+  'coding_task_events','coding_task_status','coding_task_verify','coding_tree','evidence_verify','file_read',
+  'host_file_read','machine_fs_list','machine_fs_read','machine_fs_stat','machine_list','machine_ping',
+  'machine_process_list','machine_search_page','machine_search_status','machine_status','machine_system_status',
+  'native_diff_preview','native_diff_verify','process_session_list','process_session_read','process_session_status'
+]);
+const MUTATING_TOOLS=new Set([
+  'agent_task_approve','agent_task_cancel','agent_task_run','agent_task_submit',
+  'autonomous_goal_approve','autonomous_goal_cancel','autonomous_goal_run','autonomous_goal_submit','autonomous_release_gate',
+  'coding_benchmark_run','coding_command_run','coding_file_write','coding_symbol_replace','coding_task_approve',
+  'coding_task_cancel','coding_task_run','coding_task_submit','coding_text_replace','contained_transform',
+  'host_exec','host_file_write','machine_fs_delete','machine_fs_edit_exact','machine_fs_mkdir','machine_fs_move',
+  'machine_fs_write','machine_revoke','machine_search_cancel','machine_search_start','native_diff_apply',
+  'process_session_action','process_session_start','process_session_terminate','proof_execute','workspace_open'
+]);
+const COMPACT_READ_ONLY={
+  machine_fs:new Set(['stat','list','read']),
+  process_session:new Set(['read','status','list']),
+  machine_observe:new Set(['machine_list','machine_status','machine_ping','search_page','search_status',
+    'process_list','system_status','hardware_query','registry_query','service_list','driver_list',
+    'socket_list','volume_list','usb_list','wsl_list']),
+  coding_inspect:new Set(['stat','search','files_read','symbol_outline','symbol_definition','symbol_references',
+    'symbol_diagnostics','symbol_implementations','symbol_rename_preview']),
+  desktop_control:new Set(['observe','status'])
+};
+const COMPACT_MUTATING={
+  machine_fs:new Set(['write','edit_exact','mkdir','move','delete']),
+  process_session:new Set(['start','write','action','terminate']),
+  machine_observe:new Set(['search_start','search_cancel']),
+  desktop_control:new Set(['target','action'])
+};
+
+export function classifyRemoteOperation(tool,args){
+  const name=tool?.name;
+  if(typeof name!=='string')return 'unknown';
+  if(Object.hasOwn(COMPACT_READ_ONLY,name)||Object.hasOwn(COMPACT_MUTATING,name)){
+    if(COMPACT_READ_ONLY[name]?.has(args?.op))return 'read_only';
+    if(COMPACT_MUTATING[name]?.has(args?.op))return 'mutating';
+    return 'unknown';
+  }
+  if(MUTATING_TOOLS.has(name))return 'mutating';
+  if(READ_ONLY_TOOLS.has(name))return 'read_only';
+  return 'unknown';
+}
+
+export async function dispatchBridgeCall({claims,binding,classification,signal,invoke}){
+  if(!claims||typeof claims.claim!=='function'||typeof invoke!=='function')throw new Error('remote dispatch dependencies invalid');
+  if(!['read_only','mutating','unknown'].includes(classification))throw new Error('remote dispatch classification invalid');
+  const claim=await claims.claim(binding);
+  if(claim.state==='TERMINAL')return claim.result;
+  const recoveredRead=claim.state==='INTERRUPTED'&&classification==='read_only'&&claim.side_effect_state==='none';
+  if((claim.state==='EXECUTING'||claim.state==='INTERRUPTED')&&!recoveredRead)throw new Error(`remote claim ${claim.claim_id} outcome unknown; reconcile before retry`);
+  if(claim.state!=='CLAIMED'&&!recoveredRead)throw new Error(`remote claim ${claim.claim_id} is ${claim.state}; no dispatch`);
+  if(signal?.aborted)throw new Error(`remote claim ${claim.claim_id} cancelled before dispatch`);
+  if(!recoveredRead){
+    try{await claims.dispatch(claim.claim_id);}
+    catch(error){throw new Error(`remote claim ${claim.claim_id} already in flight; no replay`,{cause:error});}
+  }
+  let result;
+  try{result=await invoke();}
+  catch(error){throw new Error(`remote claim ${claim.claim_id} outcome unknown after dispatch; no replay`,{cause:error});}
+  try{await claims.terminal(claim.claim_id,result);}
+  catch(error){
+    const existing=await claims.state(claim.claim_id);
+    if(recoveredRead&&existing.state==='TERMINAL')return existing.result;
+    throw new Error(`remote claim ${claim.claim_id} terminal publication failed; outcome unknown`,{cause:error});
+  }
+  return result;
+}

package/controller/deadbyte-controller.ps1

@@ -685,11 +685,31 @@ function Stop-OwnedComponent([string]$Name) {
     Remove-Item -LiteralPath (Ledger-Path $Name) -Force -ErrorAction SilentlyContinue
 }
 
-function Test-LocalReady($Cfg) {
+function Get-LocalHealth($Cfg) {
+    $response = $null
+    try {
+        $request = [System.Net.HttpWebRequest]::Create([string]$Cfg.LocalReadyUri)
+        $request.Timeout = [int]$Cfg.ProbeTimeoutSeconds * 1000
+        $request.ReadWriteTimeout = [int]$Cfg.ProbeTimeoutSeconds * 1000
+        $response = $request.GetResponse()
+    } catch [System.Net.WebException] {
+        $response = $_.Exception.Response
+        if ($null -eq $response) { return [pscustomobject]@{ State='UNREACHABLE'; StatusCode=0; Diagnostic='readiness endpoint unreachable' } }
+    } catch { return [pscustomobject]@{ State='UNREACHABLE'; StatusCode=0; Diagnostic='readiness probe failed' } }
     try {
-        $r = Invoke-WebRequest -UseBasicParsing -Uri ([string]$Cfg.LocalReadyUri) -TimeoutSec ([int]$Cfg.ProbeTimeoutSeconds)
-        return ($r.StatusCode -ge 200 -and $r.StatusCode -lt 300)
-    } catch { return $false }
+        $status = [int]$response.StatusCode
+        $reader = New-Object System.IO.StreamReader($response.GetResponseStream())
+        try { $body = $reader.ReadToEnd() } finally { $reader.Dispose() }
+        try { $parsed = $body | ConvertFrom-Json } catch { return [pscustomobject]@{ State='INVALID'; StatusCode=$status; Diagnostic='readiness response JSON invalid' } }
+        if ($parsed.schema -ne 'deadbyte.bridge-health.v1' -or [string]$parsed.state -notin @('STARTING','READY','DEGRADED','RECONCILING','STOPPING')) {
+            return [pscustomobject]@{ State='INVALID'; StatusCode=$status; Diagnostic='readiness response schema invalid' }
+        }
+        return [pscustomobject]@{ State=[string]$parsed.state; StatusCode=$status; Diagnostic=[string]$parsed.diagnostic }
+    } finally { if ($null -ne $response) { $response.Dispose() } }
+}
+function Test-LocalReady($Cfg) {
+    $health = Get-LocalHealth $Cfg
+    return ($health.State -eq 'READY' -and $health.StatusCode -ge 200 -and $health.StatusCode -lt 300)
 }
 function Get-LocalReadyListenerOwners($Cfg) {
     try { $uri = [Uri]([string]$Cfg.LocalReadyUri) } catch { Fail 'LocalReadyUri is invalid' }
@@ -719,18 +739,43 @@ function Test-LocalReadyOwned($Cfg, $Bridge) {
     if ($owners.Count -ne 1 -or $owners[0] -ne [int]$Bridge.Ledger.pid) { return $false }
     return (Test-LocalReady $Cfg)
 }
+function Get-LocalHealthOwned($Cfg, $Bridge) {
+    if (-not $Bridge -or -not $Bridge.Alive) { return [pscustomobject]@{ State='UNREACHABLE'; StatusCode=0; Diagnostic='bridge not alive' } }
+    $owners = @(Get-LocalReadyListenerOwners $Cfg)
+    if ($owners.Count -ne 1 -or $owners[0] -ne [int]$Bridge.Ledger.pid) { return [pscustomobject]@{ State='UNATTRIBUTED'; StatusCode=0; Diagnostic='readiness listener ownership mismatch' } }
+    return (Get-LocalHealth $Cfg)
+}
 
 function Get-ObservedState($Cfg) {
     $bridge = Test-OwnedInstance 'Bridge'
     $cloud = Test-OwnedInstance 'Cloud'
     $core = Get-DownstreamCoreObservation $Cfg $bridge
-    $ready = if ($bridge.Alive -and $core.alive) { try { Test-LocalReadyOwned $Cfg $bridge } catch { $false } } else { $false }
+    $health = if ($bridge.Alive -and $core.alive) { try { Get-LocalHealthOwned $Cfg $bridge } catch { [pscustomobject]@{ State='UNREACHABLE'; StatusCode=0; Diagnostic='readiness attribution failed' } } } else { [pscustomobject]@{ State='UNREACHABLE'; StatusCode=0; Diagnostic='core not alive' } }
+    $ready = $health.State -eq 'READY'
     $state = if (-not $bridge.Alive -and -not $cloud.Alive) { 'OFFLINE' }
              elseif (-not $bridge.Alive -and $cloud.Alive) { 'PARKED' }
              elseif ($bridge.Alive -and $cloud.Alive -and $ready) { 'ONLINE' }
+             elseif ($bridge.Alive -and $cloud.Alive -and $core.alive -and $health.State -eq 'DEGRADED') { 'DEGRADED' }
              elseif ($bridge.Alive -and $core.reason -eq 'startup-zero-child') { 'STARTING' }
              else { 'FAILED' }
-    [pscustomobject]@{ State=$state; Bridge=$bridge; Core=$core; Cloud=$cloud; LocalReady=$ready }
+    [pscustomobject]@{ State=$state; Bridge=$bridge; Core=$core; Cloud=$cloud; LocalReady=$ready; LocalHealth=$health }
+}
+
+function Wait-LocalOperational($Cfg) {
+    $deadline = [DateTime]::UtcNow.AddSeconds([int]$Cfg.StartTimeoutSeconds)
+    do {
+        $bridge = Test-OwnedInstance 'Bridge'
+        if (-not $bridge.Alive) { return $null }
+        $core = Get-DownstreamCoreObservation $Cfg $bridge
+        if (-not $core.alive -and $core.reason -ne 'startup-zero-child') { return $null }
+        if ($core.alive) {
+            $health = Get-LocalHealthOwned $Cfg $bridge
+            if ($health.State -in @('READY','DEGRADED')) { return $health }
+        }
+        if ([DateTime]::UtcNow -ge $deadline) { return $null }
+        Start-Sleep -Milliseconds 250
+    } while ([DateTime]::UtcNow -lt $deadline)
+    return $null
 }
 
 function Wait-LocalReady($Cfg) {
@@ -842,17 +887,18 @@ function Invoke-CoreGate($Cfg, [string]$ScriptName, [string[]]$ExtraArguments =
 
 function Start-Deadbyte($Cfg) {
     $state = Get-ObservedState $Cfg
-    if ($state.State -eq 'ONLINE') { return $state }
+    if ($state.State -in @('ONLINE','DEGRADED')) { return $state }
     if ($state.State -in @('FAILED','STARTING')) { Fail "runtime is $($state.State); inspect status and reconcile verified owned components before restart" }
     $cloudWasAlive = [bool]$state.Cloud.Alive
     Assert-LocalReadyPortAvailable $Cfg
     try {
         Start-OwnedComponent 'Bridge' $Cfg.Bridge $Cfg | Out-Null
-        if (-not (Wait-LocalReady $Cfg)) { Fail 'bridge started but owned local readiness gate failed' }
+        $localHealth = Wait-LocalOperational $Cfg
+        if ($null -eq $localHealth) { Fail 'bridge started but owned local readiness gate failed' }
         Start-OwnedComponent 'Cloud' $Cfg.Cloud $Cfg | Out-Null
         if (-not (Wait-CurrentUrl $Cfg)) { Fail 'public endpoint metadata did not become available before timeout' }
         $final = Get-ObservedState $Cfg
-        if ($final.State -ne 'ONLINE') { Fail "start gate failed: observed $($final.State)" }
+        if ($final.State -notin @('ONLINE','DEGRADED')) { Fail "start gate failed: observed $($final.State)" }
         return $final
     } catch {
         try { Stop-OwnedComponent 'Bridge' } catch {}
@@ -879,6 +925,18 @@ function Stop-Deadbyte($Cfg) {
     return $s
 }
 
+function Assert-PolicyRootsAvailable($Policy, [string]$Plane) {
+    $rootIds = @($Policy.roots.PSObject.Properties.Name)
+    if ($rootIds.Count -lt 1) { Fail "$Plane policy requires at least one root" }
+    foreach ($rootId in $rootIds) {
+        $raw = [string]$Policy.roots.$rootId.path
+        if ([string]::IsNullOrWhiteSpace($raw)) { Fail "$Plane policy root '$rootId' path missing" }
+        try { $full = [System.IO.Path]::GetFullPath($raw) } catch { Fail "$Plane policy root '$rootId' path invalid" }
+        if (-not (Test-Path -LiteralPath $full -PathType Container)) { Fail "$Plane policy root '$rootId' missing: $full" }
+    }
+    return $rootIds
+}
+
 function Get-HostPolicyMetadata($Cfg) {
     if ([string]::IsNullOrWhiteSpace([string]$Cfg.HostPolicyFile)) { Fail 'privileged host plane is not configured' }
     $policyPath = [string]$Cfg.HostPolicyFile
@@ -888,6 +946,7 @@ function Get-HostPolicyMetadata($Cfg) {
     $armFile = [System.IO.Path]::GetFullPath([string]$policy.arm_file)
     $runtimeReal = [System.IO.Path]::GetFullPath($RuntimeDir).TrimEnd('\') + '\'
     if (-not $armFile.StartsWith($runtimeReal, [System.StringComparison]::OrdinalIgnoreCase)) { Fail 'host policy arm_file must live under controller runtime directory' }
+    Assert-PolicyRootsAvailable $policy 'host' | Out-Null
     [pscustomobject]@{
         Path = $policyPath
         Sha256 = Get-ExecutableHash $policyPath
@@ -950,7 +1009,7 @@ function Get-ProcessPolicyMetadata($Cfg) {
     $runtimeReal = [System.IO.Path]::GetFullPath($RuntimeDir).TrimEnd('\') + '\'
     if (-not $grantFile.StartsWith($runtimeReal, [System.StringComparison]::OrdinalIgnoreCase)) { Fail 'process policy grant_file must live under controller runtime directory' }
     $profileIds = @($policy.profiles.PSObject.Properties.Name)
-    $rootIds = @($policy.roots.PSObject.Properties.Name)
+    $rootIds = @(Assert-PolicyRootsAvailable $policy 'process')
     if ($profileIds.Count -lt 1 -or $rootIds.Count -lt 1) { Fail 'process policy requires profiles and roots' }
     [pscustomobject]@{ Path=$policyPath; Sha256=Get-ExecutableHash $policyPath; GrantFile=$grantFile; ProfileIds=$profileIds; RootIds=$rootIds }
 }
@@ -1010,8 +1069,7 @@ function Get-CodingPolicyMetadata($Cfg) {
     $leaseFile = [System.IO.Path]::GetFullPath([string]$policy.lease_file)
     $runtimeReal = [System.IO.Path]::GetFullPath($RuntimeDir).TrimEnd('\') + '\'
     if (-not $leaseFile.StartsWith($runtimeReal, [System.StringComparison]::OrdinalIgnoreCase)) { Fail 'coding policy lease_file must live under controller runtime directory' }
-    $rootIds = @($policy.roots.PSObject.Properties.Name)
-    if ($rootIds.Count -lt 1) { Fail 'coding policy requires at least one root' }
+    $rootIds = @(Assert-PolicyRootsAvailable $policy 'coding')
     [pscustomobject]@{ Path=$policyPath; Sha256=Get-ExecutableHash $policyPath; LeaseFile=$leaseFile; RootIds=$rootIds }
 }
 
@@ -1374,7 +1432,12 @@ function Invoke-MachineSmoke($Cfg) {
     $url = Get-CurrentUrl $Cfg
     if (-not $url) { Fail 'public MCP URL unavailable' }
     Wait-PublicDnsReady $Cfg $url
-    Invoke-CoreGate $Cfg 'remote-mcp-machine-smoke-client.mjs' @($url)
+    $probeArgs = @($url)
+    if (-not [string]::IsNullOrWhiteSpace([string]$env:DEADBYTE_REMOTE_PROBE_MODE)) {
+        if ([string]$env:DEADBYTE_REMOTE_PROBE_MODE -notin @('default','desktop','host','full','revoked')) { Fail 'invalid remote enforcement probe mode' }
+        $probeArgs += [string]$env:DEADBYTE_REMOTE_PROBE_MODE
+    }
+    Invoke-CoreGate $Cfg 'remote-mcp-machine-smoke-client.mjs' $probeArgs
     Write-Host 'MACHINE IDENTITY LIVE GATE PASS: public status/list + SPKI identity + signed Ed25519 ping verified.'
 }
 

package/controller/deadbyte-process-policy.json

@@ -1,15 +1,15 @@
 {
   "schema": "deadbyte.process-policy.v1",
   "enabled": true,
-  "grant_file": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.35-r58\\controller\\runtime\\process-grant.json",
-  "state_dir": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.35-r58\\controller\\runtime\\process-state",
+  "grant_file": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.37-r60\\controller\\runtime\\process-grant.json",
+  "state_dir": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.37-r60\\controller\\runtime\\process-state",
   "native_host": {
-    "path": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.35-r58\\bin\\deadbyte-process-host.exe",
+    "path": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.37-r60\\bin\\deadbyte-process-host.exe",
     "sha256": "daf9cfb371bee88cafbf5597eaa507fec504dbe0b0ddd40d0c3c2e02817f49e4"
   },
   "roots": {
     "core": {
-      "path": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.35-r58",
+      "path": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.37-r60",
       "deny_paths": [
         "node_modules",
         "controller/runtime",

package/docs/R59-PROVENANCE.json

@@ -0,0 +1,87 @@
+{
+    "schema":  "deadbyte.provenance.v1",
+    "version":  "0.15.36",
+    "source_model":  "exact published and production-accepted 0.15.35 artifact -\u003e isolated R59 candidate -\u003e optional-plane degraded availability -\u003e runtime capability snapshot v3 -\u003e bounded Bridge Core reconciliation with no mutation replay -\u003e controller root preflight -\u003e fresh full regression/package/public frontdoor gates -\u003e operator-authorized publication with four-hour soak and clean-machine explicitly not completed -\u003e production activation/rollback/restore",
+    "signing":  "ed25519",
+    "parent_tarball_sha256":  "8259e30946d28dd138c1e2ce2f483fe1370d1658544f2adbfebafa4db8875bba",
+    "parent_activation_status":  "PRODUCTION_ACCEPTED_WITH_SIGNED_ROLLBACK_AND_RESTORE",
+    "parent_rollback_receipt_sha256":  "2f8aa5784fe6629c25af776b247b22b8e84d1a51c3420339ddd7a7445cf6ff9b",
+    "runtime_predecessor":  {
+                                "release_id":  "v0.15.35-1b5715b276facbc0",
+                                "manifest_sha256":  "1b5715b276facbc00f8e341a554472cb4829e5af60e221c357c41b66053af9d4",
+                                "generation_manifest_sha256":  "047e73b62d7b7819b84201a221a09b7e647cacf21f82101ebed4fbd7e23fc430"
+                            },
+    "source_predecessor_tarball_sha256":  "8259e30946d28dd138c1e2ce2f483fe1370d1658544f2adbfebafa4db8875bba",
+    "source_predecessor_manifest_file_sha256":  "1b5715b276facbc00f8e341a554472cb4829e5af60e221c357c41b66053af9d4",
+    "reproducibility":  "0.15.35 remains immutable production authority while R59 is developed in D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.36-r59. Publication is operator-authorized with four-hour soak and clean-machine truth preserved as NOT_COMPLETED; no stable/final claim is permitted.",
+    "public_surface_evidence":  {
+                                    "status":  "PASS",
+                                    "baseline_release":  "v0.15.35-1b5715b276facbc0",
+                                    "tool_count":  43,
+                                    "unchanged":  43,
+                                    "added":  0,
+                                    "removed":  0,
+                                    "schema_changed":  0,
+                                    "surface_sha256":  "8e98978b720633acb0c7d4d65c36a945243c47f6dbccfa64ab877329f2956fe3",
+                                    "evidence_receipt_sha256":  "2d3adcc33d010c4977974971222e6b13d613ff268097fff0eec0113e4f82f281"
+                                },
+    "fresh_full_regression":  {
+                                  "status":  "PENDING_R59_AFTER_RELEASE_IDENTITY_CUT",
+                                  "proof_path":  "proof/r59-full-regression-current.json"
+                              },
+    "inherited_r58_consolidation":  {
+                                        "frontend_status_vocabulary":  true,
+                                        "read_only_structured_status":  true,
+                                        "doctor_read_only_installation_runtime_transaction_checks":  true,
+                                        "stale_foreground_identity_hardening":  true,
+                                        "bridge_bundled_inside_release":  true,
+                                        "bridge_recursive_local_dependency_binding":  true,
+                                        "bridge_dynamic_relative_import_fail_closed":  true,
+                                        "bridge_path_escape_fail_closed":  true,
+                                        "isolated_controller_bridge_core_lifecycle":  "PASS",
+                                        "performance_acceptance":  "PASS_BOUNDED_PREPUBLISH",
+                                        "fresh_full_regression":  "PASS",
+                                        "package_acceptance":  "PENDING",
+                                        "registry_round_trip":  "PENDING",
+                                        "production_activation_rollback_restore":  "PENDING",
+                                        "stable_final_claim":  false,
+                                        "cross_plane_acceptance":  "PASS",
+                                        "public_surface_compatibility":  "PASS_43_TOOLS_NO_SCHEMA_DRIFT"
+                                    },
+    "r59_runtime_hardening":  {
+                                  "optional_plane_degradation":  true,
+                                  "stable_tool_registration_on_optional_failure":  true,
+                                  "capability_manifest_v3":  true,
+                                  "live_overlay_authority_ceiling":  true,
+                                  "bridge_bounded_reconciliation":  true,
+                                  "bridge_health_requires_fresh_child_catalog_capability_attestation":  true,
+                                  "mutation_unknown_outcome_no_replay":  true,
+                                  "read_only_retry_only_before_dispatch":  true,
+                                  "cancellation_aware_governor":  true,
+                                  "controller_policy_root_preflight":  true,
+                                  "public_surface_compatibility":  "PASS_43_TOOLS_NO_SCHEMA_DRIFT",
+                                  "frontdoor_signed_ping":  "PASS",
+                                  "four_hour_soak":  "NOT_COMPLETED",
+                                  "clean_machine":  "NOT_COMPLETED",
+                                  "stable_final_claim":  false
+                              },
+    "inherited_parent_performance_evidence":  {
+                                                  "summary_path":  "D:\\Projects\\deadbyte-mcp\\testing\\0.15.35\\performance-summary.json",
+                                                  "summary_sha256":  "4586d8462ce1ae643d255315d4b4febfdd3f731dd8728e4b37b5636b622b756c",
+                                                  "bridge_candidate_first_p95_reduction_pct":  63.632445348471286,
+                                                  "bridge_baseline_first_p95_reduction_pct":  43.06594367803213,
+                                                  "stdio_aggregate_p95_delta_pct":  1.984392678457768,
+                                                  "limitations_preserved":  true
+                                              },
+    "builder":  "deadbyte-r59-resilient-runtime",
+    "parent_release_id":  "v0.15.35-1b5715b276facbc0",
+    "parent_manifest_sha256":  "1b5715b276facbc00f8e341a554472cb4829e5af60e221c357c41b66053af9d4",
+    "parent_generation_manifest_sha256":  "047e73b62d7b7819b84201a221a09b7e647cacf21f82101ebed4fbd7e23fc430",
+    "source_predecessor_version":  "0.15.35",
+    "operator_override":  {
+                              "four_hour_soak":  "WAIVED_BY_OPERATOR",
+                              "clean_machine":  "WAIVED_BY_OPERATOR",
+                              "reason":  "Operator explicitly requested immediate deployment without further testing.",
+                              "stable_final_claim":  false
+                          }
+}

package/docs/R59-RELEASE.json

@@ -0,0 +1,187 @@
+{
+    "schema":  "deadbyte.release.v1",
+    "name":  "deadbyte-mcp",
+    "version":  "0.15.36",
+    "train":  "R59",
+    "label":  "RESILIENT CORE BRIDGE CAPABILITY RUNTIME",
+    "protocol_revision":  "2026-07-28",
+    "parent":  {
+                   "version":  "0.15.35",
+                   "release_id":  "v0.15.35-1b5715b276facbc0",
+                   "manifest_sha256":  "1b5715b276facbc00f8e341a554472cb4829e5af60e221c357c41b66053af9d4",
+                   "generation_manifest_sha256":  "047e73b62d7b7819b84201a221a09b7e647cacf21f82101ebed4fbd7e23fc430",
+                   "tarball_sha256":  "8259e30946d28dd138c1e2ce2f483fe1370d1658544f2adbfebafa4db8875bba",
+                   "activation_status":  "PRODUCTION_ACCEPTED_WITH_SIGNED_ROLLBACK_AND_RESTORE"
+               },
+    "runtime_predecessor":  {
+                                "release_id":  "v0.15.35-1b5715b276facbc0",
+                                "manifest_sha256":  "1b5715b276facbc00f8e341a554472cb4829e5af60e221c357c41b66053af9d4",
+                                "generation_manifest_sha256":  "047e73b62d7b7819b84201a221a09b7e647cacf21f82101ebed4fbd7e23fc430"
+                            },
+    "source_predecessor":  {
+                               "version":  "0.15.35",
+                               "tarball_sha256":  "8259e30946d28dd138c1e2ce2f483fe1370d1658544f2adbfebafa4db8875bba",
+                               "manifest_file_sha256":  "1b5715b276facbc00f8e341a554472cb4829e5af60e221c357c41b66053af9d4"
+                           },
+    "consolidation":  {
+                          "frontend_status_vocabulary":  true,
+                          "read_only_structured_status":  true,
+                          "doctor_read_only_installation_runtime_transaction_checks":  true,
+                          "stale_foreground_identity_hardening":  true,
+                          "bridge_bundled_inside_release":  true,
+                          "bridge_recursive_local_dependency_binding":  true,
+                          "bridge_dynamic_relative_import_fail_closed":  true,
+                          "bridge_path_escape_fail_closed":  true,
+                          "isolated_controller_bridge_core_lifecycle":  "PASS",
+                          "performance_acceptance":  "PASS_BOUNDED_PREPUBLISH",
+                          "fresh_full_regression":  "PASS",
+                          "package_acceptance":  "PENDING_R59_FINAL",
+                          "registry_round_trip":  "PENDING",
+                          "production_activation_rollback_restore":  "PENDING",
+                          "stable_final_claim":  false,
+                          "cross_plane_acceptance":  "PASS",
+                          "public_surface_compatibility":  "PASS_43_TOOLS_NO_SCHEMA_DRIFT"
+                      },
+    "stabilization":  {
+                          "semver_strict_validation":  true,
+                          "powershell_child_environment_normalized":  true,
+                          "explicit_state_root_propagation":  true,
+                          "guardian_cleanup_fail_closed":  true,
+                          "local_isolated_state_acceptance":  "PASS",
+                          "full_regression":  "PASS",
+                          "four_hour_soak":  "WAIVED_BY_OPERATOR",
+                          "clean_machine":  "WAIVED_BY_OPERATOR",
+                          "stable_final_claim":  false
+                      },
+    "platform":  {
+                     "primary":  "win32",
+                     "architectures":  [
+                                           "x64"
+                                       ]
+                 },
+    "capabilities":  {
+                         "host_execution_modes":  [
+                                                      "script",
+                                                      "inline",
+                                                      "native"
+                                                  ],
+                         "hardware_queries":  [
+                                                  "cpu",
+                                                  "gpu",
+                                                  "memory",
+                                                  "storage",
+                                                  "network",
+                                                  "pci"
+                                              ],
+                         "compact_tool_count":  43,
+                         "full_tool_count":  117,
+                         "full_tool_catalog":  {
+                                                   "path":  "docs/R49-FULL-TOOL-CATALOG.json",
+                                                   "base_sha256":  "259fdc97a24575aff3f094911b5e86e4f512b07be7c2cc1286b0fd200d03a8c9"
+                                               },
+                         "historical_r46_full_tool_count":  84,
+                         "commander_reference_public_tool_count":  26,
+                         "commander_additive_tool_count":  14,
+                         "commander_drop_in":  true,
+                         "commander_rich_pdf":  true,
+                         "commander_incremental_pdf_revisions":  true,
+                         "commander_docx":  true,
+                         "commander_docx_header_footer_search":  true,
+                         "commander_xlsx":  true,
+                         "commander_url_read":  true,
+                         "commander_external_process_identity":  true,
+                         "commander_directory_read_fallback":  true,
+                         "commander_binary_detection":  true,
+                         "commander_protocol_adversarial":  true,
+                         "atomic_mutation_unknown_effect":  true,
+                         "package_slot_version_coherence":  true,
+                         "pid_reuse_self_recovery":  true,
+                         "bounded_controller_failure_evidence":  true,
+                         "durable_task_events_preserve_signed_envelope":  true,
+                         "capability_manifest_authority_truth":  true,
+                         "capability_manifest_host_grant_truth":  true,
+                         "process_profiles":  [
+                                                  "ping_hold",
+                                                  "powershell",
+                                                  "powershell_repl"
+                                              ],
+                         "powershell_fileless":  true,
+                         "powershell_source_max_arg_bytes":  8192,
+                         "powershell_persistent_repl":  true,
+                         "process_raw_input_profile_opt_in":  true,
+                         "process_tail_reads":  true,
+                         "process_wait_reads":  true,
+                         "process_chunked_output_ring":  true,
+                         "remote_reachability_ttl":  true,
+                         "remote_probe_timeout_retry":  true,
+                         "remote_dispatch_timeout_no_retry":  true,
+                         "observation_search_session_ttl":  true,
+                         "observation_search_session_cap":  128,
+                         "windows_queries":  [
+                                                 "registry",
+                                                 "services",
+                                                 "drivers",
+                                                 "sockets",
+                                                 "volumes",
+                                                 "usb",
+                                                 "wsl"
+                                             ],
+                         "machine_fs_list_entry_fault_isolation":  true,
+                         "native_windows_observation":  true,
+                         "desktop_bounded_semantic_wait":  true,
+                         "desktop_wait_signed_final_observation":  true,
+                         "desktop_wait_autonomous_goal_binding":  true,
+                         "native_windows_observer_sha256":  "c9b46fc497b55b8f0ad1564c8e15f9c1cdf2a07f206b3c8fa7966c892058e920",
+                         "human_livelog_visual_opcode":  true,
+                         "human_livelog_absolute_root_paths":  true,
+                         "human_livelog_trace_span":  true,
+                         "human_livelog_presentation_filter":  true,
+                         "human_livelog_tty_in_place_rewrite":  true,
+                         "human_livelog_expanded_summary":  true,
+                         "runtime_package_auto_coherence":  true,
+                         "coding_command_singleflight":  true,
+                         "coding_command_result_dedup_cache":  true,
+                         "foreground_desktop_host_fail_closed":  true,
+                         "human_livelog_slow_call_marker":  true,
+                         "human_livelog_peak_inflight":  true,
+                         "human_livelog_bounded_discovery":  true,
+                         "human_livelog_single_parse":  true,
+                         "offline_predecessor_host_revoke_before_capture":  true,
+                         "offline_recovery_self_process_exclusion":  true,
+                         "offline_recovery_foreground_guardian_family_exclusion":  true,
+                         "signed_rollback_launcher_snapshot_restore":  true,
+                         "bounded_core_startup_discovery":  true,
+                         "bundled_release_bridge":  true,
+                         "bridge_recursive_dependency_binding":  true,
+                         "doctor_read_only_diagnostics":  true,
+                         "coherent_structured_status":  true,
+                         "optional_plane_degradation":  true,
+                         "capability_manifest_v3":  true,
+                         "bridge_bounded_reconciliation":  true,
+                         "mutation_unknown_outcome_no_replay":  true,
+                         "controller_policy_root_preflight":  true
+                     },
+    "r59_runtime_hardening":  {
+                                  "optional_plane_degradation":  true,
+                                  "stable_tool_registration_on_optional_failure":  true,
+                                  "capability_manifest_v3":  true,
+                                  "live_overlay_authority_ceiling":  true,
+                                  "bridge_bounded_reconciliation":  true,
+                                  "bridge_health_requires_fresh_child_catalog_capability_attestation":  true,
+                                  "mutation_unknown_outcome_no_replay":  true,
+                                  "read_only_retry_only_before_dispatch":  true,
+                                  "cancellation_aware_governor":  true,
+                                  "controller_policy_root_preflight":  true,
+                                  "public_surface_compatibility":  "PASS_43_TOOLS_NO_SCHEMA_DRIFT",
+                                  "frontdoor_signed_ping":  "PASS",
+                                  "four_hour_soak":  "NOT_COMPLETED",
+                                  "clean_machine":  "NOT_COMPLETED",
+                                  "stable_final_claim":  false
+                              },
+    "operator_override":  {
+                              "four_hour_soak":  "WAIVED_BY_OPERATOR",
+                              "clean_machine":  "WAIVED_BY_OPERATOR",
+                              "reason":  "Operator explicitly requested immediate deployment without further testing.",
+                              "stable_final_claim":  false
+                          }
+}

package/docs/R59-SBOM.cdx.json

@@ -0,0 +1,68 @@
+{
+  "bomFormat": "CycloneDX",
+  "specVersion": "1.6",
+  "serialNumber": "urn:cdx:deadbyte-mcp:r59:0.15.36",
+  "version": 1,
+  "metadata": {
+    "component": {
+      "type": "application",
+      "name": "deadbyte-mcp",
+      "version": "0.15.36"
+    }
+  },
+  "components": [
+    {
+      "type": "library",
+      "name": "@modelcontextprotocol/client",
+      "version": "2.1.0"
+    },
+    {
+      "type": "library",
+      "name": "@modelcontextprotocol/server",
+      "version": "2.1.0"
+    },
+    {
+      "type": "library",
+      "name": "typescript",
+      "version": "5.9.3"
+    },
+    {
+      "type": "library",
+      "name": "zod",
+      "version": "4.4.3"
+    },
+    {
+      "type": "file",
+      "name": "deadbyte-hardware-observer-r45.exe",
+      "version": "0.15.36",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "c9b46fc497b55b8f0ad1564c8e15f9c1cdf2a07f206b3c8fa7966c892058e920"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "deadbyte-r59-bundled-bridge",
+      "version": "0.15.36",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "32aa34687e26e37a1ad6b34245b37aa1c7523ce216225a2d189fed4f6c4ff346"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "deadbyte-r59-node-http-adapter",
+      "version": "0.15.36",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "281985edd717b991d78fe1853057a6a6cbf6fc5b57cab48ed8444b09b15dcd6e"
+        }
+      ]
+    }
+  ]
+}

package/docs/R59-TASK-CONTRACT.md

@@ -0,0 +1,26 @@
+# R59 Task Contract
+
+- TASK_ID: deadbyte-r59-robust-runtime
+- OBJECTIVE: Produce backward-compatible DEADBYTE MCP 0.15.36 with fault-isolated optional planes, live capability snapshots, resilient Bridge/Core lifecycle, and verified direct-cloudflared frontdoor operation.
+- ACTIVE_SKILL: implement-controlled-software-changes; final verification uses verify-production-implementation without repair authority.
+- LEAD_ROLE: runtime implementation
+- REVIEW_ROLES: independent release verifier after the candidate is frozen
+- SOURCES: owner-approved 0.15.35 to 0.15.36 plan; exact 0.15.35 tarball SHA-256 `8259e30946d28dd138c1e2ce2f483fe1370d1658544f2adbfebafa4db8875bba`; sealed parent manifest `1b5715b276facbc00f8e341a554472cb4829e5af60e221c357c41b66053af9d4`
+- FIXED: existing public tool names/counts/input contracts; authority planes; no Wrangler; no generic shell/PID/executable/stdin authority; no mutation of sealed 0.15.35 bytes
+- TARGETS: Core initialization, capability resolver/manifest, bundled Bridge/governor, controller diagnostics, frontdoor verification and release evidence
+- BOUNDS: optional configured planes may degrade independently; signed ledger remains the authority ceiling; no transparent replay after dispatch
+- CLASS_2_DISCRETION: bounded retry/backoff/TTL values inside owner-approved limits, reversible and test-bound
+- CLASS_3_DISCRETION: internal module boundaries, helper names and test organization
+- PROHIBITED: dynamic plugin loading; authority widening; Host/Desktop auto-arm; in-place production edits; Wrangler transport
+- METHOD_LOCK: direct cloudflared frontdoor; state-machine Bridge/Core lifecycle; signed static capability ceiling with live reducing overlay; status METHOD_CLOSED by owner instruction
+- PRODUCTION_LINEAGE: source parent 0.15.35 tarball; delivery target npm `deadbyte-mcp@0.15.36`; runtime representation signed release/generation slot
+- DEPENDENCIES: Node.js/PowerShell/MSVC already pinned by the parent; no new dependencies
+- CAPABILITY_CONTEXT: local Windows host with D: isolated test state; npm and production activation only after deterministic gates
+- ASSURANCE_MODE: HIGH_RISK
+- TESTS: focused RED/GREEN, full regression, Windows gate, isolated acceptance, four-hour soak, registry round-trip, activation/rollback/restore
+- ACCEPTANCE_ORACLES: actual MCP protocol/catalog, Ed25519 ping verification, OS process identity, protected hashes, npm registry bytes and independent receipt verifier
+- ACCEPTANCE_ENVIRONMENT: current production Windows host with isolated D: state; clean-machine proof is not claimed
+- PASS_CONDITION: every mandatory gate passes with fresh evidence and final authority is disarmed
+- STOP_CONDITION: protected parent bytes drift, authority widens, unknown mutation is replayed, mandatory gate fails, or credentials/human authentication are required
+- ROLLBACK: exact signed 0.15.35 pointer plus owned compatibility junction
+