deadbyte-mcp 0.10.0 → 0.11.0

package/src/effect-ledger.mjs

@@ -0,0 +1,47 @@
+import { createHash } from 'node:crypto';
+import { canonicalJson } from './canonical-json.mjs';
+
+export const EFFECT_LEDGER_SCHEMA='deadbyte.effect-ledger.v1';
+const HEX64=/^[0-9a-f]{64}$/;
+const ID=/^[A-Za-z0-9._-]{1,128}$/;
+const sha=value=>createHash('sha256').update(Buffer.from(canonicalJson(value),'utf8')).digest('hex');
+
+function assertHex(name,value){if(!HEX64.test(value??'')) throw new Error(`${name} must be sha256`);}
+function assertId(name,value){if(!ID.test(value??'')) throw new Error(`${name} invalid`);}
+
+export function effectIdentity({goalId,planId,stepId,mutationEpoch,action,observationHeadSha256=null}){
+  assertHex('goalId',goalId);
+  assertHex('planId',planId);
+  assertId('stepId',stepId);
+  if(!Number.isInteger(mutationEpoch)||mutationEpoch<0) throw new Error('mutationEpoch invalid');
+  if(!action||typeof action!=='object'||Array.isArray(action)||typeof action.kind!=='string') throw new Error('action invalid');
+  if(observationHeadSha256!==null) assertHex('observationHeadSha256',observationHeadSha256);
+  const effectShape={schema:EFFECT_LEDGER_SCHEMA,kind:action.kind,mutation_epoch:mutationEpoch,
+    observation_head_sha256:observationHeadSha256,action};
+  const fingerprint=sha(effectShape);
+  const identity={schema:EFFECT_LEDGER_SCHEMA,goal_id:goalId,plan_id:planId,step_id:stepId,
+    mutation_epoch:mutationEpoch,fingerprint};
+  return Object.freeze({...identity,effect_id:sha(identity)});
+}
+
+export function loopGuardDisposition(events,candidate,{maxRepeats=3,window=24}={}){
+  if(!Array.isArray(events)) throw new Error('effect events must be array');
+  if(!candidate||!HEX64.test(candidate.fingerprint??'')) throw new Error('effect candidate invalid');
+  if(!Number.isInteger(maxRepeats)||maxRepeats<1) throw new Error('maxRepeats invalid');
+  if(!Number.isInteger(window)||window<1) throw new Error('window invalid');
+  const recent=events.slice(-window);
+  const started=recent.filter(event=>event?.type==='effect_started'&&event.payload?.fingerprint===candidate.fingerprint);
+  const terminal=new Set(recent.filter(event=>['effect_completed','effect_failed'].includes(event?.type)&&HEX64.test(event.payload?.effect_id??''))
+    .map(event=>event.payload.effect_id));
+  const repeated=started.filter(event=>terminal.has(event.payload?.effect_id)).length;
+  return Object.freeze({allowed:repeated<maxRepeats,reason:repeated<maxRepeats?'allowed':'effect_repeat_limit',
+    repeated_count:repeated,max_repeats:maxRepeats,fingerprint:candidate.fingerprint});
+}
+
+export function bindEffectCompletion(effect,outcome){
+  if(!effect||!HEX64.test(effect.effect_id??'')||!HEX64.test(effect.fingerprint??'')) throw new Error('effect identity invalid');
+  if(!outcome||typeof outcome!=='object'||Array.isArray(outcome)) throw new Error('effect outcome invalid');
+  const result_sha256=sha(outcome);
+  return Object.freeze({schema:'deadbyte.effect-completion.v1',effect_id:effect.effect_id,
+    fingerprint:effect.fingerprint,result_sha256});
+}

package/src/observation-lease.mjs

@@ -0,0 +1,32 @@
+import { createHash } from 'node:crypto';
+import { canonicalJson } from './canonical-json.mjs';
+
+export const OBSERVATION_LEASE_SCHEMA='deadbyte.observation-lease.v1';
+const HEX64=/^[0-9a-f]{64}$/;
+const sha=value=>createHash('sha256').update(Buffer.from(canonicalJson(value),'utf8')).digest('hex');
+
+export function issueObservationLease({goalId,mutationEpoch,observations,ttlMs=30000,nowMs=Date.now()}){
+  if(!HEX64.test(goalId??'')) throw new Error('goalId must be sha256');
+  if(!Number.isInteger(mutationEpoch)||mutationEpoch<0) throw new Error('mutationEpoch invalid');
+  if(!Array.isArray(observations)||observations.length<1) throw new Error('observations required');
+  if(!Number.isInteger(ttlMs)||ttlMs<100) throw new Error('ttlMs invalid');
+  if(!Number.isFinite(nowMs)||nowMs<0) throw new Error('nowMs invalid');
+  const latest=[...observations].reverse().find(item=>HEX64.test(item?.event_sha256??'')||HEX64.test(item?.receipt_sha256??'')||HEX64.test(item?.result_head_sha256??''));
+  if(!latest) throw new Error('observation identity unavailable');
+  const observation_head_sha256=HEX64.test(latest.result_head_sha256??'')?latest.result_head_sha256:
+    HEX64.test(latest.receipt_sha256??'')?latest.receipt_sha256:latest.event_sha256;
+  const body={schema:OBSERVATION_LEASE_SCHEMA,goal_id:goalId,mutation_epoch:mutationEpoch,observation_head_sha256,
+    issued_at_ms:nowMs,expires_at_ms:nowMs+ttlMs};
+  return Object.freeze({...body,lease_id:sha(body)});
+}
+
+export function verifyObservationLease(lease,{goalId,currentMutationEpoch,nowMs=Date.now(),observationHeadSha256=null}){
+  if(!lease||lease.schema!==OBSERVATION_LEASE_SCHEMA||!HEX64.test(lease.lease_id??'')) throw new Error('observation lease invalid');
+  const {lease_id,...body}=lease;
+  if(sha(body)!==lease_id) throw new Error('observation lease identity mismatch');
+  if(lease.goal_id!==goalId) throw new Error('observation lease goal mismatch');
+  if(lease.mutation_epoch!==currentMutationEpoch) throw new Error('observation lease stale mutation epoch');
+  if(nowMs>lease.expires_at_ms) throw new Error('observation lease expired');
+  if(observationHeadSha256!==null&&lease.observation_head_sha256!==observationHeadSha256) throw new Error('observation lease head mismatch');
+  return Object.freeze({ok:true,lease_id:lease.lease_id,observation_head_sha256:lease.observation_head_sha256,mutation_epoch:lease.mutation_epoch});
+}

package/src/remote-live-log.mjs

@@ -74,3 +74,62 @@ export function createLiveActivityTracker(){
     }
   });
 }
+
+
+function shortSpanId(requestId){
+  return typeof requestId==='string'&&requestId.length?requestId.slice(0,8):'????????';
+}
+
+export function createLiveTimelineTracker({clock=()=>Date.now()}={}){
+  if(typeof clock!=='function') throw new Error('live timeline clock must be a function');
+  const pending=new Map();
+  const completed=new Set();
+  return Object.freeze({
+    observe(event){
+      if(!event||typeof event!=='object'||Array.isArray(event)) return null;
+      const requestId=typeof event.request_id==='string'&&event.request_id?event.request_id:null;
+      const tool=typeof event.tool==='string'&&event.tool?event.tool:null;
+      if(event.event_type==='tool.request'&&requestId&&tool){
+        if(pending.has(requestId)||completed.has(requestId)) return null;
+        pending.set(requestId,{request_id:requestId,tool,started_at_ms:clock()});
+        return `▶ [${shortSpanId(requestId)}] RUN ${tool}${summarizeArgs(event.args)}`;
+      }
+      if(event.event_type==='tool.result'&&requestId&&tool){
+        if(completed.has(requestId)) return null;
+        const span=pending.get(requestId)??null;
+        pending.delete(requestId);completed.add(requestId);
+        const error=event.outcome?.is_error===true;
+        const duration=Number.isFinite(Number(event.outcome?.duration_ms))
+          ? formatDuration(event.outcome.duration_ms)
+          : span?formatDuration(Math.max(0,clock()-span.started_at_ms)):'';
+        const marker=span?(error?'✗':'✓'):'↩';
+        const status=error?'ERR':'OK ';
+        const suffix=span?'':' (request before live window)';
+        return `${marker} [${shortSpanId(requestId)}] ${status} ${tool}${duration?` ${duration}`:''}${suffix}`;
+      }
+      return null;
+    },
+    pending(){return [...pending.values()].map(({request_id,tool})=>({request_id,tool}));},
+    reconcileInterrupted(reason='session_end'){
+      const suffix=reason==='recovery'?'recovery ended before terminal result':
+        reason==='session_end'?'session ended before terminal result':'stream ended before terminal result';
+      const lines=[...pending.values()].map(item=>`⚠ [${shortSpanId(item.request_id)}] INTERRUPTED ${item.tool} — ${suffix}`);
+      pending.clear();
+      return lines;
+    }
+  });
+}
+
+
+export function formatRuntimeDiagnosticLine(file,line){
+  if(typeof file!=='string'||typeof line!=='string'||!line) return null;
+  const label=file.split(/[\\/]/).at(-1).replace(/\.log$/i,'').toUpperCase();
+  const input=line.match(/\[TOOL IN \]\s+\S+\s+#\d+\s+([A-Za-z0-9_.-]+)/);
+  if(input) return `[${label}] IN  ${input[1]}`;
+  const output=line.match(/\[TOOL OUT\]\s+\S+\s+#\d+\s+([A-Za-z0-9_.-]+)/);
+  if(output){
+    if(/"is_error"\s*:\s*true/.test(line)) return `[${label}] ERR ${output[1]}`;
+    return `[${label}] OUT ${output[1]}`;
+  }
+  return null;
+}

package/src/remote-mcp-autonomous-smoke-client.mjs

@@ -5,6 +5,7 @@ import { fileURLToPath } from 'node:url';
 import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
 import { R36_COMPACT_GATEWAYS, R36_COMPACT_TOOL_LIMIT } from './remote-mcp-r36-parity-client.mjs';
 import { promptContexts, promptObservations, promptMutationEpoch } from './autonomous-live-state.mjs';
+import { classifyAutonomousTimeoutRecovery } from './autonomous-timeout-recovery.mjs';
 
 const endpointText = process.argv[2];
 if (!endpointText) throw new Error('usage: node src/remote-mcp-autonomous-smoke-client.mjs https://host/mcp/path');
@@ -26,22 +27,21 @@ function structured(result, label) {
   if (!result.structuredContent || typeof result.structuredContent !== 'object') throw new Error(`${label} returned no structured object`);
   return result.structuredContent;
 }
-async function recoverTimedOutGoal(client, goalId) {
+async function recoverTimedOutGoal(client, goalId, beforeJournalHead) {
   for (let poll = 0; poll < AUTONOMOUS_TIMEOUT_RECOVERY_MAX_POLLS; poll += 1) {
     const status = structured(await client.callTool(
       { name:'autonomous_goal_status', arguments:{ goal_id:goalId } },
       { timeout:30000, maxTotalTimeout:30000 }
     ), 'autonomous_goal_status');
-    if (status.state === 'succeeded') return status;
-    if (status.state === 'cancelled' || status.state === 'paused') {
+    const disposition=classifyAutonomousTimeoutRecovery(status,{beforeJournalHead});
+    if (disposition.kind === 'completed') return { kind:'completed', status };
+    if (disposition.kind === 'terminal_failure') {
       throw new Error(`autonomous goal became terminal after request timeout: ${JSON.stringify(status)}`);
     }
-    if (status.state !== 'pending' && status.state !== 'running') {
-      throw new Error(`autonomous goal returned unexpected recovery state: ${JSON.stringify(status)}`);
-    }
+    if (disposition.kind === 'resumable') return { kind:'resumable', status };
     await sleep(AUTONOMOUS_TIMEOUT_RECOVERY_POLL_MS);
   }
-  throw new Error('autonomous goal did not reach a durable terminal state after request timeout');
+  throw new Error('autonomous goal did not reach a durable terminal or resumable boundary after request timeout');
 }
 function messageText(content) {
   if (typeof content === 'string') return content;
@@ -137,6 +137,10 @@ try {
   let ran = null;
   let recoveredRequestTimeout = false;
   for (let requestRound = 0; requestRound < AUTONOMOUS_RUN_MAX_REQUESTS; requestRound += 1) {
+    const beforeRun=structured(await client.callTool(
+      { name:'autonomous_goal_status', arguments:{ goal_id:goalId } },
+      { timeout:30000, maxTotalTimeout:30000 }
+    ), 'autonomous_goal_status');
     try {
       ran = structured(await client.callTool(
         { name:'autonomous_goal_run', arguments:{ goal_id:goalId, max_cycles:AUTONOMOUS_RUN_MAX_CYCLES_PER_REQUEST } },
@@ -144,8 +148,10 @@ try {
       ), 'autonomous_goal_run');
     } catch (error) {
       if (String(error?.code ?? '') !== 'REQUEST_TIMEOUT') throw error;
-      const recovered = await recoverTimedOutGoal(client, goalId);
-      ran = { status:'completed', state:recovered.state, goal_id:goalId, recovered_from_timeout:true };
+      const recovered = await recoverTimedOutGoal(client, goalId, beforeRun.journal_head_sha256);
+      ran = recovered.kind === 'completed'
+        ? { status:'completed', state:recovered.status.state, goal_id:goalId, recovered_from_timeout:true }
+        : { status:'yielded', state:recovered.status.state, goal_id:goalId, recovered_from_timeout:true };
       recoveredRequestTimeout = true;
     }
     if (ran.status === 'completed' && ran.state === 'succeeded') break;

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.10.0';
+export const DEADBYTE_VERSION = '0.11.0';
 export const MCP_PROTOCOL_VERSION = '2026-07-28';
 export const RECEIPT_SCHEMA_V1 = 'deadbyte.receipt.v1';
 export const RECEIPT_SCHEMA_V2 = 'deadbyte.receipt.v2';

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/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.0');
   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\.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\.10\.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\.10\.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/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.0');
     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.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,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\.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 () => {

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,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.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(currentParity,new RegExp(R36_RELEASE_ID.replaceAll('.','\\.')));
+  assert.match(currentParity,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-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/);
+});