deadbyte-mcp 0.15.41 → 0.15.43

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

@@ -0,0 +1,75 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+
+const read=rel=>readFile(new URL('../'+rel,import.meta.url),'utf8');
+const json=async rel=>JSON.parse((await read(rel)).replace(/^\uFEFF/,''));
+const currentPackage=await json('package.json');
+const PARENT={
+  version:'0.15.41',
+  release_id:'v0.15.41-63a78ad159ad3003',
+  manifest_sha256:'63a78ad159ad3003db3fefafcd468bef22599c829a867f4f10a46c7a20748b3e',
+  generation_manifest_sha256:'19ae2efcdcde9f80c474f0e55851d4ada51c22813d3e05af03b11acb28c3fca5'
+};
+
+test('R65 release identity binds exact production R64 parent and durable authority-continuity train',{skip:currentPackage.version!=='0.15.42'},async()=>{
+  const [pkg,lock,bridge,release,provenance,matrix,sbom,version,gate,gaps,design]=await Promise.all([
+    json('package.json'),json('package-lock.json'),json('bridge/package.json'),json('RELEASE.json'),
+    json('PROVENANCE.json'),json('TEST-MATRIX.json'),json('SBOM.cdx.json'),read('src/version.mjs'),
+    read('scripts/gate-windows-r65-prepublish.ps1'),json('docs/R65-REFERENCE-GAP-MATRIX.json'),
+    json('docs/R65-AUTHORITY-CONTINUITY-DESIGN.json')
+  ]);
+  assert.equal(pkg.version,'0.15.42');
+  assert.equal(lock.version,pkg.version);
+  assert.equal(lock.packages[''].version,pkg.version);
+  assert.equal(bridge.version,pkg.version);
+  assert.match(version,/DEADBYTE_VERSION = '0\.15\.42'/);
+  assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r65-prepublish.ps1');
+  assert.equal(pkg.scripts['r65:focused:test'],'node scripts/r65-focused.mjs');
+
+  assert.equal(release.version,pkg.version);
+  assert.equal(release.train,'R65');
+  assert.equal(release.parent.version,PARENT.version);
+  assert.equal(release.parent.release_id,PARENT.release_id);
+  assert.equal(release.parent.manifest_sha256,PARENT.manifest_sha256);
+  assert.equal(release.parent.generation_manifest_sha256,PARENT.generation_manifest_sha256);
+  assert.deepEqual(release.runtime_predecessor,{
+    release_id:PARENT.release_id,
+    manifest_sha256:PARENT.manifest_sha256,
+    generation_manifest_sha256:PARENT.generation_manifest_sha256
+  });
+  assert.equal(release.source_predecessor.version,PARENT.version);
+  assert.equal(release.source_predecessor.manifest_file_sha256,PARENT.manifest_sha256);
+  assert.equal(release.source_predecessor.release_status,'PRODUCTION_RELEASED');
+  assert.equal(release.r65_release_control_hardening.new_public_tools,0);
+  assert.equal(release.r65_release_control_hardening.new_authority_scopes,0);
+  assert.equal(release.r65_release_control_hardening.legacy_r64_auto_restore,false);
+  assert.equal(release.r65_release_control_hardening.epoch_native_restore_requires_continuity_proof,true);
+  assert.equal(release.r65_release_control_hardening.explicit_revoke_wins,true);
+  assert.equal(release.r65_release_control_hardening.revoked_nonce_resurrection,false);
+  assert.equal(release.r65_release_control_hardening.stable_final_claim,false);
+
+  assert.equal(provenance.version,pkg.version);
+  assert.equal(provenance.parent_release_id,PARENT.release_id);
+  assert.equal(provenance.parent_manifest_sha256,PARENT.manifest_sha256);
+  assert.equal(provenance.parent_generation_manifest_sha256,PARENT.generation_manifest_sha256);
+  assert.equal(provenance.source_predecessor_version,PARENT.version);
+  assert.equal(provenance.source_predecessor_manifest_file_sha256,PARENT.manifest_sha256);
+  assert.equal(provenance.r65.production_mutations,0);
+  assert.equal(provenance.r65.npm_publications,0);
+
+  assert.equal(matrix.version,pkg.version);
+  assert.equal(matrix.train,'R65');
+  assert.ok(matrix.required.some(row=>row.id==='r65-focused'));
+  assert.ok(matrix.required.some(row=>row.id==='r65-full-regression'));
+  assert.equal(sbom.metadata.component.version,pkg.version);
+  assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r65:0.15.42');
+  assert.equal(gaps.decisions.length,7);
+  assert.equal(design.selected_method.r64_predecessor_continuity.includes('REAUTH_REQUIRED'),true);
+
+  assert.match(gate,/v0\.15\.41-63a78ad159ad3003/);
+  assert.match(gate,/63a78ad159ad3003db3fefafcd468bef22599c829a867f4f10a46c7a20748b3e/);
+  assert.match(gate,/19ae2efcdcde9f80c474f0e55851d4ada51c22813d3e05af03b11acb28c3fca5/);
+  assert.match(gate,/r65:focused:test/);
+  assert.doesNotMatch(gate,/npm\.cmd publish|--publish-only/);
+});

package/test/r65-transaction-precondition.test.mjs

@@ -0,0 +1,36 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {generateKeyPairSync} from 'node:crypto';
+import {mkdtemp,mkdir,readFile,rm,writeFile,unlink} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {performSlotUpdate,verifySlotUpdateEnvelope} from '../src/runtime-update.mjs';
+import {inspectDoctorTransactions} from '../src/doctor-transactions-r58.mjs';
+
+test('deterministic candidate precondition rejection is a signed terminal phase, not unresolved residue',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r65-precondition-'));
+  try{
+    const state=path.join(root,'state'),trust=path.join(state,'trust');
+    await mkdir(trust,{recursive:true});
+    const {privateKey,publicKey}=generateKeyPairSync('ed25519');
+    await writeFile(path.join(trust,'ed25519-private.pem'),privateKey.export({type:'pkcs8',format:'pem'}));
+    await writeFile(path.join(trust,'ed25519-public.pem'),publicKey.export({type:'spki',format:'pem'}));
+    const stage=path.join(root,'missing-candidate');
+    let failure;
+    try{await performSlotUpdate({stage,developmentRoot:path.join(root,'dev'),expectedVersion:'0.15.42',expectedManifest:'a'.repeat(64),stateRoot:state});}
+    catch(error){failure=error;}
+    assert.ok(failure?.statePath,'expected isolated precondition failure evidence');
+    const journal=JSON.parse(await readFile(failure.statePath,'utf8'));
+    assert.equal(journal.phase,'precondition_rejected');
+    const receipt=JSON.parse(await readFile(failure.failureReceiptPath,'utf8'));
+    assert.equal(receipt.body.result,'PRECONDITION_REJECTED');
+    assert.equal(verifySlotUpdateEnvelope(receipt,publicKey),true);
+    const doctor=await inspectDoctorTransactions(state);
+    assert.equal(doctor.status,'PASS');
+    assert.equal(doctor.findings.at(-1).evidence.unresolved_transactions,0);
+    await unlink(failure.failureReceiptPath);
+    const missing=await inspectDoctorTransactions(state);
+    assert.equal(missing.status,'FAIL');
+    assert.ok(missing.findings.some(item=>item.evidence?.check==='missing_failure_receipt'));
+  }finally{await rm(root,{recursive:true,force:true});}
+});

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

@@ -0,0 +1,56 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+
+const read=rel=>readFile(new URL('../'+rel,import.meta.url),'utf8');
+const json=async rel=>JSON.parse((await read(rel)).replace(/^\uFEFF/,''));
+const PARENT={
+  version:'0.15.42',
+  release_id:'v0.15.42-1b4754103dd4ca43',
+  manifest_sha256:'1b4754103dd4ca43eb81f8e33cf188b36eee3051cb182396ccc6abe2a6e6c250',
+  generation_manifest_sha256:'62dc68be55ad627f8d872b8be8c1369ecca0edf08fdedc8336c9ccee2d2809fb'
+};
+
+test('R66 identity is an exact prepublish doctor hotfix of sealed R65',async()=>{
+  const [pkg,lock,bridge,release,provenance,matrix,sbom,version,gate]=await Promise.all([
+    json('package.json'),json('package-lock.json'),json('bridge/package.json'),json('RELEASE.json'),
+    json('PROVENANCE.json'),json('TEST-MATRIX.json'),json('SBOM.cdx.json'),read('src/version.mjs'),
+    read('scripts/gate-windows-r66-prepublish.ps1')
+  ]);
+  assert.equal(pkg.version,'0.15.43');
+  assert.equal(lock.version,pkg.version);
+  assert.equal(lock.packages[''].version,pkg.version);
+  assert.equal(bridge.version,pkg.version);
+  assert.match(version,/DEADBYTE_VERSION = '0\.15\.43'/);
+  assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r66-prepublish.ps1');
+  assert.match(pkg.scripts['r66:focused:test'],/test\/r58-doctor-runtime\.test\.mjs/);
+  assert.equal(release.version,pkg.version);
+  assert.equal(release.train,'R66');
+  for(const [key,value] of Object.entries(PARENT))assert.equal(release.parent[key],value);
+  assert.deepEqual(release.runtime_predecessor,{
+    release_id:PARENT.release_id,
+    manifest_sha256:PARENT.manifest_sha256,
+    generation_manifest_sha256:PARENT.generation_manifest_sha256
+  });
+  assert.equal(release.source_predecessor.version,PARENT.version);
+  assert.equal(release.source_predecessor.manifest_file_sha256,PARENT.manifest_sha256);
+  assert.equal(release.r66_doctor_epoch_hotfix.doctor_epoch_observation_compatibility,true);
+  assert.equal(release.r66_doctor_epoch_hotfix.new_public_tools,0);
+  assert.equal(release.r66_doctor_epoch_hotfix.new_authority_scopes,0);
+  assert.equal(release.r66_doctor_epoch_hotfix.prepublish_only,true);
+  assert.equal(provenance.version,pkg.version);
+  assert.equal(provenance.parent_release_id,PARENT.release_id);
+  assert.equal(provenance.parent_manifest_sha256,PARENT.manifest_sha256);
+  assert.equal(provenance.parent_generation_manifest_sha256,PARENT.generation_manifest_sha256);
+  assert.equal(provenance.r66.new_public_tools,0);
+  assert.equal(provenance.r66.new_authority_scopes,0);
+  assert.equal(matrix.version,pkg.version);
+  assert.equal(matrix.train,'R66');
+  assert.ok(matrix.required.some(row=>row.id==='r66-focused'));
+  assert.equal(sbom.metadata.component.version,pkg.version);
+  assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r66:0.15.43');
+  assert.match(gate,/v0\.15\.42-1b4754103dd4ca43/);
+  assert.match(gate,/62dc68be55ad627f8d872b8be8c1369ecca0edf08fdedc8336c9ccee2d2809fb/);
+  assert.match(gate,/r66:focused:test/);
+  assert.doesNotMatch(gate,/npm\.cmd publish|--publish-only/);
+});

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

@@ -182,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/);
@@ -201,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);
@@ -394,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{
@@ -502,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']);

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