deadbyte-mcp 0.15.24 → 0.15.26

package/test/desktop-runtime-r40.test.mjs

@@ -19,7 +19,7 @@ function F(at,image=H('same'),window=WIN){
     bounds:{left:0,top:0,width:1000,height:800},activeWindow:window,imageSha256:image
   });
 }
-async function fixture({grantActions=['click_primary','text_input'],captureFrames=null,times=null,inputProvider=null,grounderProvider=null}={}){
+async function fixture({grantActions=['click_primary','text_input'],captureFrames=null,times=null,inputProvider=null,grounderProvider=null,clockMs=null,sleeper=null}={}){
   const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r40-desktop-runtime-'));
   const grant=path.join(root,'grant.json'),evidence=path.join(root,'evidence');
   const policy={
@@ -59,7 +59,7 @@ async function fixture({grantActions=['click_primary','text_input'],captureFrame
     '2026-09-19T02:00:01.000Z'
   ])];
   const now=()=>clock.length?clock.shift():'2026-09-19T02:00:01.000Z';
-  const runtime=createDesktopRuntime({policy,observerRuntime,inputProvider:provider,grounderProvider,privateKey,keyId:'test-key',evidenceDir:evidence,now});
+  const runtime=createDesktopRuntime({policy,observerRuntime,inputProvider:provider,grounderProvider,privateKey,keyId:'test-key',evidenceDir:evidence,now,clockMs:clockMs??undefined,sleeper:sleeper??undefined});
   return {root,grant,evidence,policy,expected,runtime,calls,publicKey};
 }
 
@@ -242,6 +242,47 @@ test('read-only observe works independently of desktop mutation grant',async()=>
   assert.match(observed.receipt_sha256,/^[0-9a-f]{64}$/);
 });
 
+test('successor desktop wait observes until a frame changes and publishes signed final evidence',async()=>{
+  let tick=0;
+  const same={frame:F('2026-09-19T02:00:00.600Z'),backend:'fake',byte_length:4};
+  const changed={frame:F('2026-09-19T02:00:00.900Z',H('changed')),backend:'fake',byte_length:4};
+  const fx=await fixture({
+    captureFrames:[same,changed],clockMs:()=>tick,sleeper:async ms=>{tick+=ms;},
+    times:['2026-09-19T02:00:01.000Z']
+  });
+  await writeFile(fx.grant,'{}');
+  const result=await fx.runtime.wait({baselineFrameId:fx.expected.frame_id,until:'frame_changed',timeoutMs:1000,pollMs:100});
+  assert.equal(result.satisfied,true);
+  assert.equal(result.timed_out,false);
+  assert.equal(result.attempts,2);
+  assert.equal(result.frame.frame_id,changed.frame.frame_id);
+  assert.match(result.receipt_sha256,/^[0-9a-f]{64}$/);
+  const receipt=JSON.parse(await readFile(path.join(fx.evidence,`${result.receipt_id}.json`),'utf8'));
+  assert.equal(receipt.kind,'desktop_wait_observation');
+  assert.equal(receipt.payload.condition,'frame_changed');
+  assert.equal(receipt.payload.satisfied,true);
+  assert.equal(fx.calls.length,0);
+});
+
+test('successor desktop wait uses local UIA matching without leaking query text or dispatching input',async()=>{
+  let tick=0,queries=0;
+  const first={frame:F('2026-09-19T02:00:00.600Z'),backend:'fake',byte_length:4};
+  const second={frame:F('2026-09-19T02:00:00.900Z'),backend:'fake',byte_length:4};
+  const grounderProvider=async({query})=>{
+    queries++;
+    return {status:'ok',query_sha256:H('wait-query'),query_kind:query.kind,ordinal:0,visited:4,truncated:false,
+      matches:queries===1?[]:[{rect:{left:1,top:2,width:3,height:4},control_type:50000,enabled:true,offscreen:false}],
+      provider_receipt_sha256:H('wait-provider')};
+  };
+  const fx=await fixture({captureFrames:[first,second],grounderProvider,clockMs:()=>tick,sleeper:async ms=>{tick+=ms;},times:['2026-09-19T02:00:01.000Z']});
+  const result=await fx.runtime.wait({baselineFrameId:fx.expected.frame_id,until:'uia_present',query:{kind:'name_exact',value:'SECRET READY',max_results:8,ordinal:0},timeoutMs:1000,pollMs:100});
+  assert.equal(result.satisfied,true);
+  assert.equal(result.match.actionable,true);
+  assert.equal(result.match.query_sha256,H('wait-query'));
+  assert.equal(JSON.stringify(result).includes('SECRET READY'),false);
+  assert.equal(fx.calls.length,0);
+});
+
 
 test('desktop runtime enforces policy max_text_bytes before observation or input effect',async()=>{
   const fx=await fixture({grantActions:['text_input']});

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

@@ -7,6 +7,7 @@ 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';
+import { expectedFullCatalogForEnv } from '../src/runtime-catalog-expectation.mjs';
 
 const here=path.dirname(fileURLToPath(import.meta.url));
 const repoRoot=path.resolve(here,'..');
@@ -15,7 +16,7 @@ const desktopPolicyPath=path.join(repoRoot,'controller','deadbyte-desktop-policy
 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()=>{
+test('R49 runtime full stdio catalog exactly matches sealed R48 base plus reviewed overlay',async()=>{
   const canonical=JSON.parse(await readFile(catalogPath,'utf8'));
   assert.equal(canonical.schema,'deadbyte.r48-full-catalog.v1');
   assert.equal(canonical.train,'R48');
@@ -61,15 +62,16 @@ test('R48 runtime full stdio catalog exactly matches canonical registration surf
     DEADBYTE_AUTONOMOUS_RUNTIME:'1',DEADBYTE_AUTONOMOUS_POLICY:path.join(f.root,'autonomous-policy.json'),
     DEADBYTE_AUTONOMOUS_SUPERVISOR_MODE:'external'
   };
+  const expected=await expectedFullCatalogForEnv(env);
   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.deepEqual(names,expected);
     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);
+    for(const name of ['agent_task_submit','autonomous_goal_submit','coding_task_submit','process_session_start','machine_fs_write','machine_search_start','desktop_wait','desktop_action','host_exec','native_diff_apply','skill_catalog']) assert.ok(names.includes(name),'missing R49 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);

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

@@ -6,7 +6,7 @@ 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 0.15.24 successor binds exact active 0.15.23 parent and Commander differential evidence',async()=>{
+test('R49 0.15.26 successor binds exact published immutable 0.15.25 parent',async()=>{
   const [pkg,lock,release,provenance,matrix]=await Promise.all([
     read('package.json').then(JSON.parse),
     read('package-lock.json').then(JSON.parse),
@@ -14,24 +14,19 @@ test('R48 0.15.24 successor binds exact active 0.15.23 parent and Commander diff
     read('PROVENANCE.json').then(JSON.parse),
     read('TEST-MATRIX.json').then(JSON.parse)
   ]);
-  assert.equal(pkg.version,'0.15.24');
-  assert.equal(lock.version,'0.15.24');
-  assert.equal(lock.packages[''].version,'0.15.24');
-  assert.equal(DEADBYTE_VERSION,'0.15.24');
-  assert.equal(release.version,'0.15.24');
-  assert.equal(provenance.version,'0.15.24');
-  assert.equal(matrix.version,'0.15.24');
-  assert.equal(release.train,'R48');
-  assert.equal(release.label,'COMMANDER DIFFERENTIAL + PROTOCOL HARDENING BASELINE');
-  assert.equal(release.parent.release_id,'v0.15.23-c97e3d21e792420e');
-  assert.equal(release.parent.manifest_sha256,'c97e3d21e792420ea90dada3c1360cd56e4c1f221daa86596d611b0d1ac351ec');
-  assert.equal(release.parent.generation_manifest_sha256,'4d2d3a4dc103576c39171c52db3436366e62d8b872bcafa4c55f2adb6d3a1126');
-  assert.equal(release.source_predecessor.version,'0.15.23');
-  assert.equal(release.source_predecessor.tarball_sha256,'8c8711805bd05b9d4f61a7c9e123d888eb65121a10c85247807a723154416af4');
-  assert.equal(release.source_predecessor.manifest_file_sha256,'c97e3d21e792420ea90dada3c1360cd56e4c1f221daa86596d611b0d1ac351ec');
+  for(const value of [pkg.version,lock.version,lock.packages[''].version,DEADBYTE_VERSION,release.version,provenance.version,matrix.version])assert.equal(value,'0.15.26');
+  assert.equal(release.train,'R49');
+  assert.equal(release.label,'BOUNDED SEMANTIC DESKTOP WAIT + REMOTE CONTROL HARDENING');
+  assert.equal(release.parent.release_id,'v0.15.25-7ed657b1aa038ee6');
+  assert.equal(release.parent.manifest_sha256,'7ed657b1aa038ee679ff081f1a83c421a5eeb5fc7ea6b746e0f661079b69b319');
+  assert.equal(release.parent.generation_manifest_sha256,'c9763738e27ec39b1180473995f2af088d85293a94f5693abd6a843e09cecec9');
+  assert.equal(release.source_predecessor.version,'0.15.25');
+  assert.equal(release.source_predecessor.tarball_sha256,'0410b41b3c891210262a4db793ee3b339862472ef069f881c9e092c1083ba6d2');
+  assert.equal(release.source_predecessor.manifest_file_sha256,'7ed657b1aa038ee679ff081f1a83c421a5eeb5fc7ea6b746e0f661079b69b319');
   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_count,117);
+  assert.equal(release.capabilities.desktop_bounded_semantic_wait,true);
   assert.equal(release.capabilities.commander_incremental_pdf_revisions,true);
   assert.equal(release.capabilities.commander_docx_header_footer_search,true);
   assert.equal(release.capabilities.commander_directory_read_fallback,true);
@@ -42,7 +37,6 @@ test('R48 0.15.24 successor binds exact active 0.15.23 parent and Commander diff
   assert.equal(provenance.parent_manifest_sha256,release.parent.manifest_sha256);
   assert.equal(provenance.parent_generation_manifest_sha256,release.parent.generation_manifest_sha256);
   assert.equal(provenance.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
-  assert.equal(matrix.full_regression_partition_proof.files,211);
-  assert.equal(matrix.full_regression_partition_proof.fail,0);
-  assert.equal(matrix.full_regression_partition_proof.task_receipt_sha256,'7711039e4807f6c2af02bbda897d0032b067e0a6631f789fd3bf801258160d3f');
+  assert.equal(matrix.predecessor_r48_full_regression_partition_proof.files,211);
+  assert.equal(matrix.predecessor_r48_full_regression_partition_proof.not_valid_as_r49_proof,true);
 });

package/test/r49-remote-control-donors.test.mjs

@@ -0,0 +1,24 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+
+const artifact=new URL('../docs/R49-REMOTE-CONTROL-DONORS.json',import.meta.url);
+
+test('R49 remote-control donor evidence pins all requested sources and records bounded native adoption',async()=>{
+  const value=JSON.parse(await readFile(artifact,'utf8'));
+  assert.equal(value.schema,'deadbyte.r49-remote-control-donors.v1');
+  assert.equal(value.donors.length,6);
+  assert.deepEqual(value.donors.map(item=>item.repository),[
+    'https://github.com/shahidx0x/better-remote-commander',
+    'https://github.com/Jennifer9911/open-remote-mcp',
+    'https://github.com/Razewang/secure-host-mcp',
+    'https://github.com/dddabtc/winremote-mcp',
+    'https://github.com/getremcp/remcp',
+    'https://github.com/trycua/cua'
+  ]);
+  for(const donor of value.donors)assert.match(donor.commit,/^[0-9a-f]{40}$/);
+  assert.equal(value.adopted_checkpoint.capability,'desktop.wait');
+  assert.equal(value.adopted_checkpoint.authority,'none');
+  assert.ok(value.adopted_checkpoint.properties.includes('no input dispatch and no action retry'));
+  assert.ok(value.explicit_non_adoptions.includes('generic shell or caller-selected executable authority'));
+});

package/test/r49-windows-gate.test.mjs

@@ -0,0 +1,33 @@
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+import test from 'node:test';
+
+const read = path => readFile(new URL(`../${path}`, import.meta.url), 'utf8');
+
+test('R49 canonical Windows gate is successor-bound and preserves the R48 historical gate', async () => {
+  const [pkgText, gate, evidence, historical, deferred] = await Promise.all([
+    read('package.json'),
+    read('scripts/gate-windows-r49.ps1'),
+    read('scripts/windows-gate-evidence-r49.mjs'),
+    read('scripts/gate-windows-r48.ps1'),
+    read('scripts/deferred-slot-operation-r46.mjs')
+  ]);
+  const pkg = JSON.parse(pkgText);
+  assert.match(pkg.scripts['gate:windows'], /gate-windows-r49\.ps1$/);
+  assert.match(gate, /DEADBYTE 0\.15\.26 \/ R49 WINDOWS GATE: PASS/);
+  assert.match(gate, /r49-remote-control-donors\.test\.mjs/);
+  assert.match(gate, /desktop-runtime-r40\.test\.mjs/);
+  assert.match(gate, /manifest-final-verify/);
+  assert.match(evidence, /deadbyte\.r49-windows-gate\.v1/);
+  assert.match(evidence, /pkg\.version==='0\.15\.26'/);
+  assert.match(evidence, /release\.train==='R49'/);
+  assert.match(historical, /DEADBYTE 0\.15\.25 \/ R48 WINDOWS GATE: PASS/);
+  assert.match(deferred, /const expectedVersion=packageIdentity\.version/);
+  assert.match(deferred, /'--expected-version',expectedVersion/);
+  assert.match(deferred, /async function awaitHandoffCompletion/);
+  assert.match(deferred, /verifySlotUpdateEnvelope\(envelope,publicKey\)/);
+  assert.match(deferred, /active pointer does not match signed activation receipt/);
+  assert.match(deferred, /failure-receipt\.json/);
+  assert.match(deferred, /await awaitHandoffCompletion\(await runSlotUpdateCli/);
+  assert.doesNotMatch(deferred, /'--expected-version','0\.15\.5'/);
+});

package/test/remote-r24-catalog.test.mjs

@@ -32,6 +32,15 @@ test('R29 remote gate accepts machine plane as an exact optional catalog dimensi
   assert.match(source, /if \(machine\) items\.push\(\.\.\.machineTools\)/);
   assert.match(source, /machine_runtime: machineRuntime/);
 });
+
+test('R49 compact remote gate independently verifies signed machine ping', async () => {
+  const source = await readFile(sourcePath, 'utf8');
+  assert.match(source, /verifyMachinePingPublic/);
+  assert.match(source, /public_key_spki_base64/);
+  assert.match(source, /machine ping public Ed25519 verification failed/);
+  assert.match(source, /ping_signature_valid: true/);
+  assert.doesNotMatch(source, /ping_signature_valid: ping\.signature_valid === true/);
+});
 test('R46 remote gate accepts seven-tool process supervision as one exact optional catalog dimension', async () => {
   const source = await readFile(sourcePath, 'utf8');
   assert.match(source, /const processTools = \[/);

package/test/tunnel-stdio-compat.test.mjs

@@ -145,13 +145,11 @@ test('installed stdio prefilter answers legacy startup probe and forwards split
   assert.deepEqual(hexLines, ['HEX:' + modern.toString('hex')]);
 });
 
-test('tunnel compatibility smoke preserves only base or base-plus-host modern catalogs', async () => {
+test('tunnel compatibility smoke derives exact modern catalog and explicitly disables Host', async () => {
   const smoke = await readFile(fileURLToPath(new URL('../src/tunnel-stdio-compat-smoke.mjs', import.meta.url)), 'utf8');
-  for (const name of ['contained_transform', 'evidence_verify', 'file_read', 'proof_execute', 'workspace_open']) assert.match(smoke, new RegExp(name));
-  for (const name of ['host_exec', 'host_file_read', 'host_file_write']) assert.match(smoke, new RegExp(name));
-  assert.match(smoke, /allowedCatalogs/);
-  assert.match(smoke, /baseTools/);
-  assert.match(smoke, /privilegedTools/);
+  assert.match(smoke, /expectedFullCatalogForEnv/);
+  assert.match(smoke, /assertExactCatalog/);
+  assert.match(smoke, /DEADBYTE_PRIVILEGED_POLICY: ''/);
   assert.doesNotMatch(smoke, /agent_task_/);
 });