deadbyte-mcp 0.15.37 → 0.15.38

package/bridge/src/r40-governor.mjs

@@ -4,24 +4,39 @@ const DESKTOP_RAW_KEYS=new Set([
   'pixels','pixel_bytes','frame_bytes','raw_bgra','raw_rgba','raw_image','screenshot_bytes','bitmap_bytes'
 ]);
 const DEFAULT_LIMITS=Object.freeze({
+  control:Object.freeze({max_active:8,max_queue:16,queue_timeout_ms:5000}),
   normal:Object.freeze({max_active:8,max_queue:32,queue_timeout_ms:30000}),
+  bulk:Object.freeze({max_active:8,max_queue:16,queue_timeout_ms:30000}),
   autonomous:Object.freeze({max_active:2,max_queue:8,queue_timeout_ms:60000}),
   desktop_observe:Object.freeze({max_active:2,max_queue:4,queue_timeout_ms:10000}),
   desktop_action:Object.freeze({max_active:1,max_queue:2,queue_timeout_ms:5000})
 });
+const DEFAULT_SHARED_LIMITS=Object.freeze({max_active:9,max_non_control_active:8});
 const DEADLINES=Object.freeze({
+  control:Object.freeze({timeout:10000,maxTotalTimeout:15000}),
   normal:Object.freeze({timeout:120000,maxTotalTimeout:180000}),
+  bulk:Object.freeze({timeout:120000,maxTotalTimeout:180000}),
   autonomous:Object.freeze({timeout:900000,maxTotalTimeout:1200000}),
   desktop_observe:Object.freeze({timeout:30000,maxTotalTimeout:60000}),
   desktop_action:Object.freeze({timeout:30000,maxTotalTimeout:45000})
 });
 
 function insist(condition,message){ if(!condition) throw new Error(message); }
-function toolClass(name){
+function toolClass(name,args={}){
   const value=String(name??'');
   if(value==='autonomous_goal_run') return 'autonomous';
-  if(value==='desktop_action') return 'desktop_action';
+  if(value==='desktop_action'||(value==='desktop_control'&&['action','target'].includes(args?.op))) return 'desktop_action';
   if(value.startsWith('desktop_')) return 'desktop_observe';
+  if(value==='desktop_control') return 'desktop_observe';
+  if(['machine_ping','machine_status','machine_revoke','machine_list','capability_manifest',
+    'autonomous_session_status','coding_session_status'].includes(value))return 'control';
+  if(value==='machine_observe'&&['machine_ping','machine_status','machine_list'].includes(args?.op))return 'control';
+  if(['coding_search','coding_command_run','coding_benchmark_run','coding_task_run',
+    'process_session_start','process_session_read','process_session_action',
+    'machine_search_start','machine_search_page'].includes(value))return 'bulk';
+  if(value==='coding_inspect'&&['search','symbol_references','symbol_implementations'].includes(args?.op))return 'bulk';
+  if(value==='process_session'&&['start','read','action'].includes(args?.op))return 'bulk';
+  if(value==='machine_observe'&&['search_start','search_page','process_list'].includes(args?.op))return 'bulk';
   return 'normal';
 }
 function estimateBase64Bytes(value){
@@ -57,8 +72,8 @@ function scanDesktopPayload(value,{maxPreviewBytes},path='result',seen=new Set()
   seen.delete(value);
 }
 
-export function bridgeToolClass(name){ return toolClass(name); }
-export function bridgeDeadlineForTool(name){ return DEADLINES[toolClass(name)]; }
+export function bridgeToolClass(name,args){ return toolClass(name,args); }
+export function bridgeDeadlineForTool(name,args){ return DEADLINES[toolClass(name,args)]; }
 export function bridgeCatalogSha256(toolNames){
   insist(Array.isArray(toolNames)&&toolNames.every(x=>typeof x==='string'),'bridge catalog names invalid');
   const sorted=[...new Set(toolNames)].sort();
@@ -95,8 +110,12 @@ export function enforceDesktopBridgeResult(toolName,result,{maxPreviewBytes=1024
   return result;
 }
 
-export function createBridgeGovernor({limits=DEFAULT_LIMITS}={}){
-  const classes=['normal','autonomous','desktop_observe','desktop_action'];
+export function createBridgeGovernor({limits:overrides={},shared:sharedOverrides={}}={}){
+  const limits={...DEFAULT_LIMITS,...overrides};
+  const shared={...DEFAULT_SHARED_LIMITS,...sharedOverrides};
+  insist(Number.isInteger(shared.max_active)&&shared.max_active>=2&&shared.max_active<=64,'bridge shared max_active invalid');
+  insist(Number.isInteger(shared.max_non_control_active)&&shared.max_non_control_active>=1&&shared.max_non_control_active<shared.max_active,'bridge shared max_non_control_active invalid');
+  const classes=['control','normal','bulk','autonomous','desktop_observe','desktop_action'];
   for(const name of classes){
     const cfg=limits[name];
     insist(cfg&&Number.isInteger(cfg.max_active)&&cfg.max_active>=1&&cfg.max_active<=64,`bridge limit ${name}.max_active invalid`);
@@ -104,6 +123,7 @@ export function createBridgeGovernor({limits=DEFAULT_LIMITS}={}){
     insist(Number.isInteger(cfg.queue_timeout_ms)&&cfg.queue_timeout_ms>=100&&cfg.queue_timeout_ms<=120000,`bridge limit ${name}.queue_timeout_ms invalid`);
   }
   const state=new Map(classes.map(name=>[name,{active:0,queue:[],admitted:0,completed:0,rejected:0,timed_out:0,cancelled:0}]));
+  let sharedActive=0,sharedNonControlActive=0;
   let sequence=0;
   let closed=false;
   const drainWaiters=[];
@@ -113,13 +133,75 @@ export function createBridgeGovernor({limits=DEFAULT_LIMITS}={}){
     while(drainWaiters.length) drainWaiters.shift()();
   }
 
-  function dispatch(name){
+  function canAdmit(name){
     const cfg=limits[name],s=state.get(name);
-    while(s.active<cfg.max_active&&s.queue.length){
+    if(s.active>=cfg.max_active)return false;
+    if(sharedActive>=shared.max_active)return false;
+    if(name!=='control'&&sharedNonControlActive>=shared.max_non_control_active)return false;
+    return true;
+  }
+
+  function noteAdmit(name){
+    sharedActive++;
+    if(name!=='control')sharedNonControlActive++;
+  }
+
+  function noteRelease(name){
+    sharedActive=Math.max(0,sharedActive-1);
+    if(name!=='control')sharedNonControlActive=Math.max(0,sharedNonControlActive-1);
+  }
+
+  function dispatchOne(name){
+    const s=state.get(name);
+    if(!canAdmit(name))return false;
+
+    while(s.queue.length){
       const waiter=s.queue.shift();
-      if(waiter.done) continue;
-      waiter.done=true; clearTimeout(waiter.timer); waiter.cleanup(); s.active++; s.admitted++;
-      waiter.resolve(makeTicket(name,waiter.tool,waiter.id,waiter.queuedAt));
+      if(waiter.done)continue;
+
+      waiter.done=true;
+      clearTimeout(waiter.timer);
+      waiter.cleanup();
+
+      s.active++;
+      noteAdmit(name);
+      s.admitted++;
+
+      waiter.resolve(
+        makeTicket(name,waiter.tool,waiter.id,waiter.queuedAt)
+      );
+
+      return true;
+    }
+
+    return false;
+  }
+
+  function oldestAdmissibleQueuedClass(){
+    let selected=null;
+
+    for(const name of classes){
+      if(!canAdmit(name))continue;
+
+      const s=state.get(name);
+      const waiter=s.queue.find(item=>!item.done);
+
+      if(!waiter)continue;
+
+      if(selected===null||waiter.id<selected.id){
+        selected={name,id:waiter.id};
+      }
+    }
+
+    return selected?.name??null;
+  }
+
+  function dispatchAvailable(){
+    while(true){
+      const name=oldestAdmissibleQueuedClass();
+
+      if(name===null)break;
+      if(!dispatchOne(name))break;
     }
   }
   function makeTicket(name,tool,id,queuedAt){
@@ -130,19 +212,19 @@ export function createBridgeGovernor({limits=DEFAULT_LIMITS}={}){
         if(released) return false;
         released=true;
         const s=state.get(name);
-        s.active=Math.max(0,s.active-1);s.completed++;
-        dispatch(name);
+        s.active=Math.max(0,s.active-1);noteRelease(name);s.completed++;
+        dispatchAvailable();
         finishDrain();
         return true;
       }
     });
   }
-  async function acquire(tool,{signal}={}){
-    const name=toolClass(tool),cfg=limits[name],s=state.get(name),id=++sequence,queuedAt=Date.now();
+  async function acquire(tool,{signal,arguments:args}={}){
+    const name=toolClass(tool,args),cfg=limits[name],s=state.get(name),id=++sequence,queuedAt=Date.now();
     if(closed){s.rejected++;throw new Error('bridge governor closed');}
     if(signal?.aborted){s.cancelled++;throw signal.reason instanceof Error?signal.reason:new Error('bridge request aborted');}
-    if(s.active<cfg.max_active){
-      s.active++;s.admitted++;
+    if(canAdmit(name)){
+      s.active++;noteAdmit(name);s.admitted++;
       return makeTicket(name,String(tool),id,queuedAt);
     }
     if(s.queue.length>=cfg.max_queue){s.rejected++;throw new Error(`bridge backpressure queue full for ${name}`);}
@@ -193,14 +275,22 @@ export function createBridgeGovernor({limits=DEFAULT_LIMITS}={}){
     return removed;
   }
   function snapshot(){
-    return Object.freeze(Object.fromEntries(classes.map(name=>{
+    const lanes=Object.fromEntries(classes.map(name=>{
       const s=state.get(name),cfg=limits[name];
       return [name,Object.freeze({active:s.active,queued:s.queue.filter(x=>!x.done).length,max_active:cfg.max_active,max_queue:cfg.max_queue,
         admitted:s.admitted,completed:s.completed,rejected:s.rejected,timed_out:s.timed_out,cancelled:s.cancelled,saturated:s.active>=cfg.max_active})];
-    })));
+    }));
+    return Object.freeze({...lanes,shared:Object.freeze({
+      active:sharedActive,
+      non_control_active:sharedNonControlActive,
+      max_active:shared.max_active,
+      max_non_control_active:shared.max_non_control_active,
+      saturated:sharedActive>=shared.max_active
+    })});
   }
   return Object.freeze({acquire,reconcile,close,snapshot});
 }
 
 export const BRIDGE_R40_DEFAULT_LIMITS=DEFAULT_LIMITS;
+export const BRIDGE_R61_SHARED_LIMITS=DEFAULT_SHARED_LIMITS;
 

package/controller/deadbyte-process-policy.json

@@ -1,15 +1,15 @@
 {
   "schema": "deadbyte.process-policy.v1",
   "enabled": true,
-  "grant_file": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.37-r60\\controller\\runtime\\process-grant.json",
-  "state_dir": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.37-r60\\controller\\runtime\\process-state",
+  "grant_file": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.38-r61\\controller\\runtime\\process-grant.json",
+  "state_dir": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.38-r61\\controller\\runtime\\process-state",
   "native_host": {
-    "path": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.37-r60\\bin\\deadbyte-process-host.exe",
+    "path": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.38-r61\\bin\\deadbyte-process-host.exe",
     "sha256": "daf9cfb371bee88cafbf5597eaa507fec504dbe0b0ddd40d0c3c2e02817f49e4"
   },
   "roots": {
     "core": {
-      "path": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.37-r60",
+      "path": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.38-r61",
       "deny_paths": [
         "node_modules",
         "controller/runtime",

package/docs/R61-TASK-CONTRACT.md

@@ -0,0 +1,11 @@
+# R61 LIVELOG and multi-workload resilience
+
+- Source: a byte-verified copy of the non-Git R60 development tree at `D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.38-r61`, retaining its three intentional LIVELOG edits. The old R60 path remains a compatibility dependency of the live 0.15.37 generation and is not an R61 edit target.
+- Sealed predecessor: `v0.15.37-1cfecd7889419da7`; release manifest `1cfecd7889419da7800814e3a2a4ffa93d48dfdb0c344a5b7b91fe8d093230aa`; generation manifest `54842021c75f01bf7ecbd5b10ab8a482ecf107765b45c46f9d39b12bab65eac4`.
+- Target: `deadbyte-mcp@0.15.38`, R61, unchanged 43-tool compact catalog and zero new authority scopes.
+- Mechanism decisions and license observations: [r61-reference-evidence.md](r61-reference-evidence.md). No donor source was copied.
+- RED: eight admitted `coding_search` jobs blocked `machine_ping` at the governor boundary; 12,000 filtered LIVELOG requests grew an unbounded identity map; a historical schema differential test referenced a moved external source despite byte-identical canonical reference content; the active 0.15.37 generation pinned Bridge source/dependency hashes to the mutable R60 development path, so the first R61 edits caused read-only controller status/doctor to fail.
+- Fix: existing Bridge governor now separates bounded control/ordinary/bulk admission; LIVELOG presentation and filter identities are bounded and audit-sequence-aware; the historical schema test reads the canonical reference corpus and retains the exact pinned SHA-256 check. The R61 updater verifies the development Bridge input but binds the generated runtime config to the manifest-verified immutable release slot. The two trusted R60 Bridge files were restored byte-for-byte from the sealed 0.15.37 slot after R61 was copied to its own path; live status returned ONLINE without restart, revoke, or slot mutation.
+- Performance evidence: `D:\Projects\deadbyte-mcp\testing\0.15.38\r61-ab-nine-rounds.json` (SHA-256 `3f10010654f08b4347c8e22e0f7ec3c521a69872878934770a0d2c0fd5b16ef7`) and 15-round 1/8 follow-up `r61-ab-single-and-eight.json` (SHA-256 `b16143ff7cb8aeced0e685352ffebeeeb74116d648d5b3509af2c66bd1f3b8a0a`). At 32-way mixed governor load, median throughput changed 790.1 → 903.75 ops/s, control p95 31.54 → 21.82 ms, and maximum observed queue depth 23 → 14. All 108 full-matrix runs had zero errors and unknown outcomes. At 1-way follow-up, throughput 244.78 → 246.82 ops/s and total p95 46.03 → 45.93 ms. This is a direct-governor/scratch-I/O benchmark, **not** full MCP transport, signed audit, or production-load proof.
+- R61 focused gate after identity change: 47/47 PASS, 0 skip. Isolated Bridge/Core cold start, public MCP status, Core recovery and stop: PASS in one run; not a multi-workload transport benchmark.
+- Final full regression, Windows gate, release manifest/doctor, package boundary after final bytes, registry, activation, rollback and restore remain separate required gates. This document is not a release PASS claim.

package/docs/r61-reference-evidence.md

@@ -0,0 +1,18 @@
+# R61 reference-mechanism decisions
+
+This is a source-inspection record, not authority to copy donor code. R61 uses
+patterns reimplemented inside existing DEADBYTE components. No donor source
+bytes or dependencies are imported.
+
+| Reference | Inspected source | Mechanism and comparison with DEADBYTE | License/decision |
+| --- | --- | --- | --- |
+| Better Remote Commander | `references/better-remote-commander/packages/relay/src/device-hub.ts`, `mcp/invoke.ts`, `NOTICE` | Replaces stale sockets, correlates call/result and uses a pong watchdog. DEADBYTE already has a single guarded Bridge dispatch and bounded reconnect; test half-open detection and shared recovery, but do not add a fleet or new relay. | Root package declares MIT; NOTICE identifies derived Desktop Commander code. ADAPT watchdog tests only; KEEP current dispatch. |
+| CUA | `references/cua/rfcs/3007-cua-driver-lifecycle-sessions.md`, `3682-typed-native-window-sdk.md`, `libs/cua-driver/rust/crates/cua-driver-core/tests/session_lifecycle.rs` | Accepted lifecycle sessions separate cleanup from authority; typed window actions distinguish snapshot target and post-action verification. DEADBYTE already has native Desktop and stale-frame controls. Add adversarial lifecycle/fresh-observation tests only if missing. RFC 2447 is superseded and not an architecture guide. | Top-level Python metadata declares MIT; component licenses must be checked before any copying. KEEP native/adapter split; ADAPT tests. |
+| Desktop Commander | `references/desktop-commander/dist/utils/toolHistory.js`, process handlers | History caps entries, stored output bytes and file size. DEADBYTE already bounds process retained output via policy, repairs PATHEXT, supports offset reads, cancellation and bounded operation history. LIVELOG completed identity set is unbounded presentation state. | Package declares MIT. ADAPT LIVELOG retention; KEEP process runtime. |
+| Open Remote MCP | `references/open-remote-mcp/docs/ARCHITECTURE.md`, `apps/agent/src/index.ts`, `NOTICE.md` | Relay policy narrows, never widens local device capability. DEADBYTE signed ledger and separate local planes are stronger; add a focused relay/local enforcement test, not a second permission system. | Root package has no license field in inspected metadata; no source copying. KEEP local authority; ADAPT test. |
+| ReMCP | `references/remcp/docs/TOOL_SELECTION_EVAL.md`, `scripts/check-distribution.mjs`, `docs/DISTRIBUTION.md` | Golden positive/negative tool-selection cases and cross-distribution identity checks. DEADBYTE already has exact catalog, release manifest and npm closure; add a small golden routing test without a new runtime dependency. | Package declares MIT. ADAPT evaluation; KEEP release machinery. |
+| Secure Host MCP | `references/secure-host-mcp/src/workspace.ts`, `src/executor.ts`, `test/workspace.test.ts` | Rejects broad workspace roots, resolves symlink parents and bounds executor time. DEADBYTE already has explicit roots, policy-pinned profiles and native containment. Probe equivalent boundary cases; do not expose generic shell or change root policy without RED evidence. | Package declares MIT. KEEP architecture; ADAPT adversarial cases if missing. |
+| WinRemote MCP | `references/winremote-mcp/src/winremote/security.py`, `tiers.py`, `tests/test_security_hardening.py` | Capability tiers and URL/OAuth hardening. DEADBYTE authority planes are narrower and independently revocable; OCR/tier expansion would add scope. Compare URL and Windows privilege boundary tests where current interfaces overlap. | Python metadata declares MIT. KEEP planes; REJECT OCR and tier expansion. |
+
+Acceptance remains based on DEADBYTE's observed behavior, not donor popularity.
+Any newly found donor gap requires a focused RED and a narrow local fix.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deadbyte-mcp",
-  "version": "0.15.37",
+  "version": "0.15.38",
   "private": false,
   "type": "module",
   "description": "Authenticated MCP agentic runtime with signed skills, persistent model backends, identity-bound remote devices, durable job supervision, immutable release slots, and separately revocable machine authority.",
@@ -42,7 +42,7 @@
     "contained:run": "node src/contained-cli.mjs workspaces/demo input.txt",
     "contained:smoke": "node src/contained-smoke.mjs",
     "mcp:contained:smoke": "node src/mcp-contained-smoke-client.mjs",
-    "gate:windows": "powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r60-prepublish.ps1",
+    "gate:windows": "powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r61-prepublish.ps1",
     "authority:smoke": "node src/authority-smoke.mjs",
     "mcp:remote:smoke": "node src/remote-mcp-smoke-client.mjs",
     "mcp:host:smoke": "node src/mcp-host-smoke-client.mjs",
@@ -85,7 +85,8 @@
     "r59:focused:test": "node --test --test-concurrency=1 test/capability-snapshot-r59.test.mjs test/capability-resolver.test.mjs test/runtime-plane-registry-r59.test.mjs test/optional-plane-degraded-r59.test.mjs test/bridge-runtime-r59.test.mjs test/controller-policy-preflight-r59.test.mjs test/r59-tool-surface-compat.test.mjs test/r58-controller-state-coherence.test.mjs",
     "r59:release:test": "node --test --test-concurrency=1 test/r59-release-contract.test.mjs test/r59-tool-surface-compat.test.mjs test/bridge-runtime-r59.test.mjs test/controller-policy-preflight-r59.test.mjs",
     "r60:focused:test": "node --test --test-concurrency=1 test/r60-authority-coherence.test.mjs test/r60-authority-enforcement.test.mjs test/r60-bridge-dispatch.test.mjs test/r60-clock-discipline.test.mjs test/r60-live-timeline.test.mjs test/r60-reconnect-errors.test.mjs test/r60-reconnect-jitter.test.mjs test/r60-remote-call-recovery.test.mjs test/r60-windows-log-decode.test.mjs test/r60-release-contract.test.mjs",
-    "r60:full:test": "node scripts/full-regression-r60.mjs"
+    "r60:full:test": "node scripts/full-regression-r60.mjs",
+    "r61:focused:test": "node --test --test-concurrency=1 test/r61-release-contract.test.mjs test/r61-release-bridge-binding.test.mjs test/r61-control-lane.test.mjs test/r61-live-timeline-bounds.test.mjs test/r61-npm-artifact-identity.test.mjs test/remote-live-log-r37.test.mjs test/bridge-runtime-r59.test.mjs test/commander-schema-differential-r48.test.mjs test/package-boundary.test.mjs test/r60-bridge-dispatch.test.mjs test/r60-authority-enforcement.test.mjs"
   },
   "bundleDependencies": [
     "@modelcontextprotocol/server",

package/scripts/gate-windows-r61-prepublish.ps1

@@ -0,0 +1,45 @@
+param(
+  [ValidateSet('all','preflight','focused','full','manifest','doctor')]
+  [string]$Stage='all'
+)
+
+$ErrorActionPreference='Stop'
+Set-StrictMode -Version 3.0
+$root=Split-Path $PSScriptRoot -Parent
+Set-Location -LiteralPath $root
+
+function Invoke-Npm([string]$Name,[string[]]$NpmArgs){
+  Write-Host "==== $Name ===="
+  & npm.cmd @NpmArgs
+  if($LASTEXITCODE -ne 0){ throw "R61 prepublish gate failed at $Name exit=$LASTEXITCODE" }
+}
+
+$stateRoot=if(-not [string]::IsNullOrWhiteSpace($env:DEADBYTE_STATE_ROOT)){
+  [IO.Path]::GetFullPath($env:DEADBYTE_STATE_ROOT)
+}else{ Join-Path $env:USERPROFILE '.deadbyte-mcp' }
+$pointer=Join-Path $stateRoot 'active-release.json'
+if(-not (Test-Path -LiteralPath $pointer -PathType Leaf)){ throw "R61 predecessor pointer missing: $pointer" }
+$active=Get-Content -LiteralPath $pointer -Raw | ConvertFrom-Json
+if($active.release_id -ne 'v0.15.37-1cfecd7889419da7'){ throw "R61 predecessor release mismatch: $($active.release_id)" }
+if($active.manifest_sha256 -ne '1cfecd7889419da7800814e3a2a4ffa93d48dfdb0c344a5b7b91fe8d093230aa'){ throw 'R61 predecessor manifest mismatch' }
+if($active.generation_manifest_sha256 -ne '54842021c75f01bf7ecbd5b10ab8a482ecf107765b45c46f9d39b12bab65eac4'){ throw 'R61 predecessor generation mismatch' }
+if($Stage -eq 'preflight'){Write-Host '==== R61 WINDOWS GATE: PASS preflight ====';return}
+
+if($Stage -eq 'all' -or $Stage -eq 'focused'){
+  Invoke-Npm 'r61-focused' @('run','r61:focused:test')
+  if($Stage -eq 'focused'){Write-Host '==== R61 WINDOWS GATE: PASS focused ====';return}
+}
+if($Stage -eq 'all' -or $Stage -eq 'full'){
+  Invoke-Npm 'full-regression' @('test')
+  if($Stage -eq 'full'){Write-Host '==== R61 WINDOWS GATE: PASS full ====';return}
+}
+if($Stage -eq 'all' -or $Stage -eq 'manifest'){
+  Invoke-Npm 'manifest-write' @('run','manifest:write')
+  Invoke-Npm 'manifest-verify' @('run','manifest:verify')
+  if($Stage -eq 'manifest'){Write-Host '==== R61 WINDOWS GATE: PASS manifest ====';return}
+}
+if($Stage -eq 'all' -or $Stage -eq 'doctor'){
+  Invoke-Npm 'doctor' @('run','doctor')
+  if($Stage -eq 'doctor'){Write-Host '==== R61 WINDOWS GATE: PASS doctor ====';return}
+}
+Write-Host '==== R61 PREPUBLISH WINDOWS GATE: PASS ===='

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

@@ -0,0 +1,22 @@
+import {createHash} from 'node:crypto';
+
+const digest=(name,bytes,encoding='hex')=>createHash(name).update(bytes).digest(encoding);
+
+export function verifyPublishedTarballIdentity({version,localBytes,registryBytes,published,tags}){
+  if(typeof version!=='string'||!/^\d+\.\d+\.\d+$/.test(version)||!Buffer.isBuffer(localBytes)||!Buffer.isBuffer(registryBytes)){
+    throw new Error('npm artifact identity inputs invalid');
+  }
+  const tarballSha256=digest('sha256',localBytes);
+  const integrity='sha512-'+digest('sha512',localBytes,'base64');
+  const shasum=digest('sha1',localBytes);
+  const dist=published?.dist??published;
+  if(published?.version!==version||dist?.integrity!==integrity||dist?.shasum!==shasum||
+     dist?.tarball!==`https://registry.npmjs.org/deadbyte-mcp/-/deadbyte-mcp-${version}.tgz`){
+    throw new Error('published registry metadata does not match the exact local tarball');
+  }
+  if(tags?.latest!==version)throw new Error(`npm latest tag mismatch: expected ${version}, got ${tags?.latest??'<missing>'}`);
+  if(digest('sha256',registryBytes)!==tarballSha256||'sha512-'+digest('sha512',registryBytes,'base64')!==integrity){
+    throw new Error('registry tarball bytes differ from the exact published local artifact');
+  }
+  return Object.freeze({tarball_sha256:tarballSha256,npm_integrity:integrity,shasum});
+}

package/scripts/npm-release-r48.mjs

@@ -1,4 +1,5 @@
 import { spawnSync } from 'node:child_process';
+import { verifyPublishedTarballIdentity } from './npm-artifact-identity-r61.mjs';
 import { mkdtemp, readFile, rm, unlink } from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
@@ -58,6 +59,8 @@ const allowedUnmanifested = new Set([
 
 async function main() {
   const isVerifyOnly = process.argv.includes('--verify-only') || process.argv.includes('--dry-run');
+  const publishOnly = process.argv.includes('--publish-only');
+  if (isVerifyOnly && publishOnly) throw new Error('--publish-only conflicts with verify-only mode');
 
   console.log(`[1/7] Reading package.json and checking registry publication status... ${isVerifyOnly ? '(MODE: VERIFY-ONLY / DRY-RUN)' : '(MODE: PUBLISH)'}`);
   const pkg = JSON.parse(await readFile(path.join(root, 'package.json'), 'utf8'));
@@ -180,6 +183,8 @@ async function main() {
       return;
     }
 
+    const localBytes = await readFile(tarball);
+
     console.log('[6/7] Publishing artifact to npm registry...');
     publishAttempted = true;
     let publishOut;
@@ -193,8 +198,15 @@ async function main() {
       }
       throw publishError;
     }
-    const published = parseJson(runNpm(['view', `deadbyte-mcp@${version}`, 'version', 'dist.integrity', 'dist.tarball', '--json'], { timeout: 120000 }));
+    const viewed = parseJson(runNpm(['view', `deadbyte-mcp@${version}`, 'version', 'dist.integrity', 'dist.shasum', 'dist.tarball', '--json'], { timeout: 120000 }));
+    const published = Array.isArray(viewed) ? viewed[0] : viewed;
+    const dist = published?.dist ?? published;
+    if(typeof dist?.tarball !== 'string')throw new Error('published registry tarball URL missing');
+    const registryResponse = await fetch(dist.tarball,{signal:AbortSignal.timeout(120000)});
+    if(!registryResponse.ok) throw new Error(`registry tarball fetch failed status=${registryResponse.status}`);
+    const registryBytes = Buffer.from(await registryResponse.arrayBuffer());
     const tags = parseJson(runNpm(['view', 'deadbyte-mcp', 'dist-tags', '--json'], { timeout: 120000 }));
+    const identity=verifyPublishedTarballIdentity({version,localBytes,registryBytes,published,tags});
 
     console.log('[7/7] Post-publish external registry smoke test (executed outside repo in temp)...');
     const tempDir = os.tmpdir();
@@ -211,16 +223,20 @@ async function main() {
       timeout: 300000,
     });
 
-    console.log('[8/8] Activating the published release into the live immutable slot and waiting for verified handoff...');
-    run(node, [path.join(root, 'scripts', 'deploy-r48.mjs')], { cwd: root, timeout: 900000 });
+    if(!publishOnly){
+      console.log('[8/8] Activating the published release into the live immutable slot and waiting for verified handoff...');
+      run(node, [path.join(root, 'scripts', 'deploy-r48.mjs')], { cwd: root, timeout: 900000 });
+    }else console.log('[8/8] Publication verified; activation deliberately deferred to the separate production gate.');
 
     releaseSucceeded = true;
     console.log('\nRELEASE SUCCESSFUL:');
     console.log(JSON.stringify({
-      status: 'published',
+      status: publishOnly?'published_verified_activation_pending':'published',
       name: pkg.name,
       version,
       tarball: filename,
+      tarball_sha256: identity.tarball_sha256,
+      npm_integrity: identity.npm_integrity,
       published,
       published_output_tail: publishOut.slice(-2000),
       dist_tags: tags,
@@ -231,7 +247,7 @@ async function main() {
     }, null, 2));
 
   } finally {
-    if (releaseSucceeded || !publishAttempted) {
+    if ((releaseSucceeded && !publishOnly) || !publishAttempted) {
       await unlink(tarball).catch(() => {});
     } else {
       console.error('Release artifact preserved after failure: ' + tarball);

package/scripts/r61-mixed-lane-benchmark.mjs

@@ -0,0 +1,98 @@
+import {mkdtemp,mkdir,readFile,readdir,stat,writeFile,open,rm} from 'node:fs/promises';
+import {spawn} from 'node:child_process';
+import {createHash} from 'node:crypto';
+import {monitorEventLoopDelay,performance} from 'node:perf_hooks';
+import {pathToFileURL} from 'node:url';
+import os from 'node:os';
+import path from 'node:path';
+
+const roots=process.argv.slice(2);
+if(roots.length!==2||roots.some(item=>!path.isAbsolute(item)))throw new Error('two absolute governor module paths required');
+const levels=(process.env.DEADBYTE_R61_BENCH_LEVELS??'1,2,4,8,16,32').split(',').map(Number);
+if(!levels.length||levels.some(level=>![1,2,4,8,16,32].includes(level))||new Set(levels).size!==levels.length)throw new Error('benchmark levels invalid');
+const ROUNDS=Number(process.env.DEADBYTE_R61_BENCH_ROUNDS??3),OPS=160;
+if(!Number.isInteger(ROUNDS)||ROUNDS<3||ROUNDS>15)throw new Error('benchmark rounds must be 3..15');
+const scratchRoot=process.env.DEADBYTE_R61_SCRATCH_ROOT;
+if(!scratchRoot||!path.isAbsolute(scratchRoot))throw new Error('explicit absolute DEADBYTE_R61_SCRATCH_ROOT required');
+const quant=(values,p)=>{const ordered=[...values].sort((a,b)=>a-b);return ordered[Math.max(0,Math.ceil(ordered.length*p)-1)]};
+const sha=value=>createHash('sha256').update(value).digest('hex');
+
+async function childOutput(){
+  const child=spawn(process.execPath,['-e','process.stdout.write("R61_CHILD_OK")'],{windowsHide:true,stdio:['ignore','pipe','pipe']});
+  let output='';for await(const chunk of child.stdout)output+=chunk;
+  const exit=await new Promise(resolve=>child.once('close',resolve));
+  if(exit!==0||output!=='R61_CHILD_OK')throw new Error('bounded child process oracle failed');
+}
+
+async function runCase(modulePath,level,round){
+  const {createBridgeGovernor}=await import(pathToFileURL(modulePath).href);
+  await mkdir(scratchRoot,{recursive:true});
+  const scratch=await mkdtemp(path.join(scratchRoot,'deadbyte-r61-bench-'));
+  const fixture=path.join(scratch,'fixture'),audit=path.join(scratch,'presentation.jsonl');
+  await mkdir(fixture);
+  const sample='deadbyte bounded corpus สวัสดี\n'.repeat(512);
+  for(let i=0;i<16;i++)await writeFile(path.join(fixture,`f${i}.txt`),sample);
+  const governor=createBridgeGovernor();
+  const calls=[],control=[],counts={error:0,unknown:0},peak={rss:process.memoryUsage().rss,queue:0,active:0};
+  const delay=monitorEventLoopDelay({resolution:20});delay.enable();
+  let next=0;
+  const started=performance.now();
+  async function worker(){
+    while(next<OPS){
+      const i=next++;
+      const kind=i%16;
+      const tool=kind<3?(kind===0?'machine_ping':'machine_status'):
+        kind<5?'capability_manifest':kind<8?'machine_fs_read':kind<10?'coding_search':
+        kind<12?'machine_fs_write':kind===12?'process_session_start':kind<15?'coding_file_read':'machine_process_list';
+      const t=performance.now();let ticket;
+      try{
+        ticket=await governor.acquire(tool);
+        if(tool==='machine_ping')sha(`nonce-${round}-${i}`);
+        else if(tool==='machine_status')await stat(fixture);
+        else if(tool==='capability_manifest')sha(await readFile(roots[0]));
+        else if(tool==='coding_search'){
+          const names=await readdir(fixture);
+          for(const name of names)if((await readFile(path.join(fixture,name),'utf8')).includes('bounded'))break;
+        }else if(tool==='machine_fs_write')await writeFile(path.join(scratch,`out-${i}.txt`),sample.slice(0,128));
+        else if(tool==='process_session_start')await childOutput();
+        else if(tool==='machine_process_list')os.cpus().length;
+        else await readFile(path.join(fixture,`f${i%16}.txt`));
+        const line=JSON.stringify({kind,at:i,hash:sha(String(i))})+'\n';
+        const handle=await open(audit,'a');try{await handle.writeFile(line);await handle.sync();}finally{await handle.close();}
+      }catch(error){counts.error++;throw error;}
+      finally{
+        ticket?.release();
+        const elapsed=performance.now()-t;
+        calls.push(elapsed);if(kind<3)control.push(elapsed);
+        const state=governor.snapshot();
+        peak.rss=Math.max(peak.rss,process.memoryUsage().rss);
+        peak.queue=Math.max(peak.queue,...Object.values(state).map(value=>value.queued));
+        peak.active=Math.max(peak.active,...Object.values(state).map(value=>value.active));
+      }
+    }
+  }
+  try{
+    await Promise.all(Array.from({length:level},()=>worker()));
+    await governor.close();
+    const total=performance.now()-started;
+    return {level,round,n:calls.length,throughput_ops_s:OPS*1000/total,p50_ms:quant(calls,.5),p95_ms:quant(calls,.95),
+      p99_ms:quant(calls,.99),max_ms:Math.max(...calls),control_p95_ms:quant(control,.95),
+      event_loop_p95_ms:delay.percentile(95)/1e6,peak_rss_bytes:peak.rss,peak_queue:peak.queue,
+      peak_active:peak.active,errors:counts.error,unknown:counts.unknown};
+  }finally{delay.disable();await rm(scratch,{recursive:true,force:true});}
+}
+
+const results=[];
+for(const level of levels)for(let round=0;round<ROUNDS;round++){
+  const order=round%2===0?[0,1]:[1,0];
+  for(const index of order)results.push({target:index,...await runCase(roots[index],level,round)});
+}
+const report={schema:'deadbyte.r61.mixed-lane-benchmark.v1',node:process.version,platform:process.platform,
+  governor_sha256:await Promise.all(roots.map(async value=>sha(await readFile(value)))),levels,rounds:ROUNDS,operations_per_run:OPS,
+  limitations:['direct governor and real scratch I/O, not full MCP transport','presentation traffic is fsynced fixture data, not signed audit'],results};
+const outputPath=process.env.DEADBYTE_R61_BENCH_OUTPUT;
+if(outputPath){
+  if(!path.isAbsolute(outputPath))throw new Error('benchmark output must be absolute');
+  await writeFile(outputPath,JSON.stringify(report,null,2)+'\n',{flag:'wx'});
+  console.log(JSON.stringify({schema:report.schema,output_path:outputPath,result_count:results.length,governor_sha256:report.governor_sha256}));
+}else console.log(JSON.stringify(report,null,2));

package/src/deadbyte-cli.mjs

@@ -226,12 +226,12 @@ function parseAuditLogLine(file,line){
   if(!/^segment-\d{8}\.jsonl$/.test(path.basename(file))||!line) return null;
   try{return JSON.parse(line);}catch{return null;}
 }
-function formatLogLine(file,line,{auditEvent=null,activityTracker=null,sequence=null,verbose=false,displayMode='unicode'}={}){
+function formatLogLine(file,line,{auditEvent=null,activityTracker=null,sequence=null,sourceSequence=null,verbose=false,displayMode='unicode'}={}){
   if(!line) return null;
   if(/^segment-\d{8}\.jsonl$/.test(path.basename(file))){
     const event=auditEvent??parseAuditLogLine(file,line);
     if(!event) return null;
-    return activityTracker?activityTracker.observe(event,{sequence}):formatCompactAuditEvent(event);
+    return activityTracker?activityTracker.observe(event,{sequence,sourceSequence}):formatCompactAuditEvent(event);
   }
   return formatRuntimeDiagnosticLine(file,line,{verbose,displayMode});
 }
@@ -328,7 +328,7 @@ function timelineFilterEvent(timeline){
 async function tailRemoteLogs(root,signal,{journal=null,offsets=null,activityTracker=null,timelineFilter=null,timelineWriter=null,verbose=false,displayMode='unicode'}={}){
   process.stdout.write(verbose
     ? '[LOG] Verbose live timeline. Full sanitized request detail enabled; Ctrl+C disconnects and revokes authority.\n'
-    : '[LOG] Human live timeline. Transport IN/OUT hidden; full replay/audit detail remains on disk. Ctrl+C disconnects and revokes authority.\n');
+    : '[LOG] Human live timeline. Transport IN/OUT hidden; full replay/audit detail remains on disk. START/DONE retained; heartbeat bursts folded; Ctrl+C disconnects and revokes authority.\n');
   const activeOffsets=offsets??await snapshotRemoteLogOffsets(root);
   const partialLines=new Map();
   let liveFiles=[...activeOffsets.keys()];
@@ -358,7 +358,8 @@ async function tailRemoteLogs(root,signal,{journal=null,offsets=null,activityTra
           : await journal.recordTerminal(timeline);
         if(recorded?.duplicate) continue;
         const accepted=timelineFilter&&timeline?timelineFilter.accept(timelineFilterEvent(timeline)):true;
-        const formatted=formatLogLine(file,line,{auditEvent,activityTracker,sequence:recorded?.event?.seq??null,verbose,displayMode});
+        const formatted=formatLogLine(file,line,{auditEvent,activityTracker,sequence:recorded?.event?.seq??null,
+          sourceSequence:Number.isSafeInteger(auditEvent?.seq)?auditEvent.seq:null,verbose,displayMode});
         if(!formatted||!accepted) continue;
         const output=Array.isArray(formatted)?formatted:[formatted];
         for(const item of output) if(item){
@@ -512,9 +513,9 @@ async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,fil
     filePath:remoteResultJournalPath(ctx.root,marker.result_session_id),sessionId:marker.result_session_id,maxEntries:2048
   });
   const rootPaths=await readLiveRootPaths(ctx.root);
-  const activityTracker=createLiveTimelineTracker({verbose,displayMode,rootPaths,trace});
+  const activityTracker=createLiveTimelineTracker({verbose,displayMode,rootPaths,trace,foldHeartbeats:!verbose});
   const timelineFilter=filterExpression?createLiveTimelineFilter(filterExpression):null;
-  const timelineWriter=createLiveTimelineWriter({stream:process.stdout,displayMode,rewrite:!verbose});
+  const timelineWriter=createLiveTimelineWriter({stream:process.stdout,displayMode,rewrite:false});
   const aborter=new AbortController();
   const abort=()=>aborter.abort();
   const watchStdin=!process.stdin.isTTY;
@@ -588,6 +589,8 @@ async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,fil
     if(logTask) await logTask.catch(()=>{});
     timelineWriter.flush();
     for(const line of activityTracker.reconcileInterrupted('session_end')) process.stdout.write(`${line}\n`);
+    const filterRetention=timelineFilter?.retention();
+    if(filterRetention?.evicted>0) process.stdout.write(`[WARN] LIVELOG filter evicted ${filterRetention.evicted} presentation identities; full audit remains on disk.\n`);
     process.stdout.write(`${activityTracker.summary()}\n`);
     process.removeListener('SIGINT',abort);process.removeListener('SIGTERM',abort);
     if(watchStdin){process.stdin.removeListener('end',abort);process.stdin.removeListener('close',abort);process.stdin.pause();}