deadbyte-mcp 0.15.39 → 0.15.42

package/test/remote-session-cli.test.mjs

@@ -1,5 +1,6 @@
 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 os from 'node:os';
 import path from 'node:path';
@@ -181,7 +182,7 @@ winTest('remote refuses READY when public signed MCP execution probe fails',asyn
   try{
     child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
     const output=await collect(child);
-    const ended=await Promise.race([output.closed,sleep(6500).then(()=>({timeout:true}))]);
+    const ended=await Promise.race([output.closed,sleep(12000).then(()=>({timeout:true}))]);
     assert.equal(ended.timeout,undefined,'remote did not fail closed after execution probe failure');
     assert.notEqual(ended.code,0);
     assert.doesNotMatch(output.stdout,/\[READY\]|\[OK\] ONLINE/);
@@ -200,8 +201,8 @@ winTest('remote refuses READY when controller snapshot lies about Host enforceme
   try{
     child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
     const output=await collect(child);
-    const ended=await Promise.race([output.closed,sleep(6500).then(()=>({timeout:true}))]);
-    assert.equal(ended.timeout,undefined,'remote did not reject split authority truth');
+    const ended=await Promise.race([output.closed,sleep(12000).then(()=>({timeout:true}))]);
+    assert.equal(ended.timeout,undefined,`remote did not reject split authority truth; stdout=${output.stdout.slice(-1200)} stderr=${output.stderr.slice(-1200)} trace=${(await traceCommands(fx.trace)).join(',')}`);
     assert.notEqual(ended.code,0);
     assert.doesNotMatch(output.stdout,/\[READY\]|\[OK\] ONLINE/);
     assert.match(output.stderr,/machinetest|enforcement/i);
@@ -393,7 +394,7 @@ winTest('remote --resume replays sanitized tool-call and terminal result events
     const liveIndex=secondOutput.stdout.indexOf('[LOG] Human live timeline');
     assert.ok(callReplayIndex>=0&&resultReplayIndex>callReplayIndex&&liveIndex>resultReplayIndex,'resume ordering must be call -> result -> live tail');
     second.stdin.end();
-    const secondEnded=await Promise.race([secondOutput.closed,sleep(6000).then(()=>({timeout:true}))]);
+    const secondEnded=await Promise.race([secondOutput.closed,sleep(12000).then(()=>({timeout:true}))]);
     assert.equal(secondEnded.timeout,undefined);
     assert.equal(secondEnded.code,0,secondOutput.stderr);
   }finally{
@@ -501,8 +502,8 @@ winTest('bare remote rolls back authority and parks if one plane fails to arm',a
   try{
     const child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['ignore','pipe','pipe'],windowsHide:true});
     const output=await collect(child);
-    const ended=await Promise.race([output.closed,sleep(6000).then(()=>({timeout:true}))]);
-    assert.equal(ended.timeout,undefined,'failed startup did not terminate');
+    const ended=await Promise.race([output.closed,sleep(12000).then(()=>({timeout:true}))]);
+    assert.equal(ended.timeout,undefined,`failed startup did not terminate; stdout=${output.stdout.slice(-1200)} stderr=${output.stderr.slice(-1200)} trace=${(await traceCommands(fx.trace)).join(',')}`);
     assert.notEqual(ended.code,0);
     const commands=await traceCommands(fx.trace);
     assert.deepEqual(commands.slice(0,6),['status','start','status','status','armprocess','armcoding']);
@@ -645,13 +646,14 @@ winTest('explicit remote status remains a one-shot controller command',async()=>
   }finally{await rm(fx.dir,{recursive:true,force:true});}
 });
 
-winTest('explicit remote status reports CLI package and active runtime VERSION SKEW',async()=>{
+winTest('explicit remote status keeps the coherent runtime one-shot and silent',async()=>{
   const fx=await fixture({statusOnline:true});
   try{
-    const manifest='1'.repeat(64),generation='2'.repeat(64),launcher='3'.repeat(64);
+    const manifest=createHash('sha256').update(await readFile(path.join(root,'MANIFEST.SHA256'))).digest('hex');
+    const generation='2'.repeat(64),launcher='3'.repeat(64);
     await writeFile(path.join(fx.state,'active-release.json'),JSON.stringify({
-      schema:'deadbyte.active-release.v1',release_id:`v0.15.16-${manifest.slice(0,16)}`,version:'0.15.16',manifest_sha256:manifest,
-      release_root:'C:/deadbyte/releases/0.15.16',generation_root:'C:/deadbyte/generations/0.15.16',generation_manifest_sha256:generation,
+      schema:'deadbyte.active-release.v1',release_id:`v${DEADBYTE_VERSION}-${manifest.slice(0,16)}`,version:DEADBYTE_VERSION,manifest_sha256:manifest,
+      release_root:'C:/deadbyte/releases/current',generation_root:'C:/deadbyte/generations/current',generation_manifest_sha256:generation,
       launcher_sha256:launcher,config_path:'C:/deadbyte/config.psd1'
     }),'utf8');
     const child=spawn(process.execPath,[cliPath,'remote','status'],{env:fx.env,stdio:['ignore','pipe','pipe'],windowsHide:true});
@@ -659,7 +661,7 @@ winTest('explicit remote status reports CLI package and active runtime VERSION S
     const ended=await Promise.race([output.closed,sleep(6000).then(()=>({timeout:true}))]);
     assert.equal(ended.timeout,undefined);
     assert.equal(ended.code,0,output.stderr);
-    assert.ok(output.stderr.includes(`VERSION SKEW: CLI package ${DEADBYTE_VERSION}; active runtime 0.15.16`),output.stderr);
+    assert.doesNotMatch(output.stderr,/VERSION SKEW/);
     assert.deepEqual(await traceCommands(fx.trace),['status']);
   }finally{await rm(fx.dir,{recursive:true,force:true});}
 });

package/test/standing-grants.test.mjs

@@ -1,23 +1,26 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
+import { mkdtemp, mkdir, readFile, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { loadCodingPolicy, codingSessionStatus } from '../src/coding-plane.mjs';
 import { assertAutonomousArmed, loadAutonomousPolicy, autonomousSessionStatus, recheckAutonomousAuthority } from '../src/autonomous-policy.mjs';
 import { loadHostPolicy, assertHostArmed } from '../src/host-plane.mjs';
 import { createHash } from 'node:crypto';
+import { createAuthorityEpochStore } from '../src/authority-continuity-r65.mjs';
+import { prepareAuthorityTestTrust } from './r65-authority-test-trust.mjs';
 
 const sha = bytes => createHash('sha256').update(bytes).digest('hex');
 const farFuture = new Date('2099-01-01T00:00:00Z');
 
 async function fixture() {
   const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-standing-'));
+  await prepareAuthorityTestTrust(root);
   const project = path.join(root, 'project');
   await mkdir(project);
   const codingPath = path.join(root, 'coding.json');
   await writeFile(codingPath, JSON.stringify({ schema:'deadbyte.coding-policy.v1', enabled:true,
-    lease_file:path.join(root,'coding-grant.json'), evidence_dir:path.join(root,'coding-evidence'),
+    lease_file:path.join(root,'runtime','coding-grant.json'), evidence_dir:path.join(root,'coding-evidence'),
     roots:{ project:{ path:project, read:true, write:true, exec:false, deny_paths:[] } }, commands:{} }));
   const coding = await loadCodingPolicy(codingPath);
   return { root, project, coding, codingPath };
@@ -27,6 +30,10 @@ test('coding standing grant remains armed until explicit revocation', async () =
   await writeFile(coding.lease_file, JSON.stringify({ schema:'deadbyte.coding-grant.v2',
     policy_sha256:coding.policy_sha256, instance_nonce:'a'.repeat(64), root_ids:['project'],
     granted_at_utc:'2026-09-04T00:00:00Z' }));
+  const codingBytes=await readFile(coding.lease_file);
+  await createAuthorityEpochStore({runtimeDir:path.dirname(coding.lease_file),policyBytes:await readFile(coding.policy_path)}).append({
+    plane:'coding',action:'grant',grantBytes:codingBytes,grantInstanceNonce:'a'.repeat(64),updateId:null
+  });
   const status = await codingSessionStatus(coding, farFuture);
   assert.equal(status.armed, true);
   assert.equal(status.reason, 'standing-grant');
@@ -37,13 +44,17 @@ test('autonomous standing grant remains armed until explicit revocation', async
   const { root, coding } = await fixture();
   const policyPath = path.join(root, 'autonomous.json');
   await writeFile(policyPath, JSON.stringify({ schema:'deadbyte.autonomous-policy.v1', enabled:true,
-    lease_file:path.join(root,'autonomous-grant.json'), evidence_dir:path.join(root,'autonomous-evidence'),
+    lease_file:path.join(root,'runtime','autonomous-grant.json'), evidence_dir:path.join(root,'autonomous-evidence'),
     coding_policy_sha256:coding.policy_sha256, root_ids:['project'], planner:{backend:'client_sampling'},
     limits:{max_iterations:4,max_mutations:4,max_wall_ms:null}, profiles:{} }));
   const policy = await loadAutonomousPolicy(policyPath, coding);
   await writeFile(policy.lease_file, JSON.stringify({ schema:'deadbyte.autonomous-grant.v2',
     policy_sha256:policy.policy_sha256, coding_policy_sha256:coding.policy_sha256,
     instance_nonce:'b'.repeat(64), root_ids:['project'], granted_at_utc:'2026-09-04T00:00:00Z' }));
+  const autonomousBytes=await readFile(policy.lease_file);
+  await createAuthorityEpochStore({runtimeDir:path.dirname(policy.lease_file),policyBytes:await readFile(policy.policy_path)}).append({
+    plane:'autonomous',action:'grant',grantBytes:autonomousBytes,grantInstanceNonce:'b'.repeat(64),updateId:null
+  });
   const status = await autonomousSessionStatus(policy, farFuture);
   assert.equal(status.armed, true);
   assert.equal(status.reason, 'standing-grant');
@@ -55,15 +66,20 @@ test('autonomous standing grant remains armed until explicit revocation', async
 });
 test('host standing grant remains armed until explicit revocation', async () => {
   const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-host-standing-'));
+  await prepareAuthorityTestTrust(root);
   const project = path.join(root, 'project');
   await mkdir(project);
   const policyPath = path.join(root, 'host.json');
   await writeFile(policyPath, JSON.stringify({ schema:'deadbyte.host-policy.v1', enabled:true,
-    arm_file:path.join(root,'host-grant.json'), roots:{ project:{path:project,read:true,write:true,exec:false} },
+    arm_file:path.join(root,'runtime','host-grant.json'), roots:{ project:{path:project,read:true,write:true,exec:false} },
     commands:{} }));
   const policy = await loadHostPolicy(policyPath);
   await writeFile(policy.arm_file, JSON.stringify({ schema:'deadbyte.host-grant.v2',
     policy_sha256:policy.policy_sha256, instance_nonce:'c'.repeat(64), granted_at_utc:'2026-09-04T00:00:00Z' }));
+  const hostBytes=await readFile(policy.arm_file);
+  await createAuthorityEpochStore({runtimeDir:path.dirname(policy.arm_file),policyBytes:await readFile(policy.policy_path)}).append({
+    plane:'host',action:'grant',grantBytes:hostBytes,grantInstanceNonce:'c'.repeat(64),updateId:null
+  });
   const status = await assertHostArmed(policy, farFuture);
   assert.equal(status.standing, true);
   assert.equal(status.remaining_ms, null);