deadbyte-mcp 0.15.65 → 0.15.67

package/test/r172-activation-recovery.test.mjs

@@ -0,0 +1,95 @@
+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';
+import {classifyActivationPreflight} from '../src/activation-preflight-r65.mjs';
+import {createActivationClaimManager} from '../src/activation-lock-r65.mjs';
+import {createAuthorityEpochStore} from '../src/authority-continuity-r65.mjs';
+import {prepareAuthorityTestTrust} from './r65-authority-test-trust.mjs';
+import {withAuthorityProof} from './helpers/r75-authority-proof.mjs';
+
+const hex = c => c.repeat(64);
+const sha = bytes => createHash('sha256').update(bytes).digest('hex');
+const planes = ['process', 'coding', 'autonomous', 'desktop', 'host'];
+
+test('R172 accepts epoch-revoked only when independent proof says verified disarmed', () => {
+  const parent = {release_id: 'v0-parent', version: '0.15.61', manifest_sha256: hex('1'), generation_manifest_sha256: hex('2')};
+  const authority = Object.fromEntries(planes.map(plane => [plane, {
+    configured: true, armed: false, reason: plane === 'coding' ? 'epoch-revoked' : 'disarmed',
+    epoch_seq: null, epoch_sha256: null
+  }]));
+  const policy_sha256 = Object.fromEntries(planes.map((plane, index) => [plane, hex(String(index + 3))]));
+  const observation = withAuthorityProof({state: 'ONLINE', local_ready: true,
+    bridge: {alive: true, reason: 'verified', pid: 10}, core: {alive: true, reason: 'verified', pid: 11},
+    cloud: {alive: true, reason: 'verified', pid: 12}, supervisor: {running: true}, authority, policy_sha256,
+    active_release_id: parent.release_id, active_manifest_sha256: parent.manifest_sha256,
+    active_generation_manifest_sha256: parent.generation_manifest_sha256});
+  const result = classifyActivationPreflight({pointer: parent, expectedParent: parent,
+    candidate: {version: '0.15.67', manifest_sha256: hex('9')},
+    expectedCandidate: {version: '0.15.67', manifest_sha256: hex('9')}, observation});
+  assert.equal(result.state, 'ONLINE_READY');
+  const forged = structuredClone(observation);
+  forged.authority_proof.coding.state = 'UNVERIFIED';
+  assert.equal(classifyActivationPreflight({pointer: parent, expectedParent: parent,
+    candidate: {version: '0.15.67', manifest_sha256: hex('9')},
+    expectedCandidate: {version: '0.15.67', manifest_sha256: hex('9')}, observation: forged}).state, 'AUTHORITY_UNVERIFIED');
+});
+
+test('R172 reclaims a pre-dispatch continuity abort only after signed revoke has a trusted terminal grant', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-r172-continuity-abort-'));
+  try {
+    const runtime = await prepareAuthorityTestTrust(root), updates = path.join(root, 'evidence', 'updates');
+    const generation = path.join(root, 'generations', 'v0-parent-g1');
+    await mkdir(updates, {recursive: true}); await mkdir(generation, {recursive: true});
+    const grantFile = path.join(runtime, 'coding-grant.json');
+    const policy = {schema: 'deadbyte.coding-policy.v1', enabled: true, lease_file: grantFile,
+      roots: {project: {path: path.join(root, 'project')}}};
+    const policyBytes = Buffer.from(JSON.stringify(policy));
+    await writeFile(path.join(generation, 'coding-policy.json'), policyBytes);
+    const oldGrant = Buffer.from(JSON.stringify({schema: 'deadbyte.coding-grant.v1', policy_sha256: sha(policyBytes),
+      instance_nonce: hex('a'), root_ids: ['project'], granted_at_utc: new Date().toISOString()}));
+    await writeFile(grantFile, oldGrant);
+    const store = createAuthorityEpochStore({runtimeDir: runtime, policyBytes});
+    const armed = await store.append({plane: 'coding', action: 'grant', grantBytes: oldGrant,
+      grantInstanceNonce: hex('a'), updateId: null});
+    const manager = createActivationClaimManager({stateRoot: root}), subject = hex('b');
+    const claim = await manager.claim(subject), continuity = 'r65-' + 'c'.repeat(32);
+    const revoked = await store.append({plane: 'coding', action: 'transaction_revoke', grantBytes: oldGrant,
+      grantInstanceNonce: hex('a'), updateId: continuity, expectedHeadSha256: armed.event_sha256});
+    const newGrant = Buffer.from(JSON.stringify({schema: 'deadbyte.coding-grant.v1', policy_sha256: sha(policyBytes),
+      instance_nonce: hex('d'), root_ids: ['project'], granted_at_utc: new Date().toISOString()}));
+    await writeFile(grantFile, newGrant);
+    await store.append({plane: 'coding', action: 'grant', grantBytes: newGrant,
+      grantInstanceNonce: hex('d'), updateId: null, expectedHeadSha256: revoked.event_sha256});
+    const pointer = {schema: 'deadbyte.active-release.v1', release_id: 'v0-parent', version: '0.15.61',
+      manifest_sha256: hex('1'), generation_manifest_sha256: hex('2'), generation_root: generation};
+    await writeFile(path.join(root, 'active-release.json'), JSON.stringify(pointer));
+    await writeFile(path.join(updates, 'r65-activation-outcome-r172.json'), JSON.stringify({
+      schema: 'deadbyte.r65-activation-outcome.v1', claim_operation_id: claim.operation_id,
+      preflight_subject_sha256: subject, candidate_version: '0.15.66', candidate_manifest_sha256: hex('9'),
+      predecessor_release_id: pointer.release_id, outcome: {state: 'ACTIVATION_OUTCOME_UNKNOWN', preflight: 'AUTHORITY_UNVERIFIED'},
+      update_id: null, state_path: null, continuity_update_id: continuity,
+      observed_at_utc: new Date().toISOString()
+    }));
+    const next = await manager.claim(hex('e'));
+    assert.notEqual(next.operation_id, claim.operation_id);
+    await next.release();
+  } finally { await rm(root, {recursive: true, force: true}); }
+});
+
+test('R172 keeps the claim when continuity revoke is not followed by a trusted terminal state', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-r172-continuity-blocked-'));
+  try {
+    const updates = path.join(root, 'evidence', 'updates'); await mkdir(updates, {recursive: true});
+    const manager = createActivationClaimManager({stateRoot: root}), claim = await manager.claim(hex('a'));
+    await writeFile(path.join(updates, 'r65-activation-outcome-r172.json'), JSON.stringify({
+      schema: 'deadbyte.r65-activation-outcome.v1', claim_operation_id: claim.operation_id,
+      preflight_subject_sha256: hex('a'), candidate_version: '0.15.66', candidate_manifest_sha256: hex('9'),
+      predecessor_release_id: 'v0-parent', outcome: {state: 'ACTIVATION_OUTCOME_UNKNOWN', preflight: 'AUTHORITY_UNVERIFIED'},
+      update_id: null, state_path: null, continuity_update_id: 'r65-' + 'c'.repeat(32), observed_at_utc: new Date().toISOString()
+    }));
+    await assert.rejects(() => manager.claim(hex('e')), /unresolved|in progress/i);
+  } finally { await rm(root, {recursive: true, force: true}); }
+});

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

@@ -0,0 +1,35 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {DEADBYTE_VERSION} from '../src/version.mjs';
+
+const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
+const read=async rel=>JSON.parse(await readFile(path.join(root,rel),'utf8'));
+const readOptional=async rel=>{try{return await read(rel);}catch(error){if(error?.code==='ENOENT')return null;throw error;}};
+
+test('R172 binds the published source predecessor separately from the active runtime predecessor',async()=>{
+  const [pkg,lock,bridge,release,provenance,matrix,bom]=await Promise.all([
+    read('package.json'),readOptional('package-lock.json'),read('bridge/package.json'),read('RELEASE.json'),
+    read('PROVENANCE.json'),read('TEST-MATRIX.json'),read('SBOM.cdx.json')]);
+  const versions=[pkg.version,bridge.version,release.version,provenance.version,matrix.version,
+    bom.metadata.component.version,DEADBYTE_VERSION];
+  if(lock)versions.push(lock.version,lock.packages[''].version);
+  for(const value of versions)assert.equal(value,'0.15.67');
+  assert.equal(release.train,'R172'); assert.equal(matrix.train,'R172');
+  assert.equal(release.source_predecessor.version,'0.15.66');
+  assert.equal(release.source_predecessor.manifest_sha256,'962e227dace247d59aa860211388fbde461c5f9c8a7e8a878e34a14a27d355f8');
+  assert.equal(release.source_predecessor.tarball_sha256,'31b194a4fbff7dbdb9f4f275b4ea49c5115f7b0bb2241c0c72d72ef690311a5d');
+  assert.equal(release.runtime_predecessor.release_id,'v0.15.61-055d1ff0aa99e60b');
+  assert.equal(release.r172.public_tool_delta,0); assert.equal(release.r172.authority_scope_delta,0);
+});
+
+test('R172 recovery remains fail closed until final protected and publication gates pass',async()=>{
+  const [release,matrix]=await Promise.all([read('RELEASE.json'),read('TEST-MATRIX.json')]);
+  assert.equal(release.r172.current_predispatch_claim,'PENDING_VERIFIED_RECONCILIATION');
+  assert.equal(release.r172.protected_full_regression,'PENDING_FINAL_BYTES');
+  assert.equal(matrix.r172.protected_native_positive,'PASS_27_TESTS_0_FAILURES');
+  assert.equal(release.r172.npm_publish,'NOT_RUN');
+  assert.equal(release.r172.production_activation,'NOT_RUN');
+});

package/test/r59-tool-surface-compat.test.mjs

@@ -83,7 +83,7 @@ test('R72 compact baseline permits only R64 read offset and authorized coding-on
   assert.deepEqual(diff.added,[]);
   assert.deepEqual(diff.removed,[]);
   const packageVersion=JSON.parse(await readFile(path.join(repoRoot,'package.json'),'utf8')).version;
-  if(['0.15.41','0.15.42','0.15.43','0.15.44','0.15.45','0.15.46','0.15.47','0.15.48','0.15.49','0.15.50','0.15.51','0.15.52','0.15.53','0.15.54','0.15.55','0.15.56','0.15.57','0.15.58','0.15.59','0.15.60','0.15.61','0.15.62','0.15.63','0.15.64','0.15.65'].includes(packageVersion)){
+  if(['0.15.41','0.15.42','0.15.43','0.15.44','0.15.45','0.15.46','0.15.47','0.15.48','0.15.49','0.15.50','0.15.51','0.15.52','0.15.53','0.15.54','0.15.55','0.15.56','0.15.57','0.15.58','0.15.59','0.15.60','0.15.61','0.15.62','0.15.63','0.15.64','0.15.65','0.15.66','0.15.67'].includes(packageVersion)){
     assert.deepEqual([...diff.schema_changed].sort(),['machine_fs','native_diff_preview']);
     assert.equal(diff.unchanged.length,41);
     const prior=baseline.tools.find(tool=>tool.name==='machine_fs');

package/test/r63-one-shot-coherence.test.mjs

@@ -24,15 +24,20 @@ test('R63 one-shot upgrade restore plan reproduces the exact pre-upgrade authori
   ]);
 });
 
-test('R63 explicit remote command synchronizes runtime before dispatch instead of warn-only skew reporting',async()=>{
+test('R63 coherent one-shot still synchronizes before dispatch; R168 rejects skew before mutation',async()=>{
   const source=await readFile(path.join(root,'src','deadbyte-cli.mjs'),'utf8');
   const start=source.indexOf('async function runRemote(args){');
   const end=source.indexOf('\nasync function runSupervisor(',start);
   assert.ok(start>=0&&end>start,'runRemote source boundary missing');
   const body=source.slice(start,end);
+  const guarded=body.indexOf('selectR168OneShotRemotePath(');
+  const reject=body.indexOf("decision.mode==='blocked_version_skew'");
+  const observe=body.indexOf("decision.mode==='observe_active'");
   const sync=body.indexOf("await synchronizeOneShotRuntime(ctx,{displayMode:'ascii'});");
-  const dispatch=body.indexOf('invokeController(ctx,command,{allowFailure:true})');
-  assert.ok(sync>=0,'one-shot remote command must synchronize the active runtime');
-  assert.ok(dispatch>sync,'runtime synchronization must complete before controller dispatch');
-  assert.doesNotMatch(body,/reportVersionCoherence/,'warn-only skew path must not remain in one-shot dispatch');
+  const dispatch=body.indexOf("invokeController(ctx,command,{allowFailure:true})");
+  assert.ok(guarded>=0&&reject>guarded&&observe>guarded,
+    'R168 one-shot skew must choose read-only status or fail closed before synchronization');
+  assert.ok(sync>reject&&sync>observe,
+    'version-skew guard must precede coherent runtime sync');
+  assert.ok(dispatch>sync,'coherent R63 runtime synchronization must complete before dispatch');
 });