deadbyte-mcp 0.9.0 → 0.11.0

package/test/process-longrun-r36.test.mjs

@@ -0,0 +1,82 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { PROCESS_GRANT_SCHEMA, PROCESS_POLICY_SCHEMA, loadProcessPolicy } from '../src/process-policy.mjs';
+import { createProcessRuntime } from '../src/process-runtime.mjs';
+import { generateTrustKeypair } from '../src/trust.mjs';
+
+const repo=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+const host=path.join(repo,'bin','deadbyte-process-host.exe');
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const sleep=ms=>new Promise(resolve=>setTimeout(resolve,ms));
+
+async function fixture(){
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r36-longrun-'));
+  const project=path.join(root,'project'); const trust=path.join(root,'trust');
+  await mkdir(project); await mkdir(trust);
+  const script=path.join(project,'longrun.mjs');
+  await writeFile(script,`process.stdout.write('chunk-1\\n');\nsetTimeout(()=>process.stdout.write('chunk-2\\n'),180);\nsetTimeout(()=>process.stdout.write('chunk-3\\n'),360);\nsetTimeout(()=>process.exit(0),540);\n`);
+  const grantFile=path.join(root,'process-grant.json'); const stateDir=path.join(root,'state'); const policyPath=path.join(root,'process-policy.json');
+  const raw={schema:PROCESS_POLICY_SCHEMA,enabled:true,grant_file:grantFile,state_dir:stateDir,native_host:{path:host,sha256:sha(await readFile(host))},roots:{core:{path:project,deny_paths:[]}},profiles:{longrun:{executable:process.execPath,executable_sha256:sha(await readFile(process.execPath)),root_ids:['core'],transport:'pipe',prefix_args:[script],max_args:0,max_arg_bytes:256,max_sessions:1,max_input_bytes:4096,max_retained_output_bytes:65536,env_allow:['PATH','TEMP','TMP'],input_actions:{}}}};
+  await writeFile(policyPath,JSON.stringify(raw));
+  const policy=await loadProcessPolicy(policyPath);
+  await writeFile(grantFile,JSON.stringify({schema:PROCESS_GRANT_SCHEMA,policy_sha256:policy.policy_sha256,instance_nonce:'6'.repeat(64),profile_ids:['longrun'],root_ids:['core'],granted_at_utc:new Date().toISOString()}));
+  const keys=await generateTrustKeypair({privateKeyPath:path.join(trust,'private.pem'),publicKeyPath:path.join(trust,'public.pem')});
+  const make=()=>createProcessRuntime({policy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
+  return {root,project,stateDir,policy,keys,make,runtime:make()};
+}
+
+async function waitState(runtime,id,state,timeout=5000){const end=Date.now()+timeout;while(Date.now()<end){const s=await runtime.status({sessionId:id});if(s.state===state)return s;await sleep(30);}throw new Error(`timeout waiting ${state}`);}
+
+test('R36 process runtime publishes terminal state only after durable terminal journal commit', async()=>{
+  const source=await readFile(path.join(repo,'src','process-runtime.mjs'),'utf8');
+  assert.match(source,/const terminalState = session\.terminate_requested \? 'terminated' : 'exited'/);
+  const commit=source.indexOf("await appendEvent(runtime, session, terminalState");
+  const publish=source.indexOf('session.state = terminalState;',commit);
+  assert.ok(commit>=0&&publish>commit,'terminal state must publish after terminal event commit');
+});
+
+test('R36 long process returns before exit and exposes monotonic cursor chunks', {skip:process.platform!=='win32'}, async()=>{
+  const f=await fixture(); try{
+    const startedAt=Date.now();
+    const started=await f.runtime.start({profileId:'longrun',rootId:'core',cwd:'.',args:[]});
+    assert.equal(started.state,'running');
+    assert.ok(Date.now()-startedAt<500,'start waited for child exit');
+    let offset=0; let text=''; let sawPartial=false;
+    const end=Date.now()+5000;
+    while(Date.now()<end){
+      const page=await f.runtime.read({sessionId:started.session_id,offset,maxBytes:8});
+      assert.ok(page.next_offset>=offset); assert.ok(page.next_offset<=page.stream_head);
+      if(page.next_offset<page.stream_head||page.state==='running') sawPartial=true;
+      text+=Buffer.from(page.data_base64,'base64').toString('utf8'); offset=page.next_offset;
+      if(page.state==='exited'&&offset===page.stream_head) break;
+      await sleep(35);
+    }
+    assert.equal(sawPartial,true); assert.match(text,/chunk-1/); assert.match(text,/chunk-2/); assert.match(text,/chunk-3/);
+    const terminal=await waitState(f.runtime,started.session_id,'exited'); assert.equal(terminal.exit_code,0);
+    await assert.rejects(()=>f.runtime.status({sessionId:'f'.repeat(64)}),/unknown process session/i);
+  } finally {await rm(f.root,{recursive:true,force:true});}
+});
+
+test('R36 terminal process session is recovered from signed journal after wrapper restart', {skip:process.platform!=='win32'}, async()=>{
+  const f=await fixture(); try{
+    const started=await f.runtime.start({profileId:'longrun',rootId:'core',cwd:'.',args:[]});
+    await waitState(f.runtime,started.session_id,'exited');
+    const original=await f.runtime.status({sessionId:started.session_id});
+    const checked=await f.runtime.verifyEventJournal({sessionId:started.session_id}); assert.equal(checked.ok,true);
+    const restarted=f.make();
+    const recovered=await restarted.status({sessionId:started.session_id});
+    assert.equal(recovered.state,'exited'); assert.equal(recovered.exit_code,0); assert.equal(recovered.session_id,started.session_id);
+    assert.equal(recovered.journal_head_sha256,original.journal_head_sha256);
+    const listed=await restarted.list(); assert.ok(listed.sessions.some(s=>s.session_id===started.session_id));
+    const page=await restarted.read({sessionId:started.session_id,offset:0,maxBytes:65536});
+    const text=Buffer.from(page.data_base64,'base64').toString('utf8');
+    assert.match(text,/chunk-1/); assert.match(text,/chunk-3/); assert.equal(page.state,'exited');
+    const verified=await restarted.verifyEventJournal({sessionId:started.session_id}); assert.equal(verified.ok,true); assert.equal(verified.head_sha256,recovered.journal_head_sha256);
+    await assert.rejects(()=>restarted.status({sessionId:'e'.repeat(64)}),/unknown process session/i);
+  } finally {await rm(f.root,{recursive:true,force:true});}
+});

package/test/process-release-gate.test.mjs

@@ -5,12 +5,21 @@ import { fileURLToPath } from 'node:url';
 
 const packagePath = fileURLToPath(new URL('../package.json', import.meta.url));
 const gatePath = fileURLToPath(new URL('../scripts/gate-windows.ps1', import.meta.url));
+const processSmokePath = fileURLToPath(new URL('../src/process-smoke-client.mjs', import.meta.url));
 
 test('R31 package exposes the bounded process smoke command', async () => {
   const pkg = JSON.parse(await readFile(packagePath, 'utf8'));
   assert.equal(pkg.scripts['mcp:process:smoke'], 'node src/process-smoke-client.mjs');
 });
 
+test('R36 process smoke isolates grant and recovery state outside the release source tree', async () => {
+  const source = await readFile(processSmokePath, 'utf8');
+  assert.match(source, /smoke-policy\.json/);
+  assert.match(source, /grant_file:\s*path\.join\(smokeTrust,\s*'process-grant\.json'\)/);
+  assert.match(source, /state_dir:\s*path\.join\(smokeTrust,\s*'process-state'\)/);
+  assert.match(source, /DEADBYTE_PROCESS_POLICY:\s*smokePolicyPath/);
+});
+
 test('R31 Windows gate refreshes the native-host policy pin before manifest freeze', async () => {
   const pkg = JSON.parse(await readFile(packagePath, 'utf8'));
   const source = await readFile(gatePath, 'utf8');

package/test/production-docs.test.mjs

@@ -9,9 +9,9 @@ const readme=()=>readFile(path.join(root,'README.txt'),'utf8');
 
 test('production README documents one-command stdio configs for major MCP clients',async()=>{
   const text=await readme();
-  assert.match(text,/npx -y deadbyte-mcp@0\.9\.0 mcp/);
+  assert.match(text,/npx -y deadbyte-mcp@0\.11\.0 mcp/);
   assert.match(text,/CLAUDE DESKTOP/);
-  assert.match(text,/"mcpServers"[\s\S]*?"command"\s*:\s*"npx"[\s\S]*?"-y"[\s\S]*?"deadbyte-mcp@0\.9\.0"[\s\S]*?"mcp"/);
+  assert.match(text,/"mcpServers"[\s\S]*?"command"\s*:\s*"npx"[\s\S]*?"-y"[\s\S]*?"deadbyte-mcp@0\.11\.0"[\s\S]*?"mcp"/);
   assert.match(text,/CURSOR/);
   assert.match(text,/\.cursor\/mcp\.json/);
   assert.match(text,/VS CODE/);
@@ -20,7 +20,7 @@ test('production README documents one-command stdio configs for major MCP client
   assert.match(text,/CODEX/);
   assert.match(text,/\[mcp_servers\.deadbyte\]/);
   assert.match(text,/command\s*=\s*"npx"/);
-  assert.match(text,/args\s*=\s*\["-y",\s*"deadbyte-mcp@0\.9\.0",\s*"mcp"\]/);
+  assert.match(text,/args\s*=\s*\["-y",\s*"deadbyte-mcp@0\.11\.0",\s*"mcp"\]/);
 });
 
 test('production README records tracer bullet, semantic scope, remote UX, safety and document extension',async()=>{
@@ -29,8 +29,8 @@ test('production README records tracer bullet, semantic scope, remote UX, safety
   for(const token of ['coding_files_read','coding_symbol_outline','coding_symbol_definition','coding_symbol_references','coding_symbol_replace']) assert.match(text,new RegExp(token));
   assert.match(text,/JavaScript\/TypeScript|JS\/TS/);
   assert.match(text,/does not claim|not claim|limited to/i);
-  assert.match(text,/remote --verbose/);
-  assert.match(text,/compact/i);
+  assert.doesNotMatch(text,/remote --verbose/);
+  assert.match(text,/unified live timeline/i);
   assert.match(text,/workspace allowlist|coding-policy root/i);
   assert.match(text,/destructive|standing grant|authority plane/i);
   assert.match(text,/document adapter/i);

package/test/prompts-resources.test.mjs

@@ -24,7 +24,13 @@ test('MCP exposes compact workflow prompts and source-of-truth context resources
 
     const resources=await client.listResources();
     const uris=resources.resources.map(r=>r.uri).sort();
-    assert.deepEqual(uris,['deadbyte://architecture','deadbyte://context']);
+    assert.deepEqual(uris,['deadbyte://architecture','deadbyte://context','deadbyte://surface-profile']);
+    const surface=await client.readResource({uri:'deadbyte://surface-profile'});
+    const surfaceText=surface.contents.map(c=>'text' in c?c.text:'').join('\n');
+    const surfaceState=JSON.parse(surfaceText);
+    assert.equal(surfaceState.schema,'deadbyte.surface-profile.v1');
+    assert.equal(surfaceState.profile,'full');
+    assert.equal(surfaceState.compact_tool_limit,42);
     const context=await client.readResource({uri:'deadbyte://context'});
     const contextText=context.contents.map(c=>'text' in c?c.text:'').join('\n');
     assert.match(contextText,/Machine truth/i); assert.match(contextText,/Authority plane/i); assert.match(contextText,/Loop Supervisor/i);

package/test/r33-closeout-regression.test.mjs

@@ -86,7 +86,7 @@ test('audit restart reconciles an orphan request with an explicit interrupted re
   }finally{await rm(stateRoot,{recursive:true,force:true});}
 });
 
-test('Windows R35 gate emits manifest-bound machine-readable evidence outside the candidate tree', async()=>{
+test('Windows R37 gate emits manifest-bound machine-readable evidence outside the candidate tree', async()=>{
   const stateRoot=await temp('deadbyte-r33-windows-evidence-');
   try{
     const gate=await readFile(path.join(root,'scripts','gate-windows.ps1'),'utf8');
@@ -99,11 +99,12 @@ test('Windows R35 gate emits manifest-bound machine-readable evidence outside th
     assert.equal(summary.status,'written');
     const evidence=JSON.parse(await readFile(summary.path,'utf8'));
     const manifestSha=sha256(await readFile(path.join(root,'MANIFEST.SHA256')));
-    assert.equal(evidence.schema,'deadbyte.r35-windows-gate.v1');
+    assert.equal(evidence.schema,'deadbyte.r37-windows-gate.v1');
     assert.equal(evidence.status,'passed');
     assert.equal(evidence.exit_code,0);
+    assert.equal(evidence.version,'0.11.0');
     assert.equal(evidence.manifest_sha256,manifestSha);
-    assert.equal(evidence.marker,'DEADBYTE V0.9.0 / R35 WINDOWS BATCH GATE: PASS');
+    assert.equal(evidence.marker,'DEADBYTE V0.11.0 / R37 WINDOWS BATCH GATE: PASS');
     assert.ok(summary.path.startsWith(path.join(stateRoot,'evidence','release')));
   }finally{await rm(stateRoot,{recursive:true,force:true});}
 });

package/test/r33-finalization.test.mjs

@@ -26,16 +26,17 @@ test('release parity and final verifier are package entry points', async () => {
   assert.equal(typeof verifyFinalClosureObject, 'function');
 });
 
-test('final closure verifier is implementation-independent from production helpers', async () => {
+test('R37 final closure verifier is implementation-independent from production helpers', async () => {
   const verifier = await text('scripts/final-closure-verify.mjs');
   const writer = await text('scripts/final-closure.mjs');
   assert.doesNotMatch(verifier, /from ['"]\.\.\/src\//);
   assert.match(verifier, /DEADBYTE-R27-SLOT-UPDATE-V1/);
   assert.match(verifier, /DEADBYTE-MACHINE-PING-V1/);
-  assert.match(verifier, /DEADBYTE-R35-FINAL-CLOSURE-V1/);
-  assert.match(writer, /pointer\.version==='0\.9\.0'/);
-  assert.match(verifier, /envelope\.body\.version==='0\.9\.0'/);
-  assert.match(verifier, /release_label==='R35 FINAL MACHINE BASELINE'/);
+  assert.match(verifier, /DEADBYTE-R37-FINAL-CLOSURE-V1/);
+  assert.match(writer, /pointer\.version==='0\.11\.0'/);
+  assert.match(verifier, /envelope\.body\.version==='0\.11\.0'/);
+  assert.match(verifier, /release_label==='R37 FINAL MACHINE BASELINE'/);
+  assert.match(verifier, /8d1e5f09745e764796b60e0a8a0168be7334ed4bf834fad5974a80eba295b4e8/);
 });
 
 test('final closure verifier canonicalizes traversal order before exact-tree comparison', async () => {
@@ -44,11 +45,15 @@ test('final closure verifier canonicalizes traversal order before exact-tree com
   assert.match(verifier, /const expected=\[\.\.\.entries\.keys\(\)\]\.sort\(\(a,b\)=>a\.localeCompare\(b,'en'\)\);/);
 });
 
-test('autonomous live gate reuses the canonical R34 73-tool catalog', async () => {
+test('R36 autonomous live gate binds the compact gateway contract instead of the historical 73-tool public catalog', async () => {
   const autonomous = await text('src/remote-mcp-autonomous-smoke-client.mjs');
-  assert.match(autonomous, /import \{ R34_EXPECTED_TOOLS \} from '\.\/remote-mcp-r34-parity-client\.mjs';/);
-  assert.doesNotMatch(autonomous, /const expectedTools\s*=\s*\[/);
-  assert.match(autonomous, /JSON\.stringify\(names\) !== JSON\.stringify\(R34_EXPECTED_TOOLS\)/);
+  assert.match(autonomous, /R36_COMPACT_GATEWAYS/);
+  assert.match(autonomous, /R36_COMPACT_TOOL_LIMIT/);
+  assert.match(autonomous, /names\.length > R36_COMPACT_TOOL_LIMIT/);
+  for (const name of ['autonomous_goal_submit','autonomous_goal_run','autonomous_goal_verify','autonomous_release_gate','native_diff_apply','native_diff_verify']) {
+    assert.match(autonomous,new RegExp(name));
+  }
+  assert.doesNotMatch(autonomous, /R34_EXPECTED_TOOLS/);
 });
 
 test('R34 parity proves coding package tests before package-visible scratch mutation', async () => {

package/test/r36-finalization.test.mjs

@@ -0,0 +1,104 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { validateParityEvidence, R35_PREDECESSOR_RELEASE_ID, R35_PREDECESSOR_MANIFEST } from '../scripts/release-parity-r36.mjs';
+import { verifyFinalClosureObject } from '../scripts/final-closure-verify-r36.mjs';
+
+const root=new URL('../',import.meta.url);
+const text=rel=>readFile(new URL(rel,root),'utf8');
+
+function parityFixture(){
+  const manifest='a'.repeat(64);
+  return {
+    schema:'deadbyte.r36-parity.v1',status:'passed',execution_provider:'deadbyte_mcp',rdc_operation_count:0,
+    candidate:{release_id:`v0.10.0-${manifest.slice(0,16)}`,version:'0.10.0',manifest_sha256:manifest},
+    immutable_slot:{protected:true,release_root:'C:/immutable/r36',development_root:'D:/Projects/deadbyte-mcp-r36-dev'},
+    local_full:{status:'passed',tool_count:76,strict_output_schemas:true},
+    public_compact:{status:'passed',tool_count:41,capability_closure:true,gateway_count:5},
+    autonomous:{status:'passed',signed_release_verified:true,observed_failure_before_replan:true},
+    before_rollback_disarmed:{status:'passed',capability_closure:true,coding_armed:false,autonomous_armed:false},
+    rollback:{state:'completed'},stage_restore:{status:'restored',manifest_sha256:manifest},restore:{state:'completed'},
+    predecessor:{release_id:R35_PREDECESSOR_RELEASE_ID,version:'0.9.0',manifest_sha256:R35_PREDECESSOR_MANIFEST},
+    predecessor_disarmed:{status:'passed',tool_count:73},
+    successor:{release_id:`v0.10.0-${manifest.slice(0,16)}`,version:'0.10.0',manifest_sha256:manifest},
+    successor_disarmed:{status:'passed',capability_closure:true,coding_armed:false,autonomous_armed:false},
+    requirements:Object.fromEntries(['tree_read','precondition_mutation','search','owned_process','observation','coding_loop','autonomy','interrupted_recovery','evidence_verification','compact_closure','full_surface'].map(key=>[key,true]))
+  };
+}
+
+test('R36 parity validator requires full-76, compact closure, exact R35 predecessor and immutable-slot separation',()=>{
+  const good=parityFixture();
+  assert.equal(validateParityEvidence(good),true);
+  assert.throws(()=>validateParityEvidence({...good,local_full:{...good.local_full,tool_count:75}}),/full 76/i);
+  assert.throws(()=>validateParityEvidence({...good,public_compact:{...good.public_compact,capability_closure:false}}),/compact closure/i);
+  assert.throws(()=>validateParityEvidence({...good,predecessor:{...good.predecessor,manifest_sha256:'b'.repeat(64)}}),/predecessor/i);
+  assert.throws(()=>validateParityEvidence({...good,immutable_slot:{...good.immutable_slot,development_root:good.immutable_slot.release_root}}),/immutable-slot/i);
+  assert.throws(()=>validateParityEvidence({...good,stage_restore:{status:'missing',manifest_sha256:good.candidate.manifest_sha256}}),/stage restore/i);
+});
+
+test('R36 compact disarmed probe carries signed machine status/ping evidence into closure',async()=>{
+  const probe=await text('src/r36-compact-disarmed-probe.mjs');
+  assert.match(probe,/op:'machine_ping'/);
+  assert.match(probe,/machine_status/);
+  assert.match(probe,/machine_ping/);
+  assert.match(probe,/nonce/);
+});
+
+test('R36 parity captures exact successor bridge before rollback and reuses it for restore',async()=>{
+  const parity=await text('scripts/release-parity-r36.mjs');
+  assert.match(parity,/loadPowerShellDataFile/);
+  assert.match(parity,/successorBridge/);
+  assert.match(parity,/Bridge\?\.WorkingDirectory/);
+  assert.match(parity,/Bridge\?\.ScriptSha256/);
+  assert.match(parity,/const stageRestore=await restoreFrozenStage\(\{developmentRoot,releaseRoot:active\.release_root,expectedManifestSha256:candidateManifest\}\)/);
+  assert.match(parity,/scheduleDeferred\('activate',candidateManifest,\{bridgeRoot:successorBridge\.root,bridgeScriptSha256:successorBridge\.sha256\}\)/);
+});
+
+test('R36 compact parity uses bounded release-parity tests instead of the full npm suite',async()=>{
+  const parity=await text('src/remote-mcp-r36-parity-client.mjs');
+  assert.match(parity,/const testScript='scripts\/release-parity-tests\.ps1'/);
+  assert.doesNotMatch(parity,/const testScript='scripts\/autonomous-tests\.ps1'/);
+  const script=await text('scripts/release-parity-tests.ps1');
+  assert.match(script,/r36-finalization\.test\.mjs/);
+  assert.match(script,/r36-release-identity\.test\.mjs/);
+  assert.match(script,/deferred-slot-operation\.test\.mjs/);
+});
+
+test('R36 compact parity treats stale machine-fs precondition denial as expected evidence',async()=>{
+  const parity=await text('src/remote-mcp-r36-parity-client.mjs');
+  assert.match(parity,/const staleValue=stale\.structuredContent/);
+  assert.match(parity,/stale\.isError!==true\|\|staleValue\.status!=='denied'/);
+  assert.doesNotMatch(parity,/structured\(stale,'machine_fs stale'\)/);
+});
+
+test('R36 final closure writer binds compact public evidence and R36 release evidence domains',async()=>{
+  const writer=await text('scripts/final-closure-r36.mjs');
+  assert.match(writer,/DEADBYTE-R36-FINAL-CLOSURE-V1/);
+  assert.match(writer,/deadbyte\.r36-final-closure\.v1/);
+  assert.match(writer,/pointer\.version==='0\.10\.0'/);
+  assert.match(writer,/release_label:'R36 FINAL MACHINE BASELINE'/);
+  assert.match(writer,/deadbyte\.r36-parity\.v1/);
+  assert.match(writer,/deadbyte\.r36-windows-gate\.v1/);
+  assert.match(writer,/tool_count.*76|local_full[\s\S]*76/);
+  assert.match(writer,/capability_closure/);
+  assert.match(writer,/R35_PREDECESSOR_RELEASE_ID|v0\.9\.0-b95e1ec1d9a7e26a/);
+  assert.match(writer,/development_root/);
+});
+
+test('R36 independent closure verifier binds full, compact, predecessor, restore, Windows gate and immutable slot',async()=>{
+  const verifier=await text('scripts/final-closure-verify-r36.mjs');
+  assert.equal(typeof verifyFinalClosureObject,'function');
+  assert.doesNotMatch(verifier,/from ['"]\.\.\/src\//);
+  assert.match(verifier,/DEADBYTE-R36-FINAL-CLOSURE-V1/);
+  assert.match(verifier,/deadbyte\.r36-final-closure\.v1/);
+  assert.match(verifier,/envelope\.body\.version==='0\.10\.0'/);
+  assert.match(verifier,/R36 FINAL MACHINE BASELINE/);
+  assert.match(verifier,/deadbyte\.r36-parity\.v1/);
+  assert.match(verifier,/deadbyte\.r36-windows-gate\.v1/);
+  assert.match(verifier,/76/);
+  assert.match(verifier,/42/);
+  assert.match(verifier,/b95e1ec1d9a7e26a96ef492306c1be4df18c883ff03ab3b6015f677d7429ec8d/);
+  assert.match(verifier,/development_root/);
+  assert.match(verifier,/release_root/);
+  assert.match(verifier,/successor_disarmed/);
+});

package/test/r36-release-identity.test.mjs

@@ -0,0 +1,45 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+
+const root=new URL('../',import.meta.url);
+const text=rel=>readFile(new URL(rel,root),'utf8');
+const R35_RELEASE_ID='v0.9.0-b95e1ec1d9a7e26a';
+const R35_MANIFEST='b95e1ec1d9a7e26a96ef492306c1be4df18c883ff03ab3b6015f677d7429ec8d';
+const R36_RELEASE_ID='v0.10.0-8d1e5f09745e7647';
+const R36_MANIFEST='8d1e5f09745e764796b60e0a8a0168be7334ed4bf834fad5974a80eba295b4e8';
+
+test('sealed R36 historical proof scripts preserve 0.10.0 / R36 and exact R35 predecessor',async()=>{
+  const [gate,parity,closure,closureVerify,windowsGate,currentParity]=await Promise.all([
+    text('scripts/gate-windows-r36.ps1'),text('scripts/release-parity-r36.mjs'),
+    text('scripts/final-closure-r36.mjs'),text('scripts/final-closure-verify-r36.mjs'),
+    text('scripts/windows-gate-evidence-r36.mjs'),text('scripts/release-parity.mjs')
+  ]);
+  assert.match(gate,/DEADBYTE V0\.10\.0 \/ R36 WINDOWS BATCH GATE: PASS/);
+  assert.match(parity,/deadbyte\.r36-parity\.v1/);
+  assert.match(parity,new RegExp(R35_RELEASE_ID.replaceAll('.','\\.')));
+  assert.match(parity,new RegExp(R35_MANIFEST));
+  assert.match(closure,/DEADBYTE-R36-FINAL-CLOSURE-V1/);
+  assert.match(closure,/version:'0\.10\.0'/);
+  assert.match(closureVerify,/DEADBYTE-R36-FINAL-CLOSURE-V1/);
+  assert.match(windowsGate,/deadbyte\.r36-windows-gate\.v1/);
+  assert.match(currentParity,new RegExp(R36_RELEASE_ID.replaceAll('.','\\.')));
+  assert.match(currentParity,new RegExp(R36_MANIFEST));
+});
+
+test('current R37 controller still binds production remote to compact profile and restores parent environment',async()=>{
+  const controller=await text('controller/deadbyte-controller.ps1');
+  assert.match(controller,/Test-Path Env:DEADBYTE_CAPABILITY_PROFILE/);
+  assert.match(controller,/\$previousCapabilityProfileEnv = \$env:DEADBYTE_CAPABILITY_PROFILE/);
+  assert.match(controller,/\$env:DEADBYTE_CAPABILITY_PROFILE = 'compact'/);
+  assert.match(controller,/Remove-Item Env:DEADBYTE_CAPABILITY_PROFILE/);
+  assert.match(controller,/\$env:DEADBYTE_CAPABILITY_PROFILE = \$previousCapabilityProfileEnv/);
+});
+
+test('R36 surface contract remains exact full 76 plus compact gateway closure for R37',async()=>{
+  const parity=await text('src/remote-mcp-r36-parity-client.mjs');
+  assert.match(parity,/R36_EXPECTED_TOOLS/);
+  assert.match(parity,/R36_EXPECTED_TOOLS\.length !== 76|tool_count !== 76|length === 76/);
+  for(const name of ['capability_manifest','coding_inspect','machine_fs','process_session','machine_observe']) assert.match(parity,new RegExp(name));
+  assert.match(parity,/42/);
+});

package/test/r37-agent-fabric.test.mjs

@@ -0,0 +1,92 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { effectIdentity, loopGuardDisposition, bindEffectCompletion } from '../src/effect-ledger.mjs';
+import { deriveAgentMemory, queryAgentMemory } from '../src/agent-memory-plane.mjs';
+import { createWorkerScheduler } from '../src/worker-scheduler.mjs';
+import { issueObservationLease, verifyObservationLease } from '../src/observation-lease.mjs';
+
+const repo=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+
+test('R37 effect ledger detects semantically identical repeated effects across planner wording',()=>{
+  const base={goalId:'a'.repeat(64),planId:'b'.repeat(64),stepId:'fix',mutationEpoch:4,
+    action:{kind:'patch',operations:[{kind:'replace',path:'src/a.mjs',old_string:'x',new_string:'y'}]},
+    observationHeadSha256:'c'.repeat(64)};
+  const first=effectIdentity(base);
+  const second=effectIdentity({...base,plannerSummary:'different prose'});
+  assert.equal(first.fingerprint,second.fingerprint);
+  const events=[
+    {type:'effect_started',payload:{fingerprint:first.fingerprint,effect_id:first.effect_id}},
+    {type:'effect_completed',payload:{fingerprint:first.fingerprint,effect_id:first.effect_id}},
+    {type:'effect_started',payload:{fingerprint:first.fingerprint,effect_id:'d'.repeat(64)}},
+    {type:'effect_failed',payload:{fingerprint:first.fingerprint,effect_id:'d'.repeat(64)}}
+  ];
+  const guard=loopGuardDisposition(events,second,{maxRepeats:2,window:16});
+  assert.equal(guard.allowed,false);
+  assert.equal(guard.reason,'effect_repeat_limit');
+  assert.equal(guard.repeated_count,2);
+  const completion=bindEffectCompletion(first,{status:'passed',receipt_sha256:'e'.repeat(64)});
+  assert.equal(completion.effect_id,first.effect_id);
+  assert.match(completion.result_sha256,/^[0-9a-f]{64}$/);
+});
+
+test('R37 memory plane derives deterministic core archival and graph views from journal',()=>{
+  const events=[
+    {seq:1,type:'goal_created',event_sha256:'1'.repeat(64),payload:{acceptance:'all gates pass'}},
+    {seq:2,type:'profile_completed',event_sha256:'2'.repeat(64),payload:{profile_id:'quick-test',passed:true,receipt_sha256:'a'.repeat(64)}},
+    {seq:3,type:'native_diff_committed',event_sha256:'3'.repeat(64),payload:{paths:['src/a.mjs'],diff_receipt_sha256:'b'.repeat(64),mutation_epoch:1}},
+    {seq:4,type:'planner_rejected',event_sha256:'4'.repeat(64),payload:{reason:'stale approach'}},
+    {seq:5,type:'waiting_entered',event_sha256:'5'.repeat(64),payload:{reason:'needs evidence'}}
+  ];
+  const one=deriveAgentMemory(events);
+  const two=deriveAgentMemory(structuredClone(events));
+  assert.equal(one.memory_sha256,two.memory_sha256);
+  assert.deepEqual(one.core.acceptance_constraints,['all gates pass']);
+  assert.ok(one.archival.some(x=>x.type==='planner_rejected'));
+  assert.ok(one.graph.nodes.some(x=>x.id==='file:src/a.mjs'));
+  const local=queryAgentMemory(one,{query:'src a mjs',mode:'local',limit:8});
+  assert.ok(local.results.some(x=>JSON.stringify(x).includes('src/a.mjs')));
+  const global=queryAgentMemory(one,{query:'gates profiles blockers',mode:'global',limit:8});
+  assert.ok(global.results.length>0);
+  const drift=queryAgentMemory(one,{query:'src/a.mjs',mode:'drift',limit:8});
+  assert.ok(drift.results.length>0);
+});
+
+test('R37 worker scheduler enforces resources, leases and expiry recovery',()=>{
+  let now=1000;
+  const scheduler=createWorkerScheduler({maxConcurrent:2,totalCpuUnits:2,totalMemoryMb:1024,leaseMs:5000,clock:()=>now});
+  const a=scheduler.acquire({taskId:'test-a',workerClass:'test',cpuUnits:1,memoryMb:512});
+  const b=scheduler.acquire({taskId:'test-b',workerClass:'test',cpuUnits:1,memoryMb:512});
+  assert.equal(scheduler.snapshot().active.length,2);
+  assert.throws(()=>scheduler.acquire({taskId:'test-c',workerClass:'test',cpuUnits:1,memoryMb:128}),/capacity/i);
+  now=7000;
+  const c=scheduler.acquire({taskId:'test-c',workerClass:'test',cpuUnits:2,memoryMb:1024});
+  assert.equal(scheduler.snapshot().active.length,1);
+  assert.equal(c.task_id,'test-c');
+  assert.equal(scheduler.release(c.lease_id,{status:'passed'}).status,'released');
+  assert.equal(scheduler.snapshot().active.length,0);
+  assert.notEqual(a.lease_id,b.lease_id);
+});
+
+test('R37 observation leases bind effects to fresh observed state and mutation epoch',()=>{
+  const lease=issueObservationLease({goalId:'a'.repeat(64),mutationEpoch:3,
+    observations:[{event_sha256:'b'.repeat(64),receipt_sha256:'c'.repeat(64),result_head_sha256:'d'.repeat(64)}],
+    ttlMs:1000,nowMs:5000});
+  assert.equal(verifyObservationLease(lease,{goalId:'a'.repeat(64),currentMutationEpoch:3,nowMs:5500}).ok,true);
+  assert.throws(()=>verifyObservationLease(lease,{goalId:'a'.repeat(64),currentMutationEpoch:4,nowMs:5500}),/stale mutation epoch/i);
+  assert.throws(()=>verifyObservationLease(lease,{goalId:'a'.repeat(64),currentMutationEpoch:3,nowMs:7000}),/expired/i);
+});
+
+test('R37 autonomous runtime integrates memory, effect guard, worker scheduler and observation lease',async()=>{
+  const source=await readFile(path.join(repo,'src','autonomous-runtime.mjs'),'utf8');
+  assert.match(source,/deriveAgentMemory/);
+  assert.match(source,/effectIdentity/);
+  assert.match(source,/loopGuardDisposition/);
+  assert.match(source,/createWorkerScheduler/);
+  assert.match(source,/issueObservationLease/);
+  assert.match(source,/project_memory:memory/);
+  assert.match(source,/effect_guard_blocked/);
+  assert.match(source,/worker_lease_acquired/);
+});

package/test/r37-autonomous-timeout-recovery.test.mjs

@@ -0,0 +1,60 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { classifyAutonomousTimeoutRecovery } from '../src/autonomous-timeout-recovery.mjs';
+
+const before='a'.repeat(64);
+const after='b'.repeat(64);
+const base={status:'ok',state:'running',reason:null,journal_head_sha256:after,pending_request:null,pending_decision:null,run_busy:false,run_owner_pid:null,run_lock_created_at_utc:null};
+
+test('R37 timeout recovery accepts signed durable terminal success',()=>{
+  assert.deepEqual(classifyAutonomousTimeoutRecovery({...base,state:'succeeded'},{beforeJournalHead:before}),
+    {kind:'completed',state:'succeeded',journal_head_sha256:after});
+});
+
+test('R37 timeout recovery surfaces paused or cancelled as terminal failure',()=>{
+  assert.equal(classifyAutonomousTimeoutRecovery({...base,state:'paused',reason:'benchmark_regression'},{beforeJournalHead:before}).kind,'terminal_failure');
+  assert.equal(classifyAutonomousTimeoutRecovery({...base,state:'cancelled'},{beforeJournalHead:before}).kind,'terminal_failure');
+});
+
+test('R37 timeout recovery waits while planner or decision is still in flight',()=>{
+  assert.equal(classifyAutonomousTimeoutRecovery({...base,pending_request:{request_id:'x'}},{beforeJournalHead:before}).kind,'wait');
+  assert.equal(classifyAutonomousTimeoutRecovery({...base,pending_decision:{event_sha256:'c'.repeat(64)}},{beforeJournalHead:before}).kind,'wait');
+});
+
+test('R37 timeout recovery resumes only after durable head advance and cleared pending state',()=>{
+  assert.deepEqual(classifyAutonomousTimeoutRecovery(base,{beforeJournalHead:before}),{
+    kind:'resumable',state:'running',reason:'durable_cycle_completed',journal_head_sha256:after
+  });
+  assert.equal(classifyAutonomousTimeoutRecovery({...base,journal_head_sha256:before},{beforeJournalHead:before}).kind,'wait');
+});
+
+
+test('R37 public autonomous smoke binds timeout recovery to pre-run journal head and resumes yielded work',async()=>{
+  const {readFile}=await import('node:fs/promises');
+  const src=await readFile(new URL('../src/remote-mcp-autonomous-smoke-client.mjs',import.meta.url),'utf8');
+  assert.match(src,/classifyAutonomousTimeoutRecovery/);
+  assert.match(src,/const beforeRun=structured\(await client\.callTool/);
+  assert.match(src,/recoverTimedOutGoal\(client, goalId, beforeRun\.journal_head_sha256\)/);
+  assert.match(src,/recovered\.kind === 'completed'/);
+  assert.match(src,/status:'yielded'/);
+});
+
+
+test('R37 timeout recovery waits until server-side run lock is released even after durable progress',()=>{
+  const busy={...base,run_busy:true,run_owner_pid:2904,run_lock_created_at_utc:'2026-09-18T14:22:02.000Z'};
+  const result=classifyAutonomousTimeoutRecovery(busy,{beforeJournalHead:before});
+  assert.equal(result.kind,'wait');
+  assert.equal(result.reason,'server_run_in_flight');
+});
+
+test('R37 autonomous goal status exposes run-lock state for timeout-safe clients',async()=>{
+  const {readFile}=await import('node:fs/promises');
+  const [runtime,contracts]=await Promise.all([
+    readFile(new URL('../src/autonomous-runtime.mjs',import.meta.url),'utf8'),
+    readFile(new URL('../src/autonomous-output-contracts.mjs',import.meta.url),'utf8')
+  ]);
+  assert.match(runtime,/runLockStatus/);
+  assert.match(runtime,/run_busy/);
+  assert.match(contracts,/run_busy:z\.boolean/);
+  assert.match(contracts,/run_owner_pid:z\.number\(\)\.int\(\)\.min\(1\)\.nullable/);
+});

package/test/r37-finalization.test.mjs

@@ -0,0 +1,74 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { validateParityEvidence, R36_PREDECESSOR_RELEASE_ID, R36_PREDECESSOR_MANIFEST } from '../scripts/release-parity.mjs';
+import { verifyFinalClosureObject } from '../scripts/final-closure-verify.mjs';
+
+const root=new URL('../',import.meta.url);
+const text=rel=>readFile(new URL(rel,root),'utf8');
+
+function parityFixture(){
+  const manifest='a'.repeat(64);
+  return {
+    schema:'deadbyte.r37-parity.v1',status:'passed',execution_provider:'deadbyte_mcp',rdc_operation_count:0,
+    candidate:{release_id:`v0.11.0-${manifest.slice(0,16)}`,version:'0.11.0',manifest_sha256:manifest},
+    immutable_slot:{protected:true,release_root:'C:/immutable/r37',development_root:'D:/Projects/deadbyte-mcp-r36-dev'},
+    local_full:{status:'passed',tool_count:76,strict_output_schemas:true},
+    public_compact:{status:'passed',tool_count:41,capability_closure:true,gateway_count:5},
+    autonomous:{status:'passed',signed_release_verified:true,observed_failure_before_replan:true},
+    before_rollback_disarmed:{status:'passed',capability_closure:true,coding_armed:false,autonomous_armed:false},
+    rollback:{state:'completed'},stage_restore:{status:'restored',manifest_sha256:manifest},restore:{state:'completed'},
+    predecessor:{release_id:R36_PREDECESSOR_RELEASE_ID,version:'0.10.0',manifest_sha256:R36_PREDECESSOR_MANIFEST},
+    predecessor_disarmed:{status:'passed',tool_count:41,capability_closure:true},
+    successor:{release_id:`v0.11.0-${manifest.slice(0,16)}`,version:'0.11.0',manifest_sha256:manifest},
+    successor_disarmed:{status:'passed',capability_closure:true,coding_armed:false,autonomous_armed:false},
+    requirements:Object.fromEntries(['tree_read','precondition_mutation','search','owned_process','observation','coding_loop','autonomy','interrupted_recovery','evidence_verification','compact_closure','full_surface'].map(key=>[key,true]))
+  };
+}
+
+test('R37 parity validator requires full-76, compact closure, exact R36 predecessor and immutable-slot separation',()=>{
+  const good=parityFixture();
+  assert.equal(validateParityEvidence(good),true);
+  assert.throws(()=>validateParityEvidence({...good,local_full:{...good.local_full,tool_count:75}}),/full 76/i);
+  assert.throws(()=>validateParityEvidence({...good,public_compact:{...good.public_compact,capability_closure:false}}),/compact closure/i);
+  assert.throws(()=>validateParityEvidence({...good,predecessor:{...good.predecessor,manifest_sha256:'b'.repeat(64)}}),/predecessor/i);
+  assert.throws(()=>validateParityEvidence({...good,immutable_slot:{...good.immutable_slot,development_root:good.immutable_slot.release_root}}),/immutable-slot/i);
+  assert.throws(()=>validateParityEvidence({...good,stage_restore:{status:'missing',manifest_sha256:good.candidate.manifest_sha256}}),/stage restore/i);
+});
+
+test('R37 parity captures R37 bridge, exact R36 predecessor, stage reseed and successor restore',async()=>{
+  const parity=await text('scripts/release-parity.mjs');
+  assert.match(parity,/R36_PREDECESSOR_RELEASE_ID='v0\.10\.0-8d1e5f09745e7647'/);
+  assert.match(parity,/8d1e5f09745e764796b60e0a8a0168be7334ed4bf834fad5974a80eba295b4e8/);
+  assert.match(parity,/const stageRestore=await restoreFrozenStage/);
+  assert.match(parity,/publicR36Disarmed/);
+  assert.match(parity,/scheduleDeferred\('activate',candidateManifest,\{bridgeRoot:successorBridge\.root,bridgeScriptSha256:successorBridge\.sha256\}\)/);
+});
+
+test('R37 current final closure writer and independent verifier bind R37 domains and R36 predecessor',async()=>{
+  const [writer,verifier]=await Promise.all([text('scripts/final-closure.mjs'),text('scripts/final-closure-verify.mjs')]);
+  assert.equal(typeof verifyFinalClosureObject,'function');
+  assert.match(writer,/DEADBYTE-R37-FINAL-CLOSURE-V1/);
+  assert.match(writer,/deadbyte\.r37-final-closure\.v1/);
+  assert.match(writer,/pointer\.version==='0\.11\.0'/);
+  assert.match(writer,/R37 FINAL MACHINE BASELINE/);
+  assert.match(writer,/deadbyte\.r37-parity\.v1/);
+  assert.match(writer,/deadbyte\.r37-windows-gate\.v1/);
+  assert.match(writer,/R36_PREDECESSOR_RELEASE_ID/);
+  assert.doesNotMatch(verifier,/from ['"]\.\.\/src\//);
+  assert.match(verifier,/DEADBYTE-R37-FINAL-CLOSURE-V1/);
+  assert.match(verifier,/deadbyte\.r37-final-closure\.v1/);
+  assert.match(verifier,/envelope\.body\.version==='0\.11\.0'/);
+  assert.match(verifier,/R37 FINAL MACHINE BASELINE/);
+  assert.match(verifier,/deadbyte\.r37-parity\.v1/);
+  assert.match(verifier,/deadbyte\.r37-windows-gate\.v1/);
+  assert.match(verifier,/8d1e5f09745e764796b60e0a8a0168be7334ed4bf834fad5974a80eba295b4e8/);
+});
+
+test('R37 bounded public parity suite covers current release identity and agent fabric',async()=>{
+  const script=await text('scripts/release-parity-tests.ps1');
+  assert.match(script,/r37-finalization\.test\.mjs/);
+  assert.match(script,/release-version\.test\.mjs/);
+  assert.match(script,/r37-agent-fabric\.test\.mjs/);
+  assert.match(script,/remote-live-log-r37\.test\.mjs/);
+});