deadbyte-mcp 0.15.21 → 0.15.22

package/scripts/promote-local-d-generation.ps1

@@ -0,0 +1,217 @@
+#requires -Version 5.1
+[CmdletBinding()]
+param()
+Set-StrictMode -Version 3.0
+$ErrorActionPreference = 'Stop'
+
+function Fail([string]$Message) { throw "LOCAL_D_PROMOTION: $Message" }
+function Sha256-File([string]$Path) {
+    return (Get-FileHash -LiteralPath $Path -Algorithm SHA256).Hash.ToLowerInvariant()
+}
+function Sha256-Text([string]$Text) {
+    $sha = [System.Security.Cryptography.SHA256]::Create()
+    try {
+        $bytes = [System.Text.Encoding]::UTF8.GetBytes($Text)
+        return -join ($sha.ComputeHash($bytes) | ForEach-Object { $_.ToString('x2') })
+    } finally { $sha.Dispose() }
+}
+function Write-Utf8NoBom([string]$Path,[string]$Text) {
+    [System.IO.File]::WriteAllText($Path,$Text,(New-Object System.Text.UTF8Encoding($false)))
+}
+function Read-Raw([string]$Path) {
+    return [System.IO.File]::ReadAllText($Path,[System.Text.Encoding]::UTF8)
+}
+
+$stateRoot = Join-Path $env:USERPROFILE '.deadbyte-mcp'
+$pointerPath = Join-Path $stateRoot 'active-release.json'
+$launcher = Join-Path $stateRoot 'bin\DEADBYTE-MCP.ps1'
+$runtimeRoot = Join-Path $stateRoot 'runtime'
+if (-not (Test-Path -LiteralPath $pointerPath -PathType Leaf)) { Fail 'active pointer missing' }
+if (-not (Test-Path -LiteralPath $launcher -PathType Leaf)) { Fail 'stable launcher missing' }
+
+$pointerText = Read-Raw $pointerPath
+$pointer = $pointerText | ConvertFrom-Json
+if ([string]$pointer.schema -ne 'deadbyte.active-release.v1') { Fail 'active pointer schema mismatch' }
+$oldGeneration = [System.IO.Path]::GetFullPath([string]$pointer.generation_root)
+$oldManifest = Join-Path $oldGeneration 'GENERATION.SHA256'
+if (-not (Test-Path -LiteralPath $oldManifest -PathType Leaf)) { Fail 'old generation manifest missing' }
+$oldManifestHash = Sha256-File $oldManifest
+if ($oldManifestHash -ne [string]$pointer.generation_manifest_sha256) { Fail 'old generation manifest hash mismatch' }
+
+$manifestLines = @(Get-Content -LiteralPath $oldManifest -Encoding UTF8)
+$entries = @()
+foreach ($line in $manifestLines) {
+    if ([string]::IsNullOrWhiteSpace([string]$line)) { continue }
+    if ([string]$line -notmatch '^([0-9a-f]{64})  ([A-Za-z0-9._-]+)$') { Fail "malformed old generation manifest line: $line" }
+    $expected = [string]$Matches[1]
+    $name = [string]$Matches[2]
+    $path = Join-Path $oldGeneration $name
+    if (-not (Test-Path -LiteralPath $path -PathType Leaf)) { Fail "old generation file missing: $name" }
+    $actual = Sha256-File $path
+    if ($actual -ne $expected) { Fail "old generation hash mismatch: $name" }
+    $entries += [pscustomobject]@{ Name=$name; Expected=$expected }
+}
+$names = @($entries | ForEach-Object { $_.Name })
+foreach ($required in @('coding-policy.json','autonomous-policy.json','controller-config.psd1')) {
+    if ($required -notin $names) { Fail "required generation file not manifested: $required" }
+}
+
+$oldCodingPath = Join-Path $oldGeneration 'coding-policy.json'
+$oldAutonomousPath = Join-Path $oldGeneration 'autonomous-policy.json'
+$oldCodingHash = Sha256-File $oldCodingPath
+$oldAutonomousHash = Sha256-File $oldAutonomousPath
+
+$coding = (Read-Raw $oldCodingPath) | ConvertFrom-Json
+if ([string]$coding.schema -ne 'deadbyte.coding-policy.v1' -or $coding.enabled -ne $true) { Fail 'coding policy schema/enabled mismatch' }
+if ($null -eq $coding.roots) { Fail 'coding roots missing' }
+
+$localRoot = [pscustomobject][ordered]@{
+    path = 'D:\'
+    read = $true
+    write = $true
+    exec = $true
+    deny_paths = @()
+}
+if ($coding.roots.PSObject.Properties.Name -contains 'local_d') {
+    $coding.roots.local_d = $localRoot
+} else {
+    $coding.roots | Add-Member -NotePropertyName 'local_d' -NotePropertyValue $localRoot
+}
+foreach ($commandProp in @($coding.commands.PSObject.Properties)) {
+    $command = $commandProp.Value
+    if ($command.PSObject.Properties.Name -contains 'root_ids') {
+        $ids = @($command.root_ids)
+        if ('local_d' -notin $ids) { $command.root_ids = @($ids + 'local_d') }
+    }
+}
+$codingText = ($coding | ConvertTo-Json -Depth 32) + [Environment]::NewLine
+$newCodingHash = Sha256-Text $codingText
+
+$autonomous = (Read-Raw $oldAutonomousPath) | ConvertFrom-Json
+if ([string]$autonomous.schema -ne 'deadbyte.autonomous-policy.v1' -or $autonomous.enabled -ne $true) { Fail 'autonomous policy schema/enabled mismatch' }
+$autonomous.coding_policy_sha256 = $newCodingHash
+$autonomousText = ($autonomous | ConvertTo-Json -Depth 32) + [Environment]::NewLine
+$newAutonomousHash = Sha256-Text $autonomousText
+
+$seed = $oldManifestHash + [Environment]::NewLine + $newCodingHash + [Environment]::NewLine + $newAutonomousHash + [Environment]::NewLine + 'local_d=D:\'
+$generationSuffix = (Sha256-Text $seed).Substring(0,16)
+$newGenerationId = ([string]$pointer.release_id) + '-g' + $generationSuffix
+$generationStore = Join-Path $stateRoot 'generations'
+$newGeneration = Join-Path $generationStore $newGenerationId
+if (Test-Path -LiteralPath $newGeneration) { Fail "target generation already exists: $newGeneration" }
+New-Item -ItemType Directory -Path $newGeneration | Out-Null
+
+$pointerBackup = Join-Path $runtimeRoot 'active-release.before-local-d.json'
+$codingGrantPath = Join-Path $runtimeRoot 'coding-grant.json'
+$autonomousGrantPath = Join-Path $runtimeRoot 'autonomous-grant.json'
+$hadCodingGrant = Test-Path -LiteralPath $codingGrantPath -PathType Leaf
+$hadAutonomousGrant = Test-Path -LiteralPath $autonomousGrantPath -PathType Leaf
+$oldCodingGrantText = if ($hadCodingGrant) { Read-Raw $codingGrantPath } else { $null }
+$oldAutonomousGrantText = if ($hadAutonomousGrant) { Read-Raw $autonomousGrantPath } else { $null }
+$wasAutonomousArmed = $false
+if ($hadCodingGrant -and $hadAutonomousGrant) {
+    try {
+        $cg = $oldCodingGrantText | ConvertFrom-Json
+        $ag = $oldAutonomousGrantText | ConvertFrom-Json
+        $wasAutonomousArmed =
+            ([string]$cg.policy_sha256 -eq $oldCodingHash) -and
+            ([string]$ag.policy_sha256 -eq $oldAutonomousHash) -and
+            ([string]$ag.coding_policy_sha256 -eq $oldCodingHash)
+    } catch { $wasAutonomousArmed = $false }
+}
+
+$switched = $false
+try {
+    foreach ($entry in $entries) {
+        $src = Join-Path $oldGeneration $entry.Name
+        $dst = Join-Path $newGeneration $entry.Name
+        Copy-Item -LiteralPath $src -Destination $dst
+    }
+
+    Write-Utf8NoBom (Join-Path $newGeneration 'coding-policy.json') $codingText
+    Write-Utf8NoBom (Join-Path $newGeneration 'autonomous-policy.json') $autonomousText
+
+    $configPath = Join-Path $newGeneration 'controller-config.psd1'
+    $configText = Read-Raw $configPath
+    if ($configText.IndexOf($oldGeneration,[System.StringComparison]::OrdinalIgnoreCase) -lt 0) { Fail 'controller config is not bound to old generation root' }
+    $configText = $configText.Replace($oldGeneration,$newGeneration)
+    Write-Utf8NoBom $configPath $configText
+    $cfg = Import-PowerShellDataFile -LiteralPath $configPath
+    if ([System.IO.Path]::GetFullPath([string]$cfg.CodingPolicyFile) -ne [System.IO.Path]::GetFullPath((Join-Path $newGeneration 'coding-policy.json'))) { Fail 'new controller CodingPolicyFile binding mismatch' }
+    if ([System.IO.Path]::GetFullPath([string]$cfg.AutonomousPolicyFile) -ne [System.IO.Path]::GetFullPath((Join-Path $newGeneration 'autonomous-policy.json'))) { Fail 'new controller AutonomousPolicyFile binding mismatch' }
+
+    foreach ($entry in $entries) {
+        $p = Join-Path $newGeneration $entry.Name
+        $text = $null
+        try { $text = Read-Raw $p } catch { $text = $null }
+        if ($null -ne $text -and $entry.Name -ne 'controller-config.psd1' -and $text.IndexOf($oldGeneration,[System.StringComparison]::OrdinalIgnoreCase) -ge 0) {
+            Fail "unexpected old generation binding remains in $($entry.Name)"
+        }
+    }
+
+    $newManifestLines = @()
+    foreach ($entry in $entries) {
+        $p = Join-Path $newGeneration $entry.Name
+        $newManifestLines += ((Sha256-File $p) + '  ' + $entry.Name)
+    }
+    $newManifestText = ($newManifestLines -join [Environment]::NewLine) + [Environment]::NewLine
+    $newManifestPath = Join-Path $newGeneration 'GENERATION.SHA256'
+    Write-Utf8NoBom $newManifestPath $newManifestText
+    $newManifestHash = Sha256-File $newManifestPath
+
+    foreach ($line in $newManifestLines) {
+        if ($line -notmatch '^([0-9a-f]{64})  ([A-Za-z0-9._-]+)$') { Fail 'new manifest internal format error' }
+        $actual = Sha256-File (Join-Path $newGeneration ([string]$Matches[2]))
+        if ($actual -ne [string]$Matches[1]) { Fail "new generation verification failed: $($Matches[2])" }
+    }
+    if ((Sha256-File (Join-Path $newGeneration 'coding-policy.json')) -ne $newCodingHash) { Fail 'new coding hash self-check failed' }
+    if ((Sha256-File (Join-Path $newGeneration 'autonomous-policy.json')) -ne $newAutonomousHash) { Fail 'new autonomous hash self-check failed' }
+
+    Write-Utf8NoBom $pointerBackup $pointerText
+    $pointer.generation_root = $newGeneration
+    $pointer.config_path = Join-Path $newGeneration 'controller-config.psd1'
+    $pointer.generation_manifest_sha256 = $newManifestHash
+    if ($pointer.PSObject.Properties.Name -contains 'generation_id') { $pointer.generation_id = $newGenerationId }
+    if ($pointer.PSObject.Properties.Name -contains 'generation_manifest_path') { $pointer.generation_manifest_path = $newManifestPath }
+    if ($pointer.PSObject.Properties.Name -contains 'updated_at_utc') { $pointer.updated_at_utc = [DateTime]::UtcNow.ToString('o') }
+    $newPointerText = ($pointer | ConvertTo-Json -Depth 32) + [Environment]::NewLine
+    $pointerTmp = $pointerPath + '.local-d.tmp'
+    Write-Utf8NoBom $pointerTmp $newPointerText
+    Move-Item -LiteralPath $pointerTmp -Destination $pointerPath -Force
+    $switched = $true
+
+    $statusText = (& $launcher status 2>&1 | Out-String)
+    if ($LASTEXITCODE -ne 0) { Fail "launcher status failed after pointer switch: $statusText" }
+
+    $armCodingText = (& $launcher armcoding 2>&1 | Out-String)
+    if ($LASTEXITCODE -ne 0) { Fail "armcoding failed after pointer switch: $armCodingText" }
+
+    $armAutonomousText = ''
+    if ($wasAutonomousArmed) {
+        $armAutonomousText = (& $launcher armautonomous 2>&1 | Out-String)
+        if ($LASTEXITCODE -ne 0) { Fail "armautonomous failed after pointer switch: $armAutonomousText" }
+    }
+
+    Write-Output 'LOCAL_D_PROMOTION=PASS'
+    Write-Output ('OLD_GENERATION=' + $oldGeneration)
+    Write-Output ('NEW_GENERATION=' + $newGeneration)
+    Write-Output ('OLD_GENERATION_MANIFEST_SHA256=' + $oldManifestHash)
+    Write-Output ('NEW_GENERATION_MANIFEST_SHA256=' + $newManifestHash)
+    Write-Output ('OLD_CODING_POLICY_SHA256=' + $oldCodingHash)
+    Write-Output ('NEW_CODING_POLICY_SHA256=' + $newCodingHash)
+    Write-Output ('NEW_AUTONOMOUS_POLICY_SHA256=' + $newAutonomousHash)
+    Write-Output ('AUTONOMOUS_REARMED=' + $wasAutonomousArmed)
+    Write-Output ('ROLLBACK_POINTER=' + $pointerBackup)
+    Write-Output 'RESTART_REQUIRED=YES'
+} catch {
+    $message = $_.Exception.Message
+    if ($switched) {
+        try { Write-Utf8NoBom $pointerPath $pointerText } catch {}
+        if ($hadCodingGrant) { try { Write-Utf8NoBom $codingGrantPath $oldCodingGrantText } catch {} }
+        else { try { Remove-Item -LiteralPath $codingGrantPath -Force -ErrorAction SilentlyContinue } catch {} }
+        if ($hadAutonomousGrant) { try { Write-Utf8NoBom $autonomousGrantPath $oldAutonomousGrantText } catch {} }
+        else { try { Remove-Item -LiteralPath $autonomousGrantPath -Force -ErrorAction SilentlyContinue } catch {} }
+    }
+    try { if (Test-Path -LiteralPath $newGeneration) { Remove-Item -LiteralPath $newGeneration -Recurse -Force } } catch {}
+    Fail $message
+}

package/scripts/test-r48-post-bump.ps1

@@ -0,0 +1,8 @@
+$ErrorActionPreference='Stop'
+Set-StrictMode -Version Latest
+$Root=Split-Path -Parent $PSScriptRoot
+Push-Location $Root
+try {
+  & node --test --test-concurrency=1 test/r48-release-contract.test.mjs test/release-version.test.mjs test/cli-entrypoint.test.mjs test/package-boundary.test.mjs test/release-smoke-isolation.test.mjs test/full-max-catalog-r48.test.mjs
+  if($LASTEXITCODE -ne 0){throw "R48 post-bump release checks failed exit=$LASTEXITCODE"}
+} finally { Pop-Location }

package/scripts/test-r48-windows-observation.ps1

@@ -0,0 +1,8 @@
+$ErrorActionPreference='Stop'
+Set-StrictMode -Version Latest
+$Root=Split-Path -Parent $PSScriptRoot
+Push-Location $Root
+try {
+  & node --test test/machine-fs-runtime.test.mjs test/windows-observation-r48.test.mjs test/windows-observation-surface-r48.test.mjs test/hardware-observation-r45.test.mjs test/observation-mcp-tools.test.mjs test/compact-gateway-r36.test.mjs test/capability-resolver.test.mjs test/compact-catalog-r36.test.mjs test/compact-max-catalog-r45.test.mjs test/full-max-catalog-r45.test.mjs test/full-max-catalog-r46.test.mjs test/full-max-catalog-r47.test.mjs test/full-max-catalog-r48.test.mjs
+  if($LASTEXITCODE -ne 0){throw "R48 focused regression failed exit=$LASTEXITCODE"}
+} finally { Pop-Location }

package/src/capability-ledger.mjs

@@ -137,6 +137,13 @@ export const R36_CAPABILITY_ENTRIES=Object.freeze([
   gateway('observation.process_list','machine_process_list','machine_observe','process_list','DEADBYTE_OBSERVATION_RUNTIME','none',{receipt_class:'observation'}),
   gateway('observation.system_status','machine_system_status','machine_observe','system_status','DEADBYTE_OBSERVATION_RUNTIME','none',{receipt_class:'observation'}),
   gateway('observation.hardware_query','machine_hardware_query','machine_observe','hardware_query','DEADBYTE_OBSERVATION_RUNTIME','none',{receipt_class:'observation'}),
+  gateway('observation.registry_query','machine_windows_query','machine_observe','registry_query','DEADBYTE_OBSERVATION_RUNTIME','none',{receipt_class:'observation'}),
+  gateway('observation.service_list','machine_windows_query','machine_observe','service_list','DEADBYTE_OBSERVATION_RUNTIME','none',{receipt_class:'observation'}),
+  gateway('observation.driver_list','machine_windows_query','machine_observe','driver_list','DEADBYTE_OBSERVATION_RUNTIME','none',{receipt_class:'observation'}),
+  gateway('observation.socket_list','machine_windows_query','machine_observe','socket_list','DEADBYTE_OBSERVATION_RUNTIME','none',{receipt_class:'observation'}),
+  gateway('observation.volume_list','machine_windows_query','machine_observe','volume_list','DEADBYTE_OBSERVATION_RUNTIME','none',{receipt_class:'observation'}),
+  gateway('observation.usb_list','machine_windows_query','machine_observe','usb_list','DEADBYTE_OBSERVATION_RUNTIME','none',{receipt_class:'observation'}),
+  gateway('observation.wsl_list','machine_windows_query','machine_observe','wsl_list','DEADBYTE_OBSERVATION_RUNTIME','none',{receipt_class:'observation'}),
 
   gateway('desktop.status','desktop_status','desktop_control','status','DEADBYTE_DESKTOP_RUNTIME','none',{receipt_class:'desktop'}),
   gateway('desktop.observe','desktop_observe','desktop_control','observe','DEADBYTE_DESKTOP_RUNTIME','none',{receipt_class:'desktop'}),

package/src/capability-resolver.mjs

@@ -67,6 +67,13 @@ const CAPABILITY_OPERATIONS = Object.freeze({
   'observation.process_list': ['process_list'],
   'observation.system_status': ['system_status'],
   'observation.hardware_query': ['hardware_query'],
+  'observation.registry_query': ['registry_query'],
+  'observation.service_list': ['service_list'],
+  'observation.driver_list': ['driver_list'],
+  'observation.socket_list': ['socket_list'],
+  'observation.volume_list': ['volume_list'],
+  'observation.usb_list': ['usb_list'],
+  'observation.wsl_list': ['wsl_list'],
   'desktop.status': ['status'],
   'desktop.observe': ['observe'],
   'desktop.target': ['target'],

package/src/compact-gateway-mcp-tools.mjs

@@ -55,7 +55,14 @@ export const machineObserveInputSchema=z.discriminatedUnion('op',[
   z.strictObject({op:z.literal('search_cancel'),search_id:hex64}),
   z.strictObject({op:z.literal('process_list'),limit:z.number().int().min(1).max(256).default(100),include_external:z.boolean().default(false),cursor:z.string().max(512).nullable().default(null)}),
   z.strictObject({op:z.literal('system_status')}),
-  z.strictObject({op:z.literal('hardware_query'),query:z.enum(['cpu','gpu','memory','storage','network','pci'])})
+  z.strictObject({op:z.literal('hardware_query'),query:z.enum(['cpu','gpu','memory','storage','network','pci'])}),
+  z.strictObject({op:z.literal('registry_query'),hive:z.enum(['HKLM','HKCU']),key:z.string().min(1).max(1024),value:z.string().max(260).nullable().default(null)}),
+  z.strictObject({op:z.literal('service_list')}),
+  z.strictObject({op:z.literal('driver_list')}),
+  z.strictObject({op:z.literal('socket_list')}),
+  z.strictObject({op:z.literal('volume_list')}),
+  z.strictObject({op:z.literal('usb_list')}),
+  z.strictObject({op:z.literal('wsl_list')})
 ]);
 
 const capabilityManifestInputSchema=z.strictObject({});
@@ -119,7 +126,14 @@ async function machineObserve(args,machineRuntime,observationRuntime){
     search_cancel:r=>r.searchCancel({searchId:args.search_id}),
     process_list:r=>r.processList({limit:args.limit,includeExternal:args.include_external,cursor:args.cursor}),
     system_status:r=>r.systemStatus(),
-    hardware_query:r=>r.hardwareQuery({query:args.query})
+    hardware_query:r=>r.hardwareQuery({query:args.query}),
+    registry_query:r=>r.windowsQuery({query:'registry',hive:args.hive,key:args.key,value:args.value}),
+    service_list:r=>r.windowsQuery({query:'services'}),
+    driver_list:r=>r.windowsQuery({query:'drivers'}),
+    socket_list:r=>r.windowsQuery({query:'sockets'}),
+    volume_list:r=>r.windowsQuery({query:'volumes'}),
+    usb_list:r=>r.windowsQuery({query:'usb'}),
+    wsl_list:r=>r.windowsQuery({query:'wsl'})
   };
   return invoke(args.op,observationRuntime,'observation',map[args.op]);
 }

package/src/machine-fs.mjs

@@ -338,7 +338,7 @@ async function atomicWrite(target, bytes, expectedSha256, authorityCheck = null)
     assertExpected: checkExpectedFile, authorityCheck, tempTag: 'deadbyte-machine-fs' });
 }
 
-export function createMachineFsRuntime({ policy, signingKeyPath, verifyKeyPath, readWorkerPath = machineFsReadWorkerPath }) {
+export function createMachineFsRuntime({ policy, signingKeyPath, verifyKeyPath, readWorkerPath = machineFsReadWorkerPath, listEntryLstat = lstat, listEntrySha256File = sha256File }) {
   if (!policy) throw new Error('machine fs runtime requires coding policy');
   if (!signingKeyPath || !verifyKeyPath) throw new Error('machine fs runtime requires trust key paths');
 
@@ -384,9 +384,22 @@ export function createMachineFsRuntime({ policy, signingKeyPath, verifyKeyPath,
       const rel = found.relative === '.' ? child.name : `${found.relative}/${child.name}`;
       if (child.isSymbolicLink()) return { path: rel, kind: 'reparse', bytes: 0, mtime_utc: null, sha256: null };
       const childPath = path.join(found.resolved, child.name);
-      const childInfo = await lstat(childPath);
+      let childInfo;
+      try { childInfo = await listEntryLstat(childPath); }
+      catch (error) {
+        const code = typeof error?.code === 'string' && /^[A-Z0-9_]+$/.test(error.code) ? error.code : 'UNKNOWN';
+        return { path: rel, kind: 'unreadable', bytes: 0, mtime_utc: null, sha256: null, error: { code, operation: 'lstat' } };
+      }
       const kind = kindOf(childInfo);
-      const digest = hashFiles && kind === 'file' ? await sha256File(childPath) : null;
+      let digest = null;
+      if (hashFiles && kind === 'file') {
+        try { digest = await listEntrySha256File(childPath); }
+        catch (error) {
+          const code = typeof error?.code === 'string' && /^[A-Z0-9_]+$/.test(error.code) ? error.code : 'UNKNOWN';
+          return { path: rel, kind, bytes: childInfo.size, mtime_utc: childInfo.mtime.toISOString(), sha256: null,
+            error: { code, operation: 'sha256' } };
+        }
+      }
       return { path: rel, kind, bytes: kind === 'file' ? childInfo.size : 0, mtime_utc: childInfo.mtime.toISOString(), sha256: digest };
     }));
     const nextCursor = filtered.length > selected.length && selected.length

package/src/observation-mcp-tools.mjs

@@ -1,7 +1,7 @@
 import * as z from 'zod/v4';
 import {
   observationHardwareQueryOutputSchema,observationProcessListOutputSchema,observationSearchCancelOutputSchema,observationSearchPageOutputSchema,
-  observationSearchStartOutputSchema,observationSearchStatusOutputSchema,observationStructuredResult,observationSystemStatusOutputSchema
+  observationSearchStartOutputSchema,observationSearchStatusOutputSchema,observationStructuredResult,observationSystemStatusOutputSchema,observationWindowsQueryOutputSchema
 } from './observation-output-contracts.mjs';
 
 const hex64=z.string().regex(/^[0-9a-f]{64}$/);
@@ -45,4 +45,16 @@ export function registerObservationTools(server,{runtime}){
     description:'Read one typed native hardware snapshot (CPU, GPU, memory, storage, network, or PCI) with signed observation evidence. No shell or Host authority is used.',
     inputSchema:z.strictObject({query:z.enum(['cpu','gpu','memory','storage','network','pci'])}),outputSchema:observationHardwareQueryOutputSchema
   },async args=>{try{return ok(observationHardwareQueryOutputSchema,await runtime.hardwareQuery({query:args.query}));}catch(error){return fail(observationHardwareQueryOutputSchema,error);}});
+  server.registerTool('machine_windows_query',{
+    description:'Read one typed native Windows snapshot for Registry, services, drivers, sockets, volumes, USB, or WSL. No shell parsing is used.',
+    inputSchema:z.discriminatedUnion('query',[
+      z.strictObject({query:z.literal('registry'),hive:z.enum(['HKLM','HKCU']),key:z.string().min(1).max(1024),value:z.string().max(260).nullable().default(null)}),
+      z.strictObject({query:z.literal('services')}),
+      z.strictObject({query:z.literal('drivers')}),
+      z.strictObject({query:z.literal('sockets')}),
+      z.strictObject({query:z.literal('volumes')}),
+      z.strictObject({query:z.literal('usb')}),
+      z.strictObject({query:z.literal('wsl')})
+    ]),outputSchema:observationWindowsQueryOutputSchema
+  },async args=>{try{return ok(observationWindowsQueryOutputSchema,await runtime.windowsQuery(args));}catch(error){return fail(observationWindowsQueryOutputSchema,error);}});
 }

package/src/observation-output-contracts.mjs

@@ -55,6 +55,14 @@ export const observationHardwareQueryOutputSchema=statusContract({
   ...Object.fromEntries(Object.entries(evidenceShape).map(([k,v])=>[k,v.optional()]))
 },['observed_at_utc','query','data','request_sha256','result_head_sha256','receipt_id','receipt_sha256']);
 
+export const observationWindowsQueryOutputSchema=statusContract({
+  observed_at_utc:z.string().min(1).optional(),
+  query:z.enum(['registry','services','drivers','sockets','volumes','usb','wsl']).optional(),
+  data:z.record(z.string(),z.json()).optional(),
+  observer_sha256:hex64.optional(),
+  ...Object.fromEntries(Object.entries(evidenceShape).map(([k,v])=>[k,v.optional()]))
+},['observed_at_utc','query','data','request_sha256','result_head_sha256','receipt_id','receipt_sha256']);
+
 export function observationStructuredResult(schema,value,isError=false){
   return structuredToolResult(schema,value,isError);
 }

package/src/observation-runtime.mjs

@@ -15,6 +15,8 @@ const ZERO='0'.repeat(64);
 const HEX64=/^[0-9a-f]{64}$/;
 const ID=/^[A-Za-z0-9._-]{1,64}$/;
 const HARDWARE_QUERIES=new Set(['cpu','gpu','memory','storage','network','pci']);
+const WINDOWS_QUERIES=new Set(['registry','services','drivers','sockets','volumes','usb','wsl']);
+const REGISTRY_HIVES=new Set(['HKLM','HKCU']);
 const sha256Bytes=bytes=>createHash('sha256').update(bytes).digest('hex');
 const sha256Object=value=>sha256Bytes(Buffer.from(canonicalJson(value),'utf8'));
 const nowUtc=()=>new Date().toISOString();
@@ -131,12 +133,49 @@ async function defaultHardwareSnapshotProvider(query){
   }
   return {...parsed,observer_sha256:executableSha256};
 }
+function normalizeWindowsQueryArgs(input={}){
+  const query=String(input.query??'');
+  if(!WINDOWS_QUERIES.has(query)) throw new Error('windows query must be one of registry,services,drivers,sockets,volumes,usb,wsl');
+  if(query==='registry'){
+    const hive=String(input.hive??'');
+    const key=String(input.key??'');
+    const value=input.value===null||input.value===undefined?null:String(input.value);
+    if(!REGISTRY_HIVES.has(hive)) throw new Error('registry hive must be HKLM or HKCU');
+    if(key.length<1||key.length>1024||key.includes('\0')) throw new Error('registry key must contain 1-1024 non-NUL characters');
+    if(value!==null&&(value.length>260||value.includes('\0'))) throw new Error('registry value must be null or at most 260 non-NUL characters');
+    return {query,hive,key,value};
+  }
+  const extra=Object.keys(input).filter(k=>k!=='query'&&input[k]!==undefined&&input[k]!==null);
+  if(extra.length) throw new Error(`windows query '${query}' does not accept additional selectors`);
+  return {query};
+}
+async function defaultWindowsSnapshotProvider(input){
+  if(process.platform!=='win32') throw new Error('native Windows observation is supported on win32 only');
+  const args=normalizeWindowsQueryArgs(input);
+  const executable=fileURLToPath(new URL('../bin/deadbyte-hardware-observer-r45.exe',import.meta.url));
+  const executableSha256=sha256Bytes(await readFile(executable));
+  const argv=[args.query];
+  if(args.query==='registry'){
+    argv.push(args.hive,args.key);
+    if(args.value!==null) argv.push(args.value);
+  }
+  const result=spawnSync(executable,argv,{encoding:'utf8',windowsHide:true,shell:false,timeout:15000,maxBuffer:16*1024*1024});
+  if(result.error) throw result.error;
+  if(result.status!==0) throw new Error(`Windows observation failed query=${args.query}: ${String(result.stderr??result.stdout??'').trim()}`);
+  let parsed;
+  try{parsed=JSON.parse(String(result.stdout??'').trim());}
+  catch{throw new Error(`Windows observation returned invalid JSON query=${args.query}`);}
+  if(parsed?.schema!=='deadbyte.windows-query.v1'||parsed?.query!==args.query||!parsed.data||typeof parsed.data!=='object'||Array.isArray(parsed.data)){
+    throw new Error(`Windows observation contract mismatch query=${args.query}`);
+  }
+  return {...parsed,observer_sha256:executableSha256};
+}
 function requestSha(policy,operation,args){
   return sha256Object({schema:'deadbyte.observation-request.v1',policy_sha256:policy.policy_sha256,operation,args});
 }
 export function createObservationRuntime({policy,signingKeyPath,verifyKeyPath,processRuntime=null,stateRoot=path.join(os.homedir(),'.deadbyte-mcp'),
   processSnapshotProvider=defaultProcessSnapshotProvider,systemSnapshotProvider=defaultSystemSnapshotProvider,
-  ownedRuntimePidProvider=defaultOwnedRuntimePidProvider,hardwareSnapshotProvider=defaultHardwareSnapshotProvider,
+  ownedRuntimePidProvider=defaultOwnedRuntimePidProvider,hardwareSnapshotProvider=defaultHardwareSnapshotProvider,windowsSnapshotProvider=defaultWindowsSnapshotProvider,
   searchSessionTtlMs=5*60*1000,maxSearchSessions=128,clockMs=()=>Date.now()}={}){
   if(!policy||!signingKeyPath||!verifyKeyPath) throw new Error('observation runtime requires policy and trust keys');
   if(!Number.isInteger(searchSessionTtlMs)||searchSessionTtlMs<10||searchSessionTtlMs>24*60*60*1000) throw new Error('searchSessionTtlMs out of range');
@@ -337,5 +376,18 @@ export function createObservationRuntime({policy,signingKeyPath,verifyKeyPath,pr
     const receipt=await writeReceipt(runtime,'machine_hardware_query',req,head,{observed_at_utc:observedAt,query,observer_sha256:result.observer_sha256??null});
     return {...result,request_sha256:req,result_head_sha256:head,...receipt};
   }
-  return Object.freeze({policy,searchStart,searchPage,searchStatus,searchCancel,processList,systemStatus,hardwareQuery});
+  async function windowsQuery(input={}){
+    const args=normalizeWindowsQueryArgs(input);
+    const observedAt=nowUtc();
+    const snapshot=await windowsSnapshotProvider(args);
+    if(!snapshot||snapshot.schema!=='deadbyte.windows-query.v1'||snapshot.query!==args.query||!snapshot.data||typeof snapshot.data!=='object'||Array.isArray(snapshot.data)){
+      throw new Error('windows query provider contract mismatch');
+    }
+    const result={status:'ok',observed_at_utc:observedAt,query:args.query,data:snapshot.data};
+    if(typeof snapshot.observer_sha256==='string'&&HEX64.test(snapshot.observer_sha256)) result.observer_sha256=snapshot.observer_sha256;
+    const req=requestSha(policy,'machine_windows_query',args); const head=sha256Object(result);
+    const receipt=await writeReceipt(runtime,'machine_windows_query',req,head,{observed_at_utc:observedAt,query:args.query,observer_sha256:result.observer_sha256??null});
+    return {...result,request_sha256:req,result_head_sha256:head,...receipt};
+  }
+  return Object.freeze({policy,searchStart,searchPage,searchStatus,searchCancel,processList,systemStatus,hardwareQuery,windowsQuery});
 }

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.15.21';
+export const DEADBYTE_VERSION = '0.15.22';
 export const MCP_PROTOCOL_VERSION = '2026-07-28';
 export const RECEIPT_SCHEMA_V1 = 'deadbyte.receipt.v1';
 export const RECEIPT_SCHEMA_V2 = 'deadbyte.receipt.v2';

package/test/full-max-catalog-r47.test.mjs

@@ -15,7 +15,7 @@ const desktopPolicyPath=path.join(repoRoot,'controller','deadbyte-desktop-policy
 const catalogPath=path.join(repoRoot,'docs','R47-FULL-TOOL-CATALOG.json');
 const absent=async p=>{try{await access(p);return false;}catch(e){if(e?.code==='ENOENT')return true;throw e;}};
 
-test('R47 runtime full stdio catalog exactly matches canonical registration surface',async()=>{
+test('R47 runtime full stdio catalog exactly matches canonical registration surface',{skip:'historical R47 catalog; R48 supersedes it'},async()=>{
   const canonical=JSON.parse(await readFile(catalogPath,'utf8'));
   assert.equal(canonical.schema,'deadbyte.r47-full-catalog.v1');
   assert.equal(canonical.train,'R47');

package/test/full-max-catalog-r48.test.mjs

@@ -0,0 +1,78 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Client } from '@modelcontextprotocol/client';
+import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
+import { createR34Fixture } from './helpers/autonomous-r34-fixture.mjs';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const repoRoot=path.resolve(here,'..');
+const serverPath=path.join(repoRoot,'src','mcp-server.mjs');
+const desktopPolicyPath=path.join(repoRoot,'controller','deadbyte-desktop-policy.json');
+const catalogPath=path.join(repoRoot,'docs','R48-FULL-TOOL-CATALOG.json');
+const absent=async p=>{try{await access(p);return false;}catch(e){if(e?.code==='ENOENT')return true;throw e;}};
+
+test('R48 runtime full stdio catalog exactly matches canonical registration surface',async()=>{
+  const canonical=JSON.parse(await readFile(catalogPath,'utf8'));
+  assert.equal(canonical.schema,'deadbyte.r48-full-catalog.v1');
+  assert.equal(canonical.train,'R48');
+  assert.ok(Array.isArray(canonical.tools));
+  assert.equal(canonical.tool_count,canonical.tools.length);
+  assert.equal(new Set(canonical.tools).size,canonical.tools.length);
+  assert.deepEqual([...canonical.tools].sort(),canonical.tools);
+
+  const f=await createR34Fixture({authority:'disarmed'});
+  const processPolicyPath=path.join(f.root,'process-policy.json');
+  const processGrant=path.join(f.root,'process-grant.json');
+  const processState=path.join(f.root,'process-state');
+  const hostPolicyPath=path.join(f.root,'host-policy.json');
+  const hostArm=path.join(f.root,'host-arm.json');
+  const desktopRaw=JSON.parse(await readFile(desktopPolicyPath,'utf8'));
+  const desktopGrant=desktopRaw.grant_file;
+  await mkdir(processState,{recursive:true});
+  const nodeSha=createHash('sha256').update(await readFile(process.execPath)).digest('hex');
+  await writeFile(processPolicyPath,JSON.stringify({
+    schema:'deadbyte.process-policy.v1',enabled:true,grant_file:processGrant,state_dir:processState,
+    native_host:{path:process.execPath,sha256:nodeSha},
+    roots:{core:{path:f.project,deny_paths:[]}},
+    profiles:{node:{executable:process.execPath,executable_sha256:nodeSha,root_ids:['core'],prefix_args:[],transport:'pipe',max_args:8,max_arg_bytes:1024,max_sessions:2,max_input_bytes:65536,max_retained_output_bytes:262144,env_allow:['PATH','TEMP','TMP'],input_actions:{ping:'PING\\r\\n'}}}
+  },null,2));
+  await writeFile(hostPolicyPath,JSON.stringify({
+    schema:'deadbyte.host-policy.v1',enabled:true,arm_file:hostArm,max_read_bytes:262144,max_write_bytes:1048576,
+    roots:{core:{path:f.project,read:true,write:true,exec:true}},
+    commands:{node_script:{kind:'script',executable:process.execPath,executable_sha256:nodeSha,root_ids:['core'],prefix_args:[],extensions:['.mjs'],timeout_ms:5000,max_output_bytes:65536}}
+  },null,2));
+  const codingLease=f.codingPolicy.lease_file;
+  const autonomousLease=f.policy.lease_file;
+  for(const q of [processGrant,hostArm,desktopGrant,codingLease,autonomousLease]) assert.equal(await absent(q),true,'authority unexpectedly armed before start: '+q);
+
+  const client=new Client({name:'deadbyte-r48-full-catalog',version:'0.15.22'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  const env={
+    ...getDefaultEnvironment(),DEADBYTE_CAPABILITY_PROFILE:'full',DEADBYTE_AUDIT_RUNTIME:'0',
+    DEADBYTE_STATE_ROOT:path.join(f.root,'state'),DEADBYTE_WORKSPACE_ROOT:f.root,
+    DEADBYTE_SIGNING_KEY:f.keys.privateKeyPath,DEADBYTE_VERIFY_KEY:f.keys.publicKeyPath,
+    DEADBYTE_PRIVILEGED_POLICY:hostPolicyPath,DEADBYTE_MACHINE_RUNTIME:'1',DEADBYTE_AGENT_RUNTIME:'1',
+    DEADBYTE_PROCESS_RUNTIME:'1',DEADBYTE_PROCESS_POLICY:processPolicyPath,DEADBYTE_CODING_RUNTIME:'1',
+    DEADBYTE_CODING_POLICY:path.join(f.root,'coding-policy.json'),DEADBYTE_MACHINE_FS_RUNTIME:'1',
+    DEADBYTE_OBSERVATION_RUNTIME:'1',DEADBYTE_DESKTOP_RUNTIME:'1',DEADBYTE_DESKTOP_POLICY:desktopPolicyPath,
+    DEADBYTE_AUTONOMOUS_RUNTIME:'1',DEADBYTE_AUTONOMOUS_POLICY:path.join(f.root,'autonomous-policy.json'),
+    DEADBYTE_AUTONOMOUS_SUPERVISOR_MODE:'external'
+  };
+  const transport=new StdioClientTransport({command:process.execPath,args:[serverPath],cwd:repoRoot,env,stderr:'pipe'});
+  try{
+    await client.connect(transport);
+    const listed=await client.listTools();
+    const names=listed.tools.map(t=>t.name).sort();
+    assert.deepEqual(names,canonical.tools);
+    assert.equal(new Set(names).size,names.length,'runtime duplicate tool names');
+    for(const tool of listed.tools) if(tool.outputSchema!==undefined) assert.equal(tool.outputSchema?.additionalProperties,false,'non-strict output '+tool.name);
+    for(const name of ['agent_task_submit','autonomous_goal_submit','coding_task_submit','process_session_start','machine_fs_write','machine_search_start','desktop_action','host_exec','native_diff_apply','skill_catalog']) assert.ok(names.includes(name),'missing R48 surface '+name);
+  } finally {
+    await client.close().catch(()=>{});
+    for(const q of [processGrant,hostArm,desktopGrant,codingLease,autonomousLease]) assert.equal(await absent(q),true,'authority file appeared during catalog probe: '+q);
+    await f.cleanup();
+  }
+});

package/test/machine-fs-runtime.test.mjs

@@ -1,7 +1,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { createHash } from 'node:crypto';
-import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { lstat, mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { generateTrustKeypair } from '../src/trust.mjs';
@@ -10,7 +10,7 @@ import { createMachineFsRuntime, verifyMachineFsReceiptFile } from '../src/machi
 
 const sha = bytes => createHash('sha256').update(bytes).digest('hex');
 
-async function fixture({ readWorkerPath = undefined } = {}) {
+async function fixture({ readWorkerPath = undefined, listEntryLstat = undefined } = {}) {
   const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-machine-fs-'));
   const project = path.join(root, 'project');
   await mkdir(project);
@@ -30,7 +30,7 @@ async function fixture({ readWorkerPath = undefined } = {}) {
     privateKeyPath: path.join(root, 'private.pem'), publicKeyPath: path.join(root, 'public.pem')
   });
   const runtime = createMachineFsRuntime({
-    policy, signingKeyPath: keys.privateKeyPath, verifyKeyPath: keys.publicKeyPath, readWorkerPath
+    policy, signingKeyPath: keys.privateKeyPath, verifyKeyPath: keys.publicKeyPath, readWorkerPath, listEntryLstat
   });
   return { root, project, policy, keys, runtime };
 }
@@ -87,6 +87,31 @@ test('R31 machine fs supports exact mkdir/write/stat/list/range-read/edit/move/d
   assert.equal(second.next_cursor, null);
 });
 
+test('R48 machine fs listing isolates one unreadable child instead of failing the page', async () => {
+  let projectPath = null;
+  const injectedLstat = async target => {
+    if (projectPath && path.basename(target) === 'bad.txt') {
+      const error = new Error('simulated Windows lstat EINVAL');
+      error.code = 'EINVAL';
+      error.syscall = 'lstat';
+      throw error;
+    }
+    return lstat(target);
+  };
+  const f = await fixture({ listEntryLstat: injectedLstat });
+  projectPath = f.project;
+  await writeFile(path.join(f.project, 'bad.txt'), 'bad');
+  await writeFile(path.join(f.project, 'good.txt'), 'good');
+  const listed = await f.runtime.list({ rootId:'project', relativePath:'.', limit:10, hashFiles:true });
+  assert.deepEqual(listed.entries.map(item => item.path), ['bad.txt','good.txt']);
+  assert.deepEqual(listed.entries[0], {
+    path:'bad.txt', kind:'unreadable', bytes:0, mtime_utc:null, sha256:null,
+    error:{ code:'EINVAL', operation:'lstat' }
+  });
+  assert.equal(listed.entries[1].kind, 'file');
+  assert.equal(listed.entries[1].sha256, sha(Buffer.from('good')));
+});
+
 test('R31 machine fs fails closed on traversal, denied paths and stale source identity', async () => {
   const f = await fixture();
   await mkdir(path.join(f.project, 'blocked'));

package/test/observation-mcp-tools.test.mjs

@@ -16,14 +16,15 @@ function runtime(){
     searchCancel:async()=>({status:'ok',search_id:hex('a'),state:'cancelled',cancel_requested:true}),
     processList:async()=>({status:'ok',snapshot_id:hex('e'),observed_at_utc:new Date(0).toISOString(),processes:[],next_cursor:null,request_sha256:hex('b'),result_head_sha256:hex('c'),receipt_id:receipt,receipt_sha256:hex('d')}),
     systemStatus:async()=>({status:'ok',observed_at_utc:new Date(0).toISOString(),hostname:'x',platform:'win32',architecture:'x64',uptime_seconds:1,total_memory_bytes:2,free_memory_bytes:1,cpu_count:1,load_average:[0,0,0],request_sha256:hex('b'),result_head_sha256:hex('c'),receipt_id:receipt,receipt_sha256:hex('d')}),
-    hardwareQuery:async({query})=>({status:'ok',query,observed_at_utc:new Date(0).toISOString(),observer_sha256:hex('e'),data:{vendor:'x'},request_sha256:hex('b'),result_head_sha256:hex('c'),receipt_id:receipt,receipt_sha256:hex('d')})
+    hardwareQuery:async({query})=>({status:'ok',query,observed_at_utc:new Date(0).toISOString(),observer_sha256:hex('e'),data:{vendor:'x'},request_sha256:hex('b'),result_head_sha256:hex('c'),receipt_id:receipt,receipt_sha256:hex('d')}),
+    windowsQuery:async({query})=>({status:'ok',query,observed_at_utc:new Date(0).toISOString(),observer_sha256:hex('e'),data:{query},request_sha256:hex('b'),result_head_sha256:hex('c'),receipt_id:receipt,receipt_sha256:hex('d')})
   };
 }
 
-test('R45 registers exactly seven bounded observation tools including typed native hardware',()=>{
+test('R48 registers exactly eight bounded observation tools including typed native Windows observation',()=>{
   const server=new FakeServer(); registerObservationTools(server,{runtime:runtime()});
   assert.deepEqual([...server.tools.keys()].sort(),[
-    'machine_hardware_query','machine_process_list','machine_search_cancel','machine_search_page','machine_search_start','machine_search_status','machine_system_status'
+    'machine_hardware_query','machine_process_list','machine_search_cancel','machine_search_page','machine_search_start','machine_search_status','machine_system_status','machine_windows_query'
   ]);
   for(const [name,tool] of server.tools){ assert.ok(tool.spec.inputSchema,`${name} input`); assert.ok(tool.spec.outputSchema,`${name} output`); }
 });