deadbyte-mcp 0.15.2 → 0.15.4

package/src/workload-substrate.mjs

@@ -0,0 +1,87 @@
+const HEX64=/^[0-9a-f]{64}$/;
+
+function boundedInt(value,name,min,max){
+  if(!Number.isInteger(value)||value<min||value>max) throw new Error(`${name} must be in [${min}, ${max}]`);
+}
+
+export function createSequenceStream({streamId,generation=1,maxItems=10000,maxBytes=8*1024*1024}={}){
+  if(typeof streamId!=='string'||streamId.length<1) throw new Error('streamId required');
+  boundedInt(generation,'generation',1,Number.MAX_SAFE_INTEGER);
+  boundedInt(maxItems,'maxItems',1,1_000_000);
+  boundedInt(maxBytes,'maxBytes',1,1024*1024*1024);
+  const items=[];
+  let nextSeq=1;
+  let retainedBytes=0;
+  let logicalBytes=0;
+  let droppedItems=0;
+  let droppedBytes=0;
+  let status='open';
+
+  const sizeOf=(value,explicitBytes=null)=>{
+    if(Number.isInteger(explicitBytes)&&explicitBytes>=0) return explicitBytes;
+    return Buffer.byteLength(JSON.stringify(value),'utf8');
+  };
+  const coverage=()=>({
+    logical_first_seq:1,
+    logical_last_seq:nextSeq-1,
+    retained_first_seq:items[0]?.seq??nextSeq,
+    retained_last_seq:items.at(-1)?.seq??0,
+    complete:droppedItems===0,
+    truncated:droppedItems>0,
+    missing_ranges:droppedItems>0?[{from:1,to:items[0]?.seq-1??0}]:[],
+    logical_item_count:(nextSeq-1),
+    retained_item_count:items.length,
+    logical_bytes:logicalBytes,
+    retained_bytes:retainedBytes,
+    dropped_items:droppedItems,
+    dropped_bytes:droppedBytes,
+    status
+  });
+
+  function append(value,{producer='default',channel=null,sizeBytes=null}={}){
+    if(status!=='open') throw new Error('stream is not open');
+    const item={seq:nextSeq++,producer,channel,value,_sizeBytes:Number.isInteger(sizeBytes)&&sizeBytes>=0 ? sizeBytes : null};
+    const bytes=item._sizeBytes ?? sizeOf(item);
+    item._sizeBytes=bytes;
+    items.push(item); retainedBytes+=bytes; logicalBytes+=bytes;
+    while(items.length>maxItems||retainedBytes>maxBytes){
+      const evicted=items.shift();
+      const evictedBytes=evicted._sizeBytes ?? sizeOf(evicted);
+      retainedBytes-=evictedBytes;
+      droppedItems+=1; droppedBytes+=evictedBytes;
+    }
+    return item;
+  }
+  function read(fromSeq=1,limit=100){
+    boundedInt(fromSeq,'fromSeq',1,Number.MAX_SAFE_INTEGER);
+    boundedInt(limit,'limit',1,10000);
+    const c=coverage();
+    if(fromSeq<c.retained_first_seq) return {items:[],coverage:c,missing:true,from_seq:fromSeq};
+    const out=items.filter(item=>item.seq>=fromSeq).slice(0,limit);
+    return {items:out,coverage:c,missing:false,from_seq:fromSeq,next_seq:out.length?out.at(-1).seq+1:fromSeq};
+  }
+  function snapshot(){return Object.freeze({stream_id:streamId,generation,next_seq:nextSeq,logical_bytes:logicalBytes,retained_first_seq:coverage().retained_first_seq,retained_last_seq:coverage().retained_last_seq,status});}
+  function delta(previous){
+    if(!previous||previous.stream_id!==streamId||previous.generation!==generation) throw new Error('stream snapshot identity mismatch');
+    const from=previous.next_seq;
+    return read(from,10000);
+  }
+  function close(){status='closed';}
+  return Object.freeze({streamId,generation,append,read,snapshot,delta,coverage,close});
+}
+
+export function createJournalStream({streamId,generation=1,events=[],maxItems=10000,maxBytes=8*1024*1024,producer='journal',channel='event'}={}){
+  const stream=createSequenceStream({streamId,generation,maxItems,maxBytes});
+  for(const event of events){
+    const value=event?.payload && typeof event.payload==='object'
+      ? { seq:event.seq, type:event.type, payload:event.payload, event_sha256:event.event_sha256 }
+      : event;
+    stream.append(value,{producer,channel,sizeBytes:Buffer.byteLength(JSON.stringify(value),'utf8')});
+  }
+  return stream;
+}
+
+export function assertSequenceStreamSnapshot(value){
+  if(!value||typeof value!=='object'||typeof value.stream_id!=='string'||!Number.isInteger(value.next_seq)) throw new Error('invalid stream snapshot');
+  return value;
+}

package/test/coding-runtime.test.mjs

@@ -147,6 +147,18 @@ test('durable coding task chains edit command benchmark and verifies task receip
     const run = await f.tasks.run({ taskId: submitted.task_id, maxSteps: 8 });
     assert.equal(run.status, 'completed');
     assert.equal(run.state, 'succeeded');
+    const status = await f.tasks.status({ taskId: submitted.task_id });
+    assert.equal(status.stream_id, submitted.task_id);
+    assert.equal(status.stream_generation, 1);
+    assert.equal(status.stream_next_seq, 10);
+    assert.equal(status.stream_coverage.logical_item_count, 9);
+    assert.equal(status.stream_coverage.retained_item_count, 9);
+    assert.equal(status.stream_coverage.truncated, false);
+    const page = await f.tasks.events({ taskId: submitted.task_id, fromSeq: 4, limit: 3 });
+    assert.equal(page.stream_id, submitted.task_id);
+    assert.equal(page.events.length, 3);
+    assert.equal(page.events[0].seq, 4);
+    assert.equal(page.events[2].seq, 6);
     const verified = await f.tasks.verify({ taskId: submitted.task_id });
     assert.equal(verified.ok, true);
     assert.equal(verified.action_receipts_verified, 3);

package/test/coding-search-r36.test.mjs

@@ -38,6 +38,13 @@ test('R36 regex search returns multiple matches per file with deterministic sign
     assert.match(first.query_sha256,/^[0-9a-f]{64}$/);
     assert.match(first.snapshot_sha256,/^[0-9a-f]{64}$/);
     assert.match(first.page_sha256,/^[0-9a-f]{64}$/);
+    assert.equal(first.stream_id,first.query_sha256);
+    assert.equal(first.stream_generation,1);
+    assert.equal(first.stream_next_seq,6);
+    assert.equal(first.stream_coverage.logical_item_count,5);
+    assert.equal(first.stream_coverage.retained_item_count,5);
+    assert.equal(first.stream_coverage.complete,true);
+    assert.equal(first.stream_coverage.truncated,false);
     assert.ok(first.next_cursor);
     const second=await f.search({rootId:'core',path:'.',target:'content',mode:'regex',pattern:'foo\\d',caseSensitive:false,pageSize:2,maxResults:20,cursor:first.next_cursor});
     assert.equal(second.matches.length,2);

package/test/full-max-catalog-r46.test.mjs

@@ -76,8 +76,8 @@ test('R46 real max-runtime full stdio catalog is exactly 83 with skill and four
     const listed=await client.listTools();
     const names=listed.tools.map(t=>t.name).sort();
     const {R45_EXPECTED_TOOLS}=await import('../src/remote-mcp-r45-parity-client.mjs');
-    const R46_EXPECTED_TOOLS=[...R45_EXPECTED_TOOLS,'process_session_write'].sort();
-    assert.equal(names.length,83,'expected exact full R46 catalog 83, got '+names.length+': '+names.join(','));
+    const R46_EXPECTED_TOOLS=[...R45_EXPECTED_TOOLS,'process_session_cancel','process_session_write'].sort();
+    assert.equal(names.length,84,'expected exact full R46 catalog 84, got '+names.length+': '+names.join(','));
     assert.deepEqual(names,R46_EXPECTED_TOOLS);
     for(const name of ['machine_hardware_query','desktop_status','desktop_observe','desktop_target','desktop_action',
       'host_file_read','host_file_write','host_exec','skill_catalog']) assert.ok(names.includes(name),'missing '+name);

package/test/fuzzy-search-r46.test.mjs

@@ -0,0 +1,54 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { fuzzyIndexOf } from '../src/fuzzy-search-core.mjs';
+import { runFuzzySearchInWorker } from '../src/fuzzy-search.mjs';
+import { createCodingSearch } from '../src/coding-search.mjs';
+
+const sha = text => createHash('sha256').update(text,'utf8').digest('hex');
+const files = new Map([
+  ['src/a.mjs','const deadbyte_machine_identity = true;'],
+  ['src/b.mjs','const unrelated = false;']
+]);
+
+function cursorCodec(){
+  return {
+    async encode(value){ return Buffer.from(JSON.stringify(value)).toString('base64url'); },
+    async decode(value){ return JSON.parse(Buffer.from(value,'base64url').toString('utf8')); }
+  };
+}
+
+test('R46 fuzzy core and worker agree under a hard timeout boundary', async () => {
+  const text='AAAA deadbyte_machine_identity SHA256 CATALOG';
+  const direct=fuzzyIndexOf(text,'deadbyte_machine_identiti');
+  const worker=await runFuzzySearchInWorker(text,'deadbyte_machine_identiti',3000);
+  assert.equal(worker.start,direct.start);
+  assert.equal(worker.end,direct.end);
+  assert.equal(worker.distance,direct.distance);
+  assert.ok(worker.similarity >= 0.90);
+});
+
+test('R46 coding search fuzzy mode preserves bounded paging and file identity', async () => {
+  const search=createCodingSearch({
+    tree: async ({rootId,path,maxEntries}) => ({
+      status:'ok',root_id:rootId,path,
+      entries:[...files].map(([item])=>({path:item,type:'file',bytes:files.get(item).length})).slice(0,maxEntries),
+      truncated:false
+    }),
+    fileRead: async ({relativePath}) => {
+      const text=files.get(relativePath);
+      return {content:Buffer.from(text,'utf8').toString('base64'),bytes:Buffer.byteLength(text),sha256:sha(text)};
+    },
+    cursorCodec:cursorCodec()
+  });
+  const value=await search({
+    rootId:'core',path:'.',pattern:'deadbyte_machine_identiti',
+    target:'content',mode:'fuzzy',maxResults:10,maxFileBytes:4096,maxScanBytes:4096,pageSize:10
+  });
+  assert.equal(value.status,'ok');
+  assert.equal(value.matches.length,1);
+  assert.equal(value.matches[0].path,'src/a.mjs');
+  assert.equal(value.matches[0].distance,1);
+  assert.ok(value.matches[0].similarity >= 0.90);
+  assert.match(value.matches[0].file_sha256,/^[0-9a-f]{64}$/);
+});

package/test/helpers/autonomous-r34-fixture.mjs

@@ -75,8 +75,17 @@ export async function createR34Fixture({authority='armed',withFailingProfile=fal
   const nativeDiffRuntime = nativeDiffRuntimeFactory ? nativeDiffRuntimeFactory(baseNativeDiffRuntime) : baseNativeDiffRuntime;
   const createRuntime = ({codingRuntimeOverride=codingRuntime,nativeDiffRuntimeOverride=nativeDiffRuntime,desktopMemoryProviderOverride=desktopMemoryProvider,memoryProviderOverride=memoryProvider,desktopRuntimeOverride=desktopRuntime}={}) => createAutonomousRuntime({policy,codingRuntime:codingRuntimeOverride,nativeDiffRuntime:nativeDiffRuntimeOverride,machineFsRuntime,
     desktopRuntime:desktopRuntimeOverride,desktopMemoryProvider:desktopMemoryProviderOverride,memoryProvider:memoryProviderOverride,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
+  const rawRuntime=createRuntime();
+  const runtime={...rawRuntime,events:async ({goalId,fromSeq=1,limit=100})=>{
+    const page=await rawRuntime.events({goalId,fromSeq,limit});
+    const eventsDir=path.join(policy.evidence_dir,'goals',goalId,'events');
+    const names=(await (await import('node:fs/promises')).readdir(eventsDir)).filter(name=>/^[0-9]{6}\.json$/.test(name)).sort();
+    const raw=[];
+    for(const name of names.slice(fromSeq-1,fromSeq-1+limit)) raw.push(JSON.parse(await readFile(path.join(eventsDir,name),'utf8')));
+    return {...page,events:raw};
+  }};
   return {
-    root,project,target,keys,codingPolicy,policy,baseCodingRuntime,codingRuntime,machineFsRuntime,nativeDiffRuntime,createRuntime,runtime:createRuntime(),
+    root,project,target,keys,codingPolicy,policy,baseCodingRuntime,codingRuntime,machineFsRuntime,nativeDiffRuntime,createRuntime,runtime,
     initial_sha256:sha(await readFile(target)),arm,disarm,
     cleanup:()=>rm(root,{recursive:true,force:true})
   };

package/test/machine-fs-mcp-tools.test.mjs

@@ -37,6 +37,8 @@ test('R31 machine filesystem schemas expose root-relative IDs/preconditions only
   registerMachineFsTools(server, { runtime: runtime() });
   const read = server.tools.get('machine_fs_read').spec.inputSchema;
   assert.equal(read.safeParse({ root_id:'core', path:'a.txt', offset:0, max_bytes:65536, hash_file:false, timeout_ms:30000 }).success, true);
+  assert.equal(read.safeParse({ root_id:'core', path:'a.txt', offset:-4096, max_bytes:4096, hash_file:false, timeout_ms:30000 }).success, true);
+  assert.equal(read.safeParse({ root_id:'core', path:'a.txt', offset:-4194305, max_bytes:4096, hash_file:false, timeout_ms:30000 }).success, false);
   assert.equal(read.safeParse({ root_id:'core', path:'a.txt', timeout_ms:99 }).success, false);
   const write = server.tools.get('machine_fs_write').spec.inputSchema;
   const move = server.tools.get('machine_fs_move').spec.inputSchema;

package/test/machine-fs-runtime.test.mjs

@@ -53,6 +53,12 @@ test('R31 machine fs supports exact mkdir/write/stat/list/range-read/edit/move/d
   assert.equal(Buffer.from(read.data_base64, 'base64').toString('utf8'), 'beta');
   assert.equal(read.next_offset, 10);
   assert.equal(read.timeout_ms, 30000);
+  const tail = await f.runtime.read({ rootId: 'project', relativePath: 'dir/a.txt', offset: -5, maxBytes: 8 });
+  assert.equal(Buffer.from(tail.data_base64, 'base64').toString('utf8'), 'gamma');
+  assert.equal(tail.offset, 11);
+  assert.equal(tail.requested_offset, -5);
+  assert.equal(tail.next_offset, 16);
+  assert.equal(tail.eof, true);
   const edited = await f.runtime.editExact({
     rootId: 'project', relativePath: 'dir/a.txt', expectedSha256: written.sha256,
     oldString: 'beta', newString: 'BETA', expectedReplacements: 1

package/test/process-mcp-tools.test.mjs

@@ -12,7 +12,10 @@ function session(state = 'running') {
   return {
     session_id: hex('a'), profile_id: 'hold', root_id: 'core', cwd: '.', child_pid: 1234,
     creation_filetime: '133700000000000000', state, exit_code: state === 'running' ? null : 0,
-    earliest_offset: 0, stream_head: 4, stream_sha256: hex('b'), journal_head_sha256: hex('c')
+    earliest_offset: 0, stream_head: 4, stream_sha256: hex('b'),
+    stream_id: hex('f'), stream_generation: 1, stream_next_seq: 2,
+    stream_coverage: { logical_first_seq: 1, logical_last_seq: 1, retained_first_seq: 1, retained_last_seq: 1, complete: true, truncated: false, missing_ranges: [], logical_item_count: 1, retained_item_count: 1, logical_bytes: 4, retained_bytes: 4, dropped_items: 0, dropped_bytes: 0, status: 'open' },
+    termination: null, deadline: null, journal_head_sha256: hex('c')
   };
 }
 
@@ -32,7 +35,7 @@ test('R46 registers exactly seven bounded process supervision tools', () => {
   const server = new FakeServer();
   registerProcessTools(server, { runtime: runtime() });
   assert.deepEqual([...server.tools.keys()].sort(), [
-    'process_session_action','process_session_list','process_session_read','process_session_start','process_session_status','process_session_terminate','process_session_write'
+    'process_session_action','process_session_cancel','process_session_list','process_session_read','process_session_start','process_session_status','process_session_terminate','process_session_write'
   ]);
   for (const [name, tool] of server.tools) {
     assert.ok(tool.spec.inputSchema, `${name} input schema missing`);

package/test/process-runtime.test.mjs

@@ -75,7 +75,7 @@ async function fixture() {
     privateKeyPath: path.join(trust, 'private.pem'), publicKeyPath: path.join(trust, 'public.pem')
   });
   return {
-    root, project, policy, grantFile, stateDir,
+    root, project, policy, grantFile, stateDir, keys,
     runtime: createProcessRuntime({ policy, signingKeyPath: keys.privateKeyPath, verifyKeyPath: keys.publicKeyPath })
   };
 }
@@ -97,6 +97,12 @@ test('R31 runtime starts one approved profile and exposes ordered bounded output
   assert.ok(started.child_pid > 0);
   assert.match(started.creation_filetime, /^[0-9]+$/);
   assert.equal(started.profile_id, 'echo');
+  assert.equal(started.stream_id, started.session_id);
+  assert.equal(started.stream_generation, 1);
+  assert.equal(started.stream_next_seq, 1);
+  assert.equal(started.stream_coverage.logical_item_count, 0);
+  assert.equal(started.stream_coverage.retained_item_count, 0);
+  assert.equal(started.stream_coverage.complete, true);
   const observed = await waitFor(f.runtime, started.session_id, text => text.includes('DBR31RUNTIME:42'));
   assert.match(observed.text, /DBR31RUNTIME:42/);
   assert.equal(observed.page.offset, 0);
@@ -148,6 +154,17 @@ test('R46 process output retention evicts oldest bytes without losing tail ident
   assert.match(tailText, /DB_RING_TAIL_MARK/);
   const verified = await f.runtime.verifyEventJournal({ sessionId: started.session_id });
   assert.equal(verified.ok, true);
+  const recoveredRuntime = createProcessRuntime({
+    policy: f.policy,
+    signingKeyPath: f.keys.privateKeyPath,
+    verifyKeyPath: f.keys.publicKeyPath
+  });
+  const recovered = await recoveredRuntime.status({ sessionId: started.session_id });
+  assert.equal(recovered.stream_id, null);
+  assert.equal(recovered.stream_generation, null);
+  assert.equal(recovered.stream_next_seq, null);
+  assert.equal(recovered.stream_coverage, null);
+  assert.ok(recovered.stream_head > 2 * 1024 * 1024);
 });
 
 test('R46 process raw input keeps persistent PowerShell state with bounded wait and tail reads', { skip: process.platform !== 'win32' }, async () => {

package/test/r45-finalization.test.mjs

@@ -79,6 +79,6 @@ test('R45 release machinery binds 0.15.1, 82/43 surfaces, Host v2 bootstrap and
   assert.match(finalizer,/host_inline_native/);assert.match(finalizer,/native_hardware_observation/);assert.match(finalizer,/doctor_release_truth/);
   assert.match(evidence,/host_inline_native:true/);assert.match(evidence,/native_hardware_observation:true/);assert.match(evidence,/doctor_release_truth:true/);
   assert.match(manifestSource,/excludedPackagePrefixes = \[[^\]]*'tmp\/'[^\]]*'\.deadbyte-machine-fs-recovery\/'[^\]]*\]/);
-  assert.match(manifestSource,/excludedPackagePaths = new Set\(\['controller\/deadbyte-host-policy\.json'\]\)/);
+  assert.match(manifestSource,/excludedPackagePaths = new Set\(\['controller\/deadbyte-host-policy\.json','controller\/deadbyte-coding-policy\.json'\]\)/);
   assert.match(manifestSource,/excludedPackagePrefixes\.some\(prefix => rel\.startsWith\(prefix\)\)/);
 });

package/test/release-version.test.mjs

@@ -50,7 +50,7 @@ test('R46 current authority agrees on V0.15.2 and preserves exact R45 parent ide
   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:83/);
+  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/);

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