deadbyte-mcp 0.15.37 → 0.15.38

package/src/remote-live-log.mjs

@@ -275,6 +275,8 @@ function toolFilterMatch(pattern,tool){
 export function createLiveTimelineFilter(expression=''){
   const spec=parseFilterExpression(expression);
   const pending=new Map();
+  const MAX_FILTER_IDENTITIES=4096;
+  let evicted=0;
   const baseMatch=meta=>(!spec.tool||toolFilterMatch(spec.tool,meta.tool))&&(!spec.category||spec.category===meta.category)&&(!spec.trace||spec.trace===meta.trace_id);
   return Object.freeze({
     accept(event){
@@ -284,6 +286,8 @@ export function createLiveTimelineFilter(expression=''){
       if(event.event_type==='tool.request'){
         const args=event.args??{};const tool=displayToolName(rawTool,args);const trace=traceIdentity(event,args);
         const meta={tool,category:categoryForTool(tool),trace_id:trace.trace_id};
+        if(pending.has(requestId))pending.delete(requestId);
+        if(pending.size>=MAX_FILTER_IDENTITIES){pending.delete(pending.keys().next().value);evicted++;}
         pending.set(requestId,meta);
         return spec.status?false:baseMatch(meta);
       }
@@ -294,7 +298,8 @@ export function createLiveTimelineFilter(expression=''){
       }
       return false;
     },
-    spec
+    spec,
+    retention(){return Object.freeze({pending:pending.size,evicted});}
   });
 }
 export function createLiveTimelineWriter({stream=process.stdout,displayMode='unicode',rewrite=true}={}){
@@ -330,10 +335,12 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,fo
   if(!Number.isInteger(slowCallMs)||slowCallMs<100||slowCallMs>600000) throw new Error('live timeline slowCallMs invalid');
   const pending=new Map();
   const completed=new Set();
+  const MAX_PRESENTATION_IDENTITIES=4096;
   const toolCounts=new Map();
   const durationSamples=[];
   let resultCount=0,okCount=0,errorCount=0,unknownCount=0,mutationCount=0,totalDurationMs=0,slowest=null,burst=null,foldedHeartbeatLines=0,peakInFlight=0;
   let lastCapability=null,suppressedCapability=0,suppressedCapabilityReported=false;
+  let lastSourceSequence=0,pendingOverflow=0;
 
   function eventPrefix(event,sequence,{displayTool=null,icon=null}={}){
     const seq=Number.isSafeInteger(sequence)&&sequence>0?'#'+sequence+'  ':'';
@@ -362,10 +369,12 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,fo
       error?(displayMode==='ascii'?'ERR':'✗'):
       ['write','edit','run'].includes(category)?(displayMode==='ascii'?'SUCCEEDED':'✅ SUCCEEDED'):
       (displayMode==='ascii'?'OK':'✓');
+    const rawStatus=safeAtom(event.outcome?.status);
+    const statusDetail=rawStatus&&!['ok','error'].includes(rawStatus)?'  status='+rawStatus:'';
     const prefixIcon=unknown?(displayMode==='ascii'?'WARN':'⚠️'):null;
     const evidence=receipt?'  '+(displayMode==='ascii'?'RECEIPT':'🧾 receipt')+(displayMode==='ascii'?'=':'=')+receipt:'';
     const reasonSep=displayMode==='ascii'?' - ':' — ';
-    return remoteDisplayText(eventPrefix(event,sequence,{displayTool,icon:prefixIcon})+traceSuffix(span?.trace_meta)+(summary?'  '+summary:'')+(duration?'  '+duration:'')+slow+'  '+marker+evidence+(reason?reasonSep+reason:''),displayMode);
+    return remoteDisplayText(eventPrefix(event,sequence,{displayTool,icon:prefixIcon})+traceSuffix(span?.trace_meta)+(summary?'  '+summary:'')+(duration?'  '+duration:'')+slow+'  '+marker+statusDetail+evidence+(reason?reasonSep+reason:''),displayMode);
   }
   function burstLine(value){
     if(!value) return null;
@@ -386,7 +395,8 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,fo
   function addStats(event,span){
     resultCount++;
     const displayTool=span?.display_tool||event.tool;
-    toolCounts.set(displayTool,(toolCounts.get(displayTool)??0)+1);
+    const countKey=toolCounts.has(displayTool)||toolCounts.size<256?displayTool:'[other]';
+    toolCounts.set(countKey,(toolCounts.get(countKey)??0)+1);
     const outcome=outcomeClass(event);
     if(outcome==='unknown') unknownCount++;else if(outcome==='error') errorCount++;else okCount++;
     if(['write','edit','run'].includes(categoryForTool(displayTool))) mutationCount++;
@@ -397,8 +407,12 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,fo
       if(!slowest||duration>slowest.duration_ms) slowest={tool:displayTool,duration_ms:duration};
     }
   }
-  function observe(event,{sequence=null}={}){
+  function observe(event,{sequence=null,sourceSequence=null}={}){
     if(!event||typeof event!=='object'||Array.isArray(event)) return null;
+    if(Number.isSafeInteger(sourceSequence)&&sourceSequence>0){
+      if(sourceSequence<=lastSourceSequence)return null;
+      lastSourceSequence=sourceSequence;
+    }
     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){
@@ -407,10 +421,17 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,fo
       const displayTool=displayToolName(tool,args);
       const summary=summarizeLiveToolArgs(displayTool,args,{rootPaths});
       const traceMeta=traceIdentity(event,args);
+      if(pending.size>=MAX_PRESENTATION_IDENTITIES){
+        pendingOverflow++;
+        return pendingOverflow===1?remoteDisplayText('LIVELOG pending span cap reached; full audit remains on disk',displayMode):null;
+      }
       pending.set(requestId,{request_id:requestId,tool,display_tool:displayTool,summary,trace_meta:traceMeta,started_at_ms:clock()});
       peakInFlight=Math.max(peakInFlight,pending.size);
       if(verbose) return formatRemoteToolCall({...event,tool:displayTool},{clock,displayMode})+traceSuffix(traceMeta);
-      if(visibleStart(displayTool)) return eventPrefix(event,sequence,{displayTool})+traceSuffix(traceMeta)+(summary?'  '+summary:'')+'  …';
+      if(visibleStart(displayTool)){
+        const startMarker=displayMode==='ascii'?'START':'▶ START';
+        return remoteDisplayText(eventPrefix(event,sequence,{displayTool})+traceSuffix(traceMeta)+'  '+startMarker+(summary?'  '+summary:''),displayMode);
+      }
       return null;
     }
     if(event.event_type==='tool.result'&&requestId&&tool){
@@ -418,6 +439,7 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,fo
       const span=pending.get(requestId)??null;
       pending.delete(requestId);
       completed.add(requestId);
+      if(completed.size>MAX_PRESENTATION_IDENTITIES)completed.delete(completed.values().next().value);
       addStats(event,span);
       const error=event.outcome?.is_error===true;
       const nowMs=eventMs(event,clock);
@@ -487,6 +509,7 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,fo
   }
   return Object.freeze({
     observe,
+    retention(){return Object.freeze({pending:pending.size,completed:completed.size,pending_overflow:pendingOverflow,last_source_sequence:lastSourceSequence});},
     pending(){return [...pending.values()].map(({request_id,tool})=>({request_id,tool}));},
     reconcileInterrupted,
     summary

package/src/runtime-update.mjs

@@ -394,6 +394,18 @@ export async function prepareBridgeSpec(config,bootstrap){
   return next;
 }
 
+export async function prepareReleaseBridgeSpec(config,bootstrap,releaseRoot){
+  if(!bootstrap) return structuredClone(config);
+  if(typeof releaseRoot!=='string'||!path.isAbsolute(releaseRoot))throw new Error('immutable release root required for Bridge binding');
+  // Verify the requested development input, then bind runtime paths only to
+  // the manifest-verified immutable slot produced from that same candidate.
+  const verifiedSource=await prepareBridgeSpec(config,bootstrap);
+  return prepareBridgeSpec(verifiedSource,{
+    root:path.join(path.resolve(releaseRoot),'bridge'),
+    scriptSha256:verifiedSource.Bridge.ScriptSha256
+  });
+}
+
 export async function prepareAutonomousSupervisorSpec(config,{releaseRoot,enable=false}={}){
   const next=structuredClone(config);
   if(!enable) return next;
@@ -1682,7 +1694,7 @@ export async function performSlotUpdate({stage,developmentRoot,expectedVersion,e
       if(!control.desktopPolicy) throw new Error('DesktopRuntimeEnabled requires pinned desktop policy bootstrap or existing policy');
       control.config.DesktopRuntimeEnabled=true;
     }
-    control.config=await prepareBridgeSpec(control.config,bridgeBootstrap);
+    control.config=await prepareReleaseBridgeSpec(control.config,bridgeBootstrap,slot.release_root);
     control.config=await prepareNamedTunnelCloudSpec(control.config,{releaseRoot:slot.release_root,bootstrap:cloudTransport});
     control.config=await prepareAutonomousSupervisorSpec(control.config,{releaseRoot:slot.release_root,enable:enableAutonomousSupervisor});
     authorityPreparation=await prepareAuthorityPolicies({hostPolicy:control.hostPolicy,codingPolicy:control.codingPolicy},{commandPins:hostCommandPins});

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.15.37';
+export const DEADBYTE_VERSION = '0.15.38';
 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/test/bridge-runtime-r59.test.mjs

@@ -12,21 +12,21 @@ const limits={
 
 test('R59 bridge governor removes cancelled queued work and drains without replay',async()=>{
   const governor=createBridgeGovernor({limits});
-  const first=await governor.acquire('machine_status');
+  const first=await governor.acquire('coding_file_read');
   const abort=new AbortController();
-  const queued=governor.acquire('machine_ping',{signal:abort.signal});
+  const queued=governor.acquire('coding_file_read',{signal:abort.signal});
   abort.abort(new Error('caller disconnected'));
   await assert.rejects(queued,/caller disconnected|aborted/);
   assert.equal(governor.snapshot().normal.queued,0);
   assert.equal(governor.snapshot().normal.cancelled,1);
-  const queuedDuringRecovery=governor.acquire('machine_ping');
+  const queuedDuringRecovery=governor.acquire('coding_file_read');
   assert.equal(governor.reconcile('core generation changed'),1);
   await assert.rejects(queuedDuringRecovery,/core generation changed/);
   first.release();
-  const after=await governor.acquire('machine_status');
+  const after=await governor.acquire('coding_file_read');
   after.release();
   const drain=governor.close('bridge reconciling');
-  await assert.rejects(governor.acquire('machine_status'),/closed/);
+  await assert.rejects(governor.acquire('coding_file_read'),/closed/);
   await drain;
   assert.equal(governor.snapshot().normal.active,0);
 });

package/test/commander-schema-differential-r48.test.mjs

@@ -5,7 +5,7 @@ import {readFile} from 'node:fs/promises';
 import {createCommanderWireAdapter} from '../src/commander-wire-adapter-r47.mjs';
 import {registerCommanderExtendedBridge} from '../src/commander-extended-bridge-r47.mjs';
 
-const referencePath='D:\\Projects\\desktop-commander-stage-20260922\\desktop-commander\\dist\\tools\\schemas.js';
+const referencePath='D:\\Projects\\deadbyte-mcp\\references\\desktop-commander\\dist\\tools\\schemas.js';
 const expectedHash='f342345e34e48769dabaefe1b932f09d41e2e207b422f7794a15ee50ffa8f140';
 async function referenceSchemas(){
   let source=await readFile(referencePath,'utf8');

package/test/r60-release-contract.test.mjs

@@ -4,6 +4,7 @@ import {readFile} from 'node:fs/promises';
 
 const read=rel=>readFile(new URL('../'+rel,import.meta.url),'utf8');
 const json=rel=>read(rel).then(raw=>JSON.parse(raw.replace(/^\uFEFF/,'')));
+const currentPackage=await json('package.json');
 
 const PARENT=Object.freeze({
   version:'0.15.36',
@@ -12,7 +13,7 @@ const PARENT=Object.freeze({
   generation_manifest_sha256:'6134f9f26b680e13ed545da4ab5f3020f411ea2569062fb9c154c8a7e036c9dc'
 });
 
-test('R60 identity is coherent and binds the exact production-accepted 0.15.36 predecessor',async()=>{
+test('R60 identity is coherent and binds the exact production-accepted 0.15.36 predecessor',{skip:currentPackage.version!=='0.15.37'},async()=>{
   const [pkg,lock,release,prov,matrix,sbom,version,bridgePkg,contract]=await Promise.all([
     json('package.json'),json('package-lock.json'),json('RELEASE.json'),json('PROVENANCE.json'),
     json('TEST-MATRIX.json'),json('SBOM.cdx.json'),read('src/version.mjs'),json('bridge/package.json'),
@@ -46,7 +47,7 @@ test('R60 identity is coherent and binds the exact production-accepted 0.15.36 p
   assert.match(contract,/0\.15\.37/);
 });
 
-test('R60 release contract exposes the proven remote truth semantics without widening dependencies',async()=>{
+test('R60 release contract exposes the proven remote truth semantics without widening dependencies',{skip:currentPackage.version!=='0.15.37'},async()=>{
   const [pkg,release,matrix]=await Promise.all([json('package.json'),json('RELEASE.json'),json('TEST-MATRIX.json')]);
   assert.equal(Object.keys(pkg.dependencies??{}).length,4);
   assert.equal(release.r60_remote_hardening.authority_truth_coherence,true);
@@ -69,7 +70,7 @@ test('R60 release contract exposes the proven remote truth semantics without wid
   assert.equal(matrix.observed_pre_release_evidence.r60_package.status,'PASS_VERIFY_ONLY_PRE_FINAL_SEAL');
 });
 
-test('R60 package scripts bind the new focused, full-regression and Windows-gate entrypoints',async()=>{
+test('R60 package scripts bind the new focused, full-regression and Windows-gate entrypoints',{skip:currentPackage.version!=='0.15.37'},async()=>{
   const [pkg,gate]=await Promise.all([json('package.json'),read('scripts/gate-windows-r60-prepublish.ps1')]);
   assert.match(pkg.scripts['r60:focused:test'],/r60-authority-coherence\.test\.mjs/);
   assert.match(pkg.scripts['r60:focused:test'],/r60-remote-call-recovery\.test\.mjs/);

package/test/r61-control-lane.test.mjs

@@ -0,0 +1,154 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createBridgeGovernor,bridgeToolClass} from '../bridge/src/r40-governor.mjs';
+
+test('control MCP execution is admitted while unrelated bulk work saturates',async()=>{
+  const governor=createBridgeGovernor();
+  const bulk=[];
+  let control=null;
+  try{
+    for(let i=0;i<8;i++)bulk.push(await governor.acquire('coding_search'));
+    const abort=new AbortController();
+    const pending=governor.acquire('machine_ping',{signal:abort.signal});
+    const observed=await Promise.race([
+      pending.then(ticket=>({kind:'admitted',ticket})),
+      new Promise(resolve=>setTimeout(()=>resolve({kind:'blocked'}),25))
+    ]);
+    if(observed.kind==='admitted')control=observed.ticket;
+    else abort.abort(new Error('control blocked behind bulk'));
+    assert.equal(observed.kind,'admitted','control plane must not queue behind bulk');
+    assert.equal(governor.snapshot().control.active,1);
+  }finally{
+    control?.release();
+    for(const ticket of bulk)ticket.release();
+    await governor.close();
+  }
+});
+
+test('compact routes use argument operation and never promote bulk to control',()=>{
+  assert.equal(bridgeToolClass('machine_observe',{op:'machine_status'}),'control');
+  assert.equal(bridgeToolClass('machine_observe',{op:'search_page'}),'bulk');
+  assert.equal(bridgeToolClass('process_session',{op:'read'}),'bulk');
+  assert.equal(bridgeToolClass('desktop_control',{op:'action'}),'desktop_action');
+  assert.equal(bridgeToolClass('coding_file_write',{root_id:'scratch'}),'normal');
+});
+
+test('control queue saturates, cancels and drains without admitting cancelled work',async()=>{
+  const governor=createBridgeGovernor({limits:{control:{max_active:1,max_queue:1,queue_timeout_ms:100}}});
+  const first=await governor.acquire('machine_ping');
+  const abort=new AbortController();
+  const queued=governor.acquire('machine_status',{signal:abort.signal});
+  await assert.rejects(governor.acquire('machine_ping'),/queue full/);
+  assert.equal(governor.snapshot().control.queued,1);
+  abort.abort(new Error('client cancelled'));
+  await assert.rejects(queued,/client cancelled/);
+  assert.equal(governor.snapshot().control.queued,0);
+  const timed=governor.acquire('machine_status');
+  await assert.rejects(timed,/queue timeout/);
+  assert.equal(governor.snapshot().control.timed_out,1);
+  first.release();
+  const after=await governor.acquire('machine_status');
+  after.release();
+  await governor.close();
+  assert.equal(governor.snapshot().control.active,0);
+});
+test('mixed normal and bulk lanes share one bounded downstream budget while control retains a reserved slot',async()=>{
+  const governor=createBridgeGovernor();
+  const work=[];
+  let control=null;
+  let queuedTicket=null;
+  try{
+    for(let i=0;i<4;i++)work.push(await governor.acquire('coding_search'));
+    for(let i=0;i<4;i++)work.push(await governor.acquire('coding_file_read'));
+
+    const saturated=governor.snapshot();
+    assert.equal(saturated.shared.active,8);
+    assert.equal(saturated.shared.non_control_active,8);
+    assert.equal(saturated.shared.max_active,9);
+    assert.equal(saturated.shared.max_non_control_active,8);
+
+    const pendingWork=governor.acquire('coding_file_read');
+    const observedWork=await Promise.race([
+      pendingWork.then(ticket=>({kind:'admitted',ticket})),
+      new Promise(resolve=>setTimeout(()=>resolve({kind:'blocked'}),25))
+    ]);
+    assert.equal(observedWork.kind,'blocked','ninth non-control call must respect shared budget');
+
+    control=await governor.acquire('machine_ping');
+    assert.equal(governor.snapshot().shared.active,9,'control uses reserved downstream slot');
+    assert.equal(governor.snapshot().control.active,1);
+    control.release();
+    control=null;
+
+    const released=work.shift();
+    released.release();
+
+    queuedTicket=await pendingWork;
+    assert.equal(governor.snapshot().shared.non_control_active,8);
+  }finally{
+    control?.release();
+    queuedTicket?.release();
+    for(const ticket of work)ticket.release();
+    await governor.close();
+  }
+
+  const final=governor.snapshot();
+  assert.equal(final.shared.active,0);
+  assert.equal(final.shared.non_control_active,0);
+});
+test('oldest admissible waiter is not starved by control backlog',async()=>{
+  const governor=createBridgeGovernor({
+    shared:{max_active:3,max_non_control_active:2}
+  });
+  const held=[];
+  const resolved=[];
+  const normalAbort=new AbortController();
+  const controlAbort=new AbortController();
+  let normalPending=null;
+  let controlPending=null;
+
+  try{
+    held.push(await governor.acquire('coding_search'));
+    held.push(await governor.acquire('coding_search'));
+    held.push(await governor.acquire('machine_ping'));
+
+    normalPending=governor.acquire(
+      'coding_file_read',
+      {signal:normalAbort.signal}
+    ).then(ticket=>{
+      resolved.push(ticket);
+      return ticket;
+    });
+
+    controlPending=governor.acquire(
+      'machine_status',
+      {signal:controlAbort.signal}
+    ).then(ticket=>{
+      resolved.push(ticket);
+      return ticket;
+    });
+
+    const releasedBulk=held.shift();
+    releasedBulk.release();
+
+    await new Promise(resolve=>setImmediate(resolve));
+
+    assert.equal(
+      governor.snapshot().normal.active,
+      1,
+      'older non-control waiter must win the newly available admissible slot'
+    );
+  }finally{
+    normalAbort.abort(new Error('test cleanup'));
+    controlAbort.abort(new Error('test cleanup'));
+
+    await Promise.allSettled(
+      [normalPending,controlPending].filter(Boolean)
+    );
+
+    for(const ticket of resolved)ticket.release();
+    for(const ticket of held)ticket.release();
+
+    await governor.close();
+  }
+});

package/test/r61-live-timeline-bounds.test.mjs

@@ -0,0 +1,31 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createLiveTimelineTracker,createLiveTimelineFilter} from '../src/remote-live-log.mjs';
+
+test('long LIVELOG session retains bounded presentation identities and suppresses old audit replay',()=>{
+  const tracker=createLiveTimelineTracker({clock:()=>1000});
+  let sourceSequence=0;
+  for(let i=0;i<12000;i++){
+    const id=`bounded-${i}`;
+    tracker.observe({event_type:'tool.request',tool:'machine_status',request_id:id,args:{}},
+      {sourceSequence:++sourceSequence});
+    tracker.observe({event_type:'tool.result',tool:'machine_status',request_id:id,
+      outcome:{is_error:false,duration_ms:1}},{sourceSequence:++sourceSequence});
+  }
+  const stats=tracker.retention();
+  assert.ok(stats.completed<=4096,JSON.stringify(stats));
+  assert.equal(stats.pending,0);
+  const replay=tracker.observe({event_type:'tool.result',tool:'machine_status',request_id:'bounded-0',
+    outcome:{is_error:false,duration_ms:1}},{sourceSequence:2});
+  assert.equal(replay,null,'old source sequence cannot reappear as a duplicate terminal line');
+  assert.match(tracker.summary(),/12000 calls \| 12000 ok/);
+});
+
+test('filtered long session retains bounded request presentation state',()=>{
+  const filter=createLiveTimelineFilter('status=error,trace=goal-r61');
+  for(let i=0;i<12000;i++)filter.accept({event_type:'tool.request',tool:'coding_file_write',request_id:`pending-${i}`,
+    args:{goal_id:'goal-r61',root_id:'scratch',path:'x.txt'}});
+  assert.ok(filter.retention().pending<=4096);
+  const latest=filter.accept({event_type:'tool.result',tool:'coding_file_write',request_id:'pending-11999',outcome:{is_error:true}});
+  assert.equal(latest,true);
+});

package/test/r61-npm-artifact-identity.test.mjs

@@ -0,0 +1,17 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {verifyPublishedTarballIdentity} from '../scripts/npm-artifact-identity-r61.mjs';
+
+const bytes=Buffer.from('deadbyte-r61-exact-tarball-fixture');
+const sha=(name,value)=>createHash(name).update(value).digest(name==='sha512'?'base64':'hex');
+const published={version:'0.15.38',dist:{integrity:'sha512-'+sha('sha512',bytes),shasum:sha('sha1',bytes),tarball:'https://registry.npmjs.org/deadbyte-mcp/-/deadbyte-mcp-0.15.38.tgz'}};
+
+test('R61 npm round trip requires exact registry bytes, metadata, version and latest tag',()=>{
+  const accepted=verifyPublishedTarballIdentity({version:'0.15.38',localBytes:bytes,registryBytes:Buffer.from(bytes),published,tags:{latest:'0.15.38'}});
+  assert.equal(accepted.tarball_sha256,sha('sha256',bytes));
+  assert.equal(accepted.npm_integrity,published.dist.integrity);
+  assert.throws(()=>verifyPublishedTarballIdentity({version:'0.15.38',localBytes:bytes,registryBytes:Buffer.from('different'),published,tags:{latest:'0.15.38'}}),/registry tarball bytes differ/);
+  assert.throws(()=>verifyPublishedTarballIdentity({version:'0.15.38',localBytes:bytes,registryBytes:bytes,published:{...published,dist:{...published.dist,integrity:'sha512-false'}},tags:{latest:'0.15.38'}}),/registry metadata/);
+  assert.throws(()=>verifyPublishedTarballIdentity({version:'0.15.38',localBytes:bytes,registryBytes:bytes,published,tags:{latest:'0.15.37'}}),/latest tag/);
+});

package/test/r61-release-bridge-binding.test.mjs

@@ -0,0 +1,32 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,mkdir,readFile,rm,writeFile} from 'node:fs/promises';
+import {createHash} from 'node:crypto';
+import path from 'node:path';
+import os from 'node:os';
+import {prepareReleaseBridgeSpec} from '../src/runtime-update.mjs';
+
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+test('R61 update binds Bridge script and local dependencies to immutable release slot',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'r61-bridge-slot-'));
+  const source=path.join(root,'source','bridge'),slot=path.join(root,'releases','v0.15.38-test'),releaseBridge=path.join(slot,'bridge');
+  const script='import "./dep.mjs";\n';
+  try{
+    for(const bridge of [source,releaseBridge]){
+      await mkdir(path.join(bridge,'src'),{recursive:true});
+      await writeFile(path.join(bridge,'package.json'),'{"name":"deadbyte-chatgpt-bridge","version":"0.15.38"}\n');
+      await writeFile(path.join(bridge,'src','bridge.mjs'),script);
+      await writeFile(path.join(bridge,'src','dep.mjs'),'export const bound=true;\n');
+    }
+    const config={Bridge:{FilePath:process.execPath,FileSha256:sha(await readFile(process.execPath)),
+      Arguments:'src\\bridge.mjs',WorkingDirectory:source},Cloud:{}};
+    const result=await prepareReleaseBridgeSpec(config,{root:source,scriptSha256:sha(script)},slot);
+    assert.equal(result.Bridge.WorkingDirectory,releaseBridge);
+    assert.equal(result.Bridge.ScriptPath,path.join(releaseBridge,'src','bridge.mjs'));
+    assert.ok(result.Bridge.Dependencies.length>=1);
+    for(const dependency of result.Bridge.Dependencies)assert.ok(dependency.Path.startsWith(path.join(releaseBridge,'src')+path.sep));
+    await writeFile(path.join(releaseBridge,'src','bridge.mjs'),'changed\n');
+    await assert.rejects(prepareReleaseBridgeSpec(config,{root:source,scriptSha256:sha(script)},slot),/bridge script SHA-256 mismatch/);
+  }finally{await rm(root,{recursive:true,force:true});}
+});

package/test/r61-release-contract.test.mjs

@@ -0,0 +1,44 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+
+const read=rel=>readFile(new URL('../'+rel,import.meta.url),'utf8');
+const json=rel=>read(rel).then(raw=>JSON.parse(raw.replace(/^\uFEFF/,'')));
+const PARENT={
+  release_id:'v0.15.37-1cfecd7889419da7',
+  manifest_sha256:'1cfecd7889419da7800814e3a2a4ffa93d48dfdb0c344a5b7b91fe8d093230aa',
+  generation_manifest_sha256:'54842021c75f01bf7ecbd5b10ab8a482ecf107765b45c46f9d39b12bab65eac4'
+};
+
+test('R61 identity binds exact sealed 0.15.37 predecessor without a public surface expansion',async()=>{
+  const [pkg,lock,bridge,release,provenance,matrix,sbom,version,gate]=await Promise.all([
+    json('package.json'),json('package-lock.json'),json('bridge/package.json'),json('RELEASE.json'),
+    json('PROVENANCE.json'),json('TEST-MATRIX.json'),json('SBOM.cdx.json'),read('src/version.mjs'),
+    read('scripts/gate-windows-r61-prepublish.ps1')
+  ]);
+  assert.equal(pkg.version,'0.15.38');
+  assert.equal(lock.version,pkg.version);
+  assert.equal(lock.packages[''].version,pkg.version);
+  assert.equal(bridge.version,pkg.version);
+  assert.match(version,/DEADBYTE_VERSION = '0\.15\.38'/);
+  assert.equal(release.version,pkg.version);
+  assert.equal(release.train,'R61');
+  assert.equal(release.parent.version,'0.15.37');
+  for(const [key,value] of Object.entries(PARENT)){
+    assert.equal(release.parent[key],value);
+    assert.equal(release.runtime_predecessor[key],value);
+    assert.equal(provenance.runtime_predecessor[key],value);
+  }
+  assert.equal(provenance.version,pkg.version);
+  assert.equal(matrix.version,pkg.version);
+  assert.equal(matrix.train,'R61');
+  assert.equal(sbom.metadata.component.version,pkg.version);
+  assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r61:0.15.38');
+  assert.equal(Object.keys(pkg.dependencies??{}).length,4);
+  assert.equal(release.r61_multi_workload.public_surface_tool_count,43);
+  assert.equal(release.r61_multi_workload.new_authority_scopes,0);
+  assert.equal(release.r61_multi_workload.bridge_bound_to_immutable_slot,true);
+  assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r61-prepublish.ps1');
+  assert.match(gate,/v0\.15\.37-1cfecd7889419da7/);
+  assert.doesNotMatch(gate,/v0\.15\.36-090d9db3e0679c0d/);
+});

package/test/remote-live-log-r37.test.mjs

@@ -22,7 +22,7 @@ test('R40 long or mutating call gets start line and terminal error carries sanit
   const tracker=createLiveTimelineTracker({clock:()=>now});
   const start=tracker.observe({event_type:'tool.request',tool:'coding_command_run',request_id:'request-23456789',
     ts:'1970-01-01T00:00:01.000Z',args:{root_id:'core',command_id:'node_script',script_path:'scripts/check.mjs'}},{sequence:20});
-  assert.match(start,/^🏃  07:00:01\.000  #20  \[request-\]  coding_command_run  core node_script scripts\/check\.mjs  …$/);
+  assert.match(start,/^🏃  07:00:01\.000  #20  \[request-\]  coding_command_run  ▶ START  core node_script scripts\/check\.mjs$/);
   now=1900;
   const done=tracker.observe({event_type:'tool.result',tool:'coding_command_run',request_id:'request-23456789',
     ts:'1970-01-01T00:00:01.900Z',outcome:{is_error:true,duration_ms:900,reason:'script exited 1: ENOENT scripts/missing.mjs'}},{sequence:21});
@@ -72,9 +72,9 @@ test('R40 CLI exposes explicit verbose mode while keeping default live mode comp
   const {readFile}=await import('node:fs/promises');
   const src=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
   assert.match(src,/readLiveRootPaths\(ctx\.root\)/);
-  assert.match(src,/createLiveTimelineTracker\(\{verbose,displayMode,rootPaths,trace\}\)/);
+  assert.match(src,/createLiveTimelineTracker\(\{verbose,displayMode,rootPaths,trace,foldHeartbeats:!verbose\}\)/);
   assert.match(src,/createLiveTimelineFilter\(filterExpression\)/);
-  assert.match(src,/createLiveTimelineWriter\(\{stream:process\.stdout,displayMode,rewrite:!verbose\}\)/);
+  assert.match(src,/createLiveTimelineWriter\(\{stream:process\.stdout,displayMode,rewrite:false\}\)/);
   assert.match(src,/arg==='--verbose'\|\|arg==='-v'/);
   assert.match(src,/arg==='--trace'/);
   assert.match(src,/arg==='--filter'/);
@@ -100,7 +100,7 @@ test('R40 interrupted side effect is explicit failed-after-unknown-effect instea
     args:{root_id:'core',path:'x.txt',content:'x'}},{sequence:70});
   const line=tracker.observe({event_type:'tool.result',tool:'coding_file_write',request_id:'unknown-12345678',
     outcome:{status:'interrupted',is_error:true,duration_ms:0,side_effect_state:'unknown',recovery:{reason:'runtime_restart'}}},{sequence:71});
-  assert.match(line,/FAILED_AFTER_UNKNOWN_EFFECT — runtime_restart$/);
+  assert.match(line,/FAILED_AFTER_UNKNOWN_EFFECT  status=interrupted — runtime_restart$/);
   assert.doesNotMatch(line,/\s[✓✗]\s/);
 });
 
@@ -124,7 +124,7 @@ test('visual opcode projection resolves multiplexed machine_fs operation and exp
   now=1007;
   const done=tracker.observe({event_type:'tool.result',tool:'machine_fs',request_id:'machinefs-12345678',
     ts:'1970-01-01T00:00:01.007Z',outcome:{status:'committed',is_error:false,duration_ms:7,receipt_sha256s:[receipt]}},{sequence:81});
-  assert.match(done,/^📝 .*machine_fs\.write .*7ms  ✅ SUCCEEDED  🧾 receipt=11111111…$/);
+  assert.match(done,/^📝 .*machine_fs\.write .*7ms  ✅ SUCCEEDED  status=committed  🧾 receipt=11111111…$/);
 });
 
 test('visual opcode projection reserves warning semantics for explicitly unknown side effects',()=>{
@@ -133,7 +133,7 @@ test('visual opcode projection reserves warning semantics for explicitly unknown
     args:{root_id:'core',command_id:'powershell_inline',mode:'inline'}},{sequence:90});
   const done=tracker.observe({event_type:'tool.result',tool:'host_exec',request_id:'unknown-host-1234',
     outcome:{status:'interrupted',is_error:true,duration_ms:4,side_effect_state:'unknown',recovery:{reason:'runtime_restart'}}},{sequence:91});
-  assert.match(done,/^⚠️ .*host_exec .*4ms  FAILED_AFTER_UNKNOWN_EFFECT — runtime_restart$/);
+  assert.match(done,/^⚠️ .*host_exec .*4ms  FAILED_AFTER_UNKNOWN_EFFECT  status=interrupted — runtime_restart$/);
   assert.doesNotMatch(done,/❌|🚫/);
 });
 
@@ -218,3 +218,20 @@ test('R51 live timeline marks slow calls and reports peak in-flight concurrency'
   tracker.observe({event_type:'tool.result',tool:'coding_file_read',request_id:'slow-b-12345678',outcome:{is_error:false,duration_ms:5}});
   assert.match(tracker.summary(),/peak in-flight 2/);
 });
+
+test('human mutation span labels START and preserves terminal audit status',()=>{
+  const tracker=createLiveTimelineTracker({clock:()=>1000});
+  const start=tracker.observe({event_type:'tool.request',tool:'coding_file_write',request_id:'detail-1234567890',
+    args:{root_id:'core',path:'x.txt',content:'x'}},{sequence:120});
+  assert.match(start,/coding_file_write  ▶ START  core:x\.txt \(1B\)$/);
+  const done=tracker.observe({event_type:'tool.result',tool:'coding_file_write',request_id:'detail-1234567890',
+    outcome:{status:'committed',is_error:false,duration_ms:3,receipt_sha256s:['a'.repeat(64)]}},{sequence:121});
+  assert.match(done,/coding_file_write .*3ms  ✅ SUCCEEDED  status=committed  🧾 receipt=aaaaaaaa…$/);
+});
+
+test('foreground human log keeps START and DONE separate and folds heartbeat noise',async()=>{
+  const {readFile}=await import('node:fs/promises');
+  const src=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
+  assert.match(src,/createLiveTimelineTracker\(\{verbose,displayMode,rootPaths,trace,foldHeartbeats:!verbose\}\)/);
+  assert.match(src,/createLiveTimelineWriter\(\{stream:process\.stdout,displayMode,rewrite:false\}\)/);
+});

package/test/remote-session-cli.test.mjs

@@ -148,7 +148,7 @@ for(const [flag,armedPlane,disarmedPlane] of [['--desktop','desktop','host'],['-
       child=spawn(process.execPath,[cliPath,'remote',flag],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
       const output=await collect(child);
       const deadline=Date.now()+8000;
-      while(Date.now()<deadline&&!new RegExp(`${armedPlane} ARMED`).test(output.stdout)) await sleep(50);
+      while(Date.now()<deadline&&!/\[READY\]/.test(output.stdout)) await sleep(50);
       assert.match(output.stdout,/\[READY\]/,output.stderr);
       assert.match(output.stdout,new RegExp(`${armedPlane} ARMED`));
       assert.match(output.stdout,new RegExp(`${disarmedPlane} DISARMED`));