deadbyte-mcp 0.15.1 → 0.15.3

package/test/release-version.test.mjs

@@ -5,54 +5,113 @@ import { createHash } from 'node:crypto';
 
 const root=new URL('../',import.meta.url);
 const text=rel=>readFile(new URL(rel,root),'utf8');
-const PARENT_RELEASE='v0.15.0-c15fa41719be61b3';
-const PARENT_MANIFEST='c15fa41719be61b3186e49b2367a5f4c057365cfb465102dbefb7d7355f45483';
-const PARENT_GENERATION='6d7429c050b7fe893492e102f00282019116e0c9e54e4f25a5791defa1661d30';
-const PARENT_CLOSURE='533b7e0ff9ded04086dd90ed34e3b87bc427acc3c55c25bb9f4ec66cb448e667';
+const PARENT_RELEASE='v0.15.1-d55f00b5144dc31a';
+const PARENT_MANIFEST='d55f00b5144dc31a7fe39e4dc60d640a94780da6aaeca0918e87636b816d7854';
+const PARENT_GENERATION='00cde7bf540cc2804d679a39040d5b07193c5f8a0d49cac3b882402f8f4e6ad8';
 
-test('R45 current authority agrees on V0.15.1 and preserves exact sealed R44 parent',async()=>{
+test('R46 current authority agrees on V0.15.2 and preserves exact R45 parent identity',async()=>{
   const pkg=JSON.parse(await text('package.json'));
-  const [version,controller,gate,readme,architecture,controllerReadme,deferred,parity,closure,closureVerify,windowsGate,parent,r44Gate,r44Parity,r44Closure]=await Promise.all([
-    text('src/version.mjs'),text('controller/deadbyte-controller.ps1'),text('scripts/gate-windows-r45.ps1'),text('README.txt'),
-    text('docs/ARCHITECTURE.md'),text('controller/README.TXT'),text('scripts/deferred-slot-operation-r45.mjs'),
-    text('scripts/release-parity-r45.mjs'),text('scripts/final-closure-r45.mjs'),text('scripts/final-closure-verify-r45.mjs'),
-    text('scripts/windows-gate-evidence-r45.mjs'),text('R45-PARENT.json'),
-    text('scripts/gate-windows-r44.ps1'),text('scripts/release-parity-r44.mjs'),text('scripts/final-closure-r44.mjs')
+  const release=JSON.parse(await text('RELEASE.json'));
+  const [version,controller,gate,readme,architecture,controllerReadme,deferred,parity,closure,closureVerify,windowsGate,processPolicy]=await Promise.all([
+    text('src/version.mjs'),
+    text('controller/deadbyte-controller.ps1'),
+    text('scripts/gate-windows-r46.ps1'),
+    text('README.txt'),
+    text('docs/ARCHITECTURE.md'),
+    text('controller/README.TXT'),
+    text('scripts/deferred-slot-operation-r46.mjs'),
+    text('scripts/release-parity-r46.mjs'),
+    text('scripts/final-closure-r46.mjs'),
+    text('scripts/final-closure-verify-r46.mjs'),
+    text('scripts/windows-gate-evidence-r46.mjs'),
+    text('controller/deadbyte-process-policy.json')
+  ]);
+
+  assert.equal(pkg.version,'0.15.2');
+  assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r46.ps1');
+  assert.equal(pkg.scripts['self-update:deferred'],'node scripts/deferred-slot-operation-r46.mjs');
+  assert.equal(pkg.scripts['release:parity'],'node scripts/release-parity-r46.mjs');
+  assert.equal(pkg.scripts['release:final:write'],'node scripts/final-closure-r46.mjs');
+  assert.equal(pkg.scripts['release:final:verify'],'node scripts/final-closure-verify-r46.mjs');
+  assert.equal(pkg.scripts['r46:fileless:test'],"node --test --test-concurrency=1 test/process-policy.test.mjs test/process-policy-refresh.test.mjs test/release-generation.test.mjs test/process-runtime.test.mjs test/process-mcp-tools.test.mjs test/compact-gateway-r36.test.mjs test/capability-ledger-r36.test.mjs test/remote-device-r44.test.mjs test/observation-runtime.test.mjs test/observation-mcp-tools.test.mjs");
+  assert.equal(pkg.scripts['r46:full:test'],'node scripts/full-regression-r46.mjs');
+
+  assert.match(version,/DEADBYTE_VERSION = '0\.15\.2'/);
+  assert.match(controller,/CONTROLLER V0\.15\.2 \/ R46/);
+  assert.match(gate,/DEADBYTE V0\.15\.2 \/ R46 FILELESS POWERSHELL WINDOWS BATCH GATE: PASS/);
+  assert.match(readme,/^DEADBYTE MCP V0\.15\.2 \/ R46 FILELESS POWERSHELL PRODUCT BASELINE$/m);
+  assert.match(readme,/powershell\.exe -Command <source>/);
+  assert.match(architecture,/^# DEADBYTE MCP V0\.15\.2 \/ R46 ARCHITECTURE$/m);
+  assert.match(controllerReadme,/^DEADBYTE MCP V0\.15\.2 \/ R46 CONTROLLER$/m);
+  assert.match(deferred,/--expected-version','0\.15\.2'/);
+  assert.match(parity,/deadbyte\.r46-parity\.v1/);
+  assert.match(parity,/DB_R46_FILELESS_PARITY/);
+  assert.match(parity,/target_repin_verified:true/);
+  assert.match(parity,/DB_R46_REPL_VALUE=42/);
+  assert.match(parity,/raw_input_not_journaled:true/);
+  assert.match(parity,/eviction_verified:true/);
+  assert.match(windowsGate,/full_tool_count:84/);
+  assert.match(windowsGate,/remote_reachability_ttl:true/);
+  assert.match(windowsGate,/observation_search_terminal_ttl:true/);
+  assert.match(windowsGate,/observation_search_hard_cap:128/);
+  assert.match(closure,/deadbyte\.r46-final-closure\.v1/);
+  assert.match(closure,/DEADBYTE-R46-FINAL-CLOSURE-V1/);
+  assert.match(closureVerify,/DEADBYTE-R46-FINAL-CLOSURE-V1/);
+  assert.match(windowsGate,/deadbyte\.r46-windows-gate\.v1/);
+
+  assert.equal(release.version,'0.15.2');
+  assert.equal(release.train,'R46');
+  assert.equal(release.label,'FILELESS POWERSHELL PRODUCT BASELINE');
+  assert.equal(release.parent.release_id,PARENT_RELEASE);
+  assert.equal(release.parent.manifest_sha256,PARENT_MANIFEST);
+  assert.equal(release.parent.generation_manifest_sha256,PARENT_GENERATION);
+  assert.deepEqual(release.capabilities.process_profiles,['ping_hold','powershell','powershell_repl']);
+  assert.equal(release.capabilities.full_tool_count,83);
+  assert.equal(release.capabilities.compact_tool_count,43);
+  assert.equal(release.capabilities.powershell_persistent_repl,true);
+  assert.equal(release.capabilities.process_raw_input_profile_opt_in,true);
+  assert.equal(release.capabilities.powershell_fileless,true);
+  assert.equal(release.capabilities.powershell_source_max_arg_bytes,8192);
+
+  const policy=JSON.parse(processPolicy);
+  assert.ok(policy.profiles.ping_hold);
+  assert.ok(policy.profiles.powershell);
+  assert.ok(policy.profiles.powershell_repl);
+  assert.equal(policy.profiles.powershell_repl.allow_raw_input,true);
+  assert.deepEqual(policy.profiles.powershell_repl.prefix_args,['-NoLogo','-NoProfile','-NonInteractive']);
+  assert.deepEqual(policy.profiles.powershell.prefix_args,['-NoLogo','-NoProfile','-NonInteractive','-Command']);
+  assert.equal(policy.profiles.powershell.max_args,1);
+  assert.equal(policy.profiles.powershell.max_arg_bytes,8192);
+  assert.equal(policy.profiles.powershell.transport,'pipe');
+});
+
+test('R46 leaves sealed R45 release artifacts historical and unchanged in identity',async()=>{
+  const [gate,deferred,parity,closure,closureVerify,finalizer,parent]=await Promise.all([
+    text('scripts/gate-windows-r45.ps1'),
+    text('scripts/deferred-slot-operation-r45.mjs'),
+    text('scripts/release-parity-r45.mjs'),
+    text('scripts/final-closure-r45.mjs'),
+    text('scripts/final-closure-verify-r45.mjs'),
+    text('scripts/finalize-r45.mjs'),
+    text('R45-PARENT.json')
   ]);
-  assert.equal(pkg.version,'0.15.1');
-  assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r45.ps1');
-  assert.equal(pkg.scripts['r45:parent:verify'],'node scripts/verify-r45-parent.mjs');
-  assert.equal(pkg.scripts['r45:full:test'],'node scripts/full-regression-r45.mjs');
-  assert.equal(pkg.scripts['self-update:deferred'],'node scripts/deferred-slot-operation-r45.mjs');
-  assert.equal(pkg.scripts['release:parity'],'node scripts/release-parity-r45.mjs');
-  assert.equal(pkg.scripts['release:final:write'],'node scripts/final-closure-r45.mjs');
-  assert.equal(pkg.scripts['release:final:verify'],'node scripts/final-closure-verify-r45.mjs');
-  assert.equal(pkg.scripts['finalize:r45'],'node scripts/finalize-r45.mjs');
-  assert.match(version,/DEADBYTE_VERSION = '0\.15\.1'/);
-  assert.match(controller,/CONTROLLER V0\.15\.1 \/ R45/);
   assert.match(gate,/DEADBYTE V0\.15\.1 \/ R45 MACHINE FREEDOM WINDOWS BATCH GATE: PASS/);
-  assert.match(readme,/^DEADBYTE MCP V0\.15\.1 \/ R45 MACHINE FREEDOM FINAL BASELINE$/m);
-  assert.match(architecture,/^# DEADBYTE MCP V0\.15\.1 \/ R45 ARCHITECTURE$/m);
-  assert.match(controllerReadme,/^DEADBYTE MCP V0\.15\.1 \/ R45 CONTROLLER$/m);
   assert.match(deferred,/--expected-version','0\.15\.1'/);
-  assert.match(parity,/R45_PREDECESSOR_RELEASE_ID='v0\.15\.0-c15fa41719be61b3'/);
-  assert.match(parity,new RegExp(PARENT_MANIFEST));
-  assert.match(parity,/tool_count===82/);assert.match(parity,/tool_count===43/);
-  assert.match(closure,/version:'0\.15\.1'/);assert.match(closure,/DEADBYTE-R45-FINAL-CLOSURE-V1/);
-  assert.match(closureVerify,/R45_FULL_TOOL_COUNT=82/);assert.match(closureVerify,/R45_COMPACT_TOOL_COUNT=43/);
-  assert.match(windowsGate,/deadbyte\.r45-windows-gate\.v1/);
+  assert.match(parity,/deadbyte\.r45-parity\.v1/);
+  assert.match(closure,/version:'0\.15\.1'/);
+  assert.match(closure,/DEADBYTE-R45-FINAL-CLOSURE-V1/);
+  assert.match(closureVerify,/R45_FULL_TOOL_COUNT=82/);
+  assert.match(finalizer,/EXPECTED_VERSION='0\.15\.1'/);
   const parentRecord=JSON.parse(parent);
-  assert.equal(parentRecord.parent_release_id,PARENT_RELEASE);
-  assert.equal(parentRecord.parent_manifest_sha256,PARENT_MANIFEST);
-  assert.equal(parentRecord.parent_generation_manifest_sha256,PARENT_GENERATION);
-  assert.equal(parentRecord.parent_final_closure_sha256,PARENT_CLOSURE);
-  assert.match(r44Gate,/DEADBYTE V0\.15\.0 \/ R44 REMOTE AGENT SKILL WINDOWS BATCH GATE: PASS/);
-  assert.match(r44Parity,/deadbyte\.r44-parity\.v1/);
-  assert.match(r44Closure,/version:'0\.15\.0'/);
+  assert.equal(parentRecord.parent_release_id,'v0.15.0-c15fa41719be61b3');
 });
 
-test('R45 keeps ONLINE reuse and explicit Desktop authority',async()=>{
-  const [cli,controller]=await Promise.all([text('src/deadbyte-cli.mjs'),text('controller/deadbyte-controller.ps1')]);
+test('R46 keeps ONLINE reuse, explicit Desktop authority, and semantic config pin',async()=>{
+  const [cli,controller,semantic]=await Promise.all([
+    text('src/deadbyte-cli.mjs'),
+    text('controller/deadbyte-controller.ps1'),
+    text('controller/deadbyte-semantic-lsp-config.json')
+  ]);
   assert.match(cli,/controllerRuntimeReady/);
   assert.match(cli,/Runtime already ONLINE; reusing verified bridge\/cloud\/supervisor/);
   const start=controller.indexOf('function Recover-AutonomousSupervisor'),end=controller.indexOf('function Show-State',start);
@@ -62,9 +121,5 @@ test('R45 keeps ONLINE reuse and explicit Desktop authority',async()=>{
   assert.match(block,/\$hostStatus\s*=\s*Get-HostArmStatus/);
   assert.match(controller,/armdesktop/);
   assert.match(controller,/disarmdesktop/);
-});
-
-test('semantic config remains byte-pinned across R45 machine-freedom work',async()=>{
-  const semantic=await text('controller/deadbyte-semantic-lsp-config.json');
   assert.equal(createHash('sha256').update(Buffer.from(semantic,'utf8')).digest('hex'),'d274b099a298c1033fea8f1e8849751693bbc0448778d619400acb82d4f53a3b');
 });

package/test/remote-device-r44.test.mjs

@@ -102,3 +102,78 @@ test('R44 remote state corruption fails closed',async()=>{
     await assert.rejects(createRemoteDevicePlaneR44({stateDir:root,relay:new FakeRelay(),authorizeCapability:async()=>true}),/state JSON invalid/);
   }finally{await rm(root,{recursive:true,force:true});}
 });
+
+
+test('R46 remote readiness probe retries only the idempotent probe and remains bounded by timeout',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r46-remote-probe-timeout-'));
+  const key=deviceKey();
+  let attempts=0;
+  const relay={
+    requests:[],
+    async probe(value){
+      attempts+=1;
+      if(attempts===1) return await new Promise(()=>{});
+      return {device_id:value.device_id,epoch:value.epoch,nonce:value.nonce,ready:true};
+    },
+    async request(value){this.requests.push(value);return {ack:'accepted',request_id:value.request_id,terminal:{status:'completed',result_sha256:'a'.repeat(64)}};}
+  };
+  try{
+    const plane=await createRemoteDevicePlaneR44({
+      stateDir:root,relay,authorizeCapability:async()=>true,
+      relayTimeoutMs:100,probeRetries:1,reachableTtlMs:5000
+    });
+    await plane.pair({publicKeySpkiBase64:key.spki,displayName:'lab'});
+    await plane.reportOnline({deviceId:key.deviceId,epoch:1,connectionId:'retry-c'});
+    const ready=await plane.probe({deviceId:key.deviceId,epoch:1});
+    assert.equal(attempts,2);
+    assert.equal(ready.reachable,true);
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R46 remote reachability expires after the bounded probe freshness window',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r46-remote-stale-'));
+  const relay=new FakeRelay(),key=deviceKey();
+  try{
+    const plane=await createRemoteDevicePlaneR44({
+      stateDir:root,relay,authorizeCapability:async()=>true,
+      relayTimeoutMs:1000,probeRetries:0,reachableTtlMs:1000
+    });
+    await plane.pair({publicKeySpkiBase64:key.spki,displayName:'lab'});
+    await plane.reportOnline({deviceId:key.deviceId,epoch:1,connectionId:'stale-c'});
+    await plane.probe({deviceId:key.deviceId,epoch:1});
+    assert.equal((await plane.status({deviceId:key.deviceId})).reachable,true);
+    await new Promise(resolve=>setTimeout(resolve,1100));
+    assert.equal((await plane.status({deviceId:key.deviceId})).reachable,false);
+    await assert.rejects(
+      plane.dispatch({deviceId:key.deviceId,epoch:1,capabilityId:'machine.status',payload:{},requestId:'8'.repeat(64)}),
+      /not reachable|stale/i
+    );
+    assert.equal(relay.requests.length,0);
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R46 remote dispatch timeout is not retried and downgrades reachability',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r46-remote-dispatch-timeout-'));
+  const key=deviceKey();
+  let requestCount=0;
+  const relay={
+    async probe(value){return {device_id:value.device_id,epoch:value.epoch,nonce:value.nonce,ready:true};},
+    async request(){requestCount+=1;return await new Promise(()=>{});}
+  };
+  try{
+    const plane=await createRemoteDevicePlaneR44({
+      stateDir:root,relay,authorizeCapability:async()=>true,
+      relayTimeoutMs:100,probeRetries:0,reachableTtlMs:5000
+    });
+    await plane.pair({publicKeySpkiBase64:key.spki,displayName:'lab'});
+    await plane.reportOnline({deviceId:key.deviceId,epoch:1,connectionId:'dispatch-c'});
+    await plane.probe({deviceId:key.deviceId,epoch:1});
+    const result=await plane.dispatch({
+      deviceId:key.deviceId,epoch:1,capabilityId:'coding.file_read',payload:{path:'README.md'},requestId:'9'.repeat(64)
+    });
+    assert.equal(result.state,'failed');
+    assert.equal(result.error_code,'transport_error');
+    assert.equal(requestCount,1,'side-effecting dispatch must never auto-retry');
+    assert.equal((await plane.status({deviceId:key.deviceId})).reachable,false);
+  }finally{await rm(root,{recursive:true,force:true});}
+});

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

@@ -32,10 +32,10 @@ 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('R32 remote gate accepts six-tool process supervision as one exact optional catalog dimension', async () => {
+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 = \[/);
-  for (const name of ['process_session_start','process_session_read','process_session_status','process_session_list','process_session_terminate','process_session_action']) {
+  for (const name of ['process_session_start','process_session_read','process_session_status','process_session_list','process_session_terminate','process_session_action','process_session_write']) {
     assert.match(source, new RegExp(`'${name}'`));
   }
   assert.match(source, /for \(const processPlane of \[false, true\]\)/);

package/test/runtime-self-update.test.mjs

@@ -4,6 +4,7 @@ import { mkdtemp, mkdir, readFile, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
+import { spawn } from 'node:child_process';
 import {
   assertDevelopmentRootSafe,
   legacyContext,
@@ -213,11 +214,105 @@ test('R28 updater requires a stabilization window and public MCP smoke before co
   assert.match(source,/McpUrlFileSha256\s*=\s*stableMcpUrl\.sha256/);
   assert.match(source,/mcp_url_restored/);
   const stableIndex=source.indexOf('stabilizeRuntime');
-  const receiptIndex=source.indexOf('const body={schema:UPDATE_SCHEMA');
+  const receiptIndex=source.indexOf('const bodyReceipt={');
   assert.ok(stableIndex>=0&&receiptIndex>stableIndex,'stability/public gate must happen before update receipt');
 });
 
 
+
+test('R47 runtime updater arms a detached supervisor before any destructive stop', async () => {
+  const source=await readFile(new URL('../src/runtime-update.mjs',import.meta.url),'utf8');
+  const start=source.indexOf('export async function performSlotUpdate');
+  const end=source.indexOf('export async function performSlotRollback',start);
+  assert.ok(start>=0&&end>start);
+  const perform=source.slice(start,end);
+  assert.match(source,/const HANDOFF_SCHEMA='deadbyte\.r27-slot-update-handoff\.v1'/);
+  assert.match(source,/shutdown_handoff_armed/);
+  assert.match(source,/detached:true/);
+  assert.match(source,/proc\.unref\(\)/);
+  const handoffIndex=perform.indexOf('const handoff=await writeHandoff');
+  const spawnIndex=perform.indexOf('await spawnDetachedSupervisor',handoffIndex);
+  const returnIndex=perform.indexOf('return {ok:true,handed_off:true',spawnIndex);
+  assert.ok(handoffIndex>=0&&spawnIndex>handoffIndex&&returnIndex>spawnIndex);
+  assert.equal(perform.indexOf("controllerCaptured(control.ctx,'stop'"),-1);
+  assert.equal(perform.indexOf('await revokeAuthority(control.ctx'),-1);
+  assert.equal(perform.indexOf("writeState(statePath,journal,'supervisor_spawned'"),-1);
+});
+
+test('R47 supervisor resume parser is exact and recovery scans only durable update state', () => {
+  assert.deepEqual(runtimeUpdate.parseResumeHandoffArgs(['--resume-handoff','C:/state/evidence/updates/u/handoff.json']),{
+    handoff:path.resolve('C:/state/evidence/updates/u/handoff.json')
+  });
+  assert.throws(()=>runtimeUpdate.parseResumeHandoffArgs([]),/resume-handoff is required/i);
+  assert.throws(()=>runtimeUpdate.parseResumeHandoffArgs(['--resume-handoff','x','--bad']),/unknown supervisor argument/i);
+});
+
+test('R47 interrupted transition has explicit durable recovery phases', async () => {
+  const source=await readFile(new URL('../src/runtime-update.mjs',import.meta.url),'utf8');
+  for(const phase of ['shutdown_handoff_armed','supervisor_spawned','authority_revoked','old_runtime_stopped','workspace_ready','launcher_installed','pointer_committed','fresh_runtime_verified','authority_verified','completed']){
+    assert.match(source,new RegExp(phase));
+  }
+  assert.match(source,/recoverInterruptedSlotUpdates/);
+  assert.match(source,/phaseRank\(phase\)<phaseRank\('authority_revoked'\)/);
+  assert.match(source,/recovery observed predecessor already OFFLINE/);
+});
+
+
+test('R47 MCP core startup invokes durable interrupted-update recovery before serving', async () => {
+  const source=await readFile(new URL('../src/mcp-server.mjs',import.meta.url),'utf8');
+  assert.match(source,/import \{ recoverInterruptedSlotUpdates \} from '\.\/runtime-update\.mjs';/);
+  assert.match(source,/await recoverInterruptedSlotUpdates\(\{ stateRoot: runtimeStateRoot \}\)/);
+  const recoveryIndex=source.indexOf('await recoverInterruptedSlotUpdates');
+  const serveIndex=source.indexOf('serveStdio(');
+  assert.ok(recoveryIndex>=0&&serveIndex>recoveryIndex,'startup recovery must run before MCP serving starts');
+});
+
+
+test('R47 Windows detached supervisor survives termination of its parent process', { skip: process.platform !== 'win32' }, async () => {
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r47-detached-survival-'));
+  const parentPath=path.join(root,'parent.mjs');
+  const survivorPath=path.join(root,'survivor.mjs');
+  const pidPath=path.join(root,'survivor.pid');
+  await writeFile(survivorPath,[
+    "import { writeFile } from 'node:fs/promises';",
+    "const pidPath=process.argv[2];",
+    "await writeFile(pidPath,String(process.pid),'ascii');",
+    "setInterval(()=>{},1000);"
+  ].join('\n'));
+  await writeFile(parentPath,[
+    "import { spawn } from 'node:child_process';",
+    "const survivor=spawn(process.execPath,[process.argv[2],process.argv[3]],{detached:true,windowsHide:true,stdio:'ignore'});",
+    "survivor.unref();",
+    "setInterval(()=>{},1000);"
+  ].join('\n'));
+  const parent=spawn(process.execPath,[parentPath,survivorPath,pidPath],{windowsHide:true,stdio:'ignore'});
+  try{
+    const deadline=Date.now()+5000;
+    let survivorPid=0;
+    while(Date.now()<deadline){
+      try{
+        survivorPid=Number((await readFile(pidPath,'ascii')).trim());
+        if(Number.isInteger(survivorPid)&&survivorPid>0) break;
+      }catch{}
+      await new Promise(resolve=>setTimeout(resolve,50));
+    }
+    assert.ok(survivorPid>0,'detached survivor did not report PID');
+    parent.kill('SIGKILL');
+    await new Promise((resolve,reject)=>{
+      const timer=setTimeout(()=>reject(new Error('parent did not terminate after SIGKILL')),5000);
+      parent.once('exit',()=>{clearTimeout(timer);resolve();});
+      parent.once('error',error=>{clearTimeout(timer);reject(error);});
+    });
+    await new Promise(resolve=>setTimeout(resolve,350));
+    assert.doesNotThrow(()=>process.kill(survivorPid,0),'detached supervisor was terminated with its parent');
+  } finally {
+    const textPid=(await readFile(pidPath,'ascii').catch(()=>'' )).trim();
+    const cleanupPid=Number(textPid);
+    if(Number.isInteger(cleanupPid)&&cleanupPid>0){try{process.kill(cleanupPid,'SIGKILL');}catch{}}
+    try{process.kill(parent.pid,'SIGKILL');}catch{}
+  }
+});
+
 test('R29 slot-update CLI requires explicit hash-bound host repins and offline recovery opt-in', () => {
   const base=['--stage','stage','--development-root','dev','--expected-version','0.8.5','--expected-manifest',hex('a')];
   const parsed=parseUpdateArgs([...base,'--host-command-pin',`powershell_script=${hex('b')}`,'--host-command-pin',`cmd_script=${hex('c')}`,'--recover-offline-predecessor']);
@@ -286,6 +381,15 @@ test('R31 slot-update CLI binds process-policy bootstrap and machine-FS enable e
   assert.equal(parsed.enableMachineFs,true);
 });
 
+test('R46 slot-update CLI binds coding policy bootstrap as one exact pair', () => {
+  const base=['--stage','stage','--development-root','dev','--expected-version','0.15.2','--expected-manifest',hex('a')];
+  assert.throws(()=>parseUpdateArgs([...base,'--coding-policy','C:/candidate/coding.json']),/coding policy.*pair/i);
+  assert.throws(()=>parseUpdateArgs([...base,'--coding-policy-sha256',hex('b')]),/coding policy.*pair/i);
+  const parsed=parseUpdateArgs([...base,'--coding-policy','C:/candidate/coding.json','--coding-policy-sha256',hex('b')]);
+  assert.equal(parsed.codingPolicyBootstrap.path,path.resolve('C:/candidate/coding.json'));
+  assert.equal(parsed.codingPolicyBootstrap.sha256,hex('b'));
+});
+
 test('R40 slot-update CLI binds Desktop policy as one exact pair and enables runtime only explicitly', () => {
   const base=['--stage','stage','--development-root','dev','--expected-version','0.12.0','--expected-manifest',hex('a')];
   assert.throws(()=>parseUpdateArgs([...base,'--desktop-policy','C:/candidate/desktop.json']),/desktop policy.*pair/i);
@@ -299,6 +403,19 @@ test('R40 slot-update CLI binds Desktop policy as one exact pair and enables run
   assert.throws(()=>parseUpdateArgs([...base,'--enable-desktop','--enable-desktop']),/duplicate self-update argument/i);
 });
 
+test('R46 coding policy bootstrap accepts only exact pinned enabled policy bytes',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r46-coding-bootstrap-'));
+  const file=path.join(root,'coding.json');
+  const policy={schema:'deadbyte.coding-policy.v1',enabled:true,lease_file:'C:/old/grant.json',evidence_dir:'C:/old/evidence',roots:{core:{path:'C:/core',read:true,write:true,exec:true}},commands:{powershell_script:{executable:'C:/Windows/System32/WindowsPowerShell/v1.0/powershell.exe',executable_sha256:hex('1')}}};
+  const bytes=Buffer.from(JSON.stringify(policy)+'\n','utf8');await writeFile(file,bytes);
+  assert.equal(typeof runtimeUpdate.prepareCodingPolicyBootstrap,'function');
+  const accepted=await runtimeUpdate.prepareCodingPolicyBootstrap({path:file,sha256:sha(bytes)});
+  assert.equal(accepted.sha256,sha(bytes));assert.deepEqual(accepted.policy,policy);
+  await assert.rejects(runtimeUpdate.prepareCodingPolicyBootstrap({path:file,sha256:hex('f')}),/coding policy.*SHA-256 mismatch/i);
+  const bad=path.join(root,'bad.json');await writeFile(bad,JSON.stringify({...policy,enabled:false}));
+  assert.rejects(runtimeUpdate.prepareCodingPolicyBootstrap({path:bad,sha256:sha(await readFile(bad))}),/coding policy schema/i);
+});
+
 test('R40 Desktop policy bootstrap accepts only exact pinned enabled policy bytes',async()=>{
   const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r40-desktop-bootstrap-'));
   const file=path.join(root,'desktop.json');

package/test/workload-substrate.test.mjs

@@ -0,0 +1,22 @@
+import assert from 'node:assert/strict';
+import { createSequenceStream, assertSequenceStreamSnapshot } from '../src/workload-substrate.mjs';
+
+const stream=createSequenceStream({streamId:'test',maxItems:2,maxBytes:1_000_000});
+const a=stream.append({text:'a'},{producer:'p',channel:'stdout'});
+const snap=stream.snapshot();
+const b=stream.append({text:'b'},{producer:'p',channel:'stdout'});
+assert.equal(stream.delta(snap).items[0].seq,b.seq);
+stream.append({text:'c'},{producer:'p',channel:'stderr'});
+const coverage=stream.coverage();
+assert.equal(stream.snapshot().next_seq,4);
+assert.equal(coverage.logical_item_count,3);
+assert.equal(coverage.retained_item_count,2);
+assert.equal(coverage.truncated,true);
+assert.equal(coverage.complete,false);
+assert.equal(stream.read(1,10).missing,true);
+assert.equal(stream.read(2,10).items.length,2);
+assert.equal(coverage.missing_ranges[0].from,1);
+assert.equal(assertSequenceStreamSnapshot(snap).stream_id,'test');
+stream.close();
+assert.throws(()=>stream.append({text:'d'}),/not open/);
+console.log(JSON.stringify({status:'pass',stream_id:stream.streamId,logical_last_seq:coverage.logical_last_seq,retained_first_seq:coverage.retained_first_seq,truncated:coverage.truncated}));