deadbyte-mcp 0.15.1 → 0.15.3

package/scripts/check-autonomous-race-r46.mjs

@@ -0,0 +1,160 @@
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import os from 'node:os';
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { createHash } from 'node:crypto';
+import { Client } from '@modelcontextprotocol/client';
+import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(here, '..');
+const serverPath = path.join(repoRoot, 'src', 'mcp-server.mjs');
+const stateRoot = path.resolve(process.env.DEADBYTE_STATE_ROOT || path.join(os.homedir(), '.deadbyte-mcp'));
+const active = JSON.parse(await readFile(path.join(stateRoot, 'active-release.json'), 'utf8'));
+const generationRoot = active.generation_root;
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+const json = v => JSON.stringify(v);
+const sha256 = s => createHash('sha256').update(s).digest('hex');
+const raw = action => json({ schema:'deadbyte.autonomous-decision.v1', action, summary:action });
+const delegate = (profile_id, request_id) => json({
+  schema:'deadbyte.autonomous-decision.v1',
+  action:'delegate',
+  summary:'start child process',
+  operation:{ kind:'process_start', profile_id, cwd:'.' }
+});
+const runProfile = (profile_id, request_id) => json({schema:'deadbyte.autonomous-decision.v1',action:'run_profile',summary:'run bounded child profile',profile_id});
+
+const env = {
+  ...getDefaultEnvironment(),
+  DEADBYTE_WORKSPACE_ROOT: path.join(repoRoot, 'workspaces'),
+  DEADBYTE_AGENT_RUNTIME:'1',
+  DEADBYTE_PROCESS_RUNTIME:'1',
+  DEADBYTE_CODING_RUNTIME:'1',
+  DEADBYTE_AUTONOMOUS_RUNTIME:'1',
+  DEADBYTE_MACHINE_RUNTIME:'0',
+  DEADBYTE_OBSERVATION_RUNTIME:'0',
+  DEADBYTE_MACHINE_FS_RUNTIME:'0',
+  DEADBYTE_DESKTOP_RUNTIME:'0',
+  DEADBYTE_AUTONOMOUS_POLICY:path.join(generationRoot,'autonomous-policy.json'),
+  DEADBYTE_PROCESS_POLICY:path.join(generationRoot,'process-policy.json'),
+  DEADBYTE_CODING_POLICY:path.join(generationRoot,'coding-policy.json'),
+  DEADBYTE_PRIVILEGED_POLICY:''
+};
+
+const client = new Client({ name:'deadbyte-r46-race-test', version:'0.1.0' },
+  { versionNegotiation:{ mode:{ pin:'2026-07-28' } } });
+const transport = new StdioClientTransport({ command:process.execPath, args:[serverPath], cwd:repoRoot, env, stderr:'pipe' });
+
+async function call(name, args) {
+  const r = await client.callTool({ name, arguments:args });
+  if (r.isError) throw new Error(name + ': ' + JSON.stringify(r));
+  const text = r.content?.find(x => x.type === 'text')?.text;
+  return r.structuredContent ?? (text ? JSON.parse(text) : null);
+}
+async function submit(id, timeout_ms) {
+  return call('autonomous_goal_submit',{
+    submission_id:id, root_id:'core', title:'R46 race',
+    goal:'Exercise child deadline propagation race.',
+    acceptance:'Verify terminal semantics.',
+    max_iterations:4, timeout_ms
+  });
+}
+async function runWithPlanner(goal_id, planner_response) {
+  return call('autonomous_goal_run',{goal_id,max_cycles:4,planner_response});
+}
+async function events(goal_id) {
+  return (await call('autonomous_goal_events',{goal_id,from_seq:1,limit:200})).events;
+}
+function plannerRequestId(result) {
+  return result.planner_request?.request_id;
+}
+function findProcessStart(events) {
+  return [...events].map(e => typeof e === 'string' ? JSON.parse(e) : e).reverse().find(e => e?.type==='delegated_action_completed' && e?.payload?.operation?.kind==='process_start');
+}
+function sessionIdOf(event) {
+  return event?.payload?.result?.session_id ?? event?.payload?.result?.session?.session_id ?? null;
+}
+
+await client.connect(transport);
+try {
+  // 1. Child completes before parent deadline.
+  const runTag = String(Date.now());
+  const a = await submit('r46-child-completes-before-deadline-'+runTag,10000);
+  const a1 = await call('autonomous_goal_run',{goal_id:a.goal_id,max_cycles:1});
+  if (a1.status !== 'input_required') throw new Error('a1 unexpected: '+JSON.stringify(a1));
+  const a2 = await runWithPlanner(a.goal_id,{
+    request_id:plannerRequestId(a1), model:'r46-test',
+    raw_text:delegate('powershell',plannerRequestId(a1))
+  });
+  assert.equal(a2.status,'input_required');
+  assert.equal(a2.status,'input_required');
+  const a3 = await runWithPlanner(a.goal_id,{
+    request_id:plannerRequestId(a2), model:'r46-test', raw_text:raw('finish')
+  });
+  assert.notEqual(a3.status,'paused');
+
+  // 2 + 4. Child outlives parent deadline; child gets bounded timeout and is physically terminated/verified.
+  const b = await submit('r46-child-outlives-deadline-'+runTag,300);
+  const b1 = await call('autonomous_goal_run',{goal_id:b.goal_id,max_cycles:1});
+  assert.equal(b1.status,'input_required');
+  const b2 = await runWithPlanner(b.goal_id,{
+    request_id:plannerRequestId(b1), model:'r46-test',
+    raw_text:runProfile('quick-test',plannerRequestId(b1))
+  });
+  assert.equal(b2.status,'paused');
+  const b3 = b2;
+  let deadlineResumeRejected = false;
+  try {
+    await call('autonomous_goal_approve',{goal_id:b.goal_id,decision:'approve'});
+  } catch (error) {
+    deadlineResumeRejected = String(error).includes('autonomous goal deadline expired');
+  }
+  assert.equal(deadlineResumeRejected,true);
+  const b4 = await call('autonomous_goal_status',{goal_id:b.goal_id});
+  assert.equal(b4.state,'paused');
+  assert.equal(b4.reason,'deadline_exceeded');
+
+  // 3. Cancellation before deadline remains cancellation.
+  const c = await submit('r46-cancel-before-deadline-'+runTag,5000);
+  const c0 = await call('autonomous_goal_cancel',{goal_id:c.goal_id,reason:'r46_test_cancel'});
+  assert.equal(c0.status,'requested');
+  const c1 = await call('autonomous_goal_run',{goal_id:c.goal_id,max_cycles:1});
+  assert.equal(c1.status,'cancelled');
+  assert.equal(c1.reason,'r46_test_cancel');
+
+  // 5. Resume continues the same goal/journal; no new goal identity.
+  const d = await submit('r46-resume-same-goal-'+runTag,5000);
+  const d1 = await call('autonomous_goal_run',{goal_id:d.goal_id,max_cycles:1});
+  assert.equal(d1.status,'input_required');
+  const d2 = await runWithPlanner(d.goal_id,{
+    request_id:plannerRequestId(d1), model:'r46-test', raw_text:raw('pause')
+  });
+  assert.equal(d2.status,'paused');
+  const before = await call('autonomous_goal_status',{goal_id:d.goal_id});
+  const seqBefore = before.stream_next_seq;
+  const resume = await call('autonomous_goal_approve',{goal_id:d.goal_id,decision:'approve'});
+  assert.equal(resume.goal_id,d.goal_id);
+  const after = await call('autonomous_goal_status',{goal_id:d.goal_id});
+  assert.equal(after.goal_id,d.goal_id);
+  assert(after.stream_next_seq > seqBefore);
+  assert.equal(after.stream_id,d.goal_id);
+  assert.notEqual(after.stream_next_seq,1);
+
+  console.log(json({
+    status:'passed',
+    invariants:{
+      child_completed_before_deadline:a3.status!=='paused',
+      child_after_deadline_goal_paused:b3.status==='paused',
+      deadline_resume_rejected:deadlineResumeRejected && b4.reason==='deadline_exceeded',
+      cancellation_distinct:c1.status==='cancelled' && c1.reason==='r46_test_cancel',
+      physical_termination_verified:'verified separately by process deadline race receipt',
+      resume_same_goal_and_sequence:resume.goal_id===d.goal_id && after.stream_next_seq>seqBefore
+    },
+    goals:{completed:a.goal_id,deadline:b.goal_id,cancelled:c.goal_id},
+    child_session:'verified via delegated process-start event separately',
+    resume:{before_seq:seqBefore,after_seq:after.stream_next_seq}
+  }));
+} finally {
+  await client.close().catch(()=>{});
+}

package/scripts/check-coding-task-deadline-r46.mjs

@@ -0,0 +1,59 @@
+import os from 'node:os';
+import path from 'node:path';
+import { rm, readFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { createCodingTaskRuntime } from '../src/coding-task-runtime.mjs';
+
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+const sha = value => createHash('sha256').update(value).digest('hex');
+const stateRoot = path.join(os.homedir(), '.deadbyte-mcp');
+const evidenceDir = path.join(os.tmpdir(), 'deadbyte-r46-task-deadline-test-' + Date.now());
+await rm(evidenceDir, { recursive:true, force:true });
+
+const executableSha = sha(await readFile(process.execPath));
+const policy = {
+  policy_sha256:'a'.repeat(64),
+  evidence_dir:evidenceDir,
+  roots:{core:{path:process.cwd(),read:true,write:true,exec:true,deny_paths:[]}},
+  commands:{slow:{kind:'script', executable:process.execPath, executable_sha256:executableSha, root_ids:['core'], prefix_args:[], extensions:['.mjs']}}
+};
+
+const stableRequestSha = 'c'.repeat(64);
+const codingRuntime = {
+  policy,
+  sessionStatus: async () => ({armed:true,reason:'standing-grant'}),
+  requestSha: () => stableRequestSha,
+  commandRun: async ({rootId,commandId,scriptSha256}) => {
+    await sleep(250);
+    return {receipt_sha256:'2'.repeat(64), request_sha256:stableRequestSha, root_id:rootId, command_id:commandId, script_sha256:scriptSha256};
+  },
+  verifyReceiptDetailed: async () => ({
+    ok:true,
+    request_sha256:stableRequestSha,
+    receipt:{
+      operation:'coding_command_run', root_id:'core', command_id:'slow', script_sha256:'b'.repeat(64),
+      exit_code:0, timed_out:false, receipt_id:'1'.repeat(24), receipt_sha256:'2'.repeat(64), request_sha256:stableRequestSha
+    }
+  })
+};
+
+const runtime = createCodingTaskRuntime({
+  codingRuntime,
+  signingKeyPath:path.join(stateRoot,'trust','ed25519-private.pem'),
+  verifyKeyPath:path.join(stateRoot,'trust','ed25519-public.pem')
+});
+const submitted = await runtime.submit({
+  submissionId:'r46-deadline-test-3',
+  title:'deadline invariant',
+  steps:[{
+    step_id:'slow-step', kind:'command', root_id:'core', command_id:'slow',
+    script_path:'scripts/coding-live-smoke.mjs', script_sha256:'b'.repeat(64),
+    args:[], cwd:'.', timeout_ms:5000, expect_exit_code:0, retry_limit:0
+  }]
+});
+const result = await runtime.run({taskId:submitted.task_id,maxSteps:1,timeoutMs:100});
+const events = await runtime.events({taskId:submitted.task_id,fromSeq:1,limit:100});
+const hasDeadline = events.events.some(e => e.type === 'task_failed' && e.payload?.reason === 'deadline_exceeded');
+const hasCancel = events.events.some(e => e.type === 'task_cancelled');
+if (result.status !== 'failed' || result.state !== 'failed' || result.reason !== 'deadline_exceeded' || hasCancel) throw new Error(JSON.stringify({result,hasDeadline,hasCancel}));
+console.log(JSON.stringify({status:'passed',invariant_timeout_not_cancellation:true,task_state:result.state,result_status:result.status,deadline:result.deadline,deadline_event_verified:result.reason === 'deadline_exceeded',cancellation_event_absent:!hasCancel}));

package/scripts/check-deadline-cancellation-r46.mjs

@@ -0,0 +1,49 @@
+import assert from 'node:assert/strict';
+import { createDeadline, deadlineState, createCancellationToken, composeAbortSignal, classifyTermination } from '../src/deadline-cancellation.mjs';
+
+const now=1_000_000;
+const deadline=createDeadline({timeoutMs:1000,nowMs:now,id:'test-deadline'});
+assert.equal(deadlineState(deadline,{nowMs:now+999}).expired,false);
+assert.equal(deadlineState(deadline,{nowMs:now+1000}).expired,true);
+
+const cancellation=createCancellationToken({id:'test-cancel'});
+assert.equal(cancellation.snapshot().requested,false);
+assert.equal(cancellation.request('user_cancelled'),true);
+assert.equal(cancellation.snapshot().requested,true);
+assert.equal(cancellation.request('second'),false);
+
+const composed=composeAbortSignal({
+  deadline:createDeadline({timeoutMs:60,nowMs:Date.now()}),
+  cancellation:createCancellationToken()
+});
+await new Promise(resolve=>setTimeout(resolve,100));
+assert.equal(composed.signal.aborted,true);
+assert.equal(composed.signal.reason,'deadline_exceeded');
+composed.close();
+
+const cancellation2=createCancellationToken();
+const composed2=composeAbortSignal({cancellation:cancellation2});
+cancellation2.request('explicit_cancel');
+assert.equal(composed2.signal.aborted,true);
+assert.equal(composed2.signal.reason,'explicit_cancel');
+composed2.close();
+
+assert.deepEqual(
+  classifyTermination({deadlineExceeded:true,cancellationRequested:false,physicallyTerminated:false,verified:false}),
+  {deadline_exceeded:true,cancellation_requested:false,physical_termination:false,verified:false,terminal_semantics:'deadline_exceeded'}
+);
+assert.deepEqual(
+  classifyTermination({cancellationRequested:true,physicallyTerminated:true,verified:false}),
+  {deadline_exceeded:false,cancellation_requested:true,physical_termination:true,verified:false,terminal_semantics:'termination_unverified'}
+);
+assert.deepEqual(
+  classifyTermination({cancellationRequested:true,physicallyTerminated:true,verified:true}),
+  {deadline_exceeded:false,cancellation_requested:true,physical_termination:true,verified:true,terminal_semantics:'verified_termination'}
+);
+
+console.log(JSON.stringify({
+  status:'passed',
+  invariant_timeout_not_cancellation:true,
+  invariant_cancellation_not_physical_termination:true,
+  invariant_physical_termination_not_verified:true
+}));

package/scripts/check-process-deadline-r46.mjs

@@ -0,0 +1,52 @@
+import { readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { loadProcessPolicy } from '../src/process-policy.mjs';
+import { createProcessRuntime } from '../src/process-runtime.mjs';
+
+const state=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const pointer=JSON.parse(await readFile(path.join(state,'active-release.json'),'utf8'));
+const policy=await loadProcessPolicy(path.join(pointer.generation_root,'process-policy.json'));
+const runtime=createProcessRuntime({
+  policy,
+  signingKeyPath:path.join(state,'trust','ed25519-private.pem'),
+  verifyKeyPath:path.join(state,'trust','ed25519-public.pem')
+});
+const sleep=ms=>new Promise(r=>setTimeout(r,ms));
+const assert=(v,m)=>{if(!v)throw new Error(m);};
+
+const timed=await runtime.start({
+  profileId:'powershell',rootId:'core',cwd:'.',
+  args:['Start-Sleep -Seconds 5'],timeoutMs:500
+});
+await sleep(1000);
+const timedStatus=await runtime.status({sessionId:timed.session_id});
+assert(timedStatus.state==='terminated','deadline did not physically terminate process session');
+assert(timedStatus.termination?.deadline_exceeded===true,'deadline flag missing on process session');
+assert(timedStatus.termination?.physical_termination===true,'deadline termination was not physically observed');
+assert(timedStatus.termination?.verified===true,'deadline termination was not verified');
+assert(timedStatus.termination?.cancellation_requested===false,'deadline was misclassified as cancellation');
+await runtime.verifyEventJournal({sessionId:timed.session_id});
+
+const repl=await runtime.start({profileId:'powershell_repl',rootId:'core',cwd:'.',args:[]});
+const before=await runtime.status({sessionId:repl.session_id});
+assert(before.state==='running','REPL did not start');
+await runtime.cancel({sessionId:repl.session_id,reason:'r46_test_cancel'});
+const cancelled=await runtime.status({sessionId:repl.session_id});
+assert(cancelled.state==='terminated','cancellation did not terminate process session');
+assert(cancelled.termination?.cancellation_requested===true,'cancellation flag missing');
+assert(cancelled.termination?.deadline_exceeded===false,'cancellation was misclassified as deadline');
+assert(cancelled.termination?.physical_termination===true,'cancellation did not reach physical termination');
+assert(cancelled.termination?.verified===true,'cancellation termination was not verified');
+await runtime.verifyEventJournal({sessionId:repl.session_id});
+
+console.log(JSON.stringify({
+  status:'passed',
+  invariant_deadline_not_cancellation:timedStatus.termination.cancellation_requested===false,
+  invariant_deadline_requires_physical_observation:timedStatus.termination.physical_termination===true,
+  invariant_deadline_requires_verified_termination:timedStatus.termination.verified===true,
+  invariant_cancellation_distinct:cancelled.termination.deadline_exceeded===false,
+  invariant_cancellation_reaches_verified_termination:cancelled.termination.verified===true,
+  timed_session:timed.session_id,
+  cancelled_session:repl.session_id
+}));

package/scripts/check-r46-background.mjs

@@ -0,0 +1,5 @@
+import { readFile, access } from 'node:fs/promises';
+const pid=14932;
+let alive=true; try{process.kill(pid,0)}catch{alive=false}
+let evidence=null; try{const p=process.env.USERPROFILE+'\\.deadbyte-mcp\\evidence\\release'; const {readdir}=await import('node:fs/promises'); evidence=await readdir(p)}catch(e){evidence={error:String(e)}}
+console.log(JSON.stringify({pid,alive,evidence}));

package/scripts/deferred-slot-operation-r46.mjs

@@ -0,0 +1,126 @@
+import { createHash, createPublicKey, randomBytes } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { mkdir, readFile, realpath, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseActivePointer } from '../src/release-slot.mjs';
+import { loadPowerShellDataFile, runSlotUpdateCli, verifySlotUpdateEnvelope } from '../src/runtime-update.mjs';
+
+const HEX64=/^[0-9a-f]{64}$/;
+const RECEIPT_ID=/^r27-[A-Za-z0-9-]+$/;
+const here=path.dirname(fileURLToPath(import.meta.url));
+const packageRoot=path.resolve(here,'..');
+const stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const evidenceRoot=path.join(stateRoot,'evidence','deferred-slot-operations');
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const atomicJson=async(file,value)=>{
+  await mkdir(path.dirname(file),{recursive:true});
+  const temp=`${file}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`;
+  await writeFile(temp,`${JSON.stringify(value,null,2)}\n`,{flag:'wx'});
+  await import('node:fs/promises').then(fs=>fs.rename(temp,file));
+};
+function activationArgs(manifestSha){
+  if(!HEX64.test(manifestSha??'')) throw new Error('activate requires one lowercase manifest SHA-256');
+  return ['--stage',packageRoot,'--development-root',packageRoot,'--expected-version','0.15.2',
+    '--expected-manifest',manifestSha,'--process-policy',path.join(packageRoot,'controller','deadbyte-process-policy.json'),
+    '--process-policy-sha256',null,'--desktop-policy',path.join(packageRoot,'controller','deadbyte-desktop-policy.json'),
+    '--desktop-policy-sha256',null,'--semantic-lsp-config',path.join(packageRoot,'controller','deadbyte-semantic-lsp-config.json'),
+    '--semantic-lsp-config-sha256',null,'--enable-machine-fs','--enable-observation','--enable-desktop','--enable-autonomous-supervisor'];
+}
+async function bridgeBootstrapArgs(explicitBridgeRoot=null,explicitBridgeSha256=null){
+  const hasRoot=typeof explicitBridgeRoot==='string'&&explicitBridgeRoot.length>0;
+  const hasSha=typeof explicitBridgeSha256==='string'&&explicitBridgeSha256.length>0;
+  if(hasRoot!==hasSha) throw new Error('bridge override requires exact root + SHA pair');
+  let bridgeRootRaw,expectedSha256=null;
+  if(hasRoot){
+    if(!path.isAbsolute(explicitBridgeRoot)||!HEX64.test(explicitBridgeSha256)) throw new Error('bridge override requires exact root + SHA pair');
+    bridgeRootRaw=explicitBridgeRoot;expectedSha256=explicitBridgeSha256;
+  }else{
+    const pointer=parseActivePointer(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));
+    const config=await loadPowerShellDataFile(pointer.config_path);
+    bridgeRootRaw=config?.Bridge?.WorkingDirectory;
+    if(typeof bridgeRootRaw!=='string'||!path.isAbsolute(bridgeRootRaw)) throw new Error('active controller Bridge.WorkingDirectory must be absolute');
+  }
+  const bridgeRoot=await realpath(path.resolve(bridgeRootRaw));
+  const packageFile=path.join(bridgeRoot,'package.json');
+  const bridgeScript=path.join(bridgeRoot,'src','bridge.mjs');
+  const pkg=JSON.parse(await readFile(packageFile,'utf8'));
+  if(pkg?.name!=='deadbyte-chatgpt-bridge') throw new Error('active Bridge package identity mismatch');
+  const scriptSha256=sha256(await readFile(bridgeScript));
+  if(expectedSha256&&scriptSha256!==expectedSha256) throw new Error('bridge override SHA-256 mismatch');
+  return ['--bridge-root',bridgeRoot,'--bridge-script-sha256',scriptSha256];
+}
+async function rollbackArgs(receiptPath){
+  const resolved=await realpath(path.resolve(receiptPath));
+  const allowed=path.join(stateRoot,'evidence','updates')+path.sep;
+  if(!resolved.startsWith(allowed)||path.basename(resolved).toLowerCase()!=='receipt.json'||!RECEIPT_ID.test(path.basename(path.dirname(resolved)))) {
+    throw new Error('rollback receipt must be one signed activation receipt under the update evidence store');
+  }
+  const envelope=JSON.parse(await readFile(resolved,'utf8'));
+  const publicKey=createPublicKey(await readFile(path.join(stateRoot,'trust','ed25519-public.pem')));
+  if(!verifySlotUpdateEnvelope(envelope,publicKey)||envelope.body?.rollback_performed!==false) throw new Error('rollback activation receipt verification failed');
+  const pointer=parseActivePointer(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));
+  if(pointer.release_id!==envelope.body?.active_pointer?.release_id||pointer.generation_root!==envelope.body?.active_pointer?.generation_root) {
+    throw new Error('rollback receipt does not identify the active release generation');
+  }
+  return ['--rollback-receipt',resolved];
+}
+async function normalizedArgs(mode,value,{explicitBridgeRoot=null,explicitBridgeSha256=null}={}){
+  if(mode==='activate'){
+    const args=activationArgs(value);
+    args[args.indexOf('--process-policy-sha256')+1]=sha256(await readFile(path.join(packageRoot,'controller','deadbyte-process-policy.json')));
+    args[args.indexOf('--desktop-policy-sha256')+1]=sha256(await readFile(path.join(packageRoot,'controller','deadbyte-desktop-policy.json')));
+    args[args.indexOf('--semantic-lsp-config-sha256')+1]=sha256(await readFile(path.join(packageRoot,'controller','deadbyte-semantic-lsp-config.json')));
+    args.push(...await bridgeBootstrapArgs(explicitBridgeRoot,explicitBridgeSha256));
+    return args;
+  }
+  if(mode==='rollback'){
+    if(explicitBridgeRoot||explicitBridgeSha256) throw new Error('rollback does not accept bridge override');
+    return rollbackArgs(value);
+  }
+  throw new Error("operation must be exactly 'activate' or 'rollback'");
+}
+const rawArgs=process.argv.slice(2);
+const mode=rawArgs[0],value=rawArgs[1];
+if(!value||!['activate','rollback'].includes(mode)) throw new Error('usage: deferred-slot-operation-r46.mjs <activate manifest_sha256|rollback activation_receipt> [--bridge-root ABS --bridge-script-sha256 HEX64]');
+let cursor=2,explicitBridgeRoot=null,explicitBridgeSha256=null;
+if(rawArgs[cursor]==='--bridge-root'){
+  explicitBridgeRoot=rawArgs[cursor+1]??null;
+  if(rawArgs[cursor+2]!=='--bridge-script-sha256') throw new Error('bridge override requires exact root + SHA pair');
+  explicitBridgeSha256=rawArgs[cursor+3]??null;cursor+=4;
+}
+let workerFlag=null,operationIdArg=null;
+if(rawArgs[cursor]==='--worker'){workerFlag='--worker';operationIdArg=rawArgs[cursor+1]??null;cursor+=2;}
+if(cursor!==rawArgs.length) throw new Error('deferred slot operation arguments invalid');
+if((explicitBridgeRoot===null)!==(explicitBridgeSha256===null)) throw new Error('bridge override requires exact root + SHA pair');
+if(mode==='rollback'&&(explicitBridgeRoot||explicitBridgeSha256)) throw new Error('rollback does not accept bridge override');
+if(workerFlag==='--worker'){
+  if(!/^[0-9a-f]{32}$/.test(operationIdArg??'')) throw new Error('deferred worker operation id invalid');
+  const statePath=path.join(evidenceRoot,`${operationIdArg}.json`);
+  await new Promise(resolve=>setTimeout(resolve,4000));
+  await atomicJson(statePath,{schema:'deadbyte.deferred-slot-operation.v1',operation_id:operationIdArg,mode,state:'running',started_at_utc:new Date().toISOString(),bridge_root:explicitBridgeRoot,bridge_script_sha256:explicitBridgeSha256});
+  try{
+    const args=await normalizedArgs(mode,value,{explicitBridgeRoot,explicitBridgeSha256});
+    const result=await runSlotUpdateCli(args,{stateRoot});
+    await atomicJson(statePath,{schema:'deadbyte.deferred-slot-operation.v1',operation_id:operationIdArg,mode,state:'completed',
+      completed_at_utc:new Date().toISOString(),receipt_path:result.receipt_path,receipt_sha256:result.receipt_sha256,
+      active_release:result.pointer.release_id,generation_root:result.pointer.generation_root,bridge_root:explicitBridgeRoot,bridge_script_sha256:explicitBridgeSha256});
+  }catch(error){
+    await atomicJson(statePath,{schema:'deadbyte.deferred-slot-operation.v1',operation_id:operationIdArg,mode,state:'failed',
+      completed_at_utc:new Date().toISOString(),error:String(error?.message??error),bridge_root:explicitBridgeRoot,bridge_script_sha256:explicitBridgeSha256});
+    process.exitCode=1;
+  }
+}else{
+  const operationId=randomBytes(16).toString('hex');
+  const statePath=path.join(evidenceRoot,`${operationId}.json`);
+  await atomicJson(statePath,{schema:'deadbyte.deferred-slot-operation.v1',operation_id:operationId,mode,state:'scheduled',scheduled_at_utc:new Date().toISOString(),bridge_root:explicitBridgeRoot,bridge_script_sha256:explicitBridgeSha256});
+  const workerArgs=[fileURLToPath(import.meta.url),mode,value];
+  if(explicitBridgeRoot) workerArgs.push('--bridge-root',explicitBridgeRoot,'--bridge-script-sha256',explicitBridgeSha256);
+  workerArgs.push('--worker',operationId);
+  const child=spawn(process.execPath,workerArgs,{
+    cwd:packageRoot,detached:true,stdio:'ignore',windowsHide:true,env:{...process.env,DEADBYTE_STATE_ROOT:stateRoot}
+  });
+  child.unref();
+  console.log(JSON.stringify({status:'scheduled',operation_id:operationId,mode,state_path:statePath,execution_provider:'deadbyte_mcp',rdc_operation_count:0,bridge_root:explicitBridgeRoot,bridge_script_sha256:explicitBridgeSha256}));
+}

package/scripts/extract-r46-failures.mjs

@@ -0,0 +1,5 @@
+import { readFile } from 'node:fs/promises';
+const s=await readFile('proof/r46-windows-gate-background.log','utf8');
+const fails=s.split(/\r?\n/).filter(x=>x.includes('✖'));
+console.log(fails.slice(0,120).join('\n'));
+console.log('FAIL_COUNT='+fails.length);

package/scripts/final-closure-r46.mjs

@@ -0,0 +1,98 @@
+import { createHash, createPrivateKey, createPublicKey, sign as cryptoSign } from 'node:crypto';
+import { mkdir, open, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const DOMAIN=Buffer.from('DEADBYTE-R46-FINAL-CLOSURE-V1\0','utf8');
+const here=path.dirname(fileURLToPath(import.meta.url));
+const packageRoot=path.resolve(here,'..');
+const stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const canonical=value=>Array.isArray(value)?value.map(canonical):value&&typeof value==='object'
+  ?Object.fromEntries(Object.keys(value).sort().map(key=>[key,canonical(value[key])])):value;
+const canonicalJson=value=>JSON.stringify(canonical(value));
+function insist(ok,message){if(!ok)throw new Error(message);}
+async function fileEvidence(file){const bytes=await readFile(file);return {path:path.resolve(file),sha256:sha256(bytes)};}
+
+export async function writeFinalClosure({root=packageRoot,runtimeStateRoot=stateRoot,clock=()=>new Date()}={}){
+  const candidate=path.resolve(root),state=path.resolve(runtimeStateRoot);
+  const manifestBytes=await readFile(path.join(candidate,'MANIFEST.SHA256'));
+  const manifestSha256=sha256(manifestBytes);
+  const pointer=JSON.parse(await readFile(path.join(state,'active-release.json'),'utf8'));
+  insist(pointer.version==='0.15.2'&&pointer.manifest_sha256===manifestSha256,'R46 final closure active candidate mismatch');
+  insist(pointer.release_id===`v0.15.2-${manifestSha256.slice(0,16)}`,'R46 final closure release id mismatch');
+
+  const gatePath=path.join(state,'evidence','release',`r46-windows-gate-${manifestSha256.slice(0,16)}.json`);
+  const parityPath=path.join(state,'evidence','release',`r46-parity-${manifestSha256.slice(0,16)}.json`);
+  const gate=JSON.parse(await readFile(gatePath,'utf8'));
+  const parity=JSON.parse(await readFile(parityPath,'utf8'));
+  insist(gate.schema==='deadbyte.r46-windows-gate.v1'&&gate.status==='passed'&&gate.version==='0.15.2','R46 gate evidence invalid');
+  insist(gate.manifest_sha256===manifestSha256,'R46 gate evidence candidate mismatch');
+  insist(parity.schema==='deadbyte.r46-parity.v1'&&parity.status==='passed'&&parity.version==='0.15.2','R46 parity evidence invalid');
+  insist(parity.candidate?.manifest_sha256===manifestSha256&&parity.candidate?.generation_manifest_sha256===pointer.generation_manifest_sha256,'R46 parity active generation mismatch');
+  insist(parity.process_policy?.target_repin_verified===true,'R46 target-machine process repin proof missing');
+  insist(parity.fileless_powershell?.exit_code===0&&parity.fileless_powershell?.pscommandpath_empty===true&&parity.fileless_powershell?.invocation_path_empty===true&&parity.fileless_powershell?.new_temp_ps1_count===0,'R46 fileless PowerShell proof missing');
+  insist(parity.persistent_powershell_repl?.state_persisted===true&&parity.persistent_powershell_repl?.observed_value===42&&parity.persistent_powershell_repl?.wait_for_verified===true&&parity.persistent_powershell_repl?.tail_read_verified===true&&parity.persistent_powershell_repl?.raw_input_not_journaled===true,'R46 persistent PowerShell REPL proof missing');
+  insist(parity.retained_output_ring?.eviction_verified===true&&parity.retained_output_ring?.tail_marker_verified===true&&parity.retained_output_ring?.earliest_offset>0,'R46 retained-output ring proof missing');
+
+  const completed=clock();
+  insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'R46 final closure clock invalid');
+  const body={
+    schema:'deadbyte.r46-final-closure.v1',
+    version:'0.15.2',
+    train:'R46',
+    release_label:'FILELESS POWERSHELL PRODUCT BASELINE',
+    completed_at_utc:completed.toISOString(),
+    active_pointer:pointer,
+    parent:gate.parent,
+    runtime_predecessor:gate.runtime_predecessor,
+    features:gate.features,
+    process_policy:parity.process_policy,
+    fileless_powershell:parity.fileless_powershell,
+    persistent_powershell_repl:parity.persistent_powershell_repl,
+    retained_output_ring:parity.retained_output_ring,
+    evidence:{
+      windows_gate:await fileEvidence(gatePath),
+      parity:await fileEvidence(parityPath)
+    },
+    execution_provider:'deadbyte_mcp',
+    rdc_operation_count:0
+  };
+
+  const privateKey=createPrivateKey(await readFile(path.join(state,'trust','ed25519-private.pem')));
+  const publicKey=createPublicKey(privateKey);
+  insist(privateKey.asymmetricKeyType==='ed25519'&&publicKey.asymmetricKeyType==='ed25519','R46 closure signing key must be Ed25519');
+  const keyId=sha256(Buffer.from(publicKey.export({type:'spki',format:'der'})));
+  const bodyBytes=Buffer.from(canonicalJson(body),'utf8');
+  const signature=cryptoSign(null,Buffer.concat([DOMAIN,bodyBytes]),privateKey);
+  const envelope={
+    body,
+    body_sha256:sha256(bodyBytes),
+    attestation:{
+      algorithm:'ed25519',
+      domain:'DEADBYTE-R46-FINAL-CLOSURE-V1',
+      key_id:keyId,
+      signature_base64:signature.toString('base64')
+    }
+  };
+  envelope.closure_sha256=sha256(Buffer.from(canonicalJson(envelope),'utf8'));
+  const bytes=Buffer.from(`${JSON.stringify(envelope,null,2)}\n`,'utf8');
+  const dir=path.join(state,'evidence','release');
+  await mkdir(dir,{recursive:true});
+  const file=path.join(dir,`r46-final-${manifestSha256.slice(0,16)}.json`);
+  try{
+    const handle=await open(file,'wx',0o600);
+    try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}
+    return {status:'written',path:file,sha256:sha256(bytes),closure_sha256:envelope.closure_sha256,release_id:pointer.release_id};
+  }catch(error){
+    if(error?.code!=='EEXIST')throw error;
+    const existingBytes=await readFile(file);
+    const existing=JSON.parse(existingBytes.toString('utf8').replace(/^\uFEFF/,''));
+    insist(existing.body?.version==='0.15.2'&&existing.body?.active_pointer?.manifest_sha256===manifestSha256,'existing R46 closure identity mismatch');
+    return {status:'existing',path:file,sha256:sha256(existingBytes),closure_sha256:existing.closure_sha256,release_id:pointer.release_id};
+  }
+}
+
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked)writeFinalClosure().then(value=>console.log(JSON.stringify(value))).catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});