deadbyte-mcp 0.15.43 → 0.15.45

package/native/deadbyte-native-inspect-r67.cpp

@@ -0,0 +1,252 @@
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+#include <windows.h>
+#include <tlhelp32.h>
+#include <bcrypt.h>
+#include <winnt.h>
+#include <cstdint>
+#include <cstring>
+#include <iomanip>
+#include <limits>
+#include <iostream>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+#include <algorithm>
+
+#pragma comment(lib,"bcrypt.lib")
+struct Handle { HANDLE h=INVALID_HANDLE_VALUE; explicit Handle(HANDLE p):h(p){} ~Handle(){if(h&&h!=INVALID_HANDLE_VALUE)CloseHandle(h);} Handle(const Handle&)=delete; Handle& operator=(const Handle&)=delete; };
+static std::string hex(const uint64_t x){std::ostringstream s;s<<"0x"<<std::hex<<x;return s.str();}
+static std::string escape(const std::string& in){
+  std::ostringstream s;s<<'"';
+  for(unsigned char c:in){if(c=='"'||c=='\\')s<<'\\'<<char(c);else if(c=='\n')s<<"\\n";else if(c=='\r')s<<"\\r";else if(c=='\t')s<<"\\t";else if(c<32){s<<"\\u00"<<std::hex<<std::setw(2)<<std::setfill('0')<<int(c)<<std::dec;}else s<<char(c);}
+  s<<'"';return s.str();
+}
+static std::string utf8(const std::wstring& wide){
+  if(wide.empty())return {};
+  const int n=WideCharToMultiByte(CP_UTF8,WC_ERR_INVALID_CHARS,wide.data(),int(wide.size()),nullptr,0,nullptr,nullptr);
+  if(n<=0)throw std::runtime_error("invalid UTF-16"); std::string s(size_t(n),'\0');
+  if(WideCharToMultiByte(CP_UTF8,WC_ERR_INVALID_CHARS,wide.data(),int(wide.size()),s.data(),n,nullptr,nullptr)!=n)throw std::runtime_error("UTF-8 conversion failed");return s;
+}
+static std::string sha256(const uint8_t* p,size_t n){
+  BCRYPT_ALG_HANDLE alg=nullptr;BCRYPT_HASH_HANDLE ctx=nullptr;
+  if(!BCRYPT_SUCCESS(BCryptOpenAlgorithmProvider(&alg,BCRYPT_SHA256_ALGORITHM,nullptr,0)))throw std::runtime_error("CNG open failed");
+  DWORD length=0,read=0;
+  if(!BCRYPT_SUCCESS(BCryptGetProperty(alg,BCRYPT_HASH_LENGTH,reinterpret_cast<PUCHAR>(&length),sizeof(length),&read,0))||length!=32){BCryptCloseAlgorithmProvider(alg,0);throw std::runtime_error("CNG SHA length invalid");}
+  std::vector<uint8_t> digest(length);
+  NTSTATUS rc=BCryptCreateHash(alg,&ctx,nullptr,0,nullptr,0,0);
+  if(BCRYPT_SUCCESS(rc))rc=BCryptHashData(ctx,const_cast<PUCHAR>(p),ULONG(n),0);
+  if(BCRYPT_SUCCESS(rc))rc=BCryptFinishHash(ctx,digest.data(),length,0);
+  if(ctx)BCryptDestroyHash(ctx);BCryptCloseAlgorithmProvider(alg,0);
+  if(!BCRYPT_SUCCESS(rc))throw std::runtime_error("CNG hash failed");
+  std::ostringstream s;for(uint8_t b:digest)s<<std::hex<<std::setfill('0')<<std::setw(2)<<int(b);return s.str();
+}
+static std::string sha256(const std::string& s){return sha256(reinterpret_cast<const uint8_t*>(s.data()),s.size());}
+static uint64_t fticks(FILETIME t){ULARGE_INTEGER u{};u.LowPart=t.dwLowDateTime;u.HighPart=t.dwHighDateTime;return u.QuadPart;}
+static std::string timestamp(FILETIME t){SYSTEMTIME s{};if(!FileTimeToSystemTime(&t,&s))return "";std::ostringstream o;o<<std::setfill('0')<<std::setw(4)<<s.wYear<<"-"<<std::setw(2)<<s.wMonth<<"-"<<std::setw(2)<<s.wDay<<"T"<<std::setw(2)<<s.wHour<<":"<<std::setw(2)<<s.wMinute<<":"<<std::setw(2)<<s.wSecond<<"."<<std::setw(3)<<s.wMilliseconds<<"Z";return o.str();}
+static std::string image(HANDLE h){
+  std::vector<wchar_t> b(32768,L'\0');DWORD size=DWORD(b.size());
+  if(!QueryFullProcessImageNameW(h,0,b.data(),&size))return "null";
+  return escape(utf8(std::wstring(b.data(),size)));
+}
+static std::string process_item(DWORD pid,DWORD ppid,const std::wstring& name){
+  std::ostringstream o;o<<"{\"pid\":"<<pid<<",\"parent_pid\":"<<ppid<<",\"name\":"<<escape(utf8(name));
+  Handle proc(OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION,FALSE,pid));
+  if(!proc.h){const DWORD error=GetLastError();o<<",\"state\":\"unavailable\",\"win32_error\":"<<error<<"}";return o.str();}
+  FILETIME c{},e{},k{},u{};
+  if(!GetProcessTimes(proc.h,&c,&e,&k,&u)){const DWORD error=GetLastError();o<<",\"state\":\"unavailable\",\"win32_error\":"<<error<<"}";return o.str();}
+  std::vector<wchar_t> filename(32768,L'\0'); DWORD chars=DWORD(filename.size());
+  if(!QueryFullProcessImageNameW(proc.h,0,filename.data(),&chars)){
+    const DWORD error=GetLastError();o<<",\"state\":\"unavailable\",\"win32_error\":"<<error<<"}";return o.str();
+  }
+  const std::wstring full(filename.data(),chars);
+  const size_t leafIndex=full.find_last_of(L"\\/");
+  const std::wstring leaf=full.substr(leafIndex==std::wstring::npos?0:leafIndex+1);
+  if(CompareStringOrdinal(leaf.c_str(),-1,name.c_str(),-1,TRUE)!=CSTR_EQUAL){
+    o<<",\"state\":\"stale_or_reused\",\"snapshot_binding\":\"NAME_MISMATCH\",\"win32_error\":0}";return o.str();
+  }
+  const DWORD wait=WaitForSingleObject(proc.h,0);
+  if(wait!=WAIT_OBJECT_0&&wait!=WAIT_TIMEOUT){
+    const DWORD error=GetLastError();o<<",\"state\":\"unavailable\",\"win32_error\":"<<error<<"}";return o.str();
+  }
+  o<<",\"state\":\"observed\",\"snapshot_binding\":\"UNVERIFIED\",\"creation_time_utc\":"<<escape(timestamp(c))
+   <<",\"creation_filetime\":"<<escape(std::to_string(fticks(c)))
+   <<",\"image_path\":"<<escape(utf8(full))
+   <<",\"process_exited\":"<<(wait==WAIT_OBJECT_0?"true":"false")<<",\"win32_error\":0}";
+  return o.str();
+}
+static std::string snapshot(size_t limit){
+  Handle snap(CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0));
+  if(snap.h==INVALID_HANDLE_VALUE)throw std::runtime_error("CreateToolhelp32Snapshot failed "+std::to_string(GetLastError()));
+  PROCESSENTRY32W row{};row.dwSize=sizeof(row);
+  if(!Process32FirstW(snap.h,&row))throw std::runtime_error("Process32FirstW failed "+std::to_string(GetLastError()));
+  std::ostringstream o;o<<"{\"api\":\"CreateToolhelp32Snapshot+OpenProcess+GetProcessTimes+QueryFullProcessImageNameW\",\"processes\":[";
+  size_t count=0;bool more=false;
+  do{if(count>=limit){more=true;break;}if(count)o<<",";o<<process_item(row.th32ProcessID,row.th32ParentProcessID,row.szExeFile);++count;}while(Process32NextW(snap.h,&row));
+  o<<"],\"count\":"<<count<<",\"truncated\":"<<(more?"true":"false")<<"}";return o.str();
+}
+static std::string identity(DWORD pid){
+  if(pid==0)throw std::runtime_error("PID 0 has no process identity");
+  Handle proc(OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION|SYNCHRONIZE,FALSE,pid));
+  if(!proc.h)throw std::runtime_error("OpenProcess identity win32="+std::to_string(GetLastError()));
+  FILETIME c{},e{},k{},u{};
+  if(!GetProcessTimes(proc.h,&c,&e,&k,&u))throw std::runtime_error("GetProcessTimes identity win32="+std::to_string(GetLastError()));
+  const DWORD wait=WaitForSingleObject(proc.h,0);
+  if(wait!=WAIT_OBJECT_0&&wait!=WAIT_TIMEOUT)throw std::runtime_error("WaitForSingleObject identity win32="+std::to_string(GetLastError()));
+  std::ostringstream o;
+  o<<"{\"api\":\"OpenProcess+GetProcessTimes+QueryFullProcessImageNameW\",\"pid\":"<<pid
+    <<",\"creation_time_utc\":"<<escape(timestamp(c))
+    <<",\"creation_filetime\":"<<escape(std::to_string(fticks(c)))
+    <<",\"image_path\":"<<image(proc.h)
+    <<",\"process_exited\":"<<(wait==WAIT_OBJECT_0?"true":"false")<<"}";
+  return o.str();
+}
+static std::string memory_map(DWORD pid,size_t limit,uint64_t expectedCreation=0){
+  if(pid==0)throw std::runtime_error("PID 0 is not a process handle");
+  Handle proc(OpenProcess(PROCESS_QUERY_INFORMATION|SYNCHRONIZE,FALSE,pid));
+  if(!proc.h)throw std::runtime_error("OpenProcess PROCESS_QUERY_INFORMATION win32="+std::to_string(GetLastError()));
+  FILETIME c{},e{},k{},u{};
+  if(!GetProcessTimes(proc.h,&c,&e,&k,&u))throw std::runtime_error("GetProcessTimes win32="+std::to_string(GetLastError()));
+  const uint64_t cid=fticks(c);
+  if(expectedCreation!=0&&expectedCreation!=cid)throw std::runtime_error("PROCESS_IDENTITY_MISMATCH: PID is stale or reused");
+  std::ostringstream o;o<<"{\"api\":\"VirtualQueryEx\",\"pid\":"<<pid
+      <<",\"creation_time_utc\":"<<escape(timestamp(c))
+      <<",\"creation_filetime\":"<<escape(std::to_string(cid))
+      <<",\"image_path\":"<<image(proc.h)<<",\"regions\":[";
+  uint64_t pos=0;size_t count=0;bool end=false;DWORD error=0;
+  const uint64_t maxAddr=static_cast<uint64_t>(std::numeric_limits<uintptr_t>::max());
+  while(count<limit){
+    MEMORY_BASIC_INFORMATION mbi{};
+    SIZE_T result=VirtualQueryEx(proc.h,reinterpret_cast<LPCVOID>(static_cast<uintptr_t>(pos)),&mbi,sizeof(mbi));
+    if(!result){
+      error=GetLastError();
+      if(WaitForSingleObject(proc.h,0)==WAIT_OBJECT_0)throw std::runtime_error("PROCESS_EXITED_DURING_QUERY");
+      if(error==ERROR_INVALID_PARAMETER&&pos!=0)end=true;
+      break;
+    }
+    const uint64_t base=reinterpret_cast<uint64_t>(mbi.BaseAddress);
+    const uint64_t size=uint64_t(mbi.RegionSize);
+    if(!size||base>maxAddr-size)throw std::runtime_error("VirtualQueryEx non-progress/overflow");
+    if(count)o<<',';
+    o<<"{\"base\":"<<escape(hex(base))<<",\"allocation_base\":"<<escape(hex(reinterpret_cast<uint64_t>(mbi.AllocationBase)))
+     <<",\"size\":"<<escape(std::to_string(size))<<",\"state\":"<<mbi.State
+     <<",\"protect\":"<<mbi.Protect<<",\"type\":"<<mbi.Type<<"}";
+    ++count;const uint64_t next=base+size;if(next<=pos)throw std::runtime_error("VirtualQueryEx non-progress");
+    pos=next;
+  }
+  if(error&&!end)throw std::runtime_error("VirtualQueryEx win32="+std::to_string(error));
+  o<<"],\"count\":"<<count<<",\"truncated\":"<<((count==limit&&!end)?"true":"false")
+   <<",\"terminal_win32_error\":"<<(end?0:error)<<",\"terminal\":\""<<(end?"end":"limit")<<"\"";
+  FILETIME c2{},e2{},k2{},u2{};
+  if(!GetProcessTimes(proc.h,&c2,&e2,&k2,&u2)||fticks(c2)!=cid)throw std::runtime_error("process identity changed during inspection");
+  const DWORD wait=WaitForSingleObject(proc.h,0);
+  if(wait!=WAIT_OBJECT_0&&wait!=WAIT_TIMEOUT)throw std::runtime_error("WaitForSingleObject win32="+std::to_string(GetLastError()));
+  o<<",\"process_exited\":"<<(wait==WAIT_OBJECT_0?"true":"false")
+   <<",\"outcome\":\""<<(wait==WAIT_OBJECT_0?"PROCESS_EXITED":"HANDLE_IDENTITY_CONFIRMED")<<"\"}";return o.str();
+}
+static std::vector<uint8_t> filebytes(const std::wstring& filename){
+  Handle h(CreateFileW(filename.c_str(),GENERIC_READ,FILE_SHARE_READ,nullptr,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,nullptr));
+  if(h.h==INVALID_HANDLE_VALUE)throw std::runtime_error("CreateFileW win32="+std::to_string(GetLastError()));
+  LARGE_INTEGER length{};if(!GetFileSizeEx(h.h,&length))throw std::runtime_error("GetFileSizeEx failed");
+  if(length.QuadPart<64||length.QuadPart>64*1024*1024)throw std::runtime_error("PE file size outside 64B..64MiB");
+  std::vector<uint8_t> data(size_t(length.QuadPart));
+  size_t offset=0;
+  while(offset<data.size()){DWORD received=0;DWORD chunk=DWORD(std::min<size_t>(1024*1024,data.size()-offset));if(!ReadFile(h.h,data.data()+offset,chunk,&received,nullptr)||!received)throw std::runtime_error("ReadFile failed/short");offset+=received;}
+  LARGE_INTEGER final{};if(!GetFileSizeEx(h.h,&final)||final.QuadPart!=length.QuadPart)throw std::runtime_error("PE file size changed during read");
+  return data;
+}
+template<typename T>static T read_at(const std::vector<uint8_t>& b,size_t off){
+  if(off>b.size()||sizeof(T)>b.size()-off)throw std::runtime_error("PE structure truncated");
+  T v{};std::memcpy(&v,b.data()+off,sizeof(T));return v;
+}
+static std::string pe(const std::wstring& filename){
+  const auto b=filebytes(filename);
+  const auto dos=read_at<IMAGE_DOS_HEADER>(b,0);
+  if(dos.e_magic!=IMAGE_DOS_SIGNATURE||dos.e_lfanew<sizeof(IMAGE_DOS_HEADER))throw std::runtime_error("invalid MZ/PE offset");
+  const size_t off=size_t(dos.e_lfanew);
+  if(read_at<DWORD>(b,off)!=IMAGE_NT_SIGNATURE)throw std::runtime_error("invalid PE signature");
+  const auto coff=read_at<IMAGE_FILE_HEADER>(b,off+4);
+  if(coff.NumberOfSections==0||coff.NumberOfSections>96)throw std::runtime_error("invalid number of sections");
+  const size_t opt=off+4+sizeof(IMAGE_FILE_HEADER);
+  if(opt>b.size()||coff.SizeOfOptionalHeader>b.size()-opt)throw std::runtime_error("optional header truncated");
+  const WORD magic=read_at<WORD>(b,opt);
+  uint64_t base=0;DWORD entry=0;
+  if(magic==IMAGE_NT_OPTIONAL_HDR32_MAGIC){
+    if(coff.SizeOfOptionalHeader<sizeof(IMAGE_OPTIONAL_HEADER32))throw std::runtime_error("PE32 optional header truncated");
+    const auto h=read_at<IMAGE_OPTIONAL_HEADER32>(b,opt);base=h.ImageBase;entry=h.AddressOfEntryPoint;
+  }else if(magic==IMAGE_NT_OPTIONAL_HDR64_MAGIC){
+    if(coff.SizeOfOptionalHeader<sizeof(IMAGE_OPTIONAL_HEADER64))throw std::runtime_error("PE32+ optional header truncated");
+    const auto h=read_at<IMAGE_OPTIONAL_HEADER64>(b,opt);base=h.ImageBase;entry=h.AddressOfEntryPoint;
+  }else throw std::runtime_error("unsupported optional header magic");
+  const size_t sec=opt+coff.SizeOfOptionalHeader;
+  if(sec>b.size()||size_t(coff.NumberOfSections)>((b.size()-sec)/sizeof(IMAGE_SECTION_HEADER)))throw std::runtime_error("section table truncated");
+  std::ostringstream o;o<<"{\"api\":\"CreateFileW+ReadFile\",\"format\":"<<escape(magic==IMAGE_NT_OPTIONAL_HDR64_MAGIC?"PE32+":"PE32")
+    <<",\"file_path\":"<<escape(utf8(filename))<<",\"file_size\":"<<b.size()
+    <<",\"file_sha256\":"<<escape(sha256(b.data(),b.size()))<<",\"machine\":"<<coff.Machine
+    <<",\"number_of_sections\":"<<coff.NumberOfSections<<",\"image_base\":"<<escape(hex(base))
+    <<",\"entry_rva\":"<<escape(hex(entry))<<",\"sections\":[";
+  for(size_t i=0;i<coff.NumberOfSections;++i){
+    const auto s=read_at<IMAGE_SECTION_HEADER>(b,sec+i*sizeof(IMAGE_SECTION_HEADER));
+    std::string name(reinterpret_cast<const char*>(s.Name),8);const auto zero=name.find('\0');if(zero!=std::string::npos)name.resize(zero);
+    if(s.SizeOfRawData&&(size_t(s.PointerToRawData)>b.size()||size_t(s.SizeOfRawData)>b.size()-size_t(s.PointerToRawData)))throw std::runtime_error("section raw data exceeds file");
+    if(i)o<<',';
+    o<<"{\"name\":"<<escape(name)<<",\"rva\":"<<escape(hex(s.VirtualAddress))
+      <<",\"virtual_size\":"<<s.Misc.VirtualSize<<",\"raw_offset\":"<<s.PointerToRawData
+      <<",\"raw_size\":"<<s.SizeOfRawData<<",\"characteristics\":"<<s.Characteristics<<"}";
+  }
+  o<<"]}";return o.str();
+}
+int wmain(int argc,wchar_t** argv){
+ try{
+   if(argc<2)throw std::runtime_error("usage: process [limit] | map self [limit] | map PID creation_filetime [limit] | pe FILE");
+   const std::wstring op=argv[1];std::string data;
+   if(op==L"process"){
+     size_t limit=64;if(argc>2){auto x=std::stoul(argv[2]);if(x<1||x>256)throw std::runtime_error("limit must be 1..256");limit=x;}
+     data=snapshot(limit);
+   }else if(op==L"identity"){
+     if(argc!=3)throw std::runtime_error("identity requires one PID");
+     const std::wstring value=argv[2];
+     if(value.empty()||!std::all_of(value.begin(),value.end(),[](wchar_t c){return c>=L'0'&&c<=L'9';}))throw std::runtime_error("invalid PID");
+     const auto n=std::stoull(value);if(n<1||n>MAXDWORD)throw std::runtime_error("invalid PID");
+     data=identity(DWORD(n));
+   }else if(op==L"map"){
+     if(argc<3)throw std::runtime_error("map requires self or PID");
+     const bool self=std::wstring(argv[2])==L"self";
+     DWORD pid=0;size_t limit=128;uint64_t expected=0;
+     const auto parseUnsigned=[](const wchar_t* text)->uint64_t{
+       const std::wstring s=text;
+       if(s.empty()||!std::all_of(s.begin(),s.end(),[](wchar_t c){return c>=L'0'&&c<=L'9';}))
+         throw std::runtime_error("invalid unsigned number");
+       return std::stoull(s);
+     };
+     if(self){
+       if(argc>4)throw std::runtime_error("map self [limit]");
+       pid=GetCurrentProcessId();
+       if(argc==4){const auto n=parseUnsigned(argv[3]);if(n<1||n>512)throw std::runtime_error("limit must be 1..512");limit=size_t(n);}
+     }else{
+       if(argc<4||argc>5)throw std::runtime_error("map PID requires creation_filetime [limit]");
+       const auto n=parseUnsigned(argv[2]);if(n<1||n>MAXDWORD)throw std::runtime_error("invalid PID");pid=DWORD(n);
+       expected=parseUnsigned(argv[3]);if(expected==0)throw std::runtime_error("creation_filetime must be nonzero");
+       if(argc==5){const auto nLimit=parseUnsigned(argv[4]);if(nLimit<1||nLimit>512)throw std::runtime_error("limit must be 1..512");limit=size_t(nLimit);}
+     }
+     data=memory_map(pid,limit,expected);
+   }else if(op==L"pe"){
+     if(argc!=3)throw std::runtime_error("pe requires one file path");
+     data=pe(argv[2]);
+   }else throw std::runtime_error("unknown operation");
+   std::cout<<"{\"schema\":\"deadbyte.native-inspect.r67.v1\",\"status\":\"ok\",\"operation\":"<<escape(utf8(op))
+     <<",\"data\":"<<data<<",\"data_sha256\":"<<escape(sha256(data))<<"}\n";
+   return 0;
+ }catch(const std::exception& e){
+   const std::string message=e.what();const auto start=message.rfind("win32=");
+   unsigned long win32=0;std::string category="INVALID_INPUT";
+   if(message.find("PROCESS_IDENTITY_MISMATCH")!=std::string::npos)category="PROCESS_IDENTITY_MISMATCH";
+   else if(message.find("PROCESS_EXITED_DURING_QUERY")!=std::string::npos)category="PROCESS_EXITED";
+   if(start!=std::string::npos){try{win32=std::stoul(message.substr(start+6));}catch(...){win32=0;}
+     category=win32==ERROR_ACCESS_DENIED?"ACCESS_DENIED":(win32==ERROR_INVALID_PARAMETER?"INVALID_PARAMETER":"WIN32_FAILURE");}
+   std::cout<<"{\"schema\":\"deadbyte.native-inspect.r67.v1\",\"status\":\"failed\",\"error_code\":"<<escape(category)
+     <<",\"win32_error\":"<<win32<<",\"error\":"<<escape(message)<<"}\n";
+   return 2;
+ }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deadbyte-mcp",
-  "version": "0.15.43",
+  "version": "0.15.45",
   "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-r66-prepublish.ps1",
+    "gate:windows": "powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r71.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",
@@ -91,7 +91,10 @@
     "r63:focused:test": "node --test --test-concurrency=1 test/r63-release-contract.test.mjs test/r63-one-shot-coherence.test.mjs test/r51-runtime-coherence.test.mjs test/remote-session-cli.test.mjs",
     "r64:focused:test": "node --test --test-concurrency=1 test/r64-release-contract.test.mjs test/r64-machine-fs-large-read.test.mjs test/machine-fs-runtime.test.mjs test/compact-gateway-r36.test.mjs test/r61-control-lane.test.mjs test/r60-bridge-dispatch.test.mjs",
     "r65:focused:test": "node scripts/r65-focused.mjs",
-    "r66:focused:test": "node --test --test-concurrency=1 test/r66-release-contract.test.mjs test/r58-doctor-runtime.test.mjs test/r58-doctor-foreground.test.mjs test/r58-doctor-installation.test.mjs test/r65-controller-authority-epoch.test.mjs test/r65-authority-observation-epoch.test.mjs"
+    "r66:focused:test": "node --test --test-concurrency=1 test/r66-release-contract.test.mjs test/r58-doctor-runtime.test.mjs test/r58-doctor-foreground.test.mjs test/r58-doctor-installation.test.mjs test/r65-controller-authority-epoch.test.mjs test/r65-authority-observation-epoch.test.mjs",
+    "r67:focused:test": "node scripts/r67-focused-gate.mjs",
+    "r67:shard:run": "node scripts/r67-regression-shard-run.mjs",
+    "r67:shard:verify": "node scripts/r67-regression-reconcile.mjs"
   },
   "bundleDependencies": [
     "@modelcontextprotocol/server",

package/scripts/benchmark-l0-r71.mjs

@@ -0,0 +1,76 @@
+import {randomBytes,createHash} from 'node:crypto';
+import {mkdir,mkdtemp,readFile,rm,writeFile} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {loadCodingPolicy,codingSessionStatus} from '../src/coding-plane.mjs';
+import {createAuthorityEpochStore} from '../src/authority-continuity-r65.mjs';
+import {registerAutonomousTools} from '../src/autonomous-mcp-tools.mjs';
+import {classifyRemoteOperation} from '../bridge/src/remote-dispatch-r60.mjs';
+import {prepareAuthorityTestTrust} from '../test/r65-authority-test-trust.mjs';
+
+const root=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const evidenceDir=path.join(root,'testing','r71-l0-benchmark');
+const samples=100_000;
+const warmup=5_000;
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const percentile=(sorted,p)=>Number(sorted[Math.min(sorted.length-1,Math.ceil(sorted.length*p)-1)]/1e6).toFixed(6);
+
+await mkdir(evidenceDir,{recursive:true});
+const state=await mkdtemp(path.join(evidenceDir,'state-'));
+try{
+  const runtime=await prepareAuthorityTestTrust(state);
+  const project=path.join(state,'project');
+  await mkdir(project);
+  const policyPath=path.join(state,'coding-policy.json');
+  const grantFile=path.join(runtime,'coding-grant.json');
+  await writeFile(policyPath,JSON.stringify({schema:'deadbyte.coding-policy.v1',enabled:true,
+    lease_file:grantFile,evidence_dir:path.join(state,'evidence'),
+    roots:{project:{path:project,read:true,write:false,exec:false,deny_paths:[]}},commands:{}}));
+  const policy=await loadCodingPolicy(policyPath);
+  const grant={schema:'deadbyte.coding-grant.v2',policy_sha256:policy.policy_sha256,
+    instance_nonce:randomBytes(32).toString('hex'),root_ids:['project'],granted_at_utc:new Date().toISOString()};
+  await writeFile(grantFile,JSON.stringify(grant));
+  const grantBytes=await readFile(grantFile);
+  const store=createAuthorityEpochStore({runtimeDir:runtime,policyBytes:await readFile(policyPath)});
+  await store.append({plane:'coding',action:'grant',grantBytes,grantInstanceNonce:grant.instance_nonce,updateId:null});
+  const contracts=new Map();
+  registerAutonomousTools({registerTool:(name,contract)=>contracts.set(name,contract)},
+    {autonomousRuntime:{},nativeDiffRuntime:{}});
+  const schema=contracts.get('native_diff_preview')?.inputSchema;
+  if(!schema)throw new Error('native_diff_preview schema unavailable');
+  const request={root_id:'project',title:'L0 read-only probe',operations:[{kind:'write',path:'scratch.txt',
+    content:'x',encoding:'utf8',expected_sha256:'absent'}]};
+  const observed=new Float64Array(samples);
+  const execute=async()=>{
+    const parsed=schema.parse(request);
+    if(classifyRemoteOperation({name:'native_diff_preview'},parsed)!=='read_only')throw new Error('dispatch classification drift');
+    const authority=await codingSessionStatus(policy);
+    if(authority.armed!==true||authority.authority_epoch?.trusted!==true||
+       !authority.root_ids.includes(parsed.root_id)||policy.roots[parsed.root_id]?.read!==true)
+      throw new Error('signed Coding authority decision failed');
+  };
+  for(let i=0;i<warmup;i++)await execute();
+  const started=process.hrtime.bigint();
+  for(let i=0;i<samples;i++){
+    const tick=process.hrtime.bigint();
+    await execute();
+    observed[i]=Number(process.hrtime.bigint()-tick);
+  }
+  const elapsedMs=Number(process.hrtime.bigint()-started)/1e6;
+  observed.sort();
+  const result={schema:'deadbyte.r71-l0-benchmark.v1',created_at_utc:new Date().toISOString(),
+    scope:'native_diff_preview input validation + remote dispatch classification + real isolated signed Coding grant/epoch decision; excludes IPC, filesystem operation, native execution and ChatGPT',
+    clock:'process.hrtime.bigint',warmup,samples,elapsed_ms:elapsedMs,
+    p50_ms:Number(percentile(observed,0.50)),p95_ms:Number(percentile(observed,0.95)),
+    p99_ms:Number(percentile(observed,0.99)),max_ms:Number((observed.at(-1)/1e6).toFixed(6)),
+    threshold_p95_ms:1,pass:observed[Math.ceil(samples*0.95)-1]<1e6,
+    coding_policy_sha256:policy.policy_sha256,source_manifest_sha256:sha(await readFile(path.join(root,'MANIFEST.SHA256')))};
+  const bytes=Buffer.from(JSON.stringify(result)+'\n');
+  const output=path.join(evidenceDir,`result-${Date.now()}-${randomBytes(4).toString('hex')}.json`);
+  await writeFile(output,bytes,{flag:'wx'});
+  process.stdout.write(JSON.stringify({...result,evidence_path:output,evidence_sha256:sha(bytes)})+'\n');
+  if(!result.pass)process.exitCode=1;
+}finally{
+  await rm(state,{recursive:true,force:true});
+}

package/scripts/build-native-inspector-r67.ps1

@@ -0,0 +1,28 @@
+param([Parameter(Mandatory=$true)][ValidatePattern('^[0-9a-f]{64}$')][string]$SourceSha256)
+$ErrorActionPreference='Stop'
+Set-StrictMode -Version Latest
+$root=Split-Path -Parent $PSScriptRoot
+$src=Join-Path $root 'native\deadbyte-native-inspect-r67.cpp'
+$observed=(Get-FileHash -LiteralPath $src -Algorithm SHA256).Hash.ToLowerInvariant()
+if($observed -ne $SourceSha256){throw "R67 source SHA mismatch; refusing build"}
+Write-Output "R67_SOURCE_SHA256=$observed"
+$bin=Join-Path $root 'bin'
+$exe=Join-Path $bin 'deadbyte-native-inspect-r67.exe'
+$obj=Join-Path $bin 'deadbyte-native-inspect-r67.obj'
+$vswhere='C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe'
+if(!(Test-Path -LiteralPath $vswhere)){throw 'vswhere missing'}
+$install=(& $vswhere -latest -products * -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -property installationPath | Select-Object -First 1)
+if(!$install){throw 'MSVC x64 C++ toolchain missing'}
+$dev=Join-Path $install 'Common7\Tools\VsDevCmd.bat'
+$cmd=if($env:ComSpec){$env:ComSpec}else{Join-Path $env:SystemRoot 'System32\cmd.exe'}
+New-Item -ItemType Directory -Path $bin -Force | Out-Null
+$common='/nologo /std:c++17 /permissive- /W4 /WX /O2 /MT /EHsc /guard:cf /diagnostics:caret /utf-8 /Brepro /DUNICODE /D_UNICODE /D_WIN32_WINNT=0x0A00'
+$compile='cl {0} "{1}" /Fo:"{2}" /Fe:"{3}" /link bcrypt.lib /Brepro /INCREMENTAL:NO' -f $common,$src,$obj,$exe
+$line='call "{0}" -no_logo -arch=x64 -host_arch=x64 && {1}' -f $dev,$compile
+$output=& $cmd /d /s /c $line 2>&1
+$rc=$LASTEXITCODE
+$output | ForEach-Object { Write-Output ([string]$_) }
+if($rc -ne 0){throw "R67 native build failed exit=$rc"}
+if(!(Test-Path -LiteralPath $exe -PathType Leaf)){throw 'R67 native exe missing'}
+$sha=(Get-FileHash -LiteralPath $exe -Algorithm SHA256).Hash.ToLowerInvariant()
+Write-Output "R67_NATIVE_BUILD_PASS sha256=$sha path=$exe"

package/scripts/gate-windows-r67.ps1

@@ -0,0 +1,56 @@
+param(
+ [ValidateSet('preflight','focused','evidence','manifest','doctor','all')]
+ [string]$Stage='preflight',
+ [string]$OperationId=''
+)
+$ErrorActionPreference='Stop'
+Set-StrictMode -Version Latest
+$root=Split-Path -Parent $PSScriptRoot
+$parent='D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.43-r66'
+$expected='4c4a64a4c8e9f5a6e9eecce85fd0007ebcac99121b29c07f1a1fc81d1643cd33'
+$expectedGen='ef3b041e2a87c2e143d4733a98a52d9db80cd16ad7007e112fcb5202e70c77c3'
+$expectedRelease='v0.15.43-4c4a64a4c8e9f5a6'
+if(!(Test-Path -LiteralPath $parent -PathType Container)){throw 'R67 predecessor source missing'}
+$prev=(Get-FileHash -LiteralPath (Join-Path $parent 'MANIFEST.SHA256') -Algorithm SHA256).Hash.ToLowerInvariant()
+if($prev -ne $expected){throw 'R67 predecessor manifest not exact'}
+$stateRoot=Join-Path $env:USERPROFILE '.deadbyte-mcp'
+$pointerPath=Join-Path $stateRoot 'active-release.json'
+if(!(Test-Path -LiteralPath $pointerPath -PathType Leaf)){throw 'R67 active predecessor pointer missing'}
+$pointer=Get-Content -LiteralPath $pointerPath -Raw | ConvertFrom-Json
+if($pointer.release_id -ne $expectedRelease -or $pointer.manifest_sha256 -ne $expected -or
+  $pointer.generation_manifest_sha256 -ne $expectedGen){throw 'R67 active predecessor binding mismatch'}
+$pkg=Get-Content -LiteralPath (Join-Path $root 'package.json') -Raw | ConvertFrom-Json
+if($pkg.version -ne '0.15.44'){throw 'R67 package candidate version mismatch'}
+Write-Output 'R67_PREDECESSOR_PREFLIGHT=PASS'
+if($Stage -eq 'preflight'){return}
+function Invoke-Node([string]$Label,[string[]]$NodeArgs){
+ Write-Output "R67_STAGE_START=$Label"
+ & node @NodeArgs
+ if($LASTEXITCODE -ne 0){throw "R67 stage $Label exit=$LASTEXITCODE"}
+ Write-Output "R67_STAGE_PASS=$Label"
+}
+if($Stage -eq 'all' -or $Stage -eq 'focused'){
+ Invoke-Node 'focused' @('scripts/r67-focused-gate.mjs')
+ Invoke-Node 'machine-fs-smoke' @('src/machine-fs-smoke-client.mjs')
+ if($Stage -eq 'focused'){return}
+}
+if($Stage -eq 'all' -or $Stage -eq 'evidence'){
+ if($OperationId -notmatch '^[a-z0-9][a-z0-9._-]{5,63}$'){throw 'R67 full evidence operation ID required'}
+ Invoke-Node 'evidence' @('scripts/r67-regression-reconcile.mjs',$OperationId)
+ if($Stage -eq 'evidence'){return}
+}
+if($Stage -eq 'all' -or $Stage -eq 'manifest'){
+ Invoke-Node 'manifest-verify' @('scripts/release-manifest.mjs','verify')
+ if($Stage -eq 'manifest'){return}
+}
+if($Stage -eq 'all' -or $Stage -eq 'doctor'){
+ $prior=$env:DEADBYTE_STATE_ROOT
+ $isolated='D:\Projects\deadbyte-mcp\testing\0.15.44-r67\doctor-isolated-empty'
+ if(Test-Path -LiteralPath (Join-Path $isolated 'active-release.json')){throw 'isolated doctor root unexpectedly has active release pointer'}
+ try{
+  $env:DEADBYTE_STATE_ROOT=$isolated
+  Invoke-Node 'isolated-doctor' @('src/deadbyte-cli.mjs','doctor')
+ }finally{$env:DEADBYTE_STATE_ROOT=$prior}
+ if($Stage -eq 'doctor'){return}
+}
+Write-Output 'R67_WINDOWS_GATE=PASS_PREDEPLOY_CANDIDATE'

package/scripts/gate-windows-r71.ps1

@@ -0,0 +1,64 @@
+param(
+ [ValidateSet('preflight','focused','full','manifest','doctor','all')]
+ [string]$Stage='preflight'
+)
+$ErrorActionPreference='Stop'
+Set-StrictMode -Version Latest
+$root=Split-Path -Parent $PSScriptRoot
+$state=Join-Path $env:USERPROFILE '.deadbyte-mcp'
+$parent=Join-Path $state 'releases\v0.15.44-9f500af433df3e77'
+$expected='9f500af433df3e7778d4f11acf418526d5889f478114c955c8c72c0077a0636e'
+$generation='c35f6ccca58083acd53484a983ef401ee18f28b11185cd02c7b1eb3e29028c71'
+$releaseId='v0.15.44-9f500af433df3e77'
+function Sha256-File([string]$File){
+ $algorithm=[System.Security.Cryptography.SHA256]::Create()
+ try{
+  $stream=[System.IO.File]::OpenRead($File)
+  try{return ([BitConverter]::ToString($algorithm.ComputeHash($stream))).Replace('-','').ToLowerInvariant()}
+  finally{$stream.Dispose()}
+ }finally{$algorithm.Dispose()}
+}
+if(!(Test-Path -LiteralPath $parent -PathType Container)){throw 'R71 sealed predecessor slot missing'}
+if((Sha256-File (Join-Path $parent 'MANIFEST.SHA256')) -ne $expected){throw 'R71 predecessor manifest mismatch'}
+$pointer=Get-Content -LiteralPath (Join-Path $state 'active-release.json') -Raw | ConvertFrom-Json
+if($pointer.release_id -ne $releaseId -or $pointer.manifest_sha256 -ne $expected -or
+   $pointer.generation_manifest_sha256 -ne $generation){throw 'R71 active predecessor pointer mismatch'}
+$pkg=Get-Content -LiteralPath (Join-Path $root 'package.json') -Raw | ConvertFrom-Json
+if($pkg.version -ne '0.15.45'){throw 'R71 package version mismatch'}
+Write-Output 'R71_PREDECESSOR_PREFLIGHT=PASS'
+if($Stage -eq 'preflight'){return}
+function Invoke-Node([string]$Label,[string[]]$Arguments){
+ Write-Output "R71_STAGE_START=$Label"
+ & node @Arguments
+ if($LASTEXITCODE -ne 0){throw "R71 stage $Label exit=$LASTEXITCODE"}
+ Write-Output "R71_STAGE_PASS=$Label"
+}
+if($Stage -eq 'focused' -or $Stage -eq 'all'){
+ Invoke-Node 'focused' @('--test','test/native-diff.test.mjs','test/native-diff-topology-r36.test.mjs',
+  'test/capability-resolver.test.mjs','test/capability-ledger-r36.test.mjs',
+  'test/r70-owner-approval.test.mjs','test/r70-autonomous-policy-bootstrap.test.mjs',
+  'test/r71-publish-fence.test.mjs','test/r71-release-identity.test.mjs',
+  'test/r71-full-verifier-artifact.test.mjs','test/r71-native-diff-mcp-wire.test.mjs')
+ if($Stage -eq 'focused'){return}
+}
+if($Stage -eq 'full' -or $Stage -eq 'all'){
+ Write-Output 'R71_STAGE_START=full'
+ & powershell -NoProfile -ExecutionPolicy Bypass -File (Join-Path $root 'scripts\verify-r70-full-regression.ps1')
+ if($LASTEXITCODE -ne 0){throw "R71 full regression exit=$LASTEXITCODE"}
+ Write-Output 'R71_STAGE_PASS=full'
+ if($Stage -eq 'full'){return}
+}
+if($Stage -eq 'manifest' -or $Stage -eq 'all'){
+ Invoke-Node 'manifest' @('scripts/release-manifest.mjs','verify')
+ if($Stage -eq 'manifest'){return}
+}
+if($Stage -eq 'doctor' -or $Stage -eq 'all'){
+ $previous=$env:DEADBYTE_STATE_ROOT
+ $isolated='D:\Projects\deadbyte-mcp\testing\0.15.45-r71\doctor-isolated-empty'
+ if(Test-Path -LiteralPath (Join-Path $isolated 'active-release.json')){throw 'R71 isolated doctor state has an unexpected pointer'}
+ try{
+  $env:DEADBYTE_STATE_ROOT=$isolated
+  Invoke-Node 'isolated-doctor' @('src/deadbyte-cli.mjs','doctor')
+ }finally{$env:DEADBYTE_STATE_ROOT=$previous}
+}
+Write-Output 'R71_WINDOWS_GATE=PASS_PREDEPLOY_CANDIDATE'

package/scripts/npm-preserve-artifact-r67.mjs

@@ -0,0 +1,99 @@
+import {createHash,randomBytes} from 'node:crypto';
+import {lstat,readFile,open,link,unlink} from 'node:fs/promises';
+import path from 'node:path';
+
+function sha256(bytes){return createHash('sha256').update(bytes).digest('hex');}
+function integrity(bytes){return 'sha512-'+createHash('sha512').update(bytes).digest('base64');}
+async function regular(pathname,label){
+ const stat=await lstat(pathname);
+ if(!stat.isFile()||stat.isSymbolicLink())throw new Error(label+' must be a regular non-symlink file');
+ return stat;
+}
+function assertSameIdentity(before,after){
+ if(before.dev!==after.dev||before.ino!==after.ino||before.size!==after.size)
+  throw new Error('source artifact identity changed during preservation; do not remove original');
+}
+
+/**
+ * Preserve an npm-packed immutable tarball across Windows volumes.
+ * Uses an exclusive staging file ON THE DESTINATION VOLUME, syncs complete
+ * verified bytes, and publishes with a same-volume, no-clobber hard link.
+ * No rename(D: -> C:), no partial destination visibility, no npm publish.
+ * Preserving exact bytes is NOT permission to send them to npm.
+ */
+export async function preserveNpmTarball({source,destination,expectedIntegrity,expectedShasum}={}){
+ if(typeof source!=='string'||typeof destination!=='string'||
+    !path.isAbsolute(source)||!path.isAbsolute(destination)||
+    path.resolve(source)===path.resolve(destination))throw new Error('absolute distinct source and destination required');
+ if(typeof expectedIntegrity!=='string'||!/^sha512-[A-Za-z0-9+/]+=*$/.test(expectedIntegrity))
+  throw new Error('npm SHA-512 integrity precondition required');
+ if(expectedShasum!==undefined&&!/^[a-f0-9]{40}$/.test(expectedShasum))
+  throw new Error('invalid npm packed artifact SHA-1 precondition');
+
+ const original=await regular(source,'source artifact');
+ if(original.size===0||original.size>128*1024*1024)throw new Error('npm artifact size outside permitted budget');
+ const bytes=await readFile(source);
+ assertSameIdentity(original,await regular(source,'source artifact'));
+ if(bytes.length!==original.size||integrity(bytes)!==expectedIntegrity)
+  throw new Error('npm packed artifact integrity mismatch; original retained');
+ if(expectedShasum!==undefined&&createHash('sha1').update(bytes).digest('hex')!==expectedShasum)
+  throw new Error('npm packed artifact shasum mismatch; original retained');
+ const hash=sha256(bytes);
+ let committed=false;
+ try{
+  const existing=await regular(destination,'preserved artifact');
+  const preserved=await readFile(destination);
+  if(existing.size!==bytes.length||sha256(preserved)!==hash||integrity(preserved)!==expectedIntegrity)
+   throw new Error('existing preserved artifact differs; manual conflict reconciliation required');
+  committed=true;
+ }catch(error){
+  if(error?.code!=='ENOENT')throw error;
+ }
+ let staging=null;
+ if(!committed){
+  staging=path.join(path.dirname(destination),'.'+path.basename(destination)+'.stage-'+process.pid+'-'+randomBytes(8).toString('hex'));
+  try{
+   const handle=await open(staging,'wx',0o600);
+   try{
+    await handle.writeFile(bytes);
+    await handle.sync();
+   }finally{await handle.close();}
+   const staged=await readFile(staging);
+   if(staged.length!==bytes.length||sha256(staged)!==hash||integrity(staged)!==expectedIntegrity)
+    throw new Error('staged artifact integrity mismatch; original retained');
+   // Atomic visibility of already-fsynced bytes, exclusively on the destination volume.
+   try{await link(staging,destination);}
+   catch(error){
+    if(error?.code!=='EEXIST')throw error;
+    const existing=await regular(destination,'preserved artifact');
+    const preserved=await readFile(destination);
+    if(existing.size!==bytes.length||sha256(preserved)!==hash||integrity(preserved)!==expectedIntegrity)
+     throw new Error('concurrent preserved artifact conflict; original retained');
+   }
+   committed=true;
+  }finally{
+   if(staging)await unlink(staging).catch(e=>{if(e?.code!=='ENOENT')throw e;});
+  }
+ }
+ // Final post-commit verification before relinquishing the source artifact.
+ const final=await regular(destination,'preserved artifact');
+ const preserved=await readFile(destination);
+ if(final.size!==bytes.length||sha256(preserved)!==hash||integrity(preserved)!==expectedIntegrity)
+  throw new Error('preserved artifact changed after commit; original retained');
+ const current=await regular(source,'source artifact');
+ assertSameIdentity(original,current);
+ if(sha256(await readFile(source))!==hash)throw new Error('source bytes changed after commit; retain for reconciliation');
+ await unlink(source);
+ return {status:staging?'VERIFIED_PRESERVED':'VERIFIED_ALREADY_PRESERVED',
+  sha256:hash,bytes:bytes.length,integrity:expectedIntegrity};
+}
+
+export async function assertVacantPackDestination({root,filename}={}){
+ if(typeof root!=='string'||!path.isAbsolute(root)||typeof filename!=='string'||
+    !/^[A-Za-z0-9][A-Za-z0-9._-]*\.tgz$/.test(filename)||filename!==path.basename(filename))
+   throw new Error('invalid npm pack target');
+ const target=path.join(root,filename);
+ try{await lstat(target);}
+ catch(error){if(error?.code==='ENOENT')return target;throw error;}
+ throw new Error('PACK_BLOCKED existing npm tarball must be archived and reconciled before npm pack: '+target);
+}