deadbyte-mcp 0.15.46 → 0.15.48

package/SBOM.cdx.json

@@ -1,13 +1,13 @@
 {
   "bomFormat": "CycloneDX",
   "specVersion": "1.6",
-  "serialNumber": "urn:cdx:deadbyte-mcp:r72:0.15.46",
+  "serialNumber": "urn:cdx:deadbyte-mcp:r74:0.15.47",
   "version": 1,
   "metadata": {
     "component": {
       "type": "application",
       "name": "deadbyte-mcp",
-      "version": "0.15.46"
+      "version": "0.15.47"
     }
   },
   "components": [

package/TEST-MATRIX.json

@@ -1,7 +1,7 @@
 {
   "schema": "deadbyte.test-matrix.v1",
-  "version": "0.15.46",
-  "train": "R72",
+  "version": "0.15.48",
+  "train": "R74",
   "primary_platform": "win32-x64",
   "reference": {
     "package": "@wonderwhy-er/desktop-commander",

package/bridge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deadbyte-chatgpt-bridge",
-  "version": "0.15.46",
+  "version": "0.15.47",
   "private": true,
   "type": "module",
   "engines": {

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.46-r72\\controller\\runtime\\process-grant.json",
-  "state_dir": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.46-r72\\controller\\runtime\\process-state",
+  "grant_file": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.48-r108-release-dev\\controller\\runtime\\process-grant.json",
+  "state_dir": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.48-r108-release-dev\\controller\\runtime\\process-state",
   "native_host": {
-    "path": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.46-r72\\bin\\deadbyte-process-host.exe",
+    "path": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.48-r108-release-dev\\bin\\deadbyte-process-host.exe",
     "sha256": "daf9cfb371bee88cafbf5597eaa507fec504dbe0b0ddd40d0c3c2e02817f49e4"
   },
   "roots": {
     "core": {
-      "path": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.46-r72",
+      "path": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.48-r108-release-dev",
       "deny_paths": [
         "node_modules",
         "controller/runtime",
@@ -20,7 +20,7 @@
   "profiles": {
     "ping_hold": {
       "executable": "C:\\WINDOWS\\System32\\cmd.exe",
-      "executable_sha256": "97ac98b1a92c286054cce55239cfccdfc23a5517bd07fe693072c9ca96c7dabb",
+      "executable_sha256": "15cd209c995b7d3009c91ca40892d5b8f1fb162f3e5f10716642ea278e8e0d7b",
       "root_ids": [
         "core"
       ],
@@ -45,7 +45,7 @@
     },
     "powershell": {
       "executable": "C:\\WINDOWS\\System32\\WindowsPowerShell\\v1.0\\powershell.exe",
-      "executable_sha256": "8bb6fa8c283b4d92120b1ef249a9b311b0f804d4cabbe9981159976c8be76a5e",
+      "executable_sha256": "60c9b29843624dd8af6b6a7b26147753be6aeef65098b9a503cc50850afe410f",
       "root_ids": [
         "core"
       ],
@@ -76,7 +76,7 @@
     },
     "powershell_repl": {
       "executable": "C:\\WINDOWS\\System32\\WindowsPowerShell\\v1.0\\powershell.exe",
-      "executable_sha256": "8bb6fa8c283b4d92120b1ef249a9b311b0f804d4cabbe9981159976c8be76a5e",
+      "executable_sha256": "60c9b29843624dd8af6b6a7b26147753be6aeef65098b9a503cc50850afe410f",
       "root_ids": [
         "core"
       ],

package/docs/R73-CAPABILITY-GAP-MATRIX.json

@@ -0,0 +1,17 @@
+{
+  "schema": "deadbyte.r73-reference-differential.v1",
+  "scope": "read-only static comparison; no donor runtime or benchmark was executed",
+  "references": [
+    {"version":"0.2.52","root":"D:/Projects/deadbyte-mcp/references/desktop-commander v0.2.52","license":"MIT per package.json"},
+    {"version":"0.3.0","root":"D:/Projects/deadbyte-mcp/references/desktop-commander v0.3.0","license":"MIT per package.json and LICENSE"},
+    {"version":"0.3.1-alpha.2","root":"D:/Projects/deadbyte-mcp/references/desktop-commander-0.3.1-alpha.2/static","license":"MIT per package.json and LICENSE"}
+  ],
+  "findings": [
+    {"mechanism":"process-tree cleanup","donor_evidence":"desktop-commander v0.3.0/dist/utils/process-tree.js","deadbyte_evidence":"native/deadbyte-process-host.cpp; src/process-runtime.mjs","decision":"KEEP","reason":"DEADBYTE Job Object ownership and creation-time identity are stronger than PID-only taskkill; test PID reuse instead of porting code."},
+    {"mechanism":"atomic file replacement","donor_evidence":"desktop-commander v0.3.0/dist/utils/atomic-write.js; dist/utils/rename.js","deadbyte_evidence":"src/atomic-mutation.mjs; test/atomic-mutation.test.mjs","decision":"ADAPT","reason":"The existing mutation lock could reclaim a live writer solely from aged mtime. R73 adds owner liveness and lock identity checks, retaining exact preconditions and unknown-effect semantics."},
+    {"mechanism":"corrupt config recovery","donor_evidence":"desktop-commander v0.3.0/dist/config-recovery.js","deadbyte_evidence":"src/runtime-update.mjs; src/activation-preflight-r65.mjs","decision":"DEFER","reason":"No reproduced DEADBYTE config recovery defect yet; avoid a second unsanctioned recovery path."},
+    {"mechanism":"bounded remote reconnect and telemetry","donor_evidence":"desktop-commander v0.3.0/dist/remote-device/remote-channel.js; dist/remote-device/transport-telemetry.js","deadbyte_evidence":"src/remote-device-r44.mjs; bridge/src/remote-call-claims-r60.mjs","decision":"KEEP","reason":"DEADBYTE has durable pre-dispatch claims and no-replay; focused recovery tests are required before any runtime change."},
+    {"mechanism":"alpha presentation and transport changes","donor_evidence":"desktop-commander-0.3.1-alpha.2/static/dist/utils/toolHistory.js; static/dist/remote-device/remote-channel.js","deadbyte_evidence":"src/remote-live-log.mjs; bridge/src/remote-dispatch-r60.mjs","decision":"DEFER","reason":"Static alpha snapshot is not behavioral or performance evidence; no compatible regression has been demonstrated."}
+  ],
+  "code_copied": false
+}

package/docs/R73-EXECUTION-CONTRACT.md

@@ -0,0 +1,11 @@
+# R73 controlled successor contract
+
+- Objective: improve post-0.15.46 correctness and recovery from reproducible defects; do not claim competitor superiority without equivalent runtime measurements.
+- Source master: published `deadbyte-mcp@0.15.46` tarball at `C:\Users\DEADBYTE\.deadbyte-mcp\evidence\npm-publication\0.15.46\deadbyte-mcp-0.15.46.tgz`, SHA-256 `b1a7c215e66fba14b1f1c19675dd3c9e75340d41fd5bd2a3d778175624bfc03e`. The extracted 2,288-file manifest verifies as `55c42123634a7fc3550c0cc24f09dc769ce777a9566032faab9247bb8d85067a`.
+- Runtime predecessor: active `v0.15.45-34aa8d1241cfb8bf` (manifest `34aa8d1241cfb8bf0b5ba303bf3c06e0e9e1bf01f64457bca659d6dd4d634fdc`); observed OFFLINE with all five authority planes DISARMED on 2026-10-15. Published source and active runtime are intentionally distinct.
+- Target: this non-Git `deadbyte-mcp-0.15.47-r73` successor only. The published tarball, R72 tree, active slots, grants, evidence, and reference corpus are protected.
+- Method: inspect actual current primitives and three Desktop Commander reference snapshots; capture RED for any behavioral change; implement the smallest native fix; focused GREEN, adversarial tests, full regression, Windows gate, independent review, manifest and verify-only package proof. No donor code reuse, generic shell, public tool or authority expansion.
+- Decision authority: owner has approved bounded source/tests in isolated successor (Class 2/3). License choice, new public interface/authority, deployment, npm publication, active runtime operations and production grant changes remain Class 1 and are prohibited in this task.
+- Assurance: HIGH_RISK for authority, filesystem, process, remote replay and release evidence. Acceptance oracles are fixture-controlled runtime state, independent file/process identity, exact hash/receipt verification, protocol responses and actual exit codes. Static comparison is not runtime acceptance.
+- Stop conditions: source/tarball identity drift; unavoidable production effect; missing independent owner authority; unresolved ambiguous mutation; or a mandatory gate that cannot pass without scope expansion. Preserve failed evidence. Do not seal a final release.
+- Rollback: discard only R73 successor changes through an explicitly reviewed file-level recovery from the verified 0.15.46 tarball; never reset or clean another tree.

package/docs/R73-IMPLEMENTATION-CHANGELOG.md

@@ -0,0 +1,12 @@
+# R73 candidate change log
+
+- Bootstrapped this non-Git successor from the verified published 0.15.46 tarball, not the mutable R72 tree. Active runtime 0.15.45 was not operated on.
+- RED: the identical six-case test file against the SHA-verified 0.15.46 predecessor `src/atomic-mutation.mjs` returned 3 pass / 3 fail. An aged lock was deleted while its writer was alive, a dead-owner lock was stolen without atomic ownership proof, and post-commit lock ownership loss was not classified. Against R73, the same six cases returned 6 pass / 0 fail.
+- GREEN: retain owner identity in the lock, do not reclaim an aged live lock, and never auto-delete an aged dead-owner lock without an atomic compare-and-delete primitive. Dead-owner locks fail closed with explicit reconciliation required; this trades automatic availability for serialization safety. New-lock I/O failure attempts to clean its own marker, timeout uses monotonic elapsed time, and post-commit lock ownership loss is classified as unknown effect. No public schema or authority change.
+- R67 v2 receipt reconciliation was already implemented. The npm tarball omitted `package-lock.json`; R73 regenerated it offline from 0.15.46 package metadata (matching the R72 source lock SHA-256 `bdddc9cba7a985feea78d3ec6c7100bb650587dcfee852eaa420f08fc6fdbb12`). The real CLI reconciler now returns `STALE_SOURCE`, 32 stale shards and zero integrity faults against historical R67 evidence, never a fabricated PASS.
+- Package boundary RED: npm dry-run inventory included two generated `testing/r70-verifier` artifacts. Added `.npmignore` for generated test evidence/reference/private environment paths; the identical behavioral test is GREEN. Existing evidence files were not deleted.
+- Full regression exposed four setup failures unrelated to the new lock behavior: the R48 pinned donor path no longer existed, and process policy retained four R72-root paths after tarball extraction. The donor file at `desktop-commander v0.2.52` has the exact pinned SHA-256 `f342345e34e48769dabaefe1b932f09d41e2e207b422f7794a15ee50ffa8f140`; the test now points there without changing expectations. The process policy was rebound only to this isolated successor and refreshed with the canonical native/system hash tool. Targeted 8/8 tests pass.
+- The R72 `RELEASE.json.r72_hotfix` hashes describe an earlier candidate seal, not the final published tarball: embedded `883d73…`/`1aa877…` differ from final manifest `55c421…`/tarball `b1a7c2…`. The current R72 publication fence reads the external manifest and evidence index, not these embedded hashes. R73 must not promote this historical snapshot to a final claim.
+- npm package metadata declares no license, while inspected Desktop Commander snapshots say MIT. No license was chosen for DEADBYTE.
+
+No npm publish, production activation, rollback, grant change, donor code copy, or final-release seal is authorized in R73.

package/docs/R73-REMAINING-DEFECTS.md

@@ -0,0 +1,9 @@
+# R73 remaining boundaries
+
+1. A dead owner may leave an aged `.deadbyte-mutation.lock`. R73 refuses automatic deletion because a pathname check followed by unlink can remove a new writer's lock. Recovery requires independent target/receipt reconciliation and an ownership-safe OS primitive or reviewed operator action; no mutation is retried while the lock remains.
+2. Lock-file serialization assumes cooperative writers within an authorized root. A hostile process with write access to the same directory can replace the marker between read and unlink. Directory access control and exact SHA preconditions remain necessary; this file lock is not a hostile-local-process security boundary.
+3. Published 0.15.46 package omits `package-lock.json`; R73 regenerated the 0.15.46 lock offline in the isolated successor, matching the R72 source lock hash. The real R67 CLI now runs here and reports `STALE_SOURCE` for all 32 historical shards, not PASS. This does not change the published tarball or backfill historical receipts.
+4. `RELEASE.json.r72_hotfix` contains prepublication candidate hashes, not the final published 0.15.46 tarball/manifest hashes. The actual R72 publish fence uses external evidence and current manifest bytes. R73 documentation labels this historical snapshot; future release contracts should use explicit snapshot/final fields without self-referential embedded hashes.
+5. DEADBYTE npm package has no `license` field or root license file. Owner must decide licensing; donor MIT terms do not license DEADBYTE by implication.
+6. No donor runtime benchmark or ChatGPT remote end-to-end comparison has been performed. Static reference inspection cannot establish performance or capability superiority.
+7. R73 package version/metadata remain 0.15.46/R72 pending behavioral and release gates. This directory is a development successor, not a sealed or publishable 0.15.47 artifact.

package/docs/R74-KERNEL-LOCK-BINARY.json

@@ -0,0 +1,11 @@
+{
+  "schema": "deadbyte.r74-kernel-lock-binary.v1",
+  "status": "candidate",
+  "exe": "bin/deadbyte-kernel-lock-r74.exe",
+  "sha256": "a1dbb8963ab89f7c99f06c78612bfa15c3fb8ed7fbc48c1b17d160d4e4f02b4c",
+  "source": "native/deadbyte-kernel-lock-r74.cpp",
+  "source_sha256": "9cb7f1f8d5e267d7f7359307ab1136b91214b021b01831075514a69f7fe0368a",
+  "allow_network_egress": false,
+  "max_output_bytes": 65536,
+  "exit_fail_closed": true
+}

package/docs/R75-RECOVERY-HANDOFF.md

@@ -0,0 +1,16 @@
+# R75 isolated authority recovery hardening
+
+- Source predecessor: `D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.48-r75`, non-Git, verified 2,304-file manifest SHA-256 `e70561e261610d451d33731a5f19b8439548d7062bed4bf109c4e90f1cd8cf38` before copy.
+- Published source identity remains `0.15.47`; active runtime predecessor observed read-only as `v0.15.45-34aa8d1241cfb8bf`, OFFLINE, with no plane armed. The Autonomous status reason was a broad Coding root, not verified clean-disarmed evidence.
+- This successor keeps `0.15.47/R74` package metadata during behavior verification. It is neither sealed nor release-ready. Production slots, grants, pointer, and historical evidence were not mutated.
+- RED: an `armed=false` Autonomous observation with an unverified reason was activation-safe; an object or Boolean observation without direct grant proof was activation-safe; a startup primary failure was hidden by cleanup failure; malformed ownership marker exited successfully. Each now has a matching focused GREEN test.
+- Authority proof reads each policy by digest, resolves its policy-bound grant location within the isolated runtime, checks grant presence, and requires stable regular-file identity across reads. Host policy v1/v2 remain accepted. The broad-root issuance validator is not used for revocation observation.
+- The existing R75 Autonomous revocation split and startup AggregateError were retained. The new CLI change addresses failure masking in the post-synchronization lifecycle and makes unverified marker cleanup terminal rather than success.
+- R72 isolated controller fixtures verify broad-root absent-grant revocation, signed epoch revocation attempt for a present grant, external-path denial and failed epoch handling. These tests do not operate the production predecessor.
+- Recovery boundary added after independent review: absent owner PID and PID reuse are not ownership evidence. A marker with no verified guardian/owner now remains in place and startup fails closed without touching authority. Identical behavioral RED 0/2 (stale marker proceeded, PID reuse passed), then GREEN 2/2; full remote-session CLI suite 30/30. The verified guardian cleanup path remains intact. This leaves manual reconciliation necessary for an orphan marker without a verified guardian; it does not authorize marker deletion.
+- Remaining proof before `R75_RECOVERY_VERIFIED`: rerun final-byte full regression, Windows gate, manifest, native/bin identity, package inspection, isolated install/doctor, and final independent review.
+- First full verifier run on an intermediate manifest produced 1,574 tests: 1,525 pass, 5 fail, 44 historical skips. The failures were isolated preflight fixture lacking the newly required runtime/policy proof; copied Process policy still pointed to R74; a CLI source-grep harness assumed LF only; and two frozen R72 identity tests asserted version 0.15.46 against current development 0.15.47. The first three fixtures/paths were corrected, and R72-only tests now carry explicit historical-version skip reasons. This first run is not final-byte PASS evidence.
+- A later full verifier on intermediate bytes produced 1,575 tests: 1,527 pass, 2 fail, 46 historical skips. Both failures were R58 tests expecting automatic stale-marker removal from an absent/reused PID. Their isolated fixtures now assert the safer R75 contract instead: no authority command, no marker removal, no foreground READY. Focused rerun 4/4 passed. This intermediate full run is not final-byte PASS evidence.
+- Final production-source gates: durable full verifier `1,575 tests / 1,529 pass / 0 fail / 46 historical/version-scoped skip`, stdout SHA-256 `740f30b8078ecc88142645b4197fcce65abfdc952f086457734769b77dd12a35`; Windows gate focused `56 / 54 pass / 0 fail / 2 historical skip`, repeated full `1,575 / 1,529 pass / 0 fail / 46 skip`, stdout SHA-256 `3b1878039f6b3f123dc2fd4d0bf58b97c51a54309dfa380c50508a35e026e9ba`. Isolated doctor PASS.
+- Exact development package before this handoff update: 2,310 tar members, 12,088,356 bytes, tarball SHA-256 `ee550022b468b998e9d34d2a01e61fb85af9fe89c7812fcffa70d08fca1dda28`, isolated npm install/doctor PASS and canonical npm release `--verify-only` PASS. Publication and activation were not run. Regenerate the development manifest/package after this documentation update before using an exact package claim.
+- Independent review: the owner-PID stale-marker deletion path is closed. Armed epoch validity is verified by the controller and composed with independent pinned grant-file observation, not reverified from signed epoch bytes by this module. `releaseRemoteSession` still has a read-identity then pathname-remove TOCTOU boundary; no production-only runtime or crash proof was performed. These limitations must not be described as proven away.

package/docs/R85-EPOCH-LOCK-BINARY.json

@@ -0,0 +1,13 @@
+{
+  "schema": "deadbyte.r85-epoch-lock-binary.v1",
+  "status": "development-candidate",
+  "platform": "win32-x64",
+  "node_api_version": 8,
+  "source": "native/deadbyte-epoch-lock-r85.cpp",
+  "source_sha256": "c451c257467b6a141918400b61855bac0e466015c1f3901e8be56ce6d9c32c7f",
+  "addon": "bin/deadbyte-epoch-lock-r85.node",
+  "addon_sha256": "fb73007ca2303d66120940f192461aac2fa4c45dc4603d920f0878d77e65cfed",
+  "build_node_header_version": "25.9.0",
+  "build_node_api_header_sha256": "2d4560831e525b47b060ec8a0864ab73993df9e20215ce9f0fe7b24cd31af32a",
+  "build_node_import_lib_sha256": "e3577a5a4a772b21646fe05a24d53ce3727395bbbc412f326889ddf7129bc7a9"
+}

package/native/deadbyte-epoch-lock-r85.cpp

@@ -0,0 +1,241 @@
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+#define NAPI_VERSION 8
+#include <windows.h>
+#include <node_api.h>
+#include <algorithm>
+#include <cstddef>
+#include <cstring>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace {
+struct Lease {
+  HANDLE leaf = INVALID_HANDLE_VALUE;
+  std::vector<HANDLE> ancestors;
+  bool renamed = false;
+  ~Lease() {
+    if (leaf != INVALID_HANDLE_VALUE) CloseHandle(leaf);
+    for (auto it = ancestors.rbegin(); it != ancestors.rend(); ++it) CloseHandle(*it);
+  }
+};
+
+void Throw(napi_env env, const char* message) { napi_throw_error(env, nullptr, message); }
+void ThrowWin32(napi_env env, const char* message, DWORD code) {
+  std::string detail = std::string(message) + " (win32=" + std::to_string(code) + ")";
+  Throw(env, detail.c_str());
+}
+bool Text(napi_env env, napi_value value, std::string& out) {
+  size_t size = 0;
+  if (napi_get_value_string_utf8(env, value, nullptr, 0, &size) != napi_ok || size > 32760) return false;
+  out.resize(size);
+  size_t actual = 0;
+  return napi_get_value_string_utf8(env, value, out.data(), size + 1, &actual) == napi_ok && actual == size &&
+    out.find('\0') == std::string::npos;
+}
+bool Wide(const std::string& input, std::wstring& output) {
+  if (input.empty()) return false;
+  int needed = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, input.data(), static_cast<int>(input.size()), nullptr, 0);
+  if (needed < 1) return false;
+  output.resize(needed);
+  return MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, input.data(), static_cast<int>(input.size()),
+    output.data(), needed) == needed;
+}
+bool LocalFullPath(const std::wstring& input, std::wstring& output) {
+  DWORD needed = GetFullPathNameW(input.c_str(), 0, nullptr, nullptr);
+  if (needed < 4 || needed > 32760) return false;
+  std::vector<wchar_t> chars(needed);
+  if (GetFullPathNameW(input.c_str(), needed, chars.data(), nullptr) != needed - 1) return false;
+  output.assign(chars.data());
+  if (output.size() < 4 || !((output[0] >= L'A' && output[0] <= L'Z') ||
+      (output[0] >= L'a' && output[0] <= L'z')) || output[1] != L':' || output[2] != L'\\' ||
+      output.find(L':', 2) != std::wstring::npos || output.back() == L'\\') return false;
+  return true;
+}
+bool PinDirectory(const std::wstring& directory, Lease& lease) {
+  HANDLE h = CreateFileW(directory.c_str(), FILE_READ_ATTRIBUTES, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
+    FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, nullptr);
+  if (h == INVALID_HANDLE_VALUE) return false;
+  FILE_ATTRIBUTE_TAG_INFO info{};
+  if (!GetFileInformationByHandleEx(h, FileAttributeTagInfo, &info, sizeof(info)) ||
+      !(info.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) || (info.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)) {
+    CloseHandle(h); SetLastError(ERROR_REPARSE_TAG_INVALID); return false;
+  }
+  lease.ancestors.push_back(h);
+  return true;
+}
+bool PinAncestors(const std::wstring& full, Lease& lease) {
+  const size_t end = full.find_last_of(L'\\');
+  if (end == std::wstring::npos || end < 2) return false;
+  std::wstring current = full.substr(0, 3);
+  if (!PinDirectory(current, lease)) return false;
+  size_t at = 3;
+  while (at < end) {
+    size_t next = full.find(L'\\', at);
+    if (next == std::wstring::npos || next > end) next = end;
+    if (next == at) return false;
+    current += full.substr(at, next - at);
+    if (!PinDirectory(current, lease)) return false;
+    current += L'\\';
+    at = next + 1;
+  }
+  return true;
+}
+DWORD ClosePinnedAncestors(Lease& lease) {
+  DWORD firstError = ERROR_SUCCESS;
+  for (auto it = lease.ancestors.rbegin(); it != lease.ancestors.rend(); ++it) {
+    if (!CloseHandle(*it) && firstError == ERROR_SUCCESS) firstError = GetLastError();
+  }
+  lease.ancestors.clear();
+  return firstError;
+}
+DWORD DisposeHeldLeaf(Lease& lease) {
+  if (lease.leaf == INVALID_HANDLE_VALUE) return ERROR_INVALID_HANDLE;
+  FILE_DISPOSITION_INFO disposition{};
+  disposition.DeleteFile = TRUE;
+  if (!SetFileInformationByHandle(lease.leaf, FileDispositionInfo, &disposition, sizeof(disposition)))
+    return GetLastError();
+  return ERROR_SUCCESS;
+}
+void ThrowWin32WithCleanup(napi_env env, const char* message, DWORD primary, DWORD cleanup) {
+  std::string detail = std::string(message) + " (win32=" + std::to_string(primary);
+  if (cleanup != ERROR_SUCCESS) detail += ", cleanup_win32=" + std::to_string(cleanup);
+  detail += ")";
+  Throw(env, detail.c_str());
+}
+void Finalize(napi_env, void* data, void*) { delete static_cast<Lease*>(data); }
+
+napi_value Acquire(napi_env env, napi_callback_info info) {
+  size_t argc = 3;
+  napi_value argv[3];
+  if (napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr) != napi_ok || argc != 3) {
+    Throw(env, "epoch native acquire arguments invalid"); return nullptr;
+  }
+  std::string pathUtf8, nonce;
+  void* content = nullptr;
+  size_t contentLength = 0;
+  bool buffer = false;
+  if (!Text(env, argv[0], pathUtf8) || napi_is_buffer(env, argv[1], &buffer) != napi_ok || !buffer ||
+      napi_get_buffer_info(env, argv[1], &content, &contentLength) != napi_ok ||
+      contentLength < 2 || contentLength > 16384 || !Text(env, argv[2], nonce) || nonce.size() != 32 ||
+      !std::all_of(nonce.begin(), nonce.end(), [](unsigned char c) {
+        return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f');
+      })) {
+    Throw(env, "epoch native acquire arguments invalid"); return nullptr;
+  }
+  std::wstring widePath, full;
+  if (!Wide(pathUtf8, widePath) || !LocalFullPath(widePath, full)) {
+    Throw(env, "epoch native lock requires ordinary local-drive path"); return nullptr;
+  }
+  auto lease = std::make_unique<Lease>();
+  if (!PinAncestors(full, *lease)) {
+    ThrowWin32(env, "epoch native ancestor pin failed closed", GetLastError()); return nullptr;
+  }
+  DWORD existing = GetFileAttributesW(full.c_str());
+  if (existing != INVALID_FILE_ATTRIBUTES) {
+    napi_value result;
+    napi_get_null(env, &result);
+    return result;
+  }
+  DWORD existenceError = GetLastError();
+  if (existenceError != ERROR_FILE_NOT_FOUND && existenceError != ERROR_PATH_NOT_FOUND) {
+    ThrowWin32(env, "epoch native target existence uncertain", existenceError); return nullptr;
+  }
+  std::wstring nonceWide(nonce.begin(), nonce.end());
+  std::wstring temporary = full + L".r85-" + nonceWide + L".tmp";
+  lease->leaf = CreateFileW(temporary.c_str(), GENERIC_READ | GENERIC_WRITE | DELETE | FILE_READ_ATTRIBUTES,
+    0, nullptr, CREATE_NEW, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OPEN_REPARSE_POINT, nullptr);
+  if (lease->leaf == INVALID_HANDLE_VALUE) {
+    ThrowWin32(env, "epoch native temp create failed closed", GetLastError()); return nullptr;
+  }
+  FILE_ATTRIBUTE_TAG_INFO tag{};
+  if (!GetFileInformationByHandleEx(lease->leaf, FileAttributeTagInfo, &tag, sizeof(tag)) ||
+      (tag.FileAttributes & (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT))) {
+    DWORD error = GetLastError(); DWORD cleanup = DisposeHeldLeaf(*lease);
+    ThrowWin32WithCleanup(env, "epoch native leaf identity failed closed", error, cleanup); return nullptr;
+  }
+  const auto* bytes = static_cast<const unsigned char*>(content);
+  size_t written = 0;
+  while (written < contentLength) {
+    DWORD part = 0;
+    if (!WriteFile(lease->leaf, bytes + written, static_cast<DWORD>(contentLength - written), &part, nullptr) || !part) {
+      DWORD error = GetLastError(); DWORD cleanup = DisposeHeldLeaf(*lease);
+      ThrowWin32WithCleanup(env, "epoch native lock write failed closed", error, cleanup); return nullptr;
+    }
+    written += part;
+  }
+  if (!FlushFileBuffers(lease->leaf)) {
+    DWORD error = GetLastError(); DWORD cleanup = DisposeHeldLeaf(*lease);
+    ThrowWin32WithCleanup(env, "epoch native lock flush failed closed", error, cleanup); return nullptr;
+  }
+  const size_t renameSize = offsetof(FILE_RENAME_INFO, FileName) + (full.size() + 1) * sizeof(wchar_t);
+  std::vector<unsigned char> renameBuffer(renameSize, 0);
+  auto* renameInfo = reinterpret_cast<FILE_RENAME_INFO*>(renameBuffer.data());
+  renameInfo->ReplaceIfExists = FALSE;
+  renameInfo->RootDirectory = nullptr;
+  renameInfo->FileNameLength = static_cast<DWORD>(full.size() * sizeof(wchar_t));
+  std::memcpy(renameInfo->FileName, full.data(), renameInfo->FileNameLength);
+  if (!SetFileInformationByHandle(lease->leaf, FileRenameInfo, renameInfo, static_cast<DWORD>(renameSize))) {
+    DWORD error = GetLastError(); DWORD cleanup = DisposeHeldLeaf(*lease);
+    if (cleanup == ERROR_SUCCESS && (error == ERROR_FILE_EXISTS || error == ERROR_ALREADY_EXISTS)) {
+      napi_value result;
+      napi_get_null(env, &result);
+      return result;
+    }
+    ThrowWin32WithCleanup(env, "epoch native lock rename failed closed", error, cleanup); return nullptr;
+  }
+  lease->renamed = true;
+  napi_value result;
+  if (napi_create_external(env, lease.get(), Finalize, nullptr, &result) != napi_ok) {
+    DWORD cleanup = DisposeHeldLeaf(*lease);
+    ThrowWin32WithCleanup(env, "epoch native handle publication failed closed", ERROR_NOT_ENOUGH_MEMORY, cleanup);
+    return nullptr;
+  }
+  lease.release();
+  return result;
+}
+
+napi_value Release(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value argv[1];
+  void* raw = nullptr;
+  if (napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr) != napi_ok || argc != 1 ||
+      napi_get_value_external(env, argv[0], &raw) != napi_ok || !raw) {
+    Throw(env, "epoch native release handle invalid"); return nullptr;
+  }
+  auto* lease = static_cast<Lease*>(raw);
+  if (lease->leaf == INVALID_HANDLE_VALUE || !lease->renamed) {
+    Throw(env, "epoch native lock already released"); return nullptr;
+  }
+  FILE_DISPOSITION_INFO disposition{};
+  disposition.DeleteFile = TRUE;
+  if (!SetFileInformationByHandle(lease->leaf, FileDispositionInfo, &disposition, sizeof(disposition))) {
+    ThrowWin32(env, "epoch native lock disposition failed closed", GetLastError()); return nullptr;
+  }
+  if (!CloseHandle(lease->leaf)) {
+    ThrowWin32(env, "epoch native lock close failed closed", GetLastError()); return nullptr;
+  }
+  lease->leaf = INVALID_HANDLE_VALUE;
+  lease->renamed = false;
+  DWORD ancestorCloseError = ClosePinnedAncestors(*lease);
+  if (ancestorCloseError != ERROR_SUCCESS) {
+    ThrowWin32(env, "epoch native ancestor close failed after lock release", ancestorCloseError);
+    return nullptr;
+  }
+  napi_value result;
+  napi_get_undefined(env, &result);
+  return result;
+}
+
+napi_value Init(napi_env env, napi_value exports) {
+  napi_value acquire, release;
+  if (napi_create_function(env, "acquire", NAPI_AUTO_LENGTH, Acquire, nullptr, &acquire) != napi_ok ||
+      napi_create_function(env, "release", NAPI_AUTO_LENGTH, Release, nullptr, &release) != napi_ok ||
+      napi_set_named_property(env, exports, "acquire", acquire) != napi_ok ||
+      napi_set_named_property(env, exports, "release", release) != napi_ok) return nullptr;
+  return exports;
+}
+}  // namespace
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)

package/native/deadbyte-kernel-lock-r74.cpp

@@ -0,0 +1,65 @@
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+#include <windows.h>
+#include <iostream>
+#include <string>
+
+int wmain(int argc, wchar_t** argv) {
+    if (argc < 3) {
+        std::cout << "{\"schema\":\"deadbyte.kernel-lock.r74.v1\",\"status\":\"failed\",\"error\":\"usage: acquire <file> | probe <file>\"}\n";
+        return 2;
+    }
+    const std::wstring op = argv[1];
+    const std::wstring path = argv[2];
+
+    if (op == L"probe") {
+        HANDLE h = CreateFileW(path.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+        if (h == INVALID_HANDLE_VALUE) {
+            DWORD err = GetLastError();
+            if (err == ERROR_SHARING_VIOLATION || err == ERROR_LOCK_VIOLATION || err == ERROR_ACCESS_DENIED) {
+                std::cout << "{\"schema\":\"deadbyte.kernel-lock.r74.v1\",\"status\":\"locked\",\"error_code\":\"SHARING_VIOLATION\",\"win32_error\":" << err << "}\n";
+                return 1;
+            }
+            std::cout << "{\"schema\":\"deadbyte.kernel-lock.r74.v1\",\"status\":\"failed\",\"error_code\":\"WIN32_ERROR\",\"win32_error\":" << err << "}\n";
+            return 2;
+        }
+        CloseHandle(h);
+        std::cout << "{\"schema\":\"deadbyte.kernel-lock.r74.v1\",\"status\":\"unlocked\"}\n";
+        return 0;
+    }
+
+    if (op == L"acquire") {
+        HANDLE h = CreateFileW(path.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+        if (h == INVALID_HANDLE_VALUE) {
+            DWORD err = GetLastError();
+            if (err == ERROR_SHARING_VIOLATION || err == ERROR_LOCK_VIOLATION || err == ERROR_ACCESS_DENIED) {
+                std::cout << "{\"schema\":\"deadbyte.kernel-lock.r74.v1\",\"status\":\"locked\",\"error_code\":\"SHARING_VIOLATION\",\"win32_error\":" << err << "}\n";
+                return 1;
+            }
+            std::cout << "{\"schema\":\"deadbyte.kernel-lock.r74.v1\",\"status\":\"failed\",\"error_code\":\"WIN32_ERROR\",\"win32_error\":" << err << "}\n";
+            return 2;
+        }
+
+        std::string record = "deadbyte.kernel-lock.r74:pid=" + std::to_string(GetCurrentProcessId()) + "\n";
+        DWORD written = 0;
+        SetFilePointer(h, 0, NULL, FILE_BEGIN);
+        SetEndOfFile(h);
+        WriteFile(h, record.data(), static_cast<DWORD>(record.size()), &written, NULL);
+        FlushFileBuffers(h);
+
+        std::cout << "{\"schema\":\"deadbyte.kernel-lock.r74.v1\",\"status\":\"acquired\",\"pid\":" << GetCurrentProcessId() << "}\n";
+        std::cout.flush();
+
+        char buf[1];
+        DWORD bytesRead = 0;
+        ReadFile(GetStdHandle(STD_INPUT_HANDLE), buf, 1, &bytesRead, NULL);
+
+        CloseHandle(h);
+        std::cout << "{\"schema\":\"deadbyte.kernel-lock.r74.v1\",\"status\":\"released\"}\n";
+        std::cout.flush();
+        return 0;
+    }
+
+    std::cout << "{\"schema\":\"deadbyte.kernel-lock.r74.v1\",\"status\":\"failed\",\"error\":\"unknown operation\"}\n";
+    return 2;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deadbyte-mcp",
-  "version": "0.15.46",
+  "version": "0.15.48",
   "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.",

package/scripts/build-epoch-lock-r85.ps1

@@ -0,0 +1,34 @@
+param(
+  [Parameter(Mandatory=$true)][ValidatePattern('^[0-9a-f]{64}$')][string]$SourceSha256,
+  [string]$NodeHeaderRoot = (Join-Path $env:LOCALAPPDATA 'node-gyp\Cache\25.9.0')
+)
+$ErrorActionPreference='Stop'
+Set-StrictMode -Version Latest
+$root=Split-Path -Parent $PSScriptRoot
+$source=Join-Path $root 'native\deadbyte-epoch-lock-r85.cpp'
+$observed=(Get-FileHash -LiteralPath $source -Algorithm SHA256).Hash.ToLowerInvariant()
+if($observed -ne $SourceSha256){throw 'R85 native source SHA mismatch; refusing build'}
+$header=Join-Path $NodeHeaderRoot 'include\node\node_api.h'
+$lib=Join-Path $NodeHeaderRoot 'x64\node.lib'
+if(!(Test-Path -LiteralPath $header -PathType Leaf) -or !(Test-Path -LiteralPath $lib -PathType Leaf)){
+  throw 'R85 pinned Node-API headers/import library unavailable; no download fallback'
+}
+$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'
+$bin=Join-Path $root 'bin'
+New-Item -ItemType Directory -Path $bin -Force | Out-Null
+$output=Join-Path $bin 'deadbyte-epoch-lock-r85.node'
+$object=Join-Path $bin 'deadbyte-epoch-lock-r85.obj'
+$include=Join-Path $NodeHeaderRoot 'include\node'
+$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 /DNODE_GYP_MODULE_NAME=deadbyte_epoch_lock_r85'
+$compile='cl {0} /LD /I"{1}" "{2}" /Fo:"{3}" /Fe:"{4}" /link /Brepro /INCREMENTAL:NO "{5}"' -f $common,$include,$source,$object,$output,$lib
+$command='call "{0}" -no_logo -arch=x64 -host_arch=x64 && {1}' -f $dev,$compile
+$cmd=if($env:ComSpec){$env:ComSpec}else{Join-Path $env:SystemRoot 'System32\cmd.exe'}
+& $cmd /d /s /c $command
+if($LASTEXITCODE -ne 0){throw "R85 native build failed exit=$LASTEXITCODE"}
+if(!(Test-Path -LiteralPath $output -PathType Leaf)){throw 'R85 native addon missing'}
+$hash=(Get-FileHash -LiteralPath $output -Algorithm SHA256).Hash.ToLowerInvariant()
+Write-Output "R85_NATIVE_BUILD_PASS source_sha256=$observed addon_sha256=$hash path=$output"

package/scripts/build-kernel-lock-r74.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-kernel-lock-r74.cpp'
+$observed=(Get-FileHash -LiteralPath $src -Algorithm SHA256).Hash.ToLowerInvariant()
+if($observed -ne $SourceSha256){throw "R74 kernel lock source SHA mismatch; refusing build"}
+Write-Output "R74_SOURCE_SHA256=$observed"
+$bin=Join-Path $root 'bin'
+$exe=Join-Path $bin 'deadbyte-kernel-lock-r74.exe'
+$obj=Join-Path $bin 'deadbyte-kernel-lock-r74.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 /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 "R74 kernel lock build failed exit=$rc"}
+if(!(Test-Path -LiteralPath $exe -PathType Leaf)){throw 'R74 kernel lock exe missing'}
+$sha=(Get-FileHash -LiteralPath $exe -Algorithm SHA256).Hash.ToLowerInvariant()
+Write-Output "R74_NATIVE_BUILD_PASS sha256=$sha path=$exe"

package/scripts/deploy-r48.mjs

@@ -10,6 +10,7 @@ import {parseAuthorityObservation} from '../src/remote-authority.mjs';
 import {classifyActivationPreflight,classifyAuthorityContinuity,orchestrateActivation} from '../src/activation-preflight-r65.mjs';
 import {createEpochNativeContinuityEngine} from '../src/activation-continuity-engine-r65.mjs';
 import {createActivationClaimManager} from '../src/activation-lock-r65.mjs';
+import {observeAuthorityEvidence} from '../src/activation-authority-proof-r75.mjs';
 
 const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
 const state=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
@@ -57,7 +58,8 @@ async function observeController(){
     if(!info.isFile()||info.isSymbolicLink())throw new Error(`activation ${plane} policy must be a regular file`);
     policySha256[plane]=await sha(file);
   }
-  return {...observed,policy_sha256:policySha256,policy_paths:policyPaths,active_release_id:active.release_id,active_manifest_sha256:active.manifest_sha256,
+  const authorityProof=await observeAuthorityEvidence({stateRoot:state,policyPaths,policySha256,authority:observed.authority});
+  return {...observed,authority_proof:authorityProof,policy_sha256:policySha256,policy_paths:policyPaths,active_release_id:active.release_id,active_manifest_sha256:active.manifest_sha256,
     active_generation_manifest_sha256:active.generation_manifest_sha256};
 }
 

package/scripts/gate-windows-r72.ps1

@@ -26,8 +26,8 @@ Push-Location $repo
 try {
     $pkg=Get-Content -LiteralPath 'package.json' -Raw | ConvertFrom-Json
     $release=Get-Content -LiteralPath 'RELEASE.json' -Raw | ConvertFrom-Json
-    if($pkg.version -ne '0.15.46' -or $release.version -ne '0.15.46' -or $release.train -ne 'R72'){
-        throw 'R72_CANDIDATE_VERSION_DRIFT'
+    if($pkg.version -ne '0.15.47' -or $release.version -ne '0.15.47' -or $release.train -ne 'R74'){
+        throw 'R74_CANDIDATE_VERSION_DRIFT'
     }
     if($release.parent.release_id -ne $parentId -or $release.parent.manifest_sha256 -ne $parentSha -or
        $release.parent.generation_manifest_sha256 -ne $parentGen){throw 'R72_PARENT_IDENTITY_DRIFT'}