deadbyte-mcp 0.15.20 → 0.15.22

package/test/capability-resolver.test.mjs

@@ -1,5 +1,8 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
+import os from 'node:os';
+import path from 'node:path';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
 import {
   CAPABILITY_STATES,
   deriveCapabilityRequirements,
@@ -22,7 +25,7 @@ test('deriveCapabilityRequirements maps dependencies accurately', () => {
     mutating: false,
     runtime_flag: 'DEADBYTE_CODING_RUNTIME'
   });
-  assert.deepEqual(reqCodingRead, ['DEADBYTE_CODING_RUNTIME', 'coding_runtime.ready']);
+  assert.deepEqual(reqCodingRead, ['DEADBYTE_CODING_RUNTIME', 'coding_session.armed']);
 
   const reqCodingWrite = deriveCapabilityRequirements({
     id: 'coding.file_write',
@@ -131,3 +134,67 @@ test('resolveCapabilityStates resolves all 5 states correctly', async () => {
   assert.equal(skillCap.diagnostic.code, 'SKILL_ENVELOPE_MISMATCH');
   assert.ok(degradedRes.degraded_capabilities.some(d => d.id === 'skill.catalog'));
 });
+
+test('capability resolver reports actual disarmed authority across coding process autonomous desktop and host', async () => {
+  const ledger={entries:[
+    {id:'coding.search',compact_tool:'coding_inspect',full_tool:'coding_search',compact_op:'search',authority:'coding',mutating:false,production:true,runtime_flag:'DEADBYTE_CODING_RUNTIME'},
+    {id:'process.start',compact_tool:'process_session',full_tool:'process_session_start',compact_op:'start',authority:'process',mutating:true,production:true,runtime_flag:'DEADBYTE_PROCESS_RUNTIME'},
+    {id:'autonomous.goal_submit',compact_tool:'autonomous_goal_submit',full_tool:'autonomous_goal_submit',compact_op:'direct',authority:'autonomous',mutating:true,production:true,runtime_flag:'DEADBYTE_AUTONOMOUS_RUNTIME'},
+    {id:'desktop.action',compact_tool:'desktop_control',full_tool:'desktop_action',compact_op:'action',authority:'desktop',mutating:true,production:true,runtime_flag:'DEADBYTE_DESKTOP_RUNTIME'},
+    {id:'host.file_read',compact_tool:'host_file_read',full_tool:'host_file_read',compact_op:'direct',authority:'host',mutating:false,production:false,runtime_flag:'DEADBYTE_PRIVILEGED_POLICY'}
+  ]};
+  const result=await resolveCapabilityStates({
+    ledger,
+    toolCatalog:['coding_inspect','process_session','autonomous_goal_submit','desktop_control','host_file_read'],
+    profile:'compact',
+    env:{},
+    codingRuntime:{sessionStatus:async()=>({armed:false,reason:'coding-disarmed'})},
+    processRuntime:{sessionStatus:async()=>({armed:false,reason:'process-disarmed'})},
+    autonomousRuntime:{sessionStatus:async()=>({armed:false,reason:'autonomous-disarmed'})},
+    desktopRuntime:{status:async()=>({armed:false,reason:'desktop-disarmed'})},
+    hostPolicy:{arm_file:path.join(os.tmpdir(),'deadbyte-capability-resolver-never-armed.json'),policy_sha256:'a'.repeat(64)}
+  });
+  const byId=id=>result.capabilities.find(item=>item.id===id);
+  assert.equal(byId('coding.search').state,CAPABILITY_STATES.DENIED);
+  assert.equal(byId('coding.search').diagnostic.code,'CODING_SESSION_DISARMED');
+  assert.equal(byId('process.start').state,CAPABILITY_STATES.DENIED);
+  assert.equal(byId('process.start').diagnostic.code,'PROCESS_SESSION_DISARMED');
+  assert.equal(byId('autonomous.goal_submit').state,CAPABILITY_STATES.DENIED);
+  assert.equal(byId('autonomous.goal_submit').diagnostic.code,'AUTONOMOUS_SESSION_DISARMED');
+  assert.equal(byId('desktop.action').state,CAPABILITY_STATES.DENIED);
+  assert.equal(byId('desktop.action').diagnostic.code,'DESKTOP_SESSION_DISARMED');
+  assert.equal(byId('host.file_read').state,CAPABILITY_STATES.DENIED);
+  assert.equal(byId('host.file_read').diagnostic.code,'HOST_POLICY_DISARMED');
+});
+
+
+test('capability resolver reports armed Host capability when the standing grant is valid', async () => {
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-capability-host-'));
+  try{
+    const armFile=path.join(root,'host-grant.json');
+    const policySha='b'.repeat(64);
+    await writeFile(armFile,JSON.stringify({
+      schema:'deadbyte.host-grant.v2',
+      policy_sha256:policySha,
+      instance_nonce:'c'.repeat(64),
+      armed_at_utc:new Date().toISOString()
+    }));
+    const result=await resolveCapabilityStates({
+      ledger:{entries:[{
+        id:'host.file_read',compact_tool:'host_file_read',full_tool:'host_file_read',compact_op:'direct',
+        authority:'host',mutating:false,production:false,runtime_flag:'DEADBYTE_PRIVILEGED_POLICY'
+      }]},
+      toolCatalog:['host_file_read'],
+      profile:'compact',
+      env:{},
+      hostPolicy:{arm_file:armFile,policy_sha256:policySha}
+    });
+    const hostRead=result.capabilities[0];
+    assert.equal(hostRead.state,CAPABILITY_STATES.AVAILABLE);
+    assert.equal(hostRead.ready,true);
+    assert.equal(hostRead.diagnostic,null);
+    assert.deepEqual(hostRead.requires,['DEADBYTE_PRIVILEGED_POLICY','host_policy.armed']);
+  }finally{
+    await rm(root,{recursive:true,force:true});
+  }
+});

package/test/compact-max-catalog-r45.test.mjs

@@ -90,7 +90,31 @@ test('R45 real max-runtime compact stdio catalog is exactly 43 with verified ski
     assert.ok(hardware);assert.equal(hardware.authority,'none');assert.equal(hardware.compact_tool,'machine_observe');assert.equal(hardware.compact_op,'hardware_query');
     const skill=m.capabilities.find(item=>item.id==='skill.catalog');
     assert.ok(skill);assert.equal(skill.authority,'none');assert.equal(skill.mutating,false);
-    console.log(JSON.stringify({tool_count:m.tool_count,catalog_sha256:m.catalog_sha256,ledger_sha256:m.ledger_sha256,desktop:true,hardware_query:true,skill:true,authority:'DISARMED'}));
+
+    const byId=id=>m.capabilities.find(item=>item.id===id);
+    for(const [id,reasonCode] of [
+      ['coding.search','CODING_SESSION_DISARMED'],
+      ['process.start','PROCESS_SESSION_DISARMED'],
+      ['autonomous.goal_submit','AUTONOMOUS_SESSION_DISARMED'],
+      ['desktop.action','DESKTOP_SESSION_DISARMED'],
+      ['host.file_read','HOST_POLICY_DISARMED']
+    ]){
+      const item=byId(id);
+      assert.ok(item,'missing capability '+id);
+      assert.equal(item.state,'DENIED',id+' must reflect disarmed authority');
+      assert.equal(item.ready,false,id+' must not be ready while disarmed');
+      assert.equal(item.diagnostic?.code,reasonCode,id+' diagnostic mismatch');
+      assert.ok(m.unavailable_capabilities.some(entry=>entry.id===id&&entry.state==='DENIED'&&entry.reason_code===reasonCode),
+        id+' must be listed as unavailable');
+    }
+    for(const id of ['coding.task_events','coding.task_status','coding.task_verify','process.list','desktop.observe']){
+      const item=byId(id);
+      assert.ok(item,'missing read-only capability '+id);
+      assert.equal(item.state,'AVAILABLE',id+' should remain available without mutation authority');
+      assert.equal(item.ready,true,id+' should remain ready without mutation authority');
+    }
+
+    console.log(JSON.stringify({tool_count:m.tool_count,catalog_sha256:m.catalog_sha256,ledger_sha256:m.ledger_sha256,desktop:true,hardware_query:true,skill:true,authority:'DISARMED',authority_truth:true}));
   } 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);

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`); }
 });

package/test/r48-release-contract.test.mjs

@@ -6,29 +6,35 @@ import { DEADBYTE_VERSION } from '../src/version.mjs';
 const root=new URL('../',import.meta.url);
 const read=rel=>readFile(new URL(rel,root),'utf8');
 
-test('R48 successor identity is coherent and binds active 0.15.19 parent plus sealed 0.15.19 source predecessor',async()=>{
+test('R48 0.15.22 successor binds active 0.15.21 parent and native Windows observation release evidence',async()=>{
   const [pkg,lock,release,provenance]=await Promise.all([
     read('package.json').then(JSON.parse),
     read('package-lock.json').then(JSON.parse),
     read('RELEASE.json').then(JSON.parse),
     read('PROVENANCE.json').then(JSON.parse)
   ]);
-  assert.equal(pkg.version,'0.15.20');
-  assert.equal(lock.version,'0.15.20');
-  assert.equal(lock.packages[''].version,'0.15.20');
-  assert.equal(DEADBYTE_VERSION,'0.15.20');
-  assert.equal(release.version,'0.15.20');
-  assert.equal(provenance.version,'0.15.20');
+  assert.equal(pkg.version,'0.15.22');
+  assert.equal(lock.version,'0.15.22');
+  assert.equal(lock.packages[''].version,'0.15.22');
+  assert.equal(DEADBYTE_VERSION,'0.15.22');
+  assert.equal(release.version,'0.15.22');
+  assert.equal(provenance.version,'0.15.22');
   assert.equal(release.train,'R48');
-  assert.equal(release.label,'DURABLE JOURNAL AUTHENTIC EVENT HOTFIX');
-  assert.equal(release.parent.release_id,'v0.15.19-4b5fcf7acdff11e9');
-  assert.equal(release.parent.manifest_sha256,'4b5fcf7acdff11e935e8f34b5659d92d1f0c51437795432f7715d6a98a55bc29');
-  assert.equal(release.parent.generation_manifest_sha256,'610f4fef7c5e37330f7b2b0fbad69efe0a00f9c7bd256ce8e08bc87e1891680b');
-  assert.equal(release.source_predecessor.version,'0.15.19');
-  assert.equal(release.source_predecessor.tarball_sha256,'e4224ec93588cbd6d68a147cc26097e8a29ddea870fa5f3a9020ab9ed1efbe8f');
-  assert.equal(release.source_predecessor.manifest_file_sha256,'4b5fcf7acdff11e935e8f34b5659d92d1f0c51437795432f7715d6a98a55bc29');
+  assert.equal(release.label,'NATIVE WINDOWS OBSERVATION + MACHINE FS RESILIENCE');
+  assert.equal(release.parent.release_id,'v0.15.21-7c2735e0b1c6cc8d');
+  assert.equal(release.parent.manifest_sha256,'7c2735e0b1c6cc8dac6581c47b6b557d8d0157a324b67efd4df058e67cdb289f');
+  assert.equal(release.parent.generation_manifest_sha256,'b376e7fc450f44edddb0d0e1d596014c463f603e4917c56a68906b7f66f99dc7');
+  assert.equal(release.source_predecessor.version,'0.15.21');
+  assert.equal(release.source_predecessor.tarball_sha256,'3439f5f4435632e4cde385a6937e3e3d2ffcfb777295dd56aafbf3b036be7493');
+  assert.equal(release.source_predecessor.manifest_file_sha256,'7c2735e0b1c6cc8dac6581c47b6b557d8d0157a324b67efd4df058e67cdb289f');
   assert.equal(release.source_predecessor.reference_server_sha256,'dfc303bb7dd2e8d01debac50fc43bb8644d00089bffdf2887e149497cff8b305');
   assert.equal(release.source_predecessor.reference_schemas_sha256,'f342345e34e48769dabaefe1b932f09d41e2e207b422f7794a15ee50ffa8f140');
+  assert.equal(release.capabilities.full_tool_count,116);
+  assert.equal(release.capabilities.full_tool_catalog.path,'docs/R48-FULL-TOOL-CATALOG.json');
+  assert.deepEqual(release.capabilities.windows_queries,['registry','services','drivers','sockets','volumes','usb','wsl']);
+  assert.equal(release.capabilities.machine_fs_list_entry_fault_isolation,true);
+  assert.equal(release.capabilities.capability_manifest_authority_truth,true);
+  assert.equal(release.capabilities.capability_manifest_host_grant_truth,true);
   assert.equal(provenance.parent_release_id,release.parent.release_id);
   assert.equal(provenance.parent_manifest_sha256,release.parent.manifest_sha256);
   assert.equal(provenance.parent_generation_manifest_sha256,release.parent.generation_manifest_sha256);

package/test/windows-observation-r48.test.mjs

@@ -0,0 +1,63 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { generateTrustKeypair } from '../src/trust.mjs';
+import { loadCodingPolicy } from '../src/coding-plane.mjs';
+import { createObservationRuntime, verifyObservationReceiptFile } from '../src/observation-runtime.mjs';
+
+async function fixture(){
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-windows-query-r48-'));
+  const project=path.join(root,'project');await mkdir(project);
+  const policyPath=path.join(root,'coding-policy.json');
+  await writeFile(policyPath,JSON.stringify({schema:'deadbyte.coding-policy.v1',enabled:true,
+    lease_file:path.join(root,'coding-grant.json'),evidence_dir:path.join(root,'evidence'),
+    roots:{project:{path:project,read:true,write:false,exec:false,deny_paths:[]}},commands:{},
+    max_read_bytes:65536,max_write_bytes:65536}));
+  const policy=await loadCodingPolicy(policyPath);
+  const keys=await generateTrustKeypair({privateKeyPath:path.join(root,'private.pem'),publicKeyPath:path.join(root,'public.pem')});
+  const calls=[];
+  const windowsSnapshotProvider=async args=>{
+    calls.push(args);
+    return {schema:'deadbyte.windows-query.v1',query:args.query,data:{query:args.query,fixture:true},observer_sha256:'e'.repeat(64)};
+  };
+  const runtime=createObservationRuntime({policy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath,
+    stateRoot:root,processSnapshotProvider:async()=>[],systemSnapshotProvider:async()=>({hostname:'x',platform:'win32',architecture:'x64',
+      uptime_seconds:1,total_memory_bytes:1,free_memory_bytes:1,cpu_count:1,load_average:[0,0,0]}),
+    ownedRuntimePidProvider:async()=>new Set(),hardwareSnapshotProvider:async query=>({schema:'deadbyte.hardware-query.v1',query,data:{fixture:true}}),
+    windowsSnapshotProvider});
+  return {root,policy,keys,runtime,calls};
+}
+
+test('R48 typed Windows queries are read-only signed native observations',async()=>{
+  const f=await fixture();
+  assert.equal(typeof f.runtime.windowsQuery,'function','windowsQuery runtime method missing');
+  const requests=[
+    {query:'registry',hive:'HKLM',key:'SYSTEM\\CurrentControlSet\\Control',value:null},
+    {query:'services'},{query:'drivers'},{query:'sockets'},{query:'volumes'},{query:'usb'},{query:'wsl'}
+  ];
+  for(const request of requests){
+    const out=await f.runtime.windowsQuery(request);
+    assert.equal(out.status,'ok');
+    assert.equal(out.query,request.query);
+    assert.equal(out.data.query,request.query);
+    assert.match(out.observer_sha256,/^[0-9a-f]{64}$/);
+    assert.match(out.request_sha256,/^[0-9a-f]{64}$/);
+    assert.match(out.result_head_sha256,/^[0-9a-f]{64}$/);
+    assert.match(out.receipt_id,/^[0-9a-f]{24}$/);
+    const verified=await verifyObservationReceiptFile({policy:f.policy,verifyKeyPath:f.keys.publicKeyPath,receiptId:out.receipt_id});
+    assert.equal(verified.ok,true);
+    assert.equal(verified.kind,'machine_windows_query');
+  }
+  assert.deepEqual(f.calls,requests);
+});
+
+test('R48 Windows query validation rejects arbitrary commands and malformed registry selectors before dispatch',async()=>{
+  const f=await fixture();
+  assert.equal(typeof f.runtime.windowsQuery,'function','windowsQuery runtime method missing');
+  await assert.rejects(()=>f.runtime.windowsQuery({query:'powershell',command:'Get-Service'}),/windows query/i);
+  await assert.rejects(()=>f.runtime.windowsQuery({query:'registry',hive:'HKCR',key:'x'}),/registry hive/i);
+  await assert.rejects(()=>f.runtime.windowsQuery({query:'registry',hive:'HKLM',key:''}),/registry key/i);
+  assert.deepEqual(f.calls,[]);
+});

package/test/windows-observation-surface-r48.test.mjs

@@ -0,0 +1,70 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { machineObserveInputSchema, registerCompactGatewayTools } from '../src/compact-gateway-mcp-tools.mjs';
+import { registerObservationTools } from '../src/observation-mcp-tools.mjs';
+import { R36_CAPABILITY_LEDGER } from '../src/capability-ledger.mjs';
+
+const fakeServer=()=>{
+  const tools=new Map();
+  return {tools,registerTool(name,spec,handler){if(tools.has(name))throw new Error('duplicate '+name);tools.set(name,{spec,handler});}};
+};
+const ledger={schema:'deadbyte.capability-ledger.v1',entries:[],ledger_sha256:'0'.repeat(64)};
+const evidence=query=>({status:'ok',observed_at_utc:new Date(0).toISOString(),query,data:{query},observer_sha256:'e'.repeat(64),
+  request_sha256:'b'.repeat(64),result_head_sha256:'c'.repeat(64),receipt_id:'a'.repeat(24),receipt_sha256:'d'.repeat(64)});
+
+test('R48 compact machine_observe exposes seven strict Windows native operations without generic command dispatch',()=>{
+  const valid=[
+    {op:'registry_query',hive:'HKLM',key:'SYSTEM\\CurrentControlSet\\Control',value:null},
+    {op:'service_list'},{op:'driver_list'},{op:'socket_list'},{op:'volume_list'},{op:'usb_list'},{op:'wsl_list'}
+  ];
+  for(const input of valid) assert.equal(machineObserveInputSchema.safeParse(input).success,true,JSON.stringify(input));
+  assert.equal(machineObserveInputSchema.safeParse({op:'registry_query',hive:'HKCR',key:'x',value:null}).success,false);
+  assert.equal(machineObserveInputSchema.safeParse({op:'service_list',command:'sc.exe query'}).success,false);
+  assert.equal(machineObserveInputSchema.safeParse({op:'socket_list',powershell:'Get-NetTCPConnection'}).success,false);
+});
+
+test('R48 compact machine_observe routes all Windows operations to one typed runtime method',async()=>{
+  const calls=[];
+  const observationRuntime={windowsQuery:async args=>{calls.push(args);return evidence(args.query);}};
+  const server=fakeServer();
+  registerCompactGatewayTools(server,{profile:'compact',ledger,codingRuntime:null,semanticRuntime:null,machineFsRuntime:null,processRuntime:null,
+    observationRuntime,machineRuntime:null,desktopRuntime:null,skillRuntime:null,autonomousRuntime:null,hostPolicy:null,
+    catalogProvider:()=>[...server.tools.keys()]});
+  const tool=server.tools.get('machine_observe');
+  const inputs=[
+    {op:'registry_query',hive:'HKCU',key:'Software\\Microsoft',value:'Test'},
+    {op:'service_list'},{op:'driver_list'},{op:'socket_list'},{op:'volume_list'},{op:'usb_list'},{op:'wsl_list'}
+  ];
+  for(const input of inputs){
+    const out=await tool.handler(input);
+    assert.equal(out.isError,false);
+  }
+  assert.deepEqual(calls,[
+    {query:'registry',hive:'HKCU',key:'Software\\Microsoft',value:'Test'},
+    {query:'services'},{query:'drivers'},{query:'sockets'},{query:'volumes'},{query:'usb'},{query:'wsl'}
+  ]);
+});
+
+test('R48 full observation surface exposes one typed machine_windows_query tool',()=>{
+  const server=fakeServer();
+  registerObservationTools(server,{runtime:{windowsQuery:async args=>evidence(args.query),
+    searchStart:async()=>{},searchPage:async()=>{},searchStatus:async()=>{},searchCancel:async()=>{},processList:async()=>{},systemStatus:async()=>{},hardwareQuery:async()=>{}}});
+  assert.equal(server.tools.has('machine_windows_query'),true);
+  const schema=server.tools.get('machine_windows_query').spec.inputSchema;
+  assert.equal(schema.safeParse({query:'registry',hive:'HKLM',key:'SOFTWARE',value:null}).success,true);
+  assert.equal(schema.safeParse({query:'services'}).success,true);
+  assert.equal(schema.safeParse({query:'services',command:'sc query'}).success,false);
+});
+
+test('R48 capability ledger declares every Windows observation through compact machine_observe',()=>{
+  const expected=['registry_query','service_list','driver_list','socket_list','volume_list','usb_list','wsl_list'];
+  for(const op of expected){
+    const cap=R36_CAPABILITY_LEDGER.entries.find(x=>x.id===`observation.${op}`);
+    assert.ok(cap,`missing observation.${op}`);
+    assert.equal(cap.full_tool,'machine_windows_query');
+    assert.equal(cap.compact_tool,'machine_observe');
+    assert.equal(cap.compact_op,op);
+    assert.equal(cap.authority,'none');
+    assert.equal(cap.mutating,false);
+  }
+});