deadbyte-mcp 0.15.42 → 0.15.44

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.42",
+  "version": "0.15.44",
   "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-r65-prepublish.ps1",
+    "gate:windows": "powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r67.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",
@@ -90,7 +90,11 @@
     "r62:focused:test": "node --test --test-concurrency=1 test/r62-release-contract.test.mjs test/r62-doctor-transactions-reconcile.test.mjs test/r62-doctor-receipt-semantics.test.mjs test/r62-rollback-failure-receipt.test.mjs test/r58-doctor-transactions.test.mjs test/r58-completed-update-receipt.test.mjs test/runtime-self-update.test.mjs test/r56-rollback-launcher-restore.test.mjs",
     "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"
+    "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",
+    "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/proof/CONTAINMENT-BUILD.txt

@@ -39,7 +39,7 @@ deadbyte-process-host.cpp
 exit_code=0
 ==== probe-dependencies ====
 
-Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.30-stabilization\bin\containment-probe.exe
+Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.44-r67\bin\containment-probe.exe
 
 File Type: EXECUTABLE IMAGE
 
@@ -59,7 +59,7 @@ File Type: EXECUTABLE IMAGE
 exit_code=0
 ==== contained-launcher-dependencies ====
 
-Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.30-stabilization\bin\deadbyte-exec.exe
+Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.44-r67\bin\deadbyte-exec.exe
 
 File Type: EXECUTABLE IMAGE
 
@@ -83,7 +83,7 @@ File Type: EXECUTABLE IMAGE
 exit_code=0
 ==== contained-worker-dependencies ====
 
-Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.30-stabilization\bin\contained-transform-worker.exe
+Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.44-r67\bin\contained-transform-worker.exe
 
 File Type: EXECUTABLE IMAGE
 
@@ -104,7 +104,7 @@ File Type: EXECUTABLE IMAGE
 exit_code=0
 ==== contained-reverse-worker-dependencies ====
 
-Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.30-stabilization\bin\contained-reverse-worker.exe
+Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.44-r67\bin\contained-reverse-worker.exe
 
 File Type: EXECUTABLE IMAGE
 
@@ -125,7 +125,7 @@ File Type: EXECUTABLE IMAGE
 exit_code=0
 ==== named-tunnel-host-dependencies ====
 
-Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.30-stabilization\bin\deadbyte-tunnel-host.exe
+Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.44-r67\bin\deadbyte-tunnel-host.exe
 
 File Type: EXECUTABLE IMAGE
 
@@ -144,7 +144,7 @@ File Type: EXECUTABLE IMAGE
 exit_code=0
 ==== process-host-dependencies ====
 
-Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.30-stabilization\bin\deadbyte-process-host.exe
+Dump of file D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.44-r67\bin\deadbyte-process-host.exe
 
 File Type: EXECUTABLE IMAGE
 

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-r66-prepublish.ps1

@@ -0,0 +1,65 @@
+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 "R66 prepublish gate failed at $Name exit=$LASTEXITCODE" }
+}
+
+function Get-FileSha256([string]$File){
+  $hasher=[Security.Cryptography.SHA256]::Create()
+  try{
+    $bytes=[IO.File]::ReadAllBytes($File)
+    return (($hasher.ComputeHash($bytes) | ForEach-Object { $_.ToString('x2') }) -join '')
+  }finally{ $hasher.Dispose() }
+}
+
+$sourceRoot='D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.42-r65'
+$sourceManifest='1b4754103dd4ca43eb81f8e33cf188b36eee3051cb182396ccc6abe2a6e6c250'
+if(-not (Test-Path -LiteralPath $sourceRoot -PathType Container)){ throw 'R66 source predecessor missing' }
+$observedSourceManifest=Get-FileSha256 (Join-Path $sourceRoot 'MANIFEST.SHA256')
+if($observedSourceManifest -ne $sourceManifest){ throw 'R66 source predecessor manifest identity mismatch' }
+& node (Join-Path $root 'scripts\verify-r65-parent-source.mjs') --root $sourceRoot --expected-manifest-sha256 $sourceManifest
+if($LASTEXITCODE -ne 0){ throw 'R66 source predecessor declared-manifest verification failed' }
+
+$stateRoot=Join-Path $env:USERPROFILE '.deadbyte-mcp'
+$pointer=Join-Path $stateRoot 'active-release.json'
+if(-not (Test-Path -LiteralPath $pointer -PathType Leaf)){ throw "R66 runtime predecessor pointer missing: $pointer" }
+$active=Get-Content -LiteralPath $pointer -Raw | ConvertFrom-Json
+if($active.release_id -ne 'v0.15.42-1b4754103dd4ca43'){ throw "R66 runtime predecessor release mismatch: $($active.release_id)" }
+if($active.manifest_sha256 -ne $sourceManifest){ throw 'R66 runtime predecessor manifest mismatch' }
+if($active.generation_manifest_sha256 -ne '62dc68be55ad627f8d872b8be8c1369ecca0edf08fdedc8336c9ccee2d2809fb'){ throw 'R66 runtime predecessor generation mismatch' }
+if($Stage -eq 'preflight'){Write-Host '==== R66 WINDOWS GATE: PASS preflight ====';return}
+
+if($Stage -eq 'all' -or $Stage -eq 'focused'){
+  Invoke-Npm 'r66-focused' @('run','r66:focused:test')
+  if($Stage -eq 'focused'){Write-Host '==== R66 WINDOWS GATE: PASS focused ====';return}
+}
+if($Stage -eq 'all' -or $Stage -eq 'full'){
+  Invoke-Npm 'full-regression' @('test')
+  if($Stage -eq 'full'){Write-Host '==== R66 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 '==== R66 WINDOWS GATE: PASS manifest ====';return}
+}
+if($Stage -eq 'all' -or $Stage -eq 'doctor'){
+  $doctorRoot='D:\Projects\deadbyte-mcp\testing\0.15.43-r66\doctor-isolated-empty'
+  if(Test-Path -LiteralPath (Join-Path $doctorRoot 'active-release.json')){ throw 'R66 isolated doctor root unexpectedly contains a release pointer' }
+  $priorStateRoot=$env:DEADBYTE_STATE_ROOT
+  try{
+    $env:DEADBYTE_STATE_ROOT=$doctorRoot
+    Invoke-Npm 'doctor-isolated-empty-state' @('run','doctor')
+  }finally{ $env:DEADBYTE_STATE_ROOT=$priorStateRoot }
+  if($Stage -eq 'doctor'){Write-Host '==== R66 WINDOWS GATE: PASS doctor ====';return}
+}
+Write-Host '==== R66 PREPUBLISH WINDOWS GATE: PASS ===='

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/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);
+}

package/scripts/npm-release-r48.mjs

@@ -1,7 +1,9 @@
 import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { reconcileNpmPublication } from './npm-publication-r65.mjs';
-import { mkdtemp, readFile, rm, unlink, mkdir, rename } from 'node:fs/promises';
+import { mkdtemp, readFile, rm, unlink, mkdir } from 'node:fs/promises';
+import {preserveNpmTarball,assertVacantPackDestination} from './npm-preserve-artifact-r67.mjs';
+import {assertR67NpmPublishReady} from './npm-release-readiness-r67.mjs';
 import { existsSync } from 'node:fs';
 import { resolveStateRoot } from '../src/state-root.mjs';
 import path from 'node:path';
@@ -86,6 +88,7 @@ async function main() {
   if (provenance.version !== version) {
     throw new Error(`PROVENANCE.json version mismatch: package=${version} provenance=${provenance.version}`);
   }
+  if (!isVerifyOnly && version==='0.15.44') assertR67NpmPublishReady(release);
   if (release.parent?.release_id !== provenance.parent_release_id ||
       release.parent?.manifest_sha256 !== provenance.parent_manifest_sha256 ||
       release.parent?.generation_manifest_sha256 !== provenance.parent_generation_manifest_sha256) {
@@ -113,6 +116,7 @@ async function main() {
   if(publicationDir)await mkdir(publicationDir,{recursive:true});
   if(resuming&&!existsSync(preservedTarball))throw new Error('immutable npm publication claim exists but exact local tarball is missing; manual artifact reconciliation required');
   if(!resuming&&preservedTarball&&existsSync(preservedTarball))throw new Error('unclaimed preserved npm tarball exists; inspect artifact evidence before another pack');
+  if(!resuming)await assertVacantPackDestination({root,filename:`deadbyte-mcp-${version}.tgz`});
   const packed=resuming?null:parseJson(runNpm(['pack', '--json'], { timeout: 180000 }));
   const packRecord=resuming?{filename:path.basename(preservedTarball)}:(Array.isArray(packed) ? packed[0] : packed?.[pkg.name]);
   const filename = packRecord?.filename;
@@ -196,7 +200,11 @@ async function main() {
       return;
     }
 
-    if(!resuming)await rename(tarball,preservedTarball);
+    if(!resuming){
+      const preserved=await preserveNpmTarball({source:tarball,destination:preservedTarball,
+        expectedIntegrity:packRecord.integrity,expectedShasum:packRecord.shasum});
+      console.log('Immutable cross-volume artifact preservation verified: '+JSON.stringify(preserved));
+    }
     const publishTarball=preservedTarball;
     const localBytes = await readFile(publishTarball);
     const localIntegrity=`sha512-${createHash('sha512').update(localBytes).digest('base64')}`;