deadbyte-mcp 0.15.2 → 0.15.4

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/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/full-regression-r46.mjs

@@ -1,20 +1,28 @@
 import { spawnSync } from 'node:child_process';
-import { readdir } from 'node:fs/promises';
+import { readdir, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const here=path.dirname(fileURLToPath(import.meta.url));
 const root=path.resolve(here,'..');
 const testDir=path.join(root,'test');
+const excluded=new Set(['full-max-catalog-r44.test.mjs','full-max-catalog-r45.test.mjs']);
 const files=(await readdir(testDir,{withFileTypes:true}))
-  .filter(entry=>entry.isFile()&&entry.name.endsWith('.test.mjs')&&!['full-max-catalog-r44.test.mjs','full-max-catalog-r45.test.mjs'].includes(entry.name))
-  .map(entry=>path.join('test',entry.name))
-  .sort((a,b)=>a.localeCompare(b,'en'));
-if(files.length<1) throw new Error('R46 full regression found no test files');
-console.log(`R46-FULL-REGRESSION files=${files.length}`);
-const result=spawnSync(process.execPath,['--test','--test-concurrency=1',...files],{
-  cwd:root,stdio:'inherit',windowsHide:true,shell:false
-});
-if(result.error) throw result.error;
-if(result.signal) throw new Error(`R46 full regression terminated by ${result.signal}`);
-process.exitCode=Number.isInteger(result.status)?result.status:1;
+  .filter(entry=>entry.isFile()&&entry.name.endsWith('.test.mjs')&&!excluded.has(entry.name));
+const weighted=[];
+for(const entry of files) weighted.push({path:path.join('test',entry.name),size:(await stat(path.join(testDir,entry.name))).size});
+weighted.sort((a,b)=>b.size-a.size||a.path.localeCompare(b.path,'en'));
+const batchCount=8;
+const batches=Array.from({length:batchCount},()=>[]);
+weighted.forEach((entry,index)=>batches[index%batchCount].push(entry.path));
+let total=0;
+for(let index=0;index<batchCount;index++){
+  const batch=batches[index].sort((a,b)=>a.localeCompare(b,'en'));
+  console.log(`R47-BOUNDED-REGRESSION batch=${index+1}/${batchCount} files=${batch.length}`);
+  const result=spawnSync(process.execPath,['--test','--test-concurrency=1',...batch],{cwd:root,stdio:'inherit',windowsHide:true,shell:false});
+  if(result.error) throw result.error;
+  if(result.signal) throw new Error(`regression batch ${index} terminated by ${result.signal}`);
+  if(result.status!==0) throw new Error(`regression batch ${index} failed with exit code ${result.status}`);
+  total+=batch.length;
+}
+console.log(`R47-BOUNDED-REGRESSION PASS files=${total} batches=${batchCount}`);

package/scripts/gate-windows-r46.ps1

@@ -7,6 +7,7 @@ function Invoke-GateStep {
         [Parameter(Mandatory = $true)][string[]]$NpmArgs
     )
     Write-Host "==== $Name ===="
+    $LASTEXITCODE = 0
     & npm.cmd @NpmArgs
     if ($LASTEXITCODE -ne 0) {
         throw "DEADBYTE V0.15.2 / R46 gate failed at $Name with exit code $LASTEXITCODE"
@@ -49,6 +50,7 @@ Invoke-GateStep -Name 'authority-smoke' -NpmArgs @('run','authority:smoke')
 Invoke-GateStep -Name 'release-manifest-final' -NpmArgs @('run','manifest:verify')
 
 Write-Host '==== windows-gate-evidence ===='
+$LASTEXITCODE = 0
 & node.exe (Join-Path $PSScriptRoot 'windows-gate-evidence-r46.mjs')
 if ($LASTEXITCODE -ne 0) {
     throw "DEADBYTE V0.15.2 / R46 gate failed at windows-gate-evidence with exit code $LASTEXITCODE"

package/scripts/inspect-r46-active.mjs

@@ -0,0 +1,2 @@
+import { readFile } from 'node:fs/promises'; import os from 'node:os'; import path from 'node:path';
+const p=path.join(os.homedir(),'.deadbyte-mcp','active-release.json'); console.log(JSON.stringify({cwd:process.cwd(),state:p,active:JSON.parse(await readFile(p,'utf8'))},null,2));

package/scripts/r47-core-failures.mjs

@@ -0,0 +1 @@
+import {spawnSync} from 'node:child_process'; const files=["test/autonomous-r34-e2e.test.mjs","test/autonomous-capability-r36.test.mjs","test/desktop-runtime-r40.test.mjs","test/coding-runtime.test.mjs"]; const r=spawnSync(process.execPath,['--test','--test-concurrency=1',...files],{stdio:'inherit',shell:false,windowsHide:true}); process.exit(r.status??1);

package/scripts/release-manifest.mjs

@@ -27,7 +27,7 @@ const requiredBundledDependencyRoots = [
   'node_modules/zod/package.json'
 ];
 const excludedPackagePrefixes = ['tmp/','.deadbyte-machine-fs-recovery/'];
-const excludedPackagePaths = new Set(['controller/deadbyte-host-policy.json']);
+const excludedPackagePaths = new Set(['controller/deadbyte-host-policy.json','controller/deadbyte-coding-policy.json']);
 const allowedWorkspacePayload = new Set([
   'workspaces/autonomous-live/fixture.txt',
   'workspaces/demo/input.txt'

package/scripts/run-r46-full-regression-background.mjs

@@ -0,0 +1,7 @@
+import { spawn } from 'node:child_process';
+import { openSync } from 'node:fs';
+const out=openSync('proof/r46-full-regression-background.log','w');
+const err=openSync('proof/r46-full-regression-background.err.log','w');
+const p=spawn(process.execPath,['scripts/full-regression-r46.mjs'],{cwd:process.cwd(),detached:true,stdio:['ignore',out,err],windowsHide:true});
+p.unref();
+console.log(JSON.stringify({pid:p.pid}));

package/scripts/run-r46-windows-gate-background.mjs

@@ -0,0 +1,6 @@
+import { spawn } from 'node:child_process';
+import { writeFile } from 'node:fs/promises';
+const child=spawn('powershell.exe',['-NoProfile','-ExecutionPolicy','Bypass','-File','scripts/gate-windows-r46.ps1'],{cwd:process.cwd(),detached:true,stdio:'ignore',windowsHide:true});
+await writeFile('proof/r46-windows-gate-background.pid.json',JSON.stringify({pid:child.pid,started_at_utc:new Date().toISOString()}));
+child.unref();
+console.log(JSON.stringify({status:'started',pid:child.pid}));

package/scripts/run-r46-windows-gate-background.ps1

@@ -0,0 +1,10 @@
+$ErrorActionPreference = 'Stop'
+$root = (Resolve-Path (Join-Path $PSScriptRoot '..')).Path
+$log = Join-Path $root 'proof/r46-windows-gate-background.log'
+$err = Join-Path $root 'proof/r46-windows-gate-background.err.log'
+$done = Join-Path $root 'proof/r46-windows-gate-background.done'
+Remove-Item -LiteralPath $done -Force -ErrorAction SilentlyContinue
+Remove-Item -LiteralPath $log -Force -ErrorAction SilentlyContinue
+Remove-Item -LiteralPath $err -Force -ErrorAction SilentlyContinue
+$p = Start-Process -FilePath 'powershell.exe' -ArgumentList @('-NoProfile','-ExecutionPolicy','Bypass','-File',(Join-Path $PSScriptRoot 'gate-windows-r46.ps1')) -WorkingDirectory $root -RedirectStandardOutput $log -RedirectStandardError $err -PassThru
+@{ pid=$p.Id; started_at_utc=(Get-Date).ToUniversalTime().ToString('o') } | ConvertTo-Json -Compress | Set-Content -LiteralPath $done -Encoding utf8

package/scripts/windows-gate-evidence-r46.mjs

@@ -32,7 +32,8 @@ export async function writeWindowsGateEvidence({
   const active=JSON.parse(await readFile(path.join(path.resolve(stateRoot),'active-release.json'),'utf8'));
   const originalParent=active.release_id===PARENT_RELEASE_ID&&active.manifest_sha256===PARENT_MANIFEST&&active.generation_manifest_sha256===PARENT_GENERATION;
   const reopenedPredecessor=active.release_id===REOPENED_RUNTIME_RELEASE_ID&&active.manifest_sha256===REOPENED_RUNTIME_MANIFEST&&active.generation_manifest_sha256===REOPENED_RUNTIME_GENERATION;
-  insist(originalParent||reopenedPredecessor,'R46 runtime predecessor identity mismatch');
+  const currentR46Predecessor=active.version==='0.15.2'&&active.manifest_sha256!==manifestSha256&&/^[0-9a-f]{64}$/.test(active.generation_manifest_sha256??'');
+  insist(originalParent||reopenedPredecessor||currentR46Predecessor,'R46 runtime predecessor identity mismatch');
   const parent={release_id:PARENT_RELEASE_ID,version:'0.15.1',manifest_sha256:PARENT_MANIFEST,generation_manifest_sha256:PARENT_GENERATION};
 
   const doctorResult=await doctor();
@@ -62,7 +63,7 @@ export async function writeWindowsGateEvidence({
       version:active.version,
       manifest_sha256:active.manifest_sha256,
       generation_manifest_sha256:active.generation_manifest_sha256,
-      mode:reopenedPredecessor?'reopened-unpublished-0.15.2':'sealed-0.15.1-parent'
+      mode:currentR46Predecessor?'current-r46-active':'reopenedPredecessor'===true?'reopened-unpublished-0.15.2':'sealed-0.15.1-parent'
     },
     features:{
       fileless_powershell:true,
@@ -83,7 +84,7 @@ export async function writeWindowsGateEvidence({
       observation_search_hard_cap:128,
       full_regression_required:true,
       compact_tool_count:43,
-      full_tool_count:83
+      full_tool_count:84
     }
   };
   const bytes=Buffer.from(`${JSON.stringify(evidence,null,2)}\n`,'utf8');

package/scripts/workload-contract-regression-r47.mjs

@@ -0,0 +1,14 @@
+import { spawnSync } from 'node:child_process';
+const files = [
+  'test/output-schema.test.mjs',
+  'test/coding-catalog-consistency.test.mjs',
+  'test/semantic-backend-registry.test.mjs',
+  'test/coding-runtime.test.mjs',
+  'test/autonomous-runtime.test.mjs',
+  'test/process-runtime.test.mjs',
+  'test/workload-substrate.test.mjs'
+];
+const result = spawnSync(process.execPath, ['--test', '--test-concurrency=1', ...files], { cwd: new URL('..', import.meta.url), stdio: 'inherit', windowsHide: true, shell: false });
+if (result.error) throw result.error;
+if (result.signal) throw new Error(`workload contract regression terminated by ${result.signal}`);
+process.exitCode = Number.isInteger(result.status) ? result.status : 1;

package/scripts/workload-stream-regression.mjs

@@ -0,0 +1,16 @@
+import { spawnSync } from 'node:child_process';
+
+const files = [
+  'test/workload-substrate.test.mjs',
+  'test/coding-search-r36.test.mjs',
+  'test/process-runtime.test.mjs'
+];
+const result = spawnSync(process.execPath, ['--test', '--test-concurrency=1', ...files], {
+  cwd: new URL('..', import.meta.url),
+  stdio: 'inherit',
+  windowsHide: true,
+  shell: false
+});
+if (result.error) throw result.error;
+if (result.signal) throw new Error(`workload stream regression terminated by ${result.signal}`);
+process.exitCode = Number.isInteger(result.status) ? result.status : 1;

package/scripts/workload-substrate-r47-regression.mjs

@@ -0,0 +1,12 @@
+import { spawnSync } from 'node:child_process';
+const files = [
+  'test/workload-substrate.test.mjs',
+  'test/coding-search-r36.test.mjs',
+  'test/process-runtime.test.mjs',
+  'test/coding-runtime.test.mjs',
+  'test/autonomous-runtime.test.mjs'
+];
+const result = spawnSync(process.execPath, ['--test', '--test-concurrency=1', ...files], { cwd: new URL('..', import.meta.url), stdio: 'inherit', windowsHide: true, shell: false });
+if (result.error) throw result.error;
+if (result.signal) throw new Error(`workload substrate regression terminated by ${result.signal}`);
+process.exitCode = Number.isInteger(result.status) ? result.status : 1;