deadbyte-mcp 0.10.0 → 0.11.1

package/src/worker-scheduler.mjs

@@ -0,0 +1,53 @@
+import { createHash } from 'node:crypto';
+import { canonicalJson } from './canonical-json.mjs';
+
+export const WORKER_SCHEDULER_SCHEMA='deadbyte.worker-scheduler.v1';
+const sha=value=>createHash('sha256').update(Buffer.from(canonicalJson(value),'utf8')).digest('hex');
+
+export function createWorkerScheduler({maxConcurrent=1,totalCpuUnits=1,totalMemoryMb=1024,leaseMs=60000,clock=()=>Date.now()}={}){
+  if(!Number.isInteger(maxConcurrent)||maxConcurrent<1) throw new Error('maxConcurrent invalid');
+  if(!Number.isInteger(totalCpuUnits)||totalCpuUnits<1) throw new Error('totalCpuUnits invalid');
+  if(!Number.isInteger(totalMemoryMb)||totalMemoryMb<1) throw new Error('totalMemoryMb invalid');
+  if(!Number.isInteger(leaseMs)||leaseMs<100) throw new Error('leaseMs invalid');
+  const active=new Map(),attempts=new Map(),history=[];
+  function reclaim(){
+    const now=clock();
+    for(const [id,lease] of active) if(lease.expires_at_ms<=now){
+      active.delete(id);history.push({...lease,status:'expired',released_at_ms:now});
+    }
+  }
+  function usage(){
+    return [...active.values()].reduce((x,l)=>({cpu:x.cpu+l.cpu_units,memory:x.memory+l.memory_mb}),{cpu:0,memory:0});
+  }
+  function snapshot(){
+    reclaim();
+    const used=usage();
+    return Object.freeze({schema:WORKER_SCHEDULER_SCHEMA,max_concurrent:maxConcurrent,total_cpu_units:totalCpuUnits,total_memory_mb:totalMemoryMb,
+      active:[...active.values()].sort((a,b)=>a.lease_id.localeCompare(b.lease_id,'en')),
+      history:[...history],used_cpu_units:used.cpu,used_memory_mb:used.memory});
+  }
+  function acquire({taskId,workerClass,cpuUnits=1,memoryMb=128}){
+    reclaim();
+    if(typeof taskId!=='string'||!taskId) throw new Error('taskId invalid');
+    if(typeof workerClass!=='string'||!workerClass) throw new Error('workerClass invalid');
+    if(!Number.isInteger(cpuUnits)||cpuUnits<1||!Number.isInteger(memoryMb)||memoryMb<1) throw new Error('worker resources invalid');
+    const used=usage();
+    if(active.size>=maxConcurrent||used.cpu+cpuUnits>totalCpuUnits||used.memory+memoryMb>totalMemoryMb) throw new Error('worker scheduler capacity exceeded');
+    const attempt=(attempts.get(taskId)??0)+1;attempts.set(taskId,attempt);
+    const issued=clock(),expires=issued+leaseMs;
+    const body={schema:'deadbyte.worker-lease.v1',task_id:taskId,worker_class:workerClass,attempt,cpu_units:cpuUnits,memory_mb:memoryMb,issued_at_ms:issued,expires_at_ms:expires};
+    const lease=Object.freeze({...body,lease_id:sha(body)});
+    active.set(lease.lease_id,lease);
+    return lease;
+  }
+  function heartbeat(leaseId){
+    reclaim();const current=active.get(leaseId);if(!current) throw new Error('worker lease unavailable');
+    const next=Object.freeze({...current,expires_at_ms:clock()+leaseMs});active.set(leaseId,next);return next;
+  }
+  function release(leaseId,{status='completed'}={}){
+    reclaim();const lease=active.get(leaseId);if(!lease) throw new Error('worker lease unavailable');
+    active.delete(leaseId);const item={...lease,status,released_at_ms:clock()};history.push(item);
+    return Object.freeze({status:'released',lease:item});
+  }
+  return Object.freeze({acquire,heartbeat,release,snapshot});
+}

package/test/autonomous-output-contract.test.mjs

@@ -48,7 +48,7 @@ test('R34 run/status output contracts accept only the sanitized public loop proj
   assert.equal(run.structuredContent.loop.phase,'ACTING');
   const status = autonomousStructuredResult(autonomousGoalStatusOutputSchema,{
     status:'ok',goal_id:'1'.repeat(64),goal_sha256:'2'.repeat(64),title:'x',root_id:'project',journal_verified:true,
-    ...baseDerived(),loop:publicLoop
+    run_busy:false,run_owner_pid:null,run_lock_created_at_utc:null,...baseDerived(),loop:publicLoop
   });
   assert.equal(status.structuredContent.loop.pending_action.kind,'patch');
   const approved = autonomousStructuredResult(autonomousGoalApproveOutputSchema,{

package/test/cli-entrypoint.test.mjs

@@ -1,6 +1,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -16,6 +17,14 @@ test('package exposes npx-first deadbyte-mcp bin and is registry-publishable',as
   assert.equal(pkg.publishConfig?.access,'public');
 });
 
+test('npx CLI reports the canonical package version through --version, -v and version',()=>{
+  for(const arg of ['--version','-v','version']){
+    const result=spawnSync(process.execPath,[cliPath,arg],{cwd:root,encoding:'utf8',windowsHide:true});
+    assert.equal(result.status,0,result.stderr);
+    assert.equal(result.stdout.trim(),'0.11.1');
+  }
+});
+
 test('npx CLI remote path invokes stable PS1 directly and never routes through CMD',async()=>{
   const source=await readFile(cliPath,'utf8');
   assert.match(source,/^#!\/usr\/bin\/env node/m);

package/test/containment.test.mjs

@@ -230,6 +230,24 @@ test('native build script targets Windows 10 and preserves MSVC diagnostics', as
   assert.doesNotMatch(source, /\$VsWhere = Join-Path \$\{env:ProgramFiles\(x86\)\}/);
 });
 
+test('native build is reproducible at both MSVC object and linker boundaries', async () => {
+  const buildScript = fileURLToPath(new URL('../scripts/build-containment.ps1', import.meta.url));
+  const source = await readFile(buildScript, 'utf8');
+  const lines = source.split(/\r?\n/);
+  const commonLine = lines.find(line => line.startsWith('$Common ='));
+  const bootstrapLine = lines.find(line => line.startsWith('$BootstrapCommon ='));
+  assert.ok(commonLine?.includes('/Brepro'), 'common compiler flags must include /Brepro');
+  assert.ok(bootstrapLine?.includes('/Brepro'), 'bootstrap compiler flags must include /Brepro');
+  for (const name of [
+    'Launcher','Probe','BootstrapKernel','BootstrapAdvapi','StageLauncher','BootstrapExit',
+    'ChildControlStage','ChildControlProbe','ContainedLauncher','ContainedWorker',
+    'ContainedReverseWorker','TunnelHost','ProcessHost'
+  ]) {
+    const line = lines.find(candidate => candidate.startsWith(`$${name}Command =`));
+    assert.ok(line?.includes('/link /Brepro /INCREMENTAL:NO'), `${name} linker flags must be reproducible and non-incremental`);
+  }
+});
+
 
 
 test('native build command composition is Windows PowerShell 5.1 parser-safe', async () => {

package/test/core.test.mjs

@@ -105,7 +105,7 @@ test('proof execution creates deterministic output and signed verifiable receipt
   assert.equal(result.receipt.request.schema, 'deadbyte.request.v1');
   assert.match(result.receipt.request.nonce, /^[0-9a-f]{64}$/);
   assert.match(result.receipt.request.sha256, /^[0-9a-f]{64}$/);
-  assert.equal(result.receipt.runtime.package_version, '0.10.0');
+  assert.equal(result.receipt.runtime.package_version, '0.11.1');
   assert.match(result.receipt.runtime.mcp_ingress_adapter, /^(?:none|tunnel-stdio-probe-compat-v1)$/);
   assert.match(result.receipt.runtime.mcp_ingress_adapter_sha256, /^[0-9a-f]{64}$/);
   assert.match(result.receipt.runtime.mcp_ingress_mode_source_sha256, /^[0-9a-f]{64}$/);

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\.10\.0 mcp/);
+  assert.match(text,/npx -y deadbyte-mcp@0\.11\.1 mcp/);
   assert.match(text,/CLAUDE DESKTOP/);
-  assert.match(text,/"mcpServers"[\s\S]*?"command"\s*:\s*"npx"[\s\S]*?"-y"[\s\S]*?"deadbyte-mcp@0\.10\.0"[\s\S]*?"mcp"/);
+  assert.match(text,/"mcpServers"[\s\S]*?"command"\s*:\s*"npx"[\s\S]*?"-y"[\s\S]*?"deadbyte-mcp@0\.11\.1"[\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\.10\.0",\s*"mcp"\]/);
+  assert.match(text,/args\s*=\s*\["-y",\s*"deadbyte-mcp@0\.11\.1",\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/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 R36 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,12 +99,12 @@ test('Windows R36 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.r36-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.10.0');
+    assert.equal(evidence.version,'0.11.1');
     assert.equal(evidence.manifest_sha256,manifestSha);
-    assert.equal(evidence.marker,'DEADBYTE V0.10.0 / R36 WINDOWS BATCH GATE: PASS');
+    assert.equal(evidence.marker,'DEADBYTE V0.11.1 / 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,17 +26,17 @@ test('release parity and final verifier are package entry points', async () => {
   assert.equal(typeof verifyFinalClosureObject, 'function');
 });
 
-test('R36 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-R36-FINAL-CLOSURE-V1/);
-  assert.match(writer, /pointer\.version==='0\.10\.0'/);
-  assert.match(verifier, /envelope\.body\.version==='0\.10\.0'/);
-  assert.match(verifier, /release_label==='R36 FINAL MACHINE BASELINE'/);
-  assert.match(verifier, /b95e1ec1d9a7e26a96ef492306c1be4df18c883ff03ab3b6015f677d7429ec8d/);
+  assert.match(verifier, /DEADBYTE-R37-FINAL-CLOSURE-V1/);
+  assert.match(writer, /pointer\.version==='0\.11\.1'/);
+  assert.match(verifier, /envelope\.body\.version==='0\.11\.1'/);
+  assert.match(verifier, /release_label==='R37 FINAL MACHINE BASELINE'/);
+  assert.match(verifier, /08c2a0008b1f84c90f7ce7faa1e3decbd03f33612bc0fdc7d1ba591b548798e8/);
 });
 
 test('final closure verifier canonicalizes traversal order before exact-tree comparison', async () => {

package/test/r36-finalization.test.mjs

@@ -1,8 +1,8 @@
 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.mjs';
-import { verifyFinalClosureObject } from '../scripts/final-closure-verify.mjs';
+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');
@@ -45,7 +45,7 @@ test('R36 compact disarmed probe carries signed machine status/ping evidence int
 });
 
 test('R36 parity captures exact successor bridge before rollback and reuses it for restore',async()=>{
-  const parity=await text('scripts/release-parity.mjs');
+  const parity=await text('scripts/release-parity-r36.mjs');
   assert.match(parity,/loadPowerShellDataFile/);
   assert.match(parity,/successorBridge/);
   assert.match(parity,/Bridge\?\.WorkingDirectory/);
@@ -72,7 +72,7 @@ test('R36 compact parity treats stale machine-fs precondition denial as expected
 });
 
 test('R36 final closure writer binds compact public evidence and R36 release evidence domains',async()=>{
-  const writer=await text('scripts/final-closure.mjs');
+  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'/);
@@ -86,7 +86,7 @@ test('R36 final closure writer binds compact public evidence and R36 release evi
 });
 
 test('R36 independent closure verifier binds full, compact, predecessor, restore, Windows gate and immutable slot',async()=>{
-  const verifier=await text('scripts/final-closure-verify.mjs');
+  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/);

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

@@ -6,35 +6,28 @@ 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('R36 current release authority is consistently 0.10.0 / R36 and preserves exact R35 predecessor',async()=>{
-  const pkg=JSON.parse(await text('package.json'));
-  const [version,controller,gate,readme,architecture,controllerReadme,deferred,parity,closure,closureVerify,windowsGate]=await Promise.all([
-    text('src/version.mjs'),text('controller/deadbyte-controller.ps1'),text('scripts/gate-windows.ps1'),
-    text('README.txt'),text('docs/ARCHITECTURE.md'),text('controller/README.TXT'),
-    text('scripts/deferred-slot-operation.mjs'),text('scripts/release-parity.mjs'),text('scripts/final-closure.mjs'),
-    text('scripts/final-closure-verify.mjs'),text('scripts/windows-gate-evidence.mjs')
+test('sealed R36 historical proof scripts preserve 0.10.0 / R36 and exact R35 predecessor',async()=>{
+  const [gate,parity,closure,closureVerify,windowsGate,r37_0110Parity]=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-r37-0110.mjs')
   ]);
-  assert.equal(pkg.version,'0.10.0');
-  assert.match(version,/DEADBYTE_VERSION = '0\.10\.0'/);
-  assert.match(controller,/CONTROLLER V0\.10\.0 \/ R36/);
   assert.match(gate,/DEADBYTE V0\.10\.0 \/ R36 WINDOWS BATCH GATE: PASS/);
-  assert.match(readme,/^DEADBYTE MCP V0\.10\.0 \/ R36 PRODUCTION BASELINE$/m);
-  assert.match(architecture,/^# DEADBYTE MCP V0\.10\.0 \/ R36 ARCHITECTURE$/m);
-  assert.match(controllerReadme,/^DEADBYTE MCP V0\.10\.0 \/ R36 CONTROLLER$/m);
-  assert.match(deferred,/--expected-version','0\.10\.0'/);
   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(closure,/release_label:'R36 FINAL MACHINE BASELINE'/);
   assert.match(closureVerify,/DEADBYTE-R36-FINAL-CLOSURE-V1/);
-  assert.match(closureVerify,/version==='0\.10\.0'/);
-  assert.match(windowsGate,/schema:'deadbyte\.r36-windows-gate\.v1'/);
+  assert.match(windowsGate,/deadbyte\.r36-windows-gate\.v1/);
+  assert.match(r37_0110Parity,new RegExp(R36_RELEASE_ID.replaceAll('.','\\.')));
+  assert.match(r37_0110Parity,new RegExp(R36_MANIFEST));
 });
 
-test('R36 controller binds production remote to compact profile and restores parent environment',async()=>{
+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/);
@@ -43,7 +36,7 @@ test('R36 controller binds production remote to compact profile and restores par
   assert.match(controller,/\$env:DEADBYTE_CAPABILITY_PROFILE = \$previousCapabilityProfileEnv/);
 });
 
-test('R36 parity source defines exact full 76-tool authority plus compact gateway closure',async()=>{
+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/);

package/test/r37-0110-history.test.mjs

@@ -0,0 +1,20 @@
+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');
+
+test('sealed public 0.11.0 release scripts remain preserved as historical R37 authority',async()=>{
+  const [gate,evidence,parity,closure,verify,deferred]=await Promise.all([
+    text('scripts/gate-windows-r37-0110.ps1'),text('scripts/windows-gate-evidence-r37-0110.mjs'),
+    text('scripts/release-parity-r37-0110.mjs'),text('scripts/final-closure-r37-0110.mjs'),
+    text('scripts/final-closure-verify-r37-0110.mjs'),text('scripts/deferred-slot-operation-r37-0110.mjs')
+  ]);
+  assert.match(gate,/V0\.11\.0 \/ R37/);
+  assert.match(evidence,/version:'0\.11\.0'/);
+  assert.match(parity,/v0\.10\.0-8d1e5f09745e7647/);
+  assert.match(parity,/candidate\?\.version==='0\.11\.0'/);
+  assert.match(closure,/version:'0\.11\.0'/);
+  assert.match(verify,/value\?\.version==='0\.11\.0'/);
+  assert.match(deferred,/--expected-version','0\.11\.0'/);
+});

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, R37_PREDECESSOR_RELEASE_ID, R37_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.1-${manifest.slice(0,16)}`,version:'0.11.1',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:R37_PREDECESSOR_RELEASE_ID,version:'0.11.0',manifest_sha256:R37_PREDECESSOR_MANIFEST},
+    predecessor_disarmed:{status:'passed',tool_count:41,capability_closure:true},
+    successor:{release_id:`v0.11.1-${manifest.slice(0,16)}`,version:'0.11.1',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 public 0.11.0 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 public 0.11.0 predecessor, stage reseed and successor restore',async()=>{
+  const parity=await text('scripts/release-parity.mjs');
+  assert.match(parity,/R37_PREDECESSOR_RELEASE_ID='v0\.11\.0-08c2a0008b1f84c9'/);
+  assert.match(parity,/08c2a0008b1f84c90f7ce7faa1e3decbd03f33612bc0fdc7d1ba591b548798e8/);
+  assert.match(parity,/const stageRestore=await restoreFrozenStage/);
+  assert.match(parity,/publicR37Disarmed/);
+  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 public 0.11.0 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\.1'/);
+  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,/R37_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\.1'/);
+  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,/08c2a0008b1f84c90f7ce7faa1e3decbd03f33612bc0fdc7d1ba591b548798e8/);
+});
+
+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/);
+});