deadbyte-mcp 0.15.10 → 0.15.12

package/MANIFEST.SHA256

@@ -606,6 +606,7 @@ a7d00bfd54525bc694b6e32f64c7ebcf5e6b7ae3657be5cc12767bce74654a47  node_modules/t
 7b6976eec43edfa68b79a459dd089c56b7a395916dbf1a01bd11e6d86e12128f  node_modules/typescript/SECURITY.md
 1af3c68039c57e539422da82a4faada506ce6d0ea6f90e0b699d02dbcdb7a90c  node_modules/typescript/ThirdPartyNoticeText.txt
 055f0ac4eed1a1591d033d59462972968bf3483b4cc07e163589569c0fb999f0  node_modules/which/bin/node-which
+89bc599ca0b3a119d711c62855b2e3619b734bf371ef55dcc049454313f9904e  node_modules/which/CHANGELOG.md
 4ec3d4c66cd87f5c8d8ad911b10f99bf27cb00cdfcff82621956e379186b016b  node_modules/which/LICENSE
 43010039ed5e89f7186960be682b3cb5cda5ab6cdfb06cbfd4f081cf0e7b4260  node_modules/which/package.json
 0c91f714f46006bc9a543e629a3ce3b63700fa8cfbe7c6310a0bcff2738356dd  node_modules/which/README.md
@@ -1328,7 +1329,7 @@ db605a698f917c4006462596e6526fe6a9c6eff9b8409e8472fe545d4b70027c  node_modules/z
 f67a25ded944912bd4621b68df17c7c70a52aae117278c076c0aabbc32a3abba  node_modules/zod/v4/mini/schemas.d.ts
 51b3a7869df2d3a1bd98acb9d5b6a61bbccc7653d7a3d8fca7f0e0db7e84e284  node_modules/zod/v4/mini/schemas.js
 3e3125b5a537a24c3632c1c5c09640ce7bcb3935901b127ad8ae3c37a27f133f  node_modules/zod/v4/package.json
-fc923c05c542ed4d3eeace06c1f782fe431d877ee0227c24096aeea45af5d03e  package.json
+76ae33a2af233622bf1145ede51bf43ee2bba99566a2c7b69da072c3eec0c80c  package.json
 8177e3a354721a73df889f386a97e7744a2e017d150aecf4bf309f5177d18690  proof/CONTAINMENT-BUILD.txt
 a8efa13e44ff50902aee64cfca542d19605a1ae23db95280ad2d44b324f3eae7  proof/MCP-SMOKE-STATUS.txt
 7c115069cc4a343ca21b0ebdee74bd8f544b02d4aa906ffa13308725825d891a  proof/NODE-SYNTAX.txt
@@ -1388,7 +1389,7 @@ d433aaea5cccd1e184775ac4d915f34e0b39c6c99916dddd009731ad5fd6443f  proof/V073-WIN
 bd0773a9e02e8ab11475c9cc5a7db29a8313233b7eab7f837922737e75ec5938  proof/VERIFY.txt
 2c821808d4596965c577f40191daee224d3aea81989778c4af97f53a83b487db  proof/WINDOWS-CONTAINED-STATUS.txt
 f8bc839c7b4fcb0ea7b7e7ad9448847c3beae6f95f2eb4d407d1b284aaa4ff68  proof/WINDOWS-CONTAINMENT-STATUS.txt
-2a17d078ccbf03b254509985b3cdf51496e8d02958b4f3bc878e5aac7bb15b10  PROVENANCE.json
+c7a11729f77023dd1d741d61b35ea0b75cca061a28f3a4cbe0062ca6a536f4ab  PROVENANCE.json
 27ca0f3c9ee3a1b6374a9c8dd98008decdd0c7659c7a569c70ad7b9734c74655  R34-BASELINE.json
 0b7ec5ee347ddfa6cca59740fc7a8fe3fc5d51406265bb12189e82fa106319d2  R41-PARENT.json
 bd2a789b0aab5663f0d208af2ca8e4ec98179bc8c7b57e70a962d4e06a3dcfc4  R42-PARENT.json
@@ -1396,8 +1397,8 @@ bd2a789b0aab5663f0d208af2ca8e4ec98179bc8c7b57e70a962d4e06a3dcfc4  R42-PARENT.jso
 f932ef78b7a72b1bb0d7aedb5fe42fbb9951c2492eb528b72442f46ddff81a6c  R44-DONORS.json
 731b4c559fc0d25dea701e4474f02400b27e8e3f4cac9f230d5214497d4490a9  R44-PARENT.json
 d33ec5d167dd44800ba4e68372b08db43deb8d01df2ef71dd435ff004ac66c8b  R45-PARENT.json
-4d8bc9d61d7558a484269cc13263b42bb39417700bb3858069d64a2d1ae190e8  README.txt
-de2c63a505343a61cfbfe4a905d9021ccdc4cce39ccb3e681c2526518bf494c5  RELEASE.json
+5d81b599350d12f019586380d0983054c48fd89a7b948b335a4cec8fb9077ad7  README.txt
+6e49e03fa679ca211372919f6ef250424bcdcc700d3be12e2552e9a07cbc950d  RELEASE.json
 507a42441c8fbb0b1bef63a13fad9e1680262cd6d34cc176b7ed0c5423ddbcc7  SBOM.cdx.json
 bd138fe5a64088e8e1a7a5bf6104c5b17317bdc8cf3ad8191ea00ed82ace7d9b  scripts/agent-eval-r42.mjs
 8d90256a6863f3bbbff02e95cb12389fc6f9e8dbcb77bf1c20c902de371425e8  scripts/archive-source-zips.mjs
@@ -1428,7 +1429,7 @@ a64b6779eff80d68d90d238dee7f2feda5ada3c5c59bcaeae2ab7812bd28404e  scripts/deferr
 751632aeb2e56b093f9589897bbe7e874db61e9238a13bd1506bde2df0b706e9  scripts/deferred-slot-operation-r45.mjs
 d4710039ceff7380f3b6a0040ad118a81eabdda2706c459f9b81f8e08978fba4  scripts/deferred-slot-operation-r46.mjs
 34116370895aeff9a424475558f4aca3b05460146455d9bb0bafcacd1a270910  scripts/deferred-slot-operation.mjs
-cabea0b3dbfccc2b24f276f8ccba9bffa9b006497eaedc83c7dd04875aa82e4d  scripts/deploy-r47.mjs
+4a8a257bfe61aa97a6607bf1e8d3233a2c7dbdf526b7fc404eb321e372db1312  scripts/deploy-r47.mjs
 2cc7a37231f8836a48c3bf4024887f38c10bfc89296ac483e4b98b3f18281933  scripts/derive-r45-parent.mjs
 67221c5619019a9d19611432d4361c99c365f14e89483e4c8f78451839960176  scripts/derive-r45-release.mjs
 87c6acc0df96a6e8bb6692bc7b12e8b386196a80cba554d9b214ff8bb12147fe  scripts/derive-r45-tests.mjs
@@ -1522,6 +1523,7 @@ cabfa63d5edb83f32b3e6e5ce22e76223644d81a3361d52a28de2dbc07e59a54  scripts/run-r4
 abf8ac3074e8964c9648b5b60069730c255faa5f4169f3aefc7a9eff350a1efc  scripts/run-skill-creator-scaffold.mjs
 caac2867971dfdf56456528b816ff56282a11cbba81510c13e1723accffac678  scripts/runtime-self-update.mjs
 b0cc75c38e0163dbcf7fb1b0d21f2dc34c71f2d0e2a156a53e570ff84afc64e6  scripts/semantic-preflight.ps1
+bf54d2dfa2a77c2c13cc0b8a9ac2eb926132ecd331ad56ebbf88cc5cc4280a96  scripts/sign-adaptive-skill.mjs
 0a115aa9829576c86cc247f754cae69ae09ba146b637d3a1c9fbc16420d20a5d  scripts/tool-surface-snapshot.mjs
 f8d9c6718cbe20e02e517297e8f35f51c7dcd51b62b8b4a483630a9cd3b1f788  scripts/verify-memory-r41.mjs
 e552634ca1f8673f5daaaf5e45302d2a7fc4b1a1eac256f60bed2c9136bafa05  scripts/verify-package.ps1
@@ -1577,13 +1579,14 @@ e5f944a310ed957e3b8f7b1cab54c082acf1b35f8fdd7d9b672ebe1a80dc37ac  src/canonical-
 da5181cec30034ddf089baa5358becb5651da238a2e7cf0888007a4c60b4ea6b  src/capability-benchmark-runner.mjs
 2b62295591f142ca4b3bc5b03e6434f7fc3c51d9502f9a40ef8a03d1f72a8899  src/capability-benchmark.mjs
 160199b25f45bd0490f6b21a9fa8194313e9673c4b2699afce68249d3d249a7b  src/capability-ledger.mjs
+ecccd8645297f2edd131b2e1a30016fb58ea9d18d8536aa784a21734c81cf209  src/capability-resolver.mjs
 94e5aeff2453cdc0239aee4d547dbbefee183c71933cb84e5e8a418fa99bc1e8  src/codex-app-server-r44.mjs
 6d0a80daaa2711e67e2597bff3db5bd2802682f559107a492f3cd89b9c6785ed  src/coding-mcp-tools.mjs
 d6fc395575f49abbbf60bf6f6ef5ee9ad51034a7e770a381e6ec34f869788306  src/coding-output-contracts.mjs
 0857a458e9c5101eee94c0596b7699adc34c50687455688fe38d03d241d27935  src/coding-plane.mjs
 38a1b4e9f5aa14cd5fd9058345c3480ae72c4a6a6eeccdc46e71297c68b5b5a6  src/coding-search.mjs
 f87284dc71c167f6a17575b93730c258ed6c433831013c776bf2d14e2b77767f  src/coding-task-runtime.mjs
-bfe4b641b61e4e7da8848c6c39d256a39191639315fb9f3c17a0b11f999ec792  src/compact-gateway-mcp-tools.mjs
+8478ef1f7b3dc89480c4310a20268048f581041bddcc0b7de9298fa2bfc654ca  src/compact-gateway-mcp-tools.mjs
 4218d1d1478d9e9a044d9b61c5ae205cd2ca0651a314900fad03992d0b12d286  src/compact-gateway-output-contracts.mjs
 40ac70ece531de7709d3c51686b36b48e0ae60283d1fb18d0adc037bfe6f9063  src/contained-cli.mjs
 d2bacef2443705e372071d0de3c72d45d57febb1dcbb11e369fce8a78bf0bf3e  src/contained-executor.mjs
@@ -1632,7 +1635,7 @@ ad4ca3635cb228b57b5b98e9518f379380ee1a03ad07ab4d12f8b7f324be2517  src/machine-mc
 e81b3ac2955e5dfafe308c82da24356a14da396230cb9fc47b231ab672d5be48  src/machine-output-contracts.mjs
 ed85d41c494a334117661ddec8191d34974fe28cb2a3378f3c04ee0e4c5d3ccc  src/mcp-contained-smoke-client.mjs
 b705345aa432b6a6ebbf62aabce1f78ba7e392bdfe998e79217eba8289ed0a7e  src/mcp-host-smoke-client.mjs
-02f6f0d456491dbd7687c4c81c7a2c3d9dd9db411d97617fcb9927b766f75a67  src/mcp-server.mjs
+3300d50f8a015bb090d5820dafe42edcc3d16a741e3ff12232ec03aadf115158  src/mcp-server.mjs
 b490c4152b16adae658b3af20a4827847866cec352e1b0c9eb6b36094116b83b  src/mcp-smoke-client.mjs
 cde7c813f5a2e9a69f09849455d1504e766963845a1f4b201ecc84090fa260d5  src/memory-r41.mjs
 9525aee66944023603f6d1ebb0768b8e8ab8bb93582a10dd7f9cd4459ee07454  src/native-diff-v2.mjs
@@ -1649,7 +1652,7 @@ b8e4e38fc38bd8d2efb01b58028944bc8133dcc42de12b1035784c5e01beca35  src/output-con
 974b5e9a5f60c4b2ac8bed629fb39a4e3c06b591995bec3f5f4756da8f3fd2e1  src/process-mcp-tools.mjs
 4c90265628194d989ac78f2b06eadbfffceb9c006d5b6c2e982f5667f7a385ed  src/process-output-contracts.mjs
 f5322664c669bc193214a803f9723e3728053f60bc008530db39a9af7f7bab75  src/process-policy.mjs
-23fb2a9394c6039d4238577eea377679fdd4be7a753e35452799ef9705aad894  src/process-runtime.mjs
+622b984e577932ed0c342a6d7e0e8a17d08e888caa2ca67c5ecc1bbcca16042a  src/process-runtime.mjs
 65d81b6cbdf4f4ce34ccef11793e79cfed6883288288915d077c11674f0873bb  src/process-smoke-client.mjs
 bb4d1532684b8f81a42377c4b0a9d4c61207856edfff496e878ffbb885b52442  src/proof-cli.mjs
 be4a4f7f16e473ac842559a5a18eccb59e3693bded59a1abc71e75ff448cc755  src/proof-worker.mjs
@@ -1686,7 +1689,7 @@ c8fd6fd3e49e866f2c3be326ab07222b36a44528ee0fc3f7b371c34a60e3c45b  src/remote-ses
 827b156eac01cc9ec6f5ca9a49219612f0da511fde770a9eb1235aa913b5e514  src/request-identity.mjs
 39251ab165bb0a0b8ea9b4c533aa0cd674934c0fa2c7f63145eac680d1d67be9  src/resource-identity.mjs
 ce2223bf6075e96cc02505c1439acce18bb1f204c5e86cf9152bb7194daf3cd2  src/runtime-identity.mjs
-9ea6bbebe732a2925b14807228cf5d74848def69b10216495498ae20f3a919ad  src/runtime-update.mjs
+3c3bd5c7479af109bd3770afe2e29200e91d5cf3533fb3225a063db659eac080  src/runtime-update.mjs
 c61335adb38bfc415fe1cdabfe2c0a87e61579dfd1e52cce91c44d6993479457  src/search-cursor.mjs
 fc5407ef8338ebeeede16225b3249166dc4d45e903d873eb46c15c3df07dc9ad  src/semantic-backend-registry.mjs
 686e9b55b9f4352b941579f186a9b9d348d86af53d052cbd5da953e7d15470ff  src/semantic-code.mjs
@@ -1704,7 +1707,7 @@ bac271c6f5218752ac5ff4decf5249e3893ddb35c63c092ce17238c27fc4d35b  src/trust-init
 16df134040e3ff1e73df722b568d3e8ac0a6923b097696cead7580da75aa8d2a  src/tunnel-stdio-compat.mjs
 642cb67d1854850e336ee73fbd71b329056bdcbdab35cea19c1a995a155ff5d9  src/verifier-cli.mjs
 8f818a4852ce3be3a380cd4736c3073a7a3e0e45cd7c7ca90588a6b843d3d022  src/verifier.mjs
-afb1d220f824f94a3c1b654213f50e25af380d22e89cba6efb0d58324026e62a  src/version.mjs
+b58265712b06c108331f51d2f42a1fe28ab5d9a06d5ee781f1c931559c104e79  src/version.mjs
 7e09c57a97289360aabfaf3d531208e54872efbfb3182f3c18203d2cb88c46b5  src/worker-registry.mjs
 76361d5ae9a710273cf64a7525082197b692236bf23689875e5fd1ef4aa96d2b  src/worker-scheduler.mjs
 4da1b32f5198bb089bc68b7eb6de21ea296678b5020018a73742bf0df57d62fa  src/workload-substrate.mjs
@@ -1745,6 +1748,7 @@ bad448d7bfd0c66b8d0dc0fa601fc22d69ccc3f447140ed0f77b68957984daea  test/capabilit
 c343906ca0878e13c576cd9f615802b1139c693bf6769a780dfb052637cf0d83  test/capability-benchmark.test.mjs
 b9a8faa4b86683ac5aea891fe6bc95f8e425fb31635176aa4603f9d582b52a79  test/capability-claims-r36.test.mjs
 a466a490759d438a8ac68919f79ddcb52253bdbecb5e4448a4fbf62af118184e  test/capability-ledger-r36.test.mjs
+5cdf20eace97fa87563c6b139390e6bd8ccbe80215f53aacd041579bfbad20d6  test/capability-resolver.test.mjs
 84eefe1a43474927fdc6fb7ef269309c662cefb229d6af2c91d9e2f0b9ba5c23  test/cli-entrypoint.test.mjs
 bec565ffa8550d56a5bb21927177c37d9d05f8353e3bc2541fc156886fe23688  test/codex-app-server-r44.test.mjs
 c43105a78ee4c93417d720ee660cfebc75b17f142a6484568e3cbaa583457f8c  test/codex-autonomous-r44.test.mjs

package/PROVENANCE.json

@@ -1,6 +1,6 @@
 {
   "schema": "deadbyte.provenance.v1",
-  "version": "0.15.10",
+  "version": "0.15.11",
   "builder": "deadbyte-r46-fileless-powershell",
   "source_model": "development-root -> MANIFEST.SHA256 -> immutable release slot -> generation bundle -> signed final closure",
   "signing": "ed25519",

package/README.txt

@@ -7,12 +7,12 @@ NPX PRIMARY OPERATOR UX
 ------------------------
 Use the npm CLI entry point instead of the legacy CMD convenience wrapper:
 
-  npx -y deadbyte-mcp@0.15.9 mcp
-  npx -y deadbyte-mcp@0.15.9 remote
-  npx -y deadbyte-mcp@0.15.9 remote status
-  npx -y deadbyte-mcp@0.15.9 remote restart
-  npx -y deadbyte-mcp@0.15.9 audit status
-  npx -y deadbyte-mcp@0.15.9 audit verify
+  npx -y deadbyte-mcp@0.15.11 mcp
+  npx -y deadbyte-mcp@0.15.11 remote
+  npx -y deadbyte-mcp@0.15.11 remote status
+  npx -y deadbyte-mcp@0.15.11 remote restart
+  npx -y deadbyte-mcp@0.15.11 audit status
+  npx -y deadbyte-mcp@0.15.11 audit verify
 
 The `mcp` command is the quiet stdio server entry for local MCP clients; stdout is reserved for MCP.
 The remote CLI invokes the stable active-release PowerShell launcher directly with shell=false.

package/RELEASE.json

@@ -1,7 +1,7 @@
-{
+{
   "schema": "deadbyte.release.v1",
   "name": "deadbyte-mcp",
-  "version": "0.15.10",
+  "version": "0.15.12",
   "train": "R46",
   "label": "FILELESS POWERSHELL PRODUCT BASELINE",
   "protocol_revision": "2026-07-28",
@@ -51,3 +51,4 @@
     "observation_search_session_cap": 128
   }
 }
+

package/node_modules/which/CHANGELOG.md

@@ -0,0 +1,166 @@
+# Changes
+
+
+## 2.0.2
+
+* Rename bin to `node-which`
+
+## 2.0.1
+
+* generate changelog and publish on version bump
+* enforce 100% test coverage
+* Promise interface
+
+## 2.0.0
+
+* Parallel tests, modern JavaScript, and drop support for node < 8
+
+## 1.3.1
+
+* update deps
+* update travis
+
+## v1.3.0
+
+* Add nothrow option to which.sync
+* update tap
+
+## v1.2.14
+
+* appveyor: drop node 5 and 0.x
+* travis-ci: add node 6, drop 0.x
+
+## v1.2.13
+
+* test: Pass missing option to pass on windows
+* update tap
+* update isexe to 2.0.0
+* neveragain.tech pledge request
+
+## v1.2.12
+
+* Removed unused require
+
+## v1.2.11
+
+* Prevent changelog script from being included in package
+
+## v1.2.10
+
+* Use env.PATH only, not env.Path
+
+## v1.2.9
+
+* fix for paths starting with ../
+* Remove unused `is-absolute` module
+
+## v1.2.8
+
+* bullet items in changelog that contain (but don't start with) #
+
+## v1.2.7
+
+* strip 'update changelog' changelog entries out of changelog
+
+## v1.2.6
+
+* make the changelog bulleted
+
+## v1.2.5
+
+* make a changelog, and keep it up to date
+* don't include tests in package
+* Properly handle relative-path executables
+* appveyor
+* Attach error code to Not Found error
+* Make tests pass on Windows
+
+## v1.2.4
+
+* Fix typo
+
+## v1.2.3
+
+* update isexe, fix regression in pathExt handling
+
+## v1.2.2
+
+* update deps, use isexe module, test windows
+
+## v1.2.1
+
+* Sometimes windows PATH entries are quoted
+* Fixed a bug in the check for group and user mode bits. This bug was introduced during refactoring for supporting strict mode.
+* doc cli
+
+## v1.2.0
+
+* Add support for opt.all and -as cli flags
+* test the bin
+* update travis
+* Allow checking for multiple programs in bin/which
+* tap 2
+
+## v1.1.2
+
+* travis
+* Refactored and fixed undefined error on Windows
+* Support strict mode
+
+## v1.1.1
+
+* test +g exes against secondary groups, if available
+* Use windows exe semantics on cygwin & msys
+* cwd should be first in path on win32, not last
+* Handle lower-case 'env.Path' on Windows
+* Update docs
+* use single-quotes
+
+## v1.1.0
+
+* Add tests, depend on is-absolute
+
+## v1.0.9
+
+* which.js: root is allowed to execute files owned by anyone
+
+## v1.0.8
+
+* don't use graceful-fs
+
+## v1.0.7
+
+* add license to package.json
+
+## v1.0.6
+
+* isc license
+
+## 1.0.5
+
+* Awful typo
+
+## 1.0.4
+
+* Test for path absoluteness properly
+* win: Allow '' as a pathext if cmd has a . in it
+
+## 1.0.3
+
+* Remove references to execPath
+* Make `which.sync()` work on Windows by honoring the PATHEXT variable.
+* Make `isExe()` always return true on Windows.
+* MIT
+
+## 1.0.2
+
+* Only files can be exes
+
+## 1.0.1
+
+* Respect the PATHEXT env for win32 support
+* should 0755 the bin
+* binary
+* guts
+* package
+* 1st

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deadbyte-mcp",
-  "version": "0.15.10",
+  "version": "0.15.12",
   "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.",
@@ -76,6 +76,8 @@
   "dependencies": {
     "@modelcontextprotocol/client": "2.0.0",
     "@modelcontextprotocol/server": "2.0.0",
+    "deadbyte-mcp": "^0.15.3",
+    "remote": "^0.0.5",
     "typescript": "5.9.3",
     "zod": "4.4.3"
   },

package/scripts/deploy-r47.mjs

@@ -21,7 +21,7 @@ const args=[
 '--desktop-policy',path.join(root,'controller','deadbyte-desktop-policy.json'),'--desktop-policy-sha256',await sha(path.join(root,'controller','deadbyte-desktop-policy.json')),
 '--semantic-lsp-config',path.join(root,'controller','deadbyte-semantic-lsp-config.json'),'--semantic-lsp-config-sha256',await sha(path.join(root,'controller','deadbyte-semantic-lsp-config.json')),
 '--bridge-root',bridgeRoot,'--bridge-script-sha256',await sha(bridgeScript),
-'--enable-machine-fs','--enable-observation','--enable-desktop','--enable-autonomous-supervisor','--restore-standing-grants'
+'--enable-machine-fs','--enable-observation','--enable-desktop','--enable-autonomous-supervisor','--restore-standing-grants','--recover-offline-predecessor'
 ];
 const result=await runSlotUpdateCli(args,{stateRoot:state});
 console.log(JSON.stringify({status:'deployed',manifest_sha256:manifest,previous_release:pointer.release_id,result}));

package/scripts/sign-adaptive-skill.mjs

@@ -0,0 +1,86 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { createHash, createPrivateKey, createPublicKey, sign } from 'node:crypto';
+import { createSkillPlane } from '../src/skill-plane-r44.mjs';
+
+const home = os.homedir();
+const stateDir = path.join(home, '.deadbyte-mcp');
+const skillDir = path.join(stateDir, 'skills', 'deadbyte-adaptive-reverse-engineering');
+const sha = b => createHash('sha256').update(b).digest('hex');
+function canonical(v) {
+  return Array.isArray(v) ? v.map(canonical) : v && typeof v === 'object'
+    ? Object.fromEntries(Object.keys(v).sort((a, b) => a.localeCompare(b, 'en')).map(k => [k, canonical(v[k])])) : v;
+}
+
+const skillBytes = await readFile(path.join(skillDir, 'SKILL.md'));
+const skillText = new TextDecoder('utf-8').decode(skillBytes);
+const skillSha = sha(skillBytes);
+
+const refFiles = ['references/adaptive-routing.md', 'references/evidence-correlation.md'].sort((a, b) => a.localeCompare(b, 'en'));
+const resources = [];
+for (const rel of refFiles) {
+  const bytes = await readFile(path.join(skillDir, ...rel.split('/')));
+  resources.push({
+    path: rel,
+    sha256: sha(bytes),
+    kind: 'reference'
+  });
+}
+
+const body = {
+  schema: 'deadbyte.skill-manifest.v1',
+  name: 'deadbyte-adaptive-reverse-engineering',
+  version: '1.1.0',
+  description: 'Adaptive evidence-driven low-level reverse-engineering workflow that selects the smallest discriminating analysis path, allocates evidence budget by information gain, tracks contradictions, correlates bytes with semantics, and closes every claim with fresh verification.',
+  audience: 'agent',
+  skill_md_sha256: skillSha,
+  resources,
+  required_capabilities: [],
+  authority_planes: ['coding'],
+  provenance: {
+    source: 'skill-creator',
+    origin_url: null,
+    source_revision: 'local-draft-2026-09-24-v1.1'
+  }
+};
+
+const bodyBytes = Buffer.from(JSON.stringify(canonical(body)), 'utf8');
+const bodySha256 = sha(bodyBytes);
+
+const privPem = await readFile(path.join(stateDir, 'trust', 'ed25519-private.pem'));
+const priv = createPrivateKey(privPem);
+const pub = createPublicKey(priv);
+const keyId = sha(pub.export({ type: 'spki', format: 'der' }));
+
+const DOMAIN = Buffer.from('DEADBYTE-SKILL-MANIFEST-V1\0', 'utf8');
+const signature = sign(null, Buffer.concat([DOMAIN, bodyBytes]), priv);
+const attestation = {
+  algorithm: 'ed25519',
+  domain: 'DEADBYTE-SKILL-MANIFEST-V1',
+  key_id: keyId,
+  signature_base64: signature.toString('base64')
+};
+
+const unsigned = { body, body_sha256: bodySha256, attestation };
+const envelope = {
+  ...unsigned,
+  manifest_sha256: sha(Buffer.from(JSON.stringify(canonical(unsigned)), 'utf8'))
+};
+
+await writeFile(path.join(skillDir, 'skill.json'), JSON.stringify(envelope, null, 2), 'utf8');
+console.log('Skill envelope written successfully:', envelope.manifest_sha256);
+
+// Verify with createSkillPlane
+const plane = await createSkillPlane({
+  root: path.join(stateDir, 'skills'),
+  verifyKeyPath: path.join(stateDir, 'trust', 'ed25519-public.pem')
+});
+const list = await plane.list();
+console.log('Skill plane list result: skills=' + list.skills.length + ' invalid=' + list.invalid_skills.length);
+if (list.invalid_skills.length > 0) {
+  console.error('Invalid skills remain:', list.invalid_skills);
+  process.exit(1);
+}
+const loaded = await plane.load({ name: 'deadbyte-adaptive-reverse-engineering' });
+console.log('Skill loaded OK: name=' + loaded.name + ' verified=' + loaded.verified);

package/src/capability-resolver.mjs

@@ -0,0 +1,303 @@
+export const CAPABILITY_STATES = Object.freeze({
+  AVAILABLE: 'AVAILABLE',
+  DEGRADED: 'DEGRADED',
+  DISABLED: 'DISABLED',
+  DENIED: 'DENIED',
+  UNAVAILABLE: 'UNAVAILABLE'
+});
+
+const CAPABILITY_OPERATIONS = Object.freeze({
+  'skill.catalog': ['list', 'load', 'resource'],
+  'machine.list': ['machine_list'],
+  'machine.status': ['machine_status'],
+  'machine.ping': ['machine_ping'],
+  'machine.revoke': ['machine_revoke'],
+  'process.start': ['start'],
+  'process.read': ['read'],
+  'process.write': ['write'],
+  'process.status': ['status'],
+  'process.list': ['list'],
+  'process.action': ['action'],
+  'process.terminate': ['terminate'],
+  'coding.session_status': ['coding_session_status'],
+  'coding.tree': ['coding_tree'],
+  'coding.stat': ['stat'],
+  'coding.search': ['search'],
+  'coding.files_read': ['files_read'],
+  'coding.file_read': ['coding_file_read'],
+  'coding.file_write': ['coding_file_write'],
+  'coding.text_replace': ['coding_text_replace'],
+  'coding.command_run': ['coding_command_run'],
+  'coding.benchmark_run': ['coding_benchmark_run'],
+  'coding.receipt_verify': ['coding_receipt_verify'],
+  'coding.task_submit': ['coding_task_submit'],
+  'coding.task_run': ['coding_task_run'],
+  'coding.task_status': ['coding_task_status'],
+  'coding.task_events': ['coding_task_events'],
+  'coding.task_cancel': ['coding_task_cancel'],
+  'coding.task_approve': ['coding_task_approve'],
+  'coding.task_verify': ['coding_task_verify'],
+  'semantic.outline': ['symbol_outline'],
+  'semantic.definition': ['symbol_definition'],
+  'semantic.references': ['symbol_references'],
+  'semantic.diagnostics': ['symbol_diagnostics'],
+  'semantic.implementations': ['symbol_implementations'],
+  'semantic.rename_preview': ['symbol_rename_preview'],
+  'semantic.replace': ['coding_symbol_replace'],
+  'machine_fs.stat': ['stat'],
+  'machine_fs.list': ['list'],
+  'machine_fs.read': ['read'],
+  'machine_fs.write': ['write'],
+  'machine_fs.edit_exact': ['edit_exact'],
+  'machine_fs.mkdir': ['mkdir'],
+  'machine_fs.move': ['move'],
+  'machine_fs.delete': ['delete'],
+  'observation.search_start': ['search_start'],
+  'observation.search_page': ['search_page'],
+  'observation.search_status': ['search_status'],
+  'observation.search_cancel': ['search_cancel'],
+  'observation.process_list': ['process_list'],
+  'observation.system_status': ['system_status'],
+  'observation.hardware_query': ['hardware_query'],
+  'desktop.status': ['status'],
+  'desktop.observe': ['observe'],
+  'desktop.target': ['target'],
+  'desktop.action': ['action'],
+  'autonomous.session_status': ['autonomous_session_status'],
+  'native_diff.preview': ['native_diff_preview'],
+  'native_diff.apply': ['native_diff_apply'],
+  'native_diff.verify': ['native_diff_verify'],
+  'autonomous.goal_submit': ['autonomous_goal_submit'],
+  'autonomous.goal_run': ['autonomous_goal_run'],
+  'autonomous.goal_status': ['autonomous_goal_status'],
+  'autonomous.goal_events': ['autonomous_goal_events'],
+  'autonomous.goal_cancel': ['autonomous_goal_cancel'],
+  'autonomous.goal_approve': ['autonomous_goal_approve'],
+  'autonomous.goal_verify': ['autonomous_goal_verify'],
+  'autonomous.release_gate': ['autonomous_release_gate'],
+  'host.file_read': ['host_file_read'],
+  'host.file_write': ['host_file_write'],
+  'host.exec': ['host_exec'],
+  'evidence.verify': ['evidence_verify']
+});
+
+export function deriveCapabilityRequirements(capability) {
+  const reqs = [];
+  if (capability.runtime_flag) reqs.push(capability.runtime_flag);
+  if (capability.id === 'skill.catalog') {
+    reqs.push('skill_plane.valid');
+    return reqs;
+  }
+  if (capability.authority === 'coding') {
+    if (capability.mutating) {
+      reqs.push('coding_session.armed', 'policy.write');
+    } else {
+      reqs.push('coding_runtime.ready');
+    }
+  } else if (capability.authority === 'process') {
+    if (capability.mutating) {
+      reqs.push('process_session.armed');
+    } else {
+      reqs.push('process_runtime.ready');
+    }
+  } else if (capability.authority === 'autonomous') {
+    if (capability.mutating) {
+      reqs.push('autonomous_session.armed');
+    } else {
+      reqs.push('autonomous_runtime.ready');
+    }
+  } else if (capability.authority === 'desktop') {
+    if (capability.mutating) {
+      reqs.push('desktop_control.armed', 'policy.desktop');
+    } else {
+      reqs.push('desktop_runtime.ready');
+    }
+  } else if (capability.authority === 'host' || capability.host_only) {
+    if (capability.mutating) {
+      reqs.push('host_policy.armed');
+    } else {
+      reqs.push('host_policy.configured');
+    }
+  }
+  return reqs;
+}
+
+export async function resolveCapabilityStates({
+  ledger,
+  toolCatalog = [],
+  profile = 'full',
+  env = process.env,
+  codingRuntime = null,
+  processRuntime = null,
+  processPolicy = null,
+  machineFsRuntime = null,
+  observationRuntime = null,
+  desktopRuntime = null,
+  desktopPolicy = null,
+  autonomousRuntime = null,
+  skillRuntime = null,
+  hostPolicy = null
+} = {}) {
+  const capabilities = ledger?.entries ?? [];
+  const resolved = [];
+  const catalogSet = new Set(toolCatalog);
+
+  // Probe session authorities asynchronously
+  let codingStatus = null;
+  if (codingRuntime?.sessionStatus) {
+    try { codingStatus = await codingRuntime.sessionStatus(); } catch {}
+  }
+
+  let autonomousStatus = null;
+  if (autonomousRuntime?.sessionStatus) {
+    try { autonomousStatus = await autonomousRuntime.sessionStatus(); } catch {}
+  }
+
+  let skillListResult = null;
+  if (skillRuntime?.list) {
+    try { skillListResult = await skillRuntime.list(); } catch (err) {
+      skillListResult = { invalid_skills: [{ name: '*', error: String(err) }] };
+    }
+  }
+
+  for (const cap of capabilities) {
+    const activeTool = profile === 'compact' ? (cap.compact_tool || cap.full_tool) : cap.full_tool;
+    const activeOp = profile === 'compact' ? (cap.compact_op || 'direct') : 'direct';
+    const ops = CAPABILITY_OPERATIONS[cap.id] ?? [activeOp];
+    const requires = deriveCapabilityRequirements(cap);
+
+    let state = CAPABILITY_STATES.AVAILABLE;
+    let ready = true;
+    let diagnostic = null;
+
+    // 1. Runtime Flag Disabled check
+    if (cap.runtime_flag && env[cap.runtime_flag] === '0') {
+      state = CAPABILITY_STATES.DISABLED;
+      ready = false;
+      diagnostic = {
+        code: 'RUNTIME_FLAG_DISABLED',
+        reason: `Runtime flag ${cap.runtime_flag}=0 is disarmed`,
+        recoverable: false
+      };
+    }
+    // 2. Tool presence check
+    else if (!catalogSet.has(activeTool)) {
+      state = CAPABILITY_STATES.UNAVAILABLE;
+      ready = false;
+      diagnostic = {
+        code: 'TOOL_NOT_REGISTERED',
+        reason: `Tool '${activeTool}' is not registered in the active tool catalog`,
+        recoverable: false
+      };
+    }
+    // 3. Subsystem runtime instantiation check
+    else if (cap.id.startsWith('machine_fs.') && !machineFsRuntime) {
+      state = CAPABILITY_STATES.UNAVAILABLE;
+      ready = false;
+      diagnostic = {
+        code: 'MACHINE_FS_NOT_INSTANTIATED',
+        reason: 'Machine filesystem runtime is uninitialized',
+        recoverable: false
+      };
+    } else if (cap.id.startsWith('observation.') && !observationRuntime) {
+      state = CAPABILITY_STATES.UNAVAILABLE;
+      ready = false;
+      diagnostic = {
+        code: 'OBSERVATION_NOT_INSTANTIATED',
+        reason: 'Observation runtime is uninitialized',
+        recoverable: false
+      };
+    } else if (cap.id.startsWith('desktop.') && !desktopRuntime) {
+      state = CAPABILITY_STATES.UNAVAILABLE;
+      ready = false;
+      diagnostic = {
+        code: 'DESKTOP_NOT_INSTANTIATED',
+        reason: 'Desktop runtime is uninitialized',
+        recoverable: false
+      };
+    } else if ((cap.authority === 'host' || cap.host_only) && !hostPolicy) {
+      state = CAPABILITY_STATES.DENIED;
+      ready = false;
+      diagnostic = {
+        code: 'HOST_POLICY_DISARMED',
+        reason: 'Privileged host policy is not configured or disarmed',
+        recoverable: true
+      };
+    }
+    // 4. Session Authority Checks
+    else if (cap.authority === 'coding' && cap.mutating && codingStatus && !codingStatus.armed) {
+      state = CAPABILITY_STATES.DENIED;
+      ready = false;
+      diagnostic = {
+        code: 'CODING_SESSION_DISARMED',
+        reason: codingStatus.reason || 'Coding session is not armed for mutation',
+        recoverable: true
+      };
+    } else if (cap.authority === 'autonomous' && cap.mutating && autonomousStatus && !autonomousStatus.armed) {
+      state = CAPABILITY_STATES.DENIED;
+      ready = false;
+      diagnostic = {
+        code: 'AUTONOMOUS_SESSION_DISARMED',
+        reason: autonomousStatus.reason || 'Autonomous session is not armed for mutation',
+        recoverable: true
+      };
+    }
+    // 5. Subsystem Health Probes (e.g. Skill Plane envelope verification)
+    else if (cap.id === 'skill.catalog') {
+      if (skillListResult?.invalid_skills && skillListResult.invalid_skills.length > 0) {
+        state = CAPABILITY_STATES.DEGRADED;
+        ready = false;
+        diagnostic = {
+          code: 'SKILL_ENVELOPE_MISMATCH',
+          reason: `Skill registry rejected envelope for: ${skillListResult.invalid_skills.map(s => s.name).join(', ')}`,
+          recoverable: true
+        };
+      }
+    }
+
+    resolved.push(Object.freeze({
+      id: cap.id,
+      tool: activeTool,
+      compact_tool: cap.compact_tool,
+      compact_op: cap.compact_op,
+      operations: ops,
+      authority: cap.authority,
+      mutating: cap.mutating,
+      production: cap.production,
+      runtime_flag: cap.runtime_flag,
+      requires,
+      state,
+      ready,
+      diagnostic
+    }));
+  }
+
+  const effectiveCapabilities = resolved
+    .filter(c => c.state === CAPABILITY_STATES.AVAILABLE)
+    .map(c => c.id);
+
+  const unavailableCapabilities = resolved
+    .filter(c => c.state === CAPABILITY_STATES.UNAVAILABLE || c.state === CAPABILITY_STATES.DISABLED || c.state === CAPABILITY_STATES.DENIED)
+    .map(c => ({
+      id: c.id,
+      state: c.state,
+      reason_code: c.diagnostic?.code ?? 'UNAVAILABLE',
+      reason: c.diagnostic?.reason ?? 'Capability not available'
+    }));
+
+  const degradedCapabilities = resolved
+    .filter(c => c.state === CAPABILITY_STATES.DEGRADED)
+    .map(c => ({
+      id: c.id,
+      state: c.state,
+      reason_code: c.diagnostic?.code ?? 'DEGRADED',
+      reason: c.diagnostic?.reason ?? 'Capability operating in degraded mode'
+    }));
+
+  return Object.freeze({
+    capabilities: resolved,
+    effective_capabilities: effectiveCapabilities,
+    unavailable_capabilities: unavailableCapabilities,
+    degraded_capabilities: degradedCapabilities
+  });
+}

package/src/compact-gateway-mcp-tools.mjs

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import * as z from 'zod/v4';
 import { compactGatewayOutputSchema, compactGatewayResult } from './compact-gateway-output-contracts.mjs';
 import { desktopControlInputSchema,invokeDesktopOperation } from './desktop-mcp-tools-r40.mjs';
+import { resolveCapabilityStates } from './capability-resolver.mjs';
 
 const id=z.string().regex(/^[A-Za-z0-9._-]{1,64}$/);
 const rel=z.string().min(1).max(2048);
@@ -123,17 +124,26 @@ async function machineObserve(args,machineRuntime,observationRuntime){
   return invoke(args.op,observationRuntime,'observation',map[args.op]);
 }
 
-export function registerCompactGatewayTools(server,{profile,ledger,codingRuntime,semanticRuntime,machineFsRuntime,processRuntime,observationRuntime,machineRuntime,desktopRuntime,catalogProvider}){
+export function registerCompactGatewayTools(server,{profile,ledger,codingRuntime,semanticRuntime,machineFsRuntime,processRuntime,observationRuntime,machineRuntime,desktopRuntime,skillRuntime,autonomousRuntime,hostPolicy,env=process.env,catalogProvider}){
   if(!server) throw new Error('compact gateway registration requires server');
   if(profile!=='compact') return;
   if(typeof catalogProvider!=='function') throw new Error('compact gateway requires catalogProvider');
-  server.registerTool('capability_manifest',{description:'Read the canonical capability ledger and exact active compact tool catalog.',inputSchema:capabilityManifestInputSchema,outputSchema:compactGatewayOutputSchema},async()=>{
+  server.registerTool('capability_manifest',{description:'Read the canonical capability ledger and exact active compact tool catalog with runtime-aware resolution.',inputSchema:capabilityManifestInputSchema,outputSchema:compactGatewayOutputSchema},async()=>{
     const toolCatalog=[...catalogProvider()].map(String).sort();
     if(toolCatalog.length<1||new Set(toolCatalog).size!==toolCatalog.length) throw new Error('compact catalog provider returned invalid catalog');
     const catalogSha256=createHash('sha256').update(JSON.stringify(toolCatalog),'utf8').digest('hex');
+    const dynamicResolution = await resolveCapabilityStates({
+      ledger, toolCatalog, profile, env,
+      codingRuntime, processRuntime, machineFsRuntime, observationRuntime, desktopRuntime,
+      autonomousRuntime, skillRuntime, hostPolicy
+    });
     return compactGatewayResult({status:'ok',op:'manifest',result:{
       schema:'deadbyte.capability-manifest.v2',profile,ledger_sha256:ledger?.ledger_sha256??null,
-      tool_catalog:toolCatalog,tool_count:toolCatalog.length,catalog_sha256:catalogSha256,capabilities:ledger?.entries??[]
+      tool_catalog:toolCatalog,tool_count:toolCatalog.length,catalog_sha256:catalogSha256,
+      capabilities:dynamicResolution.capabilities,
+      effective_capabilities:dynamicResolution.effective_capabilities,
+      unavailable_capabilities:dynamicResolution.unavailable_capabilities,
+      degraded_capabilities:dynamicResolution.degraded_capabilities
     }},false);
   });
   server.registerTool('coding_inspect',{description:'Typed compact coding inspection and semantic navigation gateway. No arbitrary tool dispatch.',inputSchema:codingInspectInputSchema,outputSchema:compactGatewayOutputSchema},args=>codingInspect(args,codingRuntime,semanticRuntime));

package/src/mcp-server.mjs

@@ -459,7 +459,8 @@ serveStdio(() => {
 
   registerCompactGatewayTools(toolServer,{
     profile:surfaceProfile,ledger:R36_CAPABILITY_LEDGER,codingRuntime,semanticRuntime,machineFsRuntime,
-    processRuntime,observationRuntime,machineRuntime,desktopRuntime,catalogProvider:()=>[...registeredToolNames]
+    processRuntime,observationRuntime,machineRuntime,desktopRuntime,skillRuntime,autonomousRuntime,hostPolicy,
+    catalogProvider:()=>[...registeredToolNames]
   });
 
   if (hostPolicy) {

package/src/process-runtime.mjs

@@ -20,12 +20,27 @@ const TERMINAL_RECOVERY_SCHEMA = 'deadbyte.process-terminal.v1';
 const sha256Bytes = bytes => createHash('sha256').update(bytes).digest('hex');
 const nowUtc = () => new Date().toISOString();
 
+const STANDARD_PATHEXT = '.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC';
+
+export function getRepairedPathExt() {
+  const current = process.env.PATHEXT;
+  if (!current) return STANDARD_PATHEXT;
+  const exts = current.split(';').map(e => e.trim().toUpperCase()).filter(Boolean);
+  if (!exts.includes('.EXE')) {
+    return [...new Set([...STANDARD_PATHEXT.split(';'), ...exts])].join(';');
+  }
+  return current;
+}
+
 function processEnvironment(profile) {
   const allow = new Set(profile.env_allow.map(name => name.toLowerCase()));
   const env = {};
   for (const [key, value] of Object.entries(process.env)) {
     if (allow.has(key.toLowerCase()) && typeof value === 'string') env[key] = value;
   }
+  if (process.platform === 'win32') {
+    env.PATHEXT = getRepairedPathExt();
+  }
   return env;
 }
 async function resolveCwd(policy, grant, profile, rootId, cwd) {

package/src/runtime-update.mjs

@@ -618,6 +618,29 @@ async function readLedger(ctx,name){
 function sameGeneration(a,b){
   return a.pid===b.pid&&a.instance_nonce===b.instance_nonce&&a.creation_time_utc===b.creation_time_utc&&a.image_sha256===b.image_sha256;
 }
+function cleanOfflinePredecessor(ctx){
+  const runtimeRoot=path.resolve(ctx.runtime_root);
+  const blockers=[
+    'bridge.instance.json','cloud.instance.json',
+    'process-grant.json','coding-grant.json','autonomous-grant.json',
+    'desktop-grant.json','host-grant.json'
+  ].filter(name=>existsSync(path.join(runtimeRoot,name)));
+  if(blockers.length) throw new Error('offline predecessor recovery blocked by runtime state: '+blockers.join(','));
+
+  const command="Get-CimInstance Win32_Process | Where-Object { \$_.Name -in @('node.exe','cloudflared.exe','deadbyte-tunnel-host.exe') } | Select-Object ProcessId,Name,ExecutablePath,CommandLine | ConvertTo-Json -Compress";
+  const result=runCaptured(powershellPath(),['-NoLogo','-NoProfile','-Command',command],{timeoutMs:15000});
+  const text=assertRun(result,'runtime process query').trim();
+  if(text){
+    let parsed;
+    try { parsed=JSON.parse(text); } catch(error){ throw new Error('runtime process query JSON invalid: '+error.message); }
+    const processes=(Array.isArray(parsed)?parsed:[parsed]).filter(item=>Number(item?.ProcessId)!==process.pid);
+    if(processes.length) throw new Error('offline predecessor recovery blocked by runtime processes: '+processes.map(item=>String(item?.Name??'unknown')+'#'+String(item?.ProcessId??'?')).join(','));
+  }
+  return {
+    online:false,offline:true,bridge_pid:null,cloud_pid:null,local_ready:false,
+    process_armed:false,coding_armed:false,autonomous_armed:false,desktop_armed:false,host_armed:false
+  };
+}
 function nodeProcesses(){
   const command=`Get-CimInstance Win32_Process -Filter \"Name='node.exe'\" | Select-Object ProcessId,ParentProcessId,CreationDate,ExecutablePath,CommandLine | ConvertTo-Json -Compress`;
   const result=runCaptured(powershellPath(),['-NoLogo','-NoProfile','-Command',command],{timeoutMs:15000});
@@ -658,7 +681,15 @@ async function captureRuntime(ctx){
   return {status,status_text:statusText.trim(),bridge,cloud,core};
 }
 async function capturePredecessor(ctx,recoverOfflinePredecessor){
-  const statusText=controllerCaptured(ctx,'status',15000),status=parseControllerStatus(statusText);
+  let statusText,status;
+  try{
+    statusText=controllerCaptured(ctx,'status',15000);
+    status=parseControllerStatus(statusText);
+  }catch(error){
+    if(!recoverOfflinePredecessor) throw error;
+    const offline=cleanOfflinePredecessor(ctx);
+    return {mode:'offline-recovery',status:offline,status_text:`controller status unavailable; clean offline evidence established: ${String(error?.message??error)}`,runtime:null};
+  }
   if(status.online&&status.bridge_pid&&status.cloud_pid&&status.local_ready){
     const runtime=await captureRuntime(ctx);
     return {mode:'online',status:runtime.status,status_text:runtime.status_text,runtime};
@@ -752,7 +783,7 @@ async function loadPointerIfPresent(stateRoot){
   const snapshot=await snapshotFile(file); const pointer=parseActivePointer(snapshot.bytes.toString('utf8'));
   await verifyActiveInstallation(stateRoot,pointer); return {file,pointer,snapshot};
 }
-async function loadControlInputs({stateRoot,sourceRoot,pointerInfo}){
+async function loadControlInputs({stateRoot,sourceRoot,pointerInfo,bridgeBootstrap=null}){
   let configPath,ctx;
   if(pointerInfo.pointer){
     configPath=pointerInfo.pointer.config_path; ctx=slotContext(stateRoot,pointerInfo.pointer);
@@ -760,7 +791,20 @@ async function loadControlInputs({stateRoot,sourceRoot,pointerInfo}){
     if(!sourceRoot) throw new Error('--source-root is required for initial slot migration');
     ctx=legacyContext(sourceRoot); configPath=path.join(ctx.source_root,'controller','deadbyte-controller.config.psd1');
   }
-  let config=await loadPowerShellDataFile(configPath); config=await normalizeComponentIdentities(config);
+  let config=await loadPowerShellDataFile(configPath);
+  if(bridgeBootstrap){
+    if(!bridgeBootstrap.root||!path.isAbsolute(bridgeBootstrap.root)||!HEX64.test(String(bridgeBootstrap.scriptSha256??''))) throw new Error('bridge bootstrap requires absolute root plus lowercase script SHA-256');
+    const bootstrapRoot=path.resolve(bridgeBootstrap.root);
+    const bootstrapScript=path.join(bootstrapRoot,'src','bridge.mjs');
+    const bootstrapActual=await sha256File(bootstrapScript);
+    if(bootstrapActual!==String(bridgeBootstrap.scriptSha256).toLowerCase()) throw new Error(`bridge script SHA-256 mismatch: expected ${String(bridgeBootstrap.scriptSha256).toLowerCase()}, found ${bootstrapActual}`);
+    if(!config.Bridge||typeof config.Bridge!=='object') throw new Error('Bridge launch specification missing');
+    config.Bridge.WorkingDirectory=bootstrapRoot;
+    config.Bridge.Arguments='src\\bridge.mjs';
+    config.Bridge.ScriptPath=bootstrapScript;
+    config.Bridge.ScriptSha256=bootstrapActual;
+  }
+  config=await normalizeComponentIdentities(config);
   const codingPath=String(config.CodingPolicyFile??''); const autonomousPath=String(config.AutonomousPolicyFile??''); const hostPath=String(config.HostPolicyFile??''); const processPath=String(config.ProcessPolicyFile??''); const desktopPath=String(config.DesktopPolicyFile??'');
   if(!path.isAbsolute(codingPath)||!path.isAbsolute(autonomousPath)) throw new Error('coding/autonomous policy paths must be absolute');
   if(processPath&&!path.isAbsolute(processPath)) throw new Error('process policy path must be absolute');
@@ -1096,6 +1140,10 @@ async function ensureFreshRuntime(ctx,oldRuntime){
   return existing??await startAndVerify(ctx,oldRuntime);
 }
 async function ensureAuthorityRevoked(ctx,prior){
+  if(!prior.process_armed&&!prior.coding_armed&&!prior.autonomous_armed&&!prior.desktop_armed&&!prior.host_armed){
+    const clean=cleanOfflinePredecessor(ctx);
+    return {revoked:false,status:clean};
+  }
   const status=parseControllerStatus(controllerCaptured(ctx,'status',15000));
   if(status.host_armed) throw new Error('host plane armed during authority revoke recovery');
   if(!status.process_armed&&!status.coding_armed&&!status.autonomous_armed&&!status.desktop_armed) {
@@ -1157,15 +1205,15 @@ async function resumeSlotUpdate({handoffPath}){
   const stableMcpUrl=body.stable_mcp_url?{...body.stable_mcp_url}:releaseState.stable_mcp_url?{...releaseState.stable_mcp_url}:null;
   const mcpUrlSnapshot=body.mcp_url_snapshot?decodeSnapshot(body.mcp_url_snapshot,'MCP URL'):{exists:false,bytes:null,sha256:null};
   const cleanup=await acquireSupervisorLease(absoluteHandoff);
+  const journal=releaseState;
+  let pointerCommitted=phaseRank(phase)>=phaseRank('pointer_committed')||samePublicPointer(currentPointer,candidatePointer);
+  let stopped=phaseRank(phase)>=phaseRank('old_runtime_stopped');
   try{
-    const journal=releaseState;
     if(phaseRank(phase)<phaseRank('supervisor_spawned')){
       await writeState(statePath,journal,'supervisor_spawned',{supervisor_pid:process.pid,supervisor_script:body.supervisor_script,supervisor_script_sha256:body.supervisor_script_sha256});
       phase='supervisor_spawned';
     }
     let revoked=phaseRank(phase)>=phaseRank('authority_revoked')||journal.revoked_before_switch===true;
-    let stopped=phaseRank(phase)>=phaseRank('old_runtime_stopped');
-    let pointerCommitted=phaseRank(phase)>=phaseRank('pointer_committed')||samePublicPointer(currentPointer,candidatePointer);
     let newRuntime=null,stabilization=null;
 
     if(phaseRank(phase)<phaseRank('authority_revoked')){
@@ -1175,12 +1223,17 @@ async function resumeSlotUpdate({handoffPath}){
       phase='authority_revoked';
     }
     if(!stopped){
-      const status=parseControllerStatus(controllerCaptured(ctx,'status',15000)),gone=await coreGone(oldRuntime);
-      if(!oldRuntime||(status.offline&&gone)){
-        await writeState(statePath,journal,'old_runtime_stopped',{stop_output:'recovery observed predecessor already OFFLINE'});
+      if(!oldRuntime){
+        cleanOfflinePredecessor(ctx);
+        await writeState(statePath,journal,'old_runtime_stopped',{stop_output:'recovery observed predecessor has no captured runtime and clean offline evidence'});
       }else{
-        const stoppedResult=await stopAndVerify(ctx,oldRuntime);
-        await writeState(statePath,journal,'old_runtime_stopped',{stop_output:stoppedResult.output});
+        const status=parseControllerStatus(controllerCaptured(ctx,'status',15000)),gone=await coreGone(oldRuntime);
+        if(status.offline&&gone){
+          await writeState(statePath,journal,'old_runtime_stopped',{stop_output:'recovery observed predecessor already OFFLINE'});
+        }else{
+          const stoppedResult=await stopAndVerify(ctx,oldRuntime);
+          await writeState(statePath,journal,'old_runtime_stopped',{stop_output:stoppedResult.output});
+        }
       }
       stopped=true; phase='old_runtime_stopped';
     }
@@ -1346,7 +1399,7 @@ export async function performSlotUpdate({stage,developmentRoot,expectedVersion,e
     const stageVerified=await verifyPackageRoot(stageRoot,expectedVersion,expectedManifest,'stage');
     const developmentVerified=await verifyPackageRoot(development,expectedVersion,expectedManifest,'development');
     const slot=await materializeReleaseSlot({source:stageRoot,stateRoot:state,version:expectedVersion,manifestSha256:expectedManifest});
-    control=await loadControlInputs({stateRoot:state,sourceRoot,pointerInfo});
+    control=await loadControlInputs({stateRoot:state,sourceRoot,pointerInfo,bridgeBootstrap});
     const hostBootstrap=await prepareHostPolicyBootstrap(hostPolicyBootstrap);if(hostBootstrap) control.hostPolicy=hostBootstrap.policy;
     const codingBootstrap=await prepareCodingPolicyBootstrap(codingPolicyBootstrap);if(codingBootstrap) control.codingPolicy=codingBootstrap.policy;
     const processBootstrap=await prepareProcessPolicyBootstrap(processPolicyBootstrap);

package/src/version.mjs

@@ -1,6 +1,7 @@
-export const DEADBYTE_VERSION = '0.15.10';
+export const DEADBYTE_VERSION = '0.15.12';
 export const MCP_PROTOCOL_VERSION = '2026-07-28';
 export const RECEIPT_SCHEMA_V1 = 'deadbyte.receipt.v1';
 export const RECEIPT_SCHEMA_V2 = 'deadbyte.receipt.v2';
 export const RECEIPT_REQUEST_SCHEMA = 'deadbyte.request.v1';
 export const RUNTIME_IDENTITY_SCHEMA = 'deadbyte.runtime.v1';
+

package/test/capability-resolver.test.mjs

@@ -0,0 +1,133 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  CAPABILITY_STATES,
+  deriveCapabilityRequirements,
+  resolveCapabilityStates
+} from '../src/capability-resolver.mjs';
+import { R36_CAPABILITY_LEDGER } from '../src/capability-ledger.mjs';
+
+test('capability resolver enforces 5 canonical states', () => {
+  assert.equal(CAPABILITY_STATES.AVAILABLE, 'AVAILABLE');
+  assert.equal(CAPABILITY_STATES.DEGRADED, 'DEGRADED');
+  assert.equal(CAPABILITY_STATES.DISABLED, 'DISABLED');
+  assert.equal(CAPABILITY_STATES.DENIED, 'DENIED');
+  assert.equal(CAPABILITY_STATES.UNAVAILABLE, 'UNAVAILABLE');
+});
+
+test('deriveCapabilityRequirements maps dependencies accurately', () => {
+  const reqCodingRead = deriveCapabilityRequirements({
+    id: 'coding.search',
+    authority: 'coding',
+    mutating: false,
+    runtime_flag: 'DEADBYTE_CODING_RUNTIME'
+  });
+  assert.deepEqual(reqCodingRead, ['DEADBYTE_CODING_RUNTIME', 'coding_runtime.ready']);
+
+  const reqCodingWrite = deriveCapabilityRequirements({
+    id: 'coding.file_write',
+    authority: 'coding',
+    mutating: true,
+    runtime_flag: 'DEADBYTE_CODING_RUNTIME'
+  });
+  assert.deepEqual(reqCodingWrite, ['DEADBYTE_CODING_RUNTIME', 'coding_session.armed', 'policy.write']);
+
+  const reqSkill = deriveCapabilityRequirements({
+    id: 'skill.catalog',
+    authority: 'operator',
+    mutating: false
+  });
+  assert.deepEqual(reqSkill, ['skill_plane.valid']);
+});
+
+test('resolveCapabilityStates resolves all 5 states correctly', async () => {
+  const allCompactTools = [
+    'capability_manifest',
+    'coding_inspect',
+    'machine_fs',
+    'process_session',
+    'machine_observe',
+    'desktop_control',
+    'skill_catalog'
+  ];
+
+  // 1. Fully available & armed state
+  const armedRes = await resolveCapabilityStates({
+    ledger: R36_CAPABILITY_LEDGER,
+    toolCatalog: allCompactTools,
+    profile: 'compact',
+    env: {},
+    codingRuntime: { sessionStatus: async () => ({ armed: true }) },
+    processRuntime: {},
+    machineFsRuntime: {},
+    observationRuntime: {},
+    desktopRuntime: {},
+    autonomousRuntime: { sessionStatus: async () => ({ armed: true }) },
+    skillRuntime: { list: async () => ({ invalid_skills: [] }) },
+    hostPolicy: {}
+  });
+
+  assert.ok(armedRes.capabilities.length > 0);
+  assert.ok(armedRes.effective_capabilities.includes('coding.search'));
+  assert.ok(armedRes.effective_capabilities.includes('skill.catalog'));
+
+  // 2. Disabled by runtime flag
+  const disabledRes = await resolveCapabilityStates({
+    ledger: R36_CAPABILITY_LEDGER,
+    toolCatalog: allCompactTools,
+    profile: 'compact',
+    env: { DEADBYTE_CODING_RUNTIME: '0' },
+    codingRuntime: { sessionStatus: async () => ({ armed: true }) },
+    processRuntime: {},
+    machineFsRuntime: {},
+    observationRuntime: {},
+    desktopRuntime: {},
+    skillRuntime: { list: async () => ({ invalid_skills: [] }) }
+  });
+
+  const codingSearch = disabledRes.capabilities.find(c => c.id === 'coding.search');
+  assert.equal(codingSearch.state, CAPABILITY_STATES.DISABLED);
+  assert.equal(codingSearch.diagnostic.code, 'RUNTIME_FLAG_DISABLED');
+  assert.ok(disabledRes.unavailable_capabilities.some(u => u.id === 'coding.search' && u.state === CAPABILITY_STATES.DISABLED));
+
+  // 3. Unavailable due to uninstantiated subsystem
+  const uninstantiatedRes = await resolveCapabilityStates({
+    ledger: R36_CAPABILITY_LEDGER,
+    toolCatalog: allCompactTools,
+    profile: 'compact',
+    env: {},
+    machineFsRuntime: null
+  });
+  const fsStat = uninstantiatedRes.capabilities.find(c => c.id === 'machine_fs.stat');
+  assert.equal(fsStat.state, CAPABILITY_STATES.UNAVAILABLE);
+  assert.equal(fsStat.diagnostic.code, 'MACHINE_FS_NOT_INSTANTIATED');
+
+  // 4. Denied when coding session is disarmed for mutating operations in full profile
+  const disarmedRes = await resolveCapabilityStates({
+    ledger: R36_CAPABILITY_LEDGER,
+    toolCatalog: ['coding_file_write', 'coding_search'],
+    profile: 'full',
+    env: {},
+    codingRuntime: { sessionStatus: async () => ({ armed: false, reason: 'policy grant not confirmed' }) },
+    machineFsRuntime: {},
+    skillRuntime: { list: async () => ({ invalid_skills: [] }) }
+  });
+  const fileWrite = disarmedRes.capabilities.find(c => c.id === 'coding.file_write');
+  assert.equal(fileWrite.state, CAPABILITY_STATES.DENIED);
+  assert.equal(fileWrite.diagnostic.code, 'CODING_SESSION_DISARMED');
+
+  // 5. Degraded when skill plane reports envelope mismatch
+  const degradedRes = await resolveCapabilityStates({
+    ledger: R36_CAPABILITY_LEDGER,
+    toolCatalog: allCompactTools,
+    profile: 'compact',
+    env: {},
+    codingRuntime: { sessionStatus: async () => ({ armed: true }) },
+    machineFsRuntime: {},
+    skillRuntime: { list: async () => ({ invalid_skills: [{ name: 'test-broken', error: 'envelope mismatch' }] }) }
+  });
+  const skillCap = degradedRes.capabilities.find(c => c.id === 'skill.catalog');
+  assert.equal(skillCap.state, CAPABILITY_STATES.DEGRADED);
+  assert.equal(skillCap.diagnostic.code, 'SKILL_ENVELOPE_MISMATCH');
+  assert.ok(degradedRes.degraded_capabilities.some(d => d.id === 'skill.catalog'));
+});