deadbyte-mcp 0.15.28 → 0.15.29

package/src/coding-plane.mjs

@@ -11,6 +11,7 @@ import { loadPrivateSigningKey, loadPublicVerifyKey } from './trust.mjs';
 import { createCodingSearch } from './coding-search.mjs';
 import { createSearchCursorCodec } from './search-cursor.mjs';
 import { atomicMutation } from './atomic-mutation.mjs';
+import { fileURLToPath } from 'node:url';
 
 export const CODING_POLICY_SCHEMA = 'deadbyte.coding-policy.v1';
 export const CODING_LEASE_SCHEMA = 'deadbyte.coding-lease.v1';
@@ -591,7 +592,7 @@ export function createCodingRuntime({ policy, signingKeyPath, verifyKeyPath }) {
       receipt_sha256: signed.receipt.receipt_sha256, request_sha256: request };
   }
   async function runCommandOnce({ rootId, commandId, scriptPath, scriptSha256, args = [], cwd = '.', timeoutMs = null,
-    executionDeadlineUtc = null, preExecutionCheck = null }) {
+    executionDeadlineUtc = null, preExecutionCheck = null, cancellationCheck = null }) {
     const lease = await assertCodingArmed(policy, rootId);
     if (!ID_RE.test(commandId ?? '')) throw new Error('invalid coding command id');
     const command = policy.commands[commandId];
@@ -633,28 +634,58 @@ export function createCodingRuntime({ policy, signingKeyPath, verifyKeyPath }) {
     if (deadlineBound < 100) throw new Error('coding execution deadline expires too soon to execute command');
     const effectiveTimeout = Math.min(requestedTimeout, command.timeout_ms, grantBound, deadlineBound);
     const argv = [...command.prefix_args, script.resolved, ...args];
+    // The internal Windows host owns a kill-on-close Job Object. Its identity
+    // is package-pinned, never selected by a caller or granted public PID input.
+    let executable=command.executable, launchArgs=argv;
+    if(process.platform==='win32'){
+      const host=fileURLToPath(new URL('../bin/deadbyte-process-host.exe',import.meta.url));
+      const hostPolicy=JSON.parse(await readFile(new URL('../controller/deadbyte-process-policy.json',import.meta.url),'utf8'));
+      if(await sha256File(host)!==hostPolicy.native_host?.sha256) throw new Error('coding process host hash changed');
+      executable=host;
+      launchArgs=[command.executable,cwdResolved,randomBytes(32).toString('hex'),'--deadbyte-transport=pipe-quiet',...argv];
+    }
+    if(cancellationCheck!==null&&typeof cancellationCheck!=='function') throw new Error('cancellation check must be internal function');
+    if(cancellationCheck&&await cancellationCheck()) throw new Error('coding command cancelled before dispatch');
+    await recheckCodingAuthority(policy,activeLease,rootId);
     const startMs = performance.now();
-    const child = spawn(command.executable, argv, {
+    const child = spawn(executable, launchArgs, {
       cwd: cwdResolved, env: codingEnvironment(), shell: false, windowsHide: true,
-      detached: false, stdio: ['ignore', 'pipe', 'pipe']
+      detached: process.platform!=='win32', stdio: ['ignore', 'pipe', 'pipe']
     });
+    const killOwned=()=>{
+      if(child.exitCode!==null||child.signalCode!==null)return;
+      if(process.platform==='win32') child.kill('SIGKILL');
+      else {try{process.kill(-child.pid,'SIGKILL');}catch(error){if(error.code!=='ESRCH')throw error;}}
+    };
     const stdoutState = { chunks: [], bytes: 0, exceeded: null };
     const stderrState = { chunks: [], bytes: 0, exceeded: null };
-    collectBounded(child.stdout, command.max_output_bytes, stdoutState, 'stdout', () => child.kill('SIGKILL'));
-    collectBounded(child.stderr, command.max_output_bytes, stderrState, 'stderr', () => child.kill('SIGKILL'));
+    collectBounded(child.stdout, command.max_output_bytes, stdoutState, 'stdout', killOwned);
+    collectBounded(child.stderr, command.max_output_bytes, stderrState, 'stderr', killOwned);
     let timedOut = false;
     let timer;
+    let cancelTimer,checking=false,cancellationError=null,finished=false;
+    if(cancellationCheck){
+      cancelTimer=setInterval(async()=>{
+        if(checking||finished)return;
+        checking=true;
+        try{if(await cancellationCheck())killOwned();}
+        catch(error){cancellationError=error;killOwned();}
+        finally{checking=false;}
+      },50);
+      cancelTimer.unref?.();
+    }
     const timerDelay = deadlineAtMs === null
       ? effectiveTimeout
       : Math.max(1, Math.min(effectiveTimeout, Math.floor(deadlineAtMs - Date.now())));
     const completion = new Promise((resolve, reject) => {
       child.once('error', reject);
       child.once('close', (code, signal) => resolve({ code, signal }));
-      timer = setTimeout(() => { timedOut = true; child.kill('SIGKILL'); }, timerDelay);
+      timer = setTimeout(() => { timedOut = true; killOwned(); }, timerDelay);
       timer.unref?.();
     });
     let result;
-    try { result = await completion; } finally { if (timer) clearTimeout(timer); }
+    try { result = await completion; } finally { finished=true;if (timer) clearTimeout(timer);if(cancelTimer)clearInterval(cancelTimer); }
+    if(cancellationError)throw cancellationError;
     if (stdoutState.exceeded || stderrState.exceeded) throw new Error(stdoutState.exceeded ?? stderrState.exceeded);
     const stdoutBytes = Buffer.concat(stdoutState.chunks);
     const stderrBytes = Buffer.concat(stderrState.chunks);
@@ -669,7 +700,7 @@ export function createCodingRuntime({ policy, signingKeyPath, verifyKeyPath }) {
   }
 
   async function commandRun({ rootId, commandId, scriptPath, scriptSha256, args = [], cwd = '.', timeoutMs = null,
-    executionDeadlineUtc = null, preExecutionCheck = null, receiptId = null, requestSha256 = null }) {
+    executionDeadlineUtc = null, preExecutionCheck = null, cancellationCheck = null, receiptId = null, requestSha256 = null }) {
     const request = requestSha256 ?? requestSha('coding_command_run', {
       root_id: rootId, command_id: commandId, script_path: scriptPath, script_sha256: scriptSha256,
       args, cwd, timeout_ms: timeoutMs
@@ -704,7 +735,7 @@ export function createCodingRuntime({ policy, signingKeyPath, verifyKeyPath }) {
     }
     const execution = (async () => {
       const started = new Date().toISOString();
-      const result = await runCommandOnce({ rootId, commandId, scriptPath, scriptSha256, args, cwd, timeoutMs, executionDeadlineUtc, preExecutionCheck });
+      const result = await runCommandOnce({ rootId, commandId, scriptPath, scriptSha256, args, cwd, timeoutMs, executionDeadlineUtc, preExecutionCheck, cancellationCheck });
       const signed = await signCodingReceipt(policy, signingKeyPath, result.lease, {
         operation: 'coding_command_run', request_sha256: request, root_id: rootId, command_id: commandId,
         script_path: scriptPath, executable_sha256: result.executable_sha256, script_sha256: result.script_sha256,
@@ -751,7 +782,7 @@ export function createCodingRuntime({ policy, signingKeyPath, verifyKeyPath }) {
 
   async function benchmarkRun({ rootId, commandId, scriptPath, scriptSha256, args = [], cwd = '.', timeoutMs = null,
     executionDeadlineUtc = null, preExecutionCheck = null, warmups = 1, iterations = 5, baselineMedianMs = null, maxRegressionPct = 5,
-    receiptId = null, requestSha256 = null }) {
+    receiptId = null, requestSha256 = null, cancellationCheck = null }) {
     if (!Number.isInteger(warmups) || warmups < 0 || warmups > 3) throw new Error('warmups must be in [0, 3]');
     if (!Number.isInteger(iterations) || iterations < 1 || iterations > 20) throw new Error('iterations must be in [1, 20]');
     if (baselineMedianMs !== null && (!Number.isFinite(baselineMedianMs) || baselineMedianMs <= 0)) throw new Error('baseline_median_ms must be positive or null');
@@ -762,13 +793,13 @@ export function createCodingRuntime({ policy, signingKeyPath, verifyKeyPath }) {
       max_regression_pct: maxRegressionPct
     });
     for (let i = 0; i < warmups; i += 1) {
-      const warm = await runCommandOnce({ rootId, commandId, scriptPath, scriptSha256, args, cwd, timeoutMs, executionDeadlineUtc, preExecutionCheck });
+      const warm = await runCommandOnce({ rootId, commandId, scriptPath, scriptSha256, args, cwd, timeoutMs, executionDeadlineUtc, preExecutionCheck, cancellationCheck });
       if (warm.timed_out || warm.exit_code !== 0) throw new Error(`benchmark warmup failed exit=${String(warm.exit_code)} timed_out=${warm.timed_out}`);
     }
     const samples = [];
     let last = null;
     for (let i = 0; i < iterations; i += 1) {
-      last = await runCommandOnce({ rootId, commandId, scriptPath, scriptSha256, args, cwd, timeoutMs, executionDeadlineUtc, preExecutionCheck });
+      last = await runCommandOnce({ rootId, commandId, scriptPath, scriptSha256, args, cwd, timeoutMs, executionDeadlineUtc, preExecutionCheck, cancellationCheck });
       if (last.timed_out || last.exit_code !== 0) throw new Error(`benchmark iteration ${i + 1} failed exit=${String(last.exit_code)} timed_out=${last.timed_out}`);
       samples.push(last.elapsed_ms);
     }

package/src/coding-task-runtime.mjs

@@ -474,7 +474,7 @@ async function reconcileInterrupted(ctx, plan, events, derived, codingRuntime, s
   return deriveState(plan, events);
 }
 
-async function executeStep(codingRuntime, plan, step, attempt) {
+async function executeStep(codingRuntime, plan, step, attempt, cancellationCheck = null) {
   const receiptId = receiptIdFor(plan.task_id, step.step_id, attempt, plan.plan_sha256);
   const requestSha256 = expectedRequest(codingRuntime, step);
   if (step.kind === 'write') {
@@ -486,12 +486,12 @@ async function executeStep(codingRuntime, plan, step, attempt) {
   } else if (step.kind === 'command') {
     await codingRuntime.commandRun({ rootId: step.root_id, commandId: step.command_id, scriptPath: step.script_path,
       scriptSha256: step.script_sha256, args: step.args, cwd: step.cwd, timeoutMs: step.timeout_ms,
-      receiptId, requestSha256 });
+      receiptId, requestSha256, cancellationCheck });
   } else if (step.kind === 'benchmark') {
     await codingRuntime.benchmarkRun({ rootId: step.root_id, commandId: step.command_id, scriptPath: step.script_path,
       scriptSha256: step.script_sha256, args: step.args, cwd: step.cwd, timeoutMs: step.timeout_ms,
       warmups: step.warmups, iterations: step.iterations, baselineMedianMs: step.baseline_median_ms,
-      maxRegressionPct: step.max_regression_pct, receiptId, requestSha256 });
+      maxRegressionPct: step.max_regression_pct, receiptId, requestSha256, cancellationCheck });
   } else {
     throw new Error(`coding step '${step.step_id}' is not executable`);
   }
@@ -670,7 +670,10 @@ export function createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyK
         try {
           const remainingMs = timeoutMs === null ? null : Math.max(100, Math.floor(deadlineState(deadline).remaining_ms));
           const boundedStep = remainingMs === null ? next : { ...next, timeout_ms: next.timeout_ms === null || next.timeout_ms === undefined ? remainingMs : Math.min(next.timeout_ms, remainingMs) };
-          const executed = await executeStep(codingRuntime, plan, boundedStep, attempt);
+          const executed = await executeStep(codingRuntime, plan, boundedStep, attempt,()=>readCancel(ctx,verifyKeyPath));
+          if(await consumeCancel(ctx,journal,signingKeyPath,verifyKeyPath)){
+            derived=deriveState(plan,journal);return {status:'cancelled',task_id:taskId,...derived};
+          }
           if (!executed.outcome.valid) {
             await appendEvent(ctx, journal, signingKeyPath, 'task_paused', {
               stepId: next.step_id, payload: { reason: 'post_execute_receipt_mismatch', detail: executed.outcome.reason }
@@ -700,6 +703,9 @@ export function createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyK
           }
           derived = deriveState(plan, journal);
         } catch (error) {
+          if(await consumeCancel(ctx,journal,signingKeyPath,verifyKeyPath)){
+            derived=deriveState(plan,journal);return {status:'cancelled',task_id:taskId,...derived};
+          }
           if (deadlineExpired()) {
             derived = await failDeadline(ctx, journal, plan, next.step_id);
             return { status: 'failed', task_id: taskId, ...derived, deadline };

package/src/runtime-update.mjs

@@ -704,7 +704,7 @@ async function captureRuntime(ctx){
   const bridge=await readLedger(ctx,'bridge'); const cloud=await readLedger(ctx,'cloud'); const core=coreProcess(ctx.core_root,bridge);
   return {status,status_text:statusText.trim(),bridge,cloud,core};
 }
-async function capturePredecessor(ctx,recoverOfflinePredecessor){
+export async function capturePredecessor(ctx,recoverOfflinePredecessor){
   let statusText,status;
   try{
     statusText=controllerCaptured(ctx,'status',15000);
@@ -738,7 +738,13 @@ async function capturePredecessor(ctx,recoverOfflinePredecessor){
   }
   if(!recoverOfflinePredecessor) throw new Error(`slot update requires ONLINE runtime: ${statusText}`);
   if(!status.offline||status.bridge_pid||status.cloud_pid||status.local_ready) throw new Error(`offline predecessor recovery requires clean OFFLINE controller state: ${statusText}`);
-  if(status.host_armed) throw new Error('offline predecessor recovery requires host plane DISARMED');
+  if(status.host_armed){
+    controllerCaptured(ctx,'disarmhost',15000);
+    statusText=controllerCaptured(ctx,'status',15000);
+    status=parseControllerStatus(statusText);
+    if(!status.offline||status.bridge_pid||status.cloud_pid||status.local_ready) throw new Error(`offline predecessor recovery changed controller state while revoking Host authority: ${statusText}`);
+    if(status.host_armed) throw new Error('offline predecessor recovery requires host plane DISARMED');
+  }
   if(status.autonomous_armed&&!status.coding_armed) throw new Error('invalid runtime authority: autonomous armed without coding');
   return {mode:'offline-recovery',status,status_text:statusText.trim(),runtime:null};
 }

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.15.28';
+export const DEADBYTE_VERSION = '0.15.29';
 export const MCP_PROTOCOL_VERSION = '2026-07-28';
 export const RECEIPT_SCHEMA_V1 = 'deadbyte.receipt.v1';
 export const RECEIPT_SCHEMA_V2 = 'deadbyte.receipt.v2';

package/test/coding-runtime.test.mjs

@@ -7,6 +7,75 @@ import path from 'node:path';
 import { generateTrustKeypair } from '../src/trust.mjs';
 import { assertCodingArmed, createCodingRuntime, loadCodingPolicy, recheckCodingAuthority } from '../src/coding-plane.mjs';
 import { createCodingTaskRuntime } from '../src/coding-task-runtime.mjs';
+import { fork } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+test('R52 caller disconnect retains one durable execution, status, attempts and terminal receipt',async()=>{
+  const f=await fixture();
+  let server;
+  try{
+    const script=path.join(f.project,'disconnect.mjs');
+    await writeFile(script,"import {appendFileSync} from 'node:fs';appendFileSync('disconnect-runs.txt',process.pid+'\\n');await new Promise(r=>setTimeout(r,750));process.stdout.write('survived-disconnect');");
+    const submission={submissionId:'caller-disconnect',steps:[{step_id:'gate',kind:'command',root_id:'project',command_id:'node_script',script_path:'disconnect.mjs',script_sha256:await sha256File(script),timeout_ms:10000}]};
+    const task=await f.tasks.submit(submission);
+    server=fork(fileURLToPath(new URL('./helpers/coding-disconnect-server.mjs',import.meta.url)),
+      [f.policyPath,f.keys.privateKeyPath,f.keys.publicKeyPath],{stdio:['ignore','ignore','ignore','ipc'],windowsHide:true,execArgv:[]});
+    const closed=new Promise(resolve=>server.once('exit',resolve));
+    server.send({taskId:task.task_id});
+    const deadline=Date.now()+10000;
+    let started=false;
+    while(Date.now()<deadline){
+      try{await readFile(path.join(f.project,'disconnect-runs.txt'));started=true;break;}catch{}
+      await new Promise(r=>setTimeout(r,20));
+    }
+    assert.ok(started,'independent runtime did not start');
+    server.disconnect(); // Caller transport goes away; execution owner stays live.
+    assert.doesNotThrow(()=>process.kill(server.pid,0));
+    const duplicate=await f.tasks.submit(submission);
+    assert.equal(duplicate.task_id,task.task_id);
+    assert.equal(duplicate.status,'existing');
+    assert.equal((await f.tasks.status({taskId:task.task_id})).steps[0].attempts,1);
+    await closed;
+    assert.equal(server.exitCode,0);
+    const recovered=createCodingTaskRuntime({codingRuntime:f.runtime,signingKeyPath:f.keys.privateKeyPath,verifyKeyPath:f.keys.publicKeyPath});
+    const status=await recovered.status({taskId:task.task_id});
+    assert.equal(status.state,'succeeded');
+    assert.equal(status.steps[0].attempts,1);
+    assert.equal((await recovered.verify({taskId:task.task_id})).ok,true);
+    assert.equal((await recovered.run({taskId:task.task_id})).status,'terminal');
+    assert.equal((await readFile(path.join(f.project,'disconnect-runs.txt'),'utf8')).trim().split(/\r?\n/).length,1);
+  }finally{if(server?.exitCode===null){server.kill();}await rm(f.root,{recursive:true,force:true});}
+});
+
+test('R52 cancelling a running durable command stops its owned descendants before terminal state',async()=>{
+  const f=await fixture();
+  let running;
+  try{
+    const script=path.join(f.project,'cancel-tree.mjs');
+    await writeFile(script,"import {spawn} from 'node:child_process'; import {writeFileSync} from 'node:fs'; const child=spawn(process.execPath,['-e',\"setTimeout(()=>require('node:fs').writeFileSync('escaped.txt','escaped'),4000)\"],{stdio:'inherit'}); writeFileSync('started.txt',String(child.pid)); setTimeout(()=>{},4000);");
+    const submission={submissionId:'cancel-running-tree',steps:[{step_id:'gate',kind:'command',root_id:'project',command_id:'node_script',script_path:'cancel-tree.mjs',script_sha256:await sha256File(script),timeout_ms:10000}]};
+    const task=await f.tasks.submit(submission);
+    running=f.tasks.run({taskId:task.task_id});
+    let descendant;
+    const deadline=Date.now()+3000;
+    while(Date.now()<deadline){
+      try{descendant=Number(await readFile(path.join(f.project,'started.txt'),'utf8'));break;}catch{}
+      await new Promise(r=>setTimeout(r,20));
+    }
+    assert.ok(descendant,'fixture did not start descendant');
+    const cancelledAt=Date.now();
+    await f.tasks.cancel({taskId:task.task_id,reason:'owned-tree-test'});
+    const result=await running;
+    assert.equal(result.status,'cancelled');
+    assert.ok(Date.now()-cancelledAt<2000,'cancellation waited for command to finish');
+    assert.throws(()=>process.kill(descendant,0),'owned descendant is still alive after terminal cancellation');
+    await assert.rejects(readFile(path.join(f.project,'escaped.txt')),e=>e.code==='ENOENT');
+    const status=await f.tasks.status({taskId:task.task_id});
+    assert.equal(status.steps[0].attempts,1);
+    const executionReceipt=await f.runtime.receiptVerify({receiptId:status.steps[0].receipt_id});
+    assert.equal(executionReceipt.ok,true,'cancelled execution must retain its signed terminal observation');
+  }finally{await running?.catch(()=>{});await rm(f.root,{recursive:true,force:true});}
+});
 
 function sha256Bytes(bytes) { return createHash('sha256').update(bytes).digest('hex'); }
 async function sha256File(file) { return sha256Bytes(await readFile(file)); }
@@ -39,7 +108,7 @@ async function fixture({ armed = true } = {}) {
   }
   const runtime = createCodingRuntime({ policy, signingKeyPath: keys.privateKeyPath, verifyKeyPath: keys.publicKeyPath });
   const tasks = createCodingTaskRuntime({ codingRuntime: runtime, signingKeyPath: keys.privateKeyPath, verifyKeyPath: keys.publicKeyPath });
-  return { root, project, policy, runtime, tasks, keys };
+  return { root, project, policyPath, policy, runtime, tasks, keys };
 }
 test('coding plane edits files under lease and verifies signed action receipts', async () => {
   const f = await fixture();

package/test/helpers/coding-disconnect-server.mjs

@@ -0,0 +1,11 @@
+import { loadCodingPolicy,createCodingRuntime } from '../../src/coding-plane.mjs';
+import { createCodingTaskRuntime } from '../../src/coding-task-runtime.mjs';
+const [policyPath,signingKeyPath,verifyKeyPath]=process.argv.slice(2);
+const policy=await loadCodingPolicy(policyPath);
+const codingRuntime=createCodingRuntime({policy,signingKeyPath,verifyKeyPath});
+const tasks=createCodingTaskRuntime({codingRuntime,signingKeyPath,verifyKeyPath});
+process.once('message',async({taskId})=>{
+  try{await tasks.run({taskId});process.exitCode=0;}
+  catch(error){console.error(error);process.exitCode=1;}
+  finally{if(process.connected)process.disconnect();}
+});

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

@@ -4,9 +4,11 @@ import test from 'node:test';
 
 const read = path => readFile(new URL(`../${path}`, import.meta.url), 'utf8');
 
-test('R51 canonical Windows gate is successor-bound and preserves R50/R49 historical gates', async () => {
-  const [pkgText, gate, evidence, historicalR50, historicalR49, deferred] = await Promise.all([
+test('R52 canonical Windows gate is successor-bound and preserves R51/R50/R49 historical gates', async () => {
+  const [pkgText, gate, evidence, historicalR51, historicalEvidenceR51, historicalR50, historicalR49, deferred] = await Promise.all([
     read('package.json'),
+    read('scripts/gate-windows-r52.ps1'),
+    read('scripts/windows-gate-evidence-r52.mjs'),
     read('scripts/gate-windows-r51.ps1'),
     read('scripts/windows-gate-evidence-r51.mjs'),
     read('scripts/gate-windows-r50.ps1'),
@@ -14,16 +16,19 @@ test('R51 canonical Windows gate is successor-bound and preserves R50/R49 histor
     read('scripts/deferred-slot-operation-r46.mjs')
   ]);
   const pkg = JSON.parse(pkgText);
-  assert.match(pkg.scripts['gate:windows'], /gate-windows-r51\.ps1$/);
-  assert.match(gate, /DEADBYTE 0\.15\.28 \/ R51 WINDOWS GATE: PASS/);
-  assert.match(gate, /r51-package-boundary/);
-  assert.match(gate, /r51-focused-contracts/);
+  assert.match(pkg.scripts['gate:windows'], /gate-windows-r52\.ps1$/);
+  assert.match(gate, /DEADBYTE 0\.15\.29 \/ R52 WINDOWS GATE: PASS/);
+  assert.match(gate, /r52-package-boundary/);
+  assert.match(gate, /r52-focused-contracts/);
   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\.r51-windows-gate\.v1/);
-  assert.match(evidence, /pkg\.version === '0\.15\.28'/);
-  assert.match(evidence, /release\.train === 'R51'/);
+  assert.match(evidence, /deadbyte\.r52-windows-gate\.v1/);
+  assert.match(evidence, /pkg\.version === '0\.15\.29'/);
+  assert.match(evidence, /release\.train === 'R52'/);
+  assert.match(evidence, /source_predecessor\.version === '0\.15\.28'/);
+  assert.match(historicalR51, /DEADBYTE 0\.15\.28 \/ R51 WINDOWS GATE: PASS/);
+  assert.match(historicalEvidenceR51, /deadbyte\.r51-windows-gate\.v1/);
   assert.match(historicalR50, /DEADBYTE 0\.15\.27 \/ R50 WINDOWS GATE: PASS/);
   assert.match(historicalR49, /DEADBYTE 0\.15\.26 \/ R49 WINDOWS GATE: PASS/);
   assert.match(deferred, /const expectedVersion=packageIdentity\.version/);

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

@@ -1,31 +1,34 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
 
 const root=new URL('../',import.meta.url);
-const read=rel=>readFile(new URL(rel,root),'utf8');
-const json=rel=>read(rel).then(JSON.parse);
+const read=rel=>readFile(new URL(rel,root));
+const json=rel=>read(rel).then(bytes=>JSON.parse(bytes.toString('utf8')));
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
 
-test('R51 release identity is coherent across package lock source metadata SBOM and gate',async()=>{
-  const [pkg,lock,release,provenance,matrix,sbom,versionSource]=await Promise.all([
-    json('package.json'),json('package-lock.json'),json('RELEASE.json'),json('PROVENANCE.json'),json('TEST-MATRIX.json'),json('SBOM.cdx.json'),read('src/version.mjs')
+test('R51 historical release metadata remains byte-frozen at published 0.15.28',async()=>{
+  const [releaseBytes,provenanceBytes,matrixBytes]=await Promise.all([
+    read('docs/R51-RELEASE.json'),
+    read('docs/R51-PROVENANCE.json'),
+    read('docs/R51-TEST-MATRIX.json')
   ]);
-  assert.equal(pkg.version,'0.15.28');
-  assert.equal(lock.version,pkg.version);
-  assert.equal(lock.packages[''].version,pkg.version);
-  assert.match(versionSource,/DEADBYTE_VERSION = '0\.15\.28'/);
-  assert.equal(release.version,pkg.version);
+  assert.equal(sha256(releaseBytes),'b89d0eaf4f07d704d2170782f10e4647daec55b5c5bdc70473865c0dae88650b');
+  assert.equal(sha256(provenanceBytes),'78e6798e92c2d9134b2e66557b2de7863367124efbcecdd5c91012bfed19a48f');
+  assert.equal(sha256(matrixBytes),'eb4d8047fe4ead69a73b3d89f2d443b6fdd88bd39bd8455b80ecaf512cb49abf');
+  const release=JSON.parse(releaseBytes.toString('utf8'));
+  const provenance=JSON.parse(provenanceBytes.toString('utf8'));
+  const matrix=JSON.parse(matrixBytes.toString('utf8'));
+  assert.equal(release.version,'0.15.28');
   assert.equal(release.train,'R51');
-  assert.equal(provenance.version,pkg.version);
-  assert.equal(matrix.version,pkg.version);
+  assert.equal(provenance.version,'0.15.28');
+  assert.equal(matrix.version,'0.15.28');
   assert.equal(matrix.train,'R51');
-  assert.equal(sbom.metadata.component.version,pkg.version);
-  assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r51:0.15.28');
-  assert.match(pkg.scripts['gate:windows'],/gate-windows-r51\.ps1/);
 });
 
-test('R51 lineage binds exact immutable published 0.15.27 parent',async()=>{
-  const [release,provenance]=await Promise.all([json('RELEASE.json'),json('PROVENANCE.json')]);
+test('R51 historical lineage binds exact 0.15.27 parent and 0.15.27 source predecessor',async()=>{
+  const [release,provenance]=await Promise.all([json('docs/R51-RELEASE.json'),json('docs/R51-PROVENANCE.json')]);
   const expected={
     release_id:'v0.15.27-1b1dbe24b45ad06a',
     manifest_sha256:'1b1dbe24b45ad06a62771d15f510662952f3d7c3e5aa08053c6c61511c523e47',
@@ -38,11 +41,10 @@ test('R51 lineage binds exact immutable published 0.15.27 parent',async()=>{
   assert.equal(provenance.parent_release_id,expected.release_id);
   assert.equal(provenance.parent_manifest_sha256,expected.manifest_sha256);
   assert.equal(provenance.parent_generation_manifest_sha256,expected.generation_manifest_sha256);
-  assert.equal(provenance.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
 });
 
-test('R51 release advertises only implemented coherence single-flight authority and livelog hardening',async()=>{
-  const release=await json('RELEASE.json');
+test('R51 historical capability claims remain frozen',async()=>{
+  const release=await json('docs/R51-RELEASE.json');
   for(const key of [
     'runtime_package_auto_coherence',
     'coding_command_singleflight',

package/test/r52-host-revocation.test.mjs

@@ -0,0 +1,65 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
+
+async function runRevoke(t,prelude){
+  if(process.platform!=='win32'){t.skip('Windows controller behavior');return;}
+  const source=await readFile(new URL('../controller/deadbyte-controller.ps1',import.meta.url),'utf8');
+  const begin=source.indexOf('function Disarm-Host(');
+  const end=source.indexOf('function Show-HostStatus(',begin);
+  assert.ok(begin>=0&&end>begin);
+  // Execute the maintained function, not a copied implementation. Simulate a
+  // filesystem that refuses deletion while Test-Path still sees the grant.
+  const script=`$ErrorActionPreference='Stop'
+function Get-HostPolicyMetadata($Cfg) { return @{ArmFile='fixture-host-grant'} }
+${prelude}
+${source.slice(begin,end)}
+try { Disarm-Host @{}; exit 0 } catch { Write-Output $_.Exception.Message; exit 7 }
+`;
+  return spawnSync('C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe',
+    ['-NoLogo','-NoProfile','-NonInteractive','-EncodedCommand',Buffer.from(script,'utf16le').toString('base64')],
+    {encoding:'utf8',windowsHide:true,timeout:15000});
+}
+
+test('R52 controller never reports successful Host revoke while grant removal failed',async t=>{
+  const result=await runRevoke(t,`
+function Remove-Item { param($LiteralPath,[switch]$Force,$ErrorAction) if($ErrorAction -eq 'Stop'){throw 'fixture access denied'} }
+function Test-Path { param($LiteralPath) return $true }
+`);
+  if(!result)return;
+  assert.equal(result.status,7,`Host revoke falsely succeeded: ${result.stdout} ${result.stderr}`);
+  assert.doesNotMatch(result.stdout,/PRIVILEGED HOST PLANE DISARMED/);
+});
+
+test('R52 controller rejects a grant that remains after nominally successful removal',async t=>{
+  const result=await runRevoke(t,`
+function Remove-Item { param($LiteralPath,[switch]$Force,$ErrorAction) }
+function Test-Path { param($LiteralPath) return $true }
+`);
+  if(!result)return;
+  assert.equal(result.status,7);
+  assert.match(result.stdout,/grant remains present/);
+  assert.doesNotMatch(result.stdout,/PRIVILEGED HOST PLANE DISARMED/);
+});
+
+test('R52 controller revocation is idempotent when no grant exists',async t=>{
+  const result=await runRevoke(t,`
+function Remove-Item { throw 'must not remove absent grant' }
+function Test-Path { param($LiteralPath) return $false }
+`);
+  if(!result)return;
+  assert.equal(result.status,0);
+  assert.match(result.stdout,/PRIVILEGED HOST PLANE DISARMED/);
+});
+
+test('R52 controller reports disarmed only after observing successful removal',async t=>{
+  const result=await runRevoke(t,`
+$script:present=$true
+function Remove-Item { param($LiteralPath,[switch]$Force,$ErrorAction) $script:present=$false }
+function Test-Path { param($LiteralPath) return $script:present }
+`);
+  if(!result)return;
+  assert.equal(result.status,0);
+  assert.match(result.stdout,/PRIVILEGED HOST PLANE DISARMED/);
+});

package/test/r52-offline-predecessor-recovery.test.mjs

@@ -0,0 +1,77 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, writeFile, readFile, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import * as runtimeUpdate from '../src/runtime-update.mjs';
+
+async function fixture(t,{revoke='success',armed=true}={}) {
+  const base=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r52-offline-host-'));
+  t.after(()=>rm(base,{recursive:true,force:true}));
+  const controllerDir=path.join(base,'controller');
+  const runtimeDir=path.join(controllerDir,'runtime');
+  await mkdir(runtimeDir,{recursive:true});
+  const marker=path.join(runtimeDir,'host-grant.json');
+  if(armed) await writeFile(marker,'stale-host-grant\n','utf8');
+  const revokeSource=revoke==='failure' ? 'exit 7' : revoke==='unchanged' ? 'exit 0' : 'Remove-Item -LiteralPath $marker -Force -ErrorAction SilentlyContinue; exit 0';
+  const controller=[
+    'param([string]$Command)',
+    '$marker = Join-Path $PSScriptRoot "runtime\\host-grant.json"',
+    `if($Command -eq "disarmhost"){ ${revokeSource} }`,
+    'if($Command -eq "status"){',
+    '  if(Test-Path -LiteralPath $marker){ $hostState = "ARMED [standing-grant]" } else { $hostState = "DISARMED [disarmed]" }',
+    '  Write-Output "DEADBYTE MCP = OFFLINE"',
+    '  Write-Output "Bridge PID   : -"',
+    '  Write-Output "Cloud PID    : -"',
+    '  Write-Output "Local ready  : False"',
+    '  Write-Output "Process plane  : DISARMED [disarmed]"',
+    '  Write-Output "Coding plane   : DISARMED [disarmed]"',
+    '  Write-Output "Autonomous     : DISARMED [disarmed]"',
+    '  Write-Output "Desktop plane : DISARMED [disarmed]"',
+    '  Write-Output ("Host plane    : {0}" -f $hostState)',
+    '  exit 0',
+    '}',
+    'exit 9'
+  ].join('\r\n');
+  await writeFile(path.join(controllerDir,'deadbyte-controller.ps1'),controller,'utf8');
+  return {base,marker};
+}
+
+test('R52 offline predecessor recovery revokes stale Host authority before capture', async t => {
+  if(process.platform!=='win32'){ t.skip('Windows controller regression'); return; }
+  assert.equal(typeof runtimeUpdate.capturePredecessor,'function','capturePredecessor must be behavior-testable');
+  const {base,marker}=await fixture(t);
+  const result=await runtimeUpdate.capturePredecessor(runtimeUpdate.legacyContext(base),true);
+  assert.equal(result.mode,'offline-recovery');
+  assert.equal(result.status.host_armed,false);
+  await assert.rejects(readFile(marker,'utf8'),error=>error?.code==='ENOENT');
+});
+
+test('R52 offline predecessor fails closed if Host revoke returns success but grant remains',async t=>{
+  if(process.platform!=='win32'){t.skip('Windows controller regression');return;}
+  const {base,marker}=await fixture(t,{revoke:'unchanged'});
+  await assert.rejects(runtimeUpdate.capturePredecessor(runtimeUpdate.legacyContext(base),true),/requires host plane DISARMED/);
+  assert.equal(await readFile(marker,'utf8'),'stale-host-grant\n');
+});
+
+test('R52 failed Host revoke leaves predecessor grant intact and denies capture',async t=>{
+  if(process.platform!=='win32'){t.skip('Windows controller regression');return;}
+  const {base,marker}=await fixture(t,{revoke:'failure'});
+  await assert.rejects(runtimeUpdate.capturePredecessor(runtimeUpdate.legacyContext(base),true));
+  assert.equal(await readFile(marker,'utf8'),'stale-host-grant\n');
+});
+
+test('R52 disarmed offline predecessor is accepted without invoking a failing revoke',async t=>{
+  if(process.platform!=='win32'){t.skip('Windows controller regression');return;}
+  const {base}=await fixture(t,{revoke:'failure',armed:false});
+  const result=await runtimeUpdate.capturePredecessor(runtimeUpdate.legacyContext(base),true);
+  assert.equal(result.mode,'offline-recovery');
+  assert.equal(result.status.host_armed,false);
+});
+
+test('R52 offline recovery requires explicit opt-in before any Host revocation',async t=>{
+  if(process.platform!=='win32'){t.skip('Windows controller regression');return;}
+  const {base,marker}=await fixture(t);
+  await assert.rejects(runtimeUpdate.capturePredecessor(runtimeUpdate.legacyContext(base),false),/requires ONLINE runtime/);
+  assert.equal(await readFile(marker,'utf8'),'stale-host-grant\n');
+});

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

@@ -0,0 +1,58 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+
+const root=new URL('../',import.meta.url);
+const read=rel=>readFile(new URL(rel,root),'utf8');
+const json=rel=>read(rel).then(JSON.parse);
+
+test('R52 current release identity is coherent across package lock source metadata SBOM and gate',async()=>{
+  const [pkg,lock,release,provenance,matrix,sbom,versionSource]=await Promise.all([
+    json('package.json'),json('package-lock.json'),json('RELEASE.json'),json('PROVENANCE.json'),json('TEST-MATRIX.json'),json('SBOM.cdx.json'),read('src/version.mjs')
+  ]);
+  assert.equal(pkg.version,'0.15.29');
+  assert.equal(lock.version,pkg.version);
+  assert.equal(lock.packages[''].version,pkg.version);
+  assert.match(versionSource,/DEADBYTE_VERSION = '0\.15\.29'/);
+  assert.equal(release.version,pkg.version);
+  assert.equal(release.train,'R52');
+  assert.equal(provenance.version,pkg.version);
+  assert.equal(matrix.version,pkg.version);
+  assert.equal(matrix.train,'R52');
+  assert.equal(sbom.metadata.component.version,pkg.version);
+  assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r52:0.15.29');
+  assert.match(pkg.scripts['gate:windows'],/gate-windows-r52\.ps1/);
+  assert.match(pkg.scripts['r52:focused:test'],/r52-offline-predecessor-recovery\.test\.mjs/);
+});
+
+test('R52 lineage binds published 0.15.28 parent separately from 0.15.27 runtime rollback target',async()=>{
+  const [release,provenance]=await Promise.all([json('RELEASE.json'),json('PROVENANCE.json')]);
+  const activeParent={
+    release_id:'v0.15.27-1b1dbe24b45ad06a',
+    manifest_sha256:'1b1dbe24b45ad06a62771d15f510662952f3d7c3e5aa08053c6c61511c523e47',
+    generation_manifest_sha256:'f87a1637b3c55ba050d079d8a5e0862a2244b306be7e985880708e0d8ded3db0'
+  };
+  assert.deepEqual(release.runtime_predecessor,activeParent);
+  assert.equal(release.parent.release_id,'v0.15.28-b879bdff63478f28');
+  assert.equal(release.parent.version,'0.15.28');
+  assert.equal(release.parent.manifest_sha256,release.source_predecessor.manifest_file_sha256);
+  assert.equal(release.parent.tarball_sha256,release.source_predecessor.tarball_sha256);
+  assert.equal(release.parent.generation_manifest_sha256,undefined);
+  assert.equal(release.source_predecessor.version,'0.15.28');
+  assert.equal(release.source_predecessor.tarball_sha256,'0a74332ba715d80a532dc871ece4826bdb917b8c7a442e71388a06d44698c411');
+  assert.equal(release.source_predecessor.manifest_file_sha256,'b879bdff63478f28d5dafadeedc8182a8fd090ab676dc0ff3566ea51ee07326f');
+  assert.equal(provenance.parent_release_id,release.parent.release_id);
+  assert.equal(provenance.parent_manifest_sha256,release.parent.manifest_sha256);
+  assert.equal(provenance.parent_tarball_sha256,release.parent.tarball_sha256);
+  assert.deepEqual(provenance.runtime_predecessor,activeParent);
+  assert.equal(provenance.parent_generation_manifest_sha256,undefined);
+  assert.equal(provenance.source_predecessor_version,'0.15.28');
+  assert.equal(provenance.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
+  assert.equal(provenance.source_predecessor_manifest_file_sha256,release.source_predecessor.manifest_file_sha256);
+  assert.equal(provenance.source_predecessor_activation_failure_receipt_sha256,'090f165c96da0d5a8e9c0815fd389fe94e8fe36c23a6878ee825b8f46bfb0bc2');
+});
+
+test('R52 advertises updater-owned offline predecessor Host revocation only after implementation',async()=>{
+  const release=await json('RELEASE.json');
+  assert.equal(release.capabilities.offline_predecessor_host_revoke_before_capture,true);
+});