deadbyte-mcp 0.15.23 → 0.15.25

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "deadbyte-mcp",
-    "version": "0.15.23",
+    "version": "0.15.25",
     "private": false,
     "type": "module",
     "description": "Authenticated MCP agentic runtime with signed skills, persistent model backends, identity-bound remote devices, durable job supervision, immutable release slots, and separately revocable machine authority.",
@@ -42,7 +42,7 @@
         "contained:run": "node src/contained-cli.mjs workspaces/demo input.txt",
         "contained:smoke": "node src/contained-smoke.mjs",
         "mcp:contained:smoke": "node src/mcp-contained-smoke-client.mjs",
-        "gate:windows": "powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r46.ps1",
+        "gate:windows": "powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r48.ps1",
         "authority:smoke": "node src/authority-smoke.mjs",
         "mcp:remote:smoke": "node src/remote-mcp-smoke-client.mjs",
         "mcp:host:smoke": "node src/mcp-host-smoke-client.mjs",
@@ -70,7 +70,7 @@
         "r47:catalog:test": "node --test --test-concurrency=1 test/full-max-catalog-r47.test.mjs",
         "r47:hardening:test": "node scripts/commander-hardening-gate-r47.mjs",
         "r48:full:test": "node scripts/full-regression-r48.mjs",
-        "r48:release:test": "node --test --test-concurrency=1 test/r48-release-contract.test.mjs test/commander-reference-contract-r48.test.mjs test/commander-extended-wire-r48.test.mjs test/commander-external-process-r48.test.mjs test/commander-office-reader-r48.test.mjs test/commander-pdf-r48.test.mjs test/commander-url-reader-r48.test.mjs test/commander-wire-contract-r47.test.mjs",
+        "r48:release:test": "node --test --test-concurrency=1 test/r48-release-contract.test.mjs test/commander-reference-contract-r48.test.mjs test/commander-extended-wire-r48.test.mjs test/commander-external-process-r48.test.mjs test/commander-office-reader-r48.test.mjs test/commander-pdf-r48.test.mjs test/commander-url-reader-r48.test.mjs test/commander-wire-contract-r47.test.mjs test/commander-protocol-adversarial-r48.test.mjs",
         "r48:catalog:test": "node --test --test-concurrency=1 test/full-max-catalog-r48.test.mjs",
         "release:npm": "node scripts/npm-release-r48.mjs"
     },

package/proof/commander-closure-20260928/DIFFERENTIAL-CHECKPOINT.json

@@ -0,0 +1,122 @@
+{
+  "schema": "deadbyte.commander-differential-checkpoint.v1",
+  "status": "INCOMPLETE",
+  "observed_at_utc": "2026-09-29T13:36:00.000Z",
+  "source": {
+    "requested_path": "D:\\Projects\\deadbyte-mcp-r36-dev",
+    "requested_path_version": "0.12.0",
+    "actual_successor_workspace": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-r42-agentic-dev",
+    "version": "0.15.25",
+    "git_head": "f9037d4847a7204ce4e1f808758ee3f0e9e7a738",
+    "path_drift_classification": "requested source path is a historical snapshot and cannot produce a successor of active 0.15.23"
+  },
+  "reference": {
+    "path": "D:\\Projects\\desktop-commander-stage-20260922\\desktop-commander",
+    "package": "@wonderwhy-er/desktop-commander",
+    "version": "0.2.51",
+    "server_sha256": "dfc303bb7dd2e8d01debac50fc43bb8644d00089bffdf2887e149497cff8b305",
+    "schemas_sha256": "f342345e34e48769dabaefe1b932f09d41e2e207b422f7794a15ee50ffa8f140"
+  },
+  "live": {
+    "release_id": "v0.15.23-c97e3d21e792420e",
+    "release_manifest_sha256": "c97e3d21e792420ea90dada3c1360cd56e4c1f221daa86596d611b0d1ac351ec",
+    "generation_manifest_sha256": "4d2d3a4dc103576c39171c52db3436366e62d8b872bcafa4c55f2adb6d3a1126",
+    "bridge_pid": 2804,
+    "cloud_pid": 13704,
+    "state": "ONLINE",
+    "authority": "Process/Coding/Autonomous/Desktop/Host ARMED standing-grant"
+  },
+  "findings": [
+    {
+      "id": "reference-biff8",
+      "classification": "REFERENCE_DEFECT",
+      "red": "real OLE/BIFF8 fixture is rejected by the reference ExcelJS xlsx reader",
+      "green": "independent BIFF8 fixture test proves reference read rejection and OOXML bytes emitted under .xls",
+      "fixture_sha256": "096168376d0abf282546749fdf6765309f895d12fe81d45c52a2c54bb6c0d139"
+    },
+    {
+      "id": "incremental-pdf-revisions",
+      "classification": "REAL_DEADBYTE_DEFECT_FIXED_IN_SOURCE",
+      "red": "valid independent-oracle-readable incremental PDF failed with PDF duplicate object 3 0",
+      "green": "latest revision accepted only when both revisions are bound by a validated classic xref Prev chain; PDF suite 10/10 PASS"
+    },
+    {
+      "id": "powershell-command-byte-preservation",
+      "classification": "OBSERVED_PASS",
+      "green": "real policy-bound PowerShell REPL preserved variables, quotes, pipe and Unicode and returned more than 1 MiB through bounded chunk reads"
+    },
+    {
+      "id": "atomic-mutation-post-effect-observation",
+      "classification": "REAL_DEADBYTE_DEFECT_FIXED_IN_SOURCE",
+      "red": "machine filesystem, coding, and Host public boundaries collapsed a post-rename observation failure into a generic denied/failed response without uncertainty identity",
+      "green": "shared atomic mutation marks FAILED_AFTER_UNKNOWN_EFFECT with unknown side-effect state and expected-after SHA-256; machine filesystem, coding, and Host structured outputs preserve it"
+    },
+    {
+      "id": "read-file-directory-and-binary-semantics",
+      "classification": "REAL_DEADBYTE_DEFECT_FIXED_IN_SOURCE",
+      "red": "reference returns a bounded recursive listing for read_file(directory) and explicit binary guidance, while DEADBYTE attempted a file read or lossy UTF-8 decoding",
+      "green": "compatibility read_file uses policy-bound stat plus paged listing for directories and deterministic binary classification without replacement-character data loss"
+    },
+    {
+      "id": "docx-outline-and-content-search",
+      "classification": "REAL_DEADBYTE_DEFECT_FIXED_IN_SOURCE",
+      "red": "reference exposes drawing markers, header/footer text, and literal DOCX part search while DEADBYTE omitted those document parts and searched ZIP bytes",
+      "green": "native bounded DOCX parsing now exposes drawing/header/footer evidence and searches document/header/footer w:t parts through deterministic compatibility sessions"
+    },
+    {
+      "id": "interactive-output-quiescence",
+      "classification": "REAL_DEADBYTE_DEFECT_FIXED_IN_SOURCE",
+      "red": "interact_with_process returned after the first stream advance and could omit the final END marker from a 1.1 MiB response",
+      "green": "bounded stream-quiescence waiting plus unconditional test cleanup passed 20 consecutive real PowerShell repetitions and the expanded 139-test hardening gate"
+    }
+  ],
+  "focused_evidence": [
+    {"scope": "schema-search", "tests": 21, "pass": 21, "fail": 0, "skip": 0},
+    {"scope": "documents-wire-url", "tests": 49, "pass": 49, "fail": 0, "skip": 0},
+    {"scope": "biff-reference", "tests": 1, "pass": 1, "fail": 0, "skip": 0},
+    {"scope": "process-adjacent", "tests": 55, "pass": 55, "fail": 0, "skip": 0},
+    {"scope": "mcp-protocol", "tests": 9, "pass": 9, "fail": 0, "skip": 0},
+    {"scope": "mcp-protocol-adversarial", "tests": 3, "pass": 3, "fail": 0, "skip": 0},
+    {"scope": "atomic-mutation-public-boundaries", "tests": 15, "pass": 14, "fail": 0, "skip": 1},
+    {"scope": "full-regression-r48", "files": 211, "batches": 8, "fail": 0, "task_receipt_sha256": "7711039e4807f6c2af02bbda897d0032b067e0a6631f789fd3bf801258160d3f"},
+    {"scope": "expanded-commander-hardening", "tests": 139, "pass": 139, "fail": 0, "skip": 0},
+    {"scope": "powershell-large-output-repeat", "runs": 20, "pass": 20, "fail": 0},
+    {"scope": "npm-audit-production", "vulnerabilities": 0},
+    {"scope": "real-performance-sample", "iterations_per_workload": 50, "reference_byte_pins_verified": true, "status": "HISTORICAL_ONLY_FRESH_RUN_BLOCKED_REFERENCE_RUNTIME_DEPS",
+      "results": {"read_file": {"reference_ops_per_sec": 55, "deadbyte_ops_per_sec": 1058}, "list_directory": {"reference_ops_per_sec": 3818, "deadbyte_ops_per_sec": 1959}, "get_file_info": {"reference_ops_per_sec": 1805, "deadbyte_ops_per_sec": 2231}, "read_multiple_files": {"reference_ops_per_sec": 30, "deadbyte_ops_per_sec": 562}}}
+    ,{"scope": "filesystem-document-search-adjacent", "tests": 54, "pass": 54, "fail": 0, "skip": 0}
+  ],
+  "changed_file_sha256": {
+    "src/commander-pdf-r48.mjs": "23cda18e86daa4163003fb5a80e0069bc19541d454f32a9a38b1d901ee39f26b",
+    "src/coding-search.mjs": "7f15b59bc240d896beddc2057354f8c72f296fe189db30c200d2c84a67d65773",
+    "src/commander-wire-adapter-r47.mjs": "a32226e302669553d39565176fc7ef9a0ace24834d2c19d3558ba33f13016ba0",
+    "src/commander-office-reader-r48.mjs": "7379825118da8fae16d63fe7c4d89b0ddb03e7649f3754adae58a4480f8b317f",
+    "test/commander-pdf-r48.test.mjs": "bfc2e6d7e1aa5332c1c81687001cdb5f923a45c5ce64925097fe11fd850e9214",
+    "test/commander-biff-reference-r48.test.mjs": "8e8b20604062a0398214e159729b10bedff334cb44bddfa4b4046b1ae396520f",
+    "test/commander-schema-differential-r48.test.mjs": "fb82a21e8752ccb82cbd6b631f3366bfe5af9a4c5a433db5a128c0a1fe703c66",
+    "test/commander-real-parity-r47.test.mjs": "5709ea1cf4e65c4f1759206123216cac6cb66d8a383c0b0a6c00f4a551d9c727"
+    ,"test/commander-wire-contract-r47.test.mjs": "d8e884e241c705b12797f911fb967a4a33b1ec6f3e15b433735882b3de4a34e5"
+    ,"test/commander-office-reader-r48.test.mjs": "abf1eb0977a064101420a0e908a4c2adbf9d606e9873433709910efafa2b4453"
+    ,"test/commander-core-bridge-r47.test.mjs": "16092ed097420b9da99573c1e84f62d011fcb5db069242d70ffd1649c704fd35"
+    ,"src/atomic-mutation.mjs": "622ee1d3c34c50a6343788cc7312e47cb43a87bdace78fb37ca7f51d453b19ad"
+    ,"src/machine-fs-mcp-tools.mjs": "5413fea537f9d72f73e89137b4c750530fbca41598b16bd9ede0e1c272111488"
+    ,"src/machine-fs-output-contracts.mjs": "d94e4478b7e465fa559065e508f65b9ef3eff815a8f2d7b2481bf2a0b05224c9"
+    ,"src/coding-mcp-tools.mjs": "c4e07aa6818cd989c43ce8d027dc7d467e05c8e2fe96b5548eea291285d3bbb1"
+    ,"src/coding-output-contracts.mjs": "059b4bef2ae6a6c2d7a706c463bea6e49d364faeb619372a429ba36c53004ab7"
+    ,"src/host-plane.mjs": "0ff88bce7ee34b22f48a1494efb16586b68c74bd46c608116eb9d9daa65fdc43"
+    ,"src/output-contracts.mjs": "6cbe72d14af097dde78e989bc7b28b48b9cb8990c989d0d40783633f3a7be465"
+    ,"src/mcp-server.mjs": "16e2250e20710b358b304a0bc41bb416ecb9a586c50d5933f6a4eb2230569b21"
+    ,"test/atomic-mutation.test.mjs": "98de1fc43092c27e0fa85f391607494b11e6cc0d53eaf47b6db1ab457c6d6a4b"
+    ,"test/coding-mcp-unknown-effect.test.mjs": "f37e260c2def4c48434b3f251a4cb756a1852843784c08cf6c39dba9045dfb69"
+    ,"scripts/commander-real-performance-benchmark-r47.mjs": "d7806aa408dc7ca74f05feec535ad6cc545f8c61892c51f0fe388bb13d975290"
+    ,"scripts/commander-hardening-gate-r47.mjs": "6d6e18b2a17448dad569dfbf60ac103c6c8bcfe73c49af93506816c3c0b7fe73"
+    ,"src/stdio-protocol-guard.mjs": "71e0ddc5e7abaedbb4659bdfb91b6e2db43a642cbec83eee62c16fb069a3c202"
+    ,"test/commander-protocol-adversarial-r48.test.mjs": "bacb96828ea0431cd5f3a8ecb637894f0bdf80b5f52e9308ba0cbb982f50bd2a"
+  },
+  "release_created": true,
+  "candidate_version": "0.15.25",
+  "publish_attempt": {"status":"PENDING_AUTH","npm_whoami":"E401 Unauthorized","registry_predecessor_version":"0.15.24","registry_predecessor_tarball_sha256":"23ea53fb4f331873c742c810f815d5ad18291f74c1bda1fd1d8c08475dbbd4ad"},
+  "published": false,
+  "activated": false,
+  "remaining_scope": "restore npm authentication, registry round-trip, successor activation, exact 0.15.23 rollback, exact successor restore and independent final closure"
+}

package/scripts/commander-hardening-gate-r47.mjs

@@ -13,7 +13,16 @@ const suites = [
   'test/commander-exhaustive-surface-r47.test.mjs',
   'test/commander-core-bridge-r47.test.mjs',
   'test/commander-wire-contract-r47.test.mjs',
-  'test/commander-protocol-r47.test.mjs'
+  'test/commander-reference-contract-r48.test.mjs',
+  'test/commander-schema-differential-r48.test.mjs',
+  'test/commander-biff-reference-r48.test.mjs',
+  'test/commander-office-reader-r48.test.mjs',
+  'test/commander-pdf-r48.test.mjs',
+  'test/commander-url-reader-r48.test.mjs',
+  'test/commander-external-process-r48.test.mjs',
+  'test/commander-protocol-r47.test.mjs',
+  'test/commander-protocol-adversarial-r48.test.mjs',
+  'test/prompts-resources.test.mjs'
 ];
 
 const startedAt = new Date().toISOString();

package/scripts/commander-real-performance-benchmark-r47.mjs

@@ -1,5 +1,5 @@
 import { performance } from 'node:perf_hooks';
-import { mkdtemp, writeFile, rm } from 'node:fs/promises';
+import { mkdtemp, writeFile, readFile, rm } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
@@ -9,7 +9,16 @@ import { loadCodingPolicy } from '../src/coding-plane.mjs';
 import { createMachineFsRuntime } from '../src/machine-fs.mjs';
 
 const N=50;
-const commanderFs=await import(pathToFileURL('D:/Projects/desktop-commander-stage-20260922/desktop-commander/dist/tools/filesystem.js').href);
+const referenceRoot=path.resolve(process.env.DEADBYTE_COMMANDER_REFERENCE_RUNTIME??'D:/Projects/desktop-commander-stage-20260922/desktop-commander');
+const expectedReferenceHashes={
+  'dist/server.js':'dfc303bb7dd2e8d01debac50fc43bb8644d00089bffdf2887e149497cff8b305',
+  'dist/tools/schemas.js':'f342345e34e48769dabaefe1b932f09d41e2e207b422f7794a15ee50ffa8f140'
+};
+for(const [relative,expected] of Object.entries(expectedReferenceHashes)){
+  const actual=createHash('sha256').update(await readFile(path.join(referenceRoot,relative))).digest('hex');
+  if(actual!==expected)throw new Error(`reference byte pin mismatch: ${relative}`);
+}
+const commanderFs=await import(pathToFileURL(path.join(referenceRoot,'dist','tools','filesystem.js')).href);
 const { readFileFromDisk, readMultipleFiles, listDirectory, getFileInfo }=commanderFs;
 const sha=b=>createHash('sha256').update(b).digest('hex');
 const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-commander-bench-'));
@@ -37,5 +46,5 @@ rows.push(await t('Commander get_file_info',()=>getFileInfo(commanderFile)));
 rows.push(await t('DEADBYTE get_file_info',()=>db.stat({rootId:'bench',relativePath:'a.txt',hash:true})));
 rows.push(await t('Commander read_multiple_files',()=>readMultipleFiles([path.join(commanderDir,'a.txt'),path.join(commanderDir,'b.txt')])));
 rows.push(await t('DEADBYTE read_multiple_files', async()=>{ await db.read({rootId:'bench',relativePath:'a.txt',offset:0,maxBytes:4096}); await db.read({rootId:'bench',relativePath:'b.txt',offset:0,maxBytes:4096}); }));
-console.log(JSON.stringify({schema:'deadbyte.commander-real-performance-benchmark.v1',reference:'@wonderwhy-er/desktop-commander dist local stage',iterations:N,rows},null,2));
+console.log(JSON.stringify({schema:'deadbyte.commander-real-performance-benchmark.v1',reference:'@wonderwhy-er/desktop-commander@0.2.51',reference_hashes:expectedReferenceHashes,iterations:N,rows},null,2));
 await rm(root,{recursive:true,force:true});

package/scripts/gate-windows-r48.ps1

@@ -0,0 +1,45 @@
+$ErrorActionPreference = 'Stop'
+Set-StrictMode -Version 3.0
+
+function Invoke-GateStep {
+    param([Parameter(Mandatory)][string]$Name,[Parameter(Mandatory)][string[]]$NpmArgs)
+    Write-Host "==== $Name ===="
+    & npm.cmd @NpmArgs
+    if ($LASTEXITCODE -ne 0) { throw "DEADBYTE 0.15.25 / R48 gate failed at $Name with exit code $LASTEXITCODE" }
+}
+
+Invoke-GateStep 'containment-build' @('run','containment:build')
+Invoke-GateStep 'process-policy-refresh' @('run','process:policy:refresh')
+Invoke-GateStep 'desktop-policy-refresh' @('run','desktop:policy:refresh')
+Invoke-GateStep 'hardware-build' @('run','hardware:build')
+
+$hostPolicy = [System.IO.Path]::GetFullPath((Join-Path $PSScriptRoot '..\controller\deadbyte-host-policy.json'))
+Remove-Item -LiteralPath $hostPolicy -Force -ErrorAction SilentlyContinue
+if (Test-Path -LiteralPath $hostPolicy) { throw 'could not establish hermetic Host policy absence' }
+
+Invoke-GateStep 'r48-release-focused' @('run','r48:release:test')
+Invoke-GateStep 'r48-catalog' @('run','r48:catalog:test')
+Invoke-GateStep 'commander-hardening' @('run','r47:hardening:test')
+Invoke-GateStep 'full-regression' @('run','r48:full:test')
+Invoke-GateStep 'mcp-smoke' @('run','mcp:smoke')
+Invoke-GateStep 'mcp-agent-smoke' @('run','mcp:agent:smoke')
+Invoke-GateStep 'mcp-coding-smoke' @('run','mcp:coding:smoke')
+Invoke-GateStep 'mcp-machine-fs-smoke' @('run','mcp:machine-fs:smoke')
+Invoke-GateStep 'mcp-observation-smoke' @('run','mcp:observation:smoke')
+Invoke-GateStep 'mcp-process-smoke' @('run','mcp:process:smoke')
+Invoke-GateStep 'mcp-autonomous-smoke' @('run','mcp:autonomous:smoke')
+Invoke-GateStep 'tunnel-stdio-compat-smoke' @('run','mcp:tunnel-compat:smoke')
+Invoke-GateStep 'containment-smoke' @('run','containment:smoke')
+Invoke-GateStep 'contained-smoke' @('run','contained:smoke')
+Invoke-GateStep 'mcp-contained-smoke' @('run','mcp:contained:smoke')
+Invoke-GateStep 'host-policy-refresh' @('run','host:policy:init')
+Invoke-GateStep 'manifest-write' @('run','manifest:write')
+Invoke-GateStep 'manifest-verify' @('run','manifest:verify')
+Invoke-GateStep 'doctor' @('run','doctor')
+Invoke-GateStep 'mcp-host-smoke' @('run','mcp:host:smoke')
+Invoke-GateStep 'authority-smoke' @('run','authority:smoke')
+Invoke-GateStep 'manifest-final-verify' @('run','manifest:verify')
+
+& node.exe (Join-Path $PSScriptRoot 'windows-gate-evidence-r48.mjs')
+if ($LASTEXITCODE -ne 0) { throw "R48 evidence writer failed with exit code $LASTEXITCODE" }
+Write-Host '==== DEADBYTE 0.15.25 / R48 WINDOWS GATE: PASS ===='

package/scripts/init-host-policy.ps1

@@ -10,7 +10,15 @@ Set-StrictMode -Version 3.0
 $ErrorActionPreference = 'Stop'
 
 function Get-Sha256Lower([string]$Path) {
-    (Get-FileHash -LiteralPath $Path -Algorithm SHA256).Hash.ToLowerInvariant()
+    $stream = [System.IO.File]::OpenRead($Path)
+    try {
+        $sha = [System.Security.Cryptography.SHA256]::Create()
+        try {
+            ([System.BitConverter]::ToString($sha.ComputeHash($stream))).Replace('-', '').ToLowerInvariant()
+        }
+        finally { $sha.Dispose() }
+    }
+    finally { $stream.Dispose() }
 }
 
 if ([string]::IsNullOrWhiteSpace($CoreRoot)) {

package/scripts/npm-release-r48.mjs

@@ -105,7 +105,8 @@ async function main() {
 
   console.log('[3/7] Packing artifact with npm pack...');
   const packed = parseJson(runNpm(['pack', '--json'], { timeout: 180000 }));
-  const filename = packed?.[0]?.filename;
+  const packRecord = Array.isArray(packed) ? packed[0] : packed?.[pkg.name];
+  const filename = packRecord?.filename;
   if (!filename) throw new Error('npm pack did not return a tarball filename');
   const tarball = path.join(root, filename);
   let releaseSucceeded = false;

package/scripts/windows-gate-evidence-r48.mjs

@@ -0,0 +1,27 @@
+import {createHash} from 'node:crypto';
+import {mkdir,open,readFile} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {doctor} from '../src/doctor-r45.mjs';
+
+const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+const stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const insist=(ok,message)=>{if(!ok)throw new Error(message);};
+const pkg=JSON.parse(await readFile(path.join(root,'package.json'),'utf8'));
+const release=JSON.parse(await readFile(path.join(root,'RELEASE.json'),'utf8'));
+const active=JSON.parse(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));
+const manifestSha256=sha256(await readFile(path.join(root,'MANIFEST.SHA256')));
+insist(pkg.version==='0.15.25'&&release.version===pkg.version&&release.train==='R48','R48 candidate identity mismatch');
+insist(active.release_id===release.parent.release_id&&active.manifest_sha256===release.parent.manifest_sha256&&active.generation_manifest_sha256===release.parent.generation_manifest_sha256,'active runtime is not the exact sealed R48 parent');
+const health=await doctor();
+insist(health.status==='ok'&&health.package_version===pkg.version&&health.manifest?.verified===true,'R48 doctor evidence invalid');
+insist(health.policy?.host_v2_ready===true,'R48 Host policy v2 is not ready');
+const evidence={schema:'deadbyte.r48-windows-gate.v1',status:'passed',exit_code:0,version:pkg.version,train:'R48',completed_at_utc:new Date().toISOString(),manifest_sha256:manifestSha256,parent:release.parent,active_predecessor:{release_id:active.release_id,version:active.version,manifest_sha256:active.manifest_sha256,generation_manifest_sha256:active.generation_manifest_sha256},doctor:{verified_entries:health.manifest.verified_entries,host_v2_ready:true},gates:{full_regression:true,commander_hardening:true,exact_catalog:true,stdio_smokes:true,manifest_final_verify:true}};
+const bytes=Buffer.from(`${JSON.stringify(evidence,null,2)}\n`);
+const dir=path.join(stateRoot,'evidence','release'); await mkdir(dir,{recursive:true});
+const target=path.join(dir,`r48-windows-gate-${manifestSha256.slice(0,16)}.json`);
+try{const handle=await open(target,'wx',0o600);try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}}
+catch(error){if(error?.code!=='EEXIST')throw error;const prior=JSON.parse(await readFile(target,'utf8'));insist(prior.schema===evidence.schema&&prior.status==='passed'&&prior.version===evidence.version&&prior.manifest_sha256===manifestSha256&&prior.parent?.release_id===release.parent.release_id,'conflicting R48 gate evidence identity');}
+console.log(JSON.stringify({status:'passed',path:target,sha256:sha256(bytes),manifest_sha256:manifestSha256}));

package/src/atomic-mutation.mjs

@@ -74,11 +74,19 @@ export async function atomicMutation({
       throw error;
     }
 
-    const after = await readState(target);
     const expectedAfter = sha256Bytes(bytes);
-    if (!after.exists || after.sha256 !== expectedAfter) throw new Error('atomic mutation post-commit hash mismatch');
-    if (verifyPostcondition) await verifyPostcondition({ before, after, expected_after_sha256: expectedAfter });
-    return { before, after, expected_after_sha256: expectedAfter };
+    try {
+      const after = await readState(target);
+      if (!after.exists || after.sha256 !== expectedAfter) throw new Error('atomic mutation post-commit hash mismatch');
+      if (verifyPostcondition) await verifyPostcondition({ before, after, expected_after_sha256: expectedAfter });
+      return { before, after, expected_after_sha256: expectedAfter };
+    } catch (error) {
+      const failure = error instanceof Error ? error : new Error(String(error));
+      failure.outcome = 'FAILED_AFTER_UNKNOWN_EFFECT';
+      failure.side_effect_state = 'unknown';
+      failure.expected_after_sha256 = expectedAfter;
+      throw failure;
+    }
   } finally {
     await releaseLock();
   }

package/src/coding-mcp-tools.mjs

@@ -46,7 +46,21 @@ const taskStep = z.union([
 ]);
 
 function result(schema, value, isError = false) { return codingStructuredResult(schema, value, isError); }
-function fail(schema, error) { return result(schema, { status: 'failed', error: String(error) }, true); }
+function fail(schema, error) {
+  const base = { status: 'failed', error: String(error) };
+  if (error?.outcome === 'FAILED_AFTER_UNKNOWN_EFFECT'
+      && error?.side_effect_state === 'unknown'
+      && HEX64.test(error?.expected_after_sha256 ?? '')) {
+    const enriched = {
+      ...base,
+      outcome: error.outcome,
+      side_effect_state: error.side_effect_state,
+      expected_after_sha256: error.expected_after_sha256
+    };
+    if (schema.safeParse(enriched).success) return result(schema, enriched, true);
+  }
+  return result(schema, base, true);
+}
 export function registerCodingTools(server, { codingRuntime, taskRuntime, semanticRuntime }) {
   if (!codingRuntime || !taskRuntime || !semanticRuntime) throw new Error('coding tool registration requires runtimes');
 

package/src/coding-output-contracts.mjs

@@ -168,7 +168,9 @@ export const codingSymbolReplaceOutputSchema = statusContract({
   shape: { root_id: z.string().min(1).max(64).optional(), path: z.string().min(1).max(512).optional(), previous_sha256: hex64.optional(),
     sha256: hex64.optional(), bytes: z.number().int().min(0).optional(), replacements: z.literal(1).optional(),
     receipt_id: receiptId.optional(), receipt_sha256: hex64.optional(), request_sha256: hex64.optional(),
-    symbol_id: hex64.optional(), symbol_name: z.string().min(1).max(256).optional(), engine: z.string().min(1).max(64).optional() },
+    symbol_id: hex64.optional(), symbol_name: z.string().min(1).max(256).optional(), engine: z.string().min(1).max(64).optional(),
+    outcome: z.literal('FAILED_AFTER_UNKNOWN_EFFECT').optional(), side_effect_state: z.literal('unknown').optional(),
+    expected_after_sha256: hex64.optional() },
   successStatuses: ['committed'], successRequired: ['root_id','path','previous_sha256','sha256','bytes','replacements','receipt_id','receipt_sha256','request_sha256','symbol_id','symbol_name','engine']
 });
 
@@ -189,14 +191,18 @@ export const codingFileWriteOutputSchema = statusContract({
   statuses: ['committed', 'failed'],
   shape: { root_id: z.string().min(1).max(64).optional(), path: z.string().min(1).max(512).optional(), previous_sha256: hex64.nullable().optional(),
     sha256: hex64.optional(), bytes: z.number().int().min(0).optional(), created: z.boolean().optional(), receipt_id: receiptId.optional(),
-    receipt_sha256: hex64.optional(), request_sha256: hex64.optional() },
+    receipt_sha256: hex64.optional(), request_sha256: hex64.optional(),
+    outcome: z.literal('FAILED_AFTER_UNKNOWN_EFFECT').optional(), side_effect_state: z.literal('unknown').optional(),
+    expected_after_sha256: hex64.optional() },
   successStatuses: ['committed'], successRequired: ['root_id', 'path', 'previous_sha256', 'sha256', 'bytes', 'created', 'receipt_id', 'receipt_sha256', 'request_sha256']
 });
 export const codingTextReplaceOutputSchema = statusContract({
   statuses: ['committed', 'failed'],
   shape: { root_id: z.string().min(1).max(64).optional(), path: z.string().min(1).max(512).optional(), previous_sha256: hex64.optional(),
     sha256: hex64.optional(), bytes: z.number().int().min(0).optional(), replacements: z.number().int().min(1).max(64).optional(),
-    receipt_id: receiptId.optional(), receipt_sha256: hex64.optional(), request_sha256: hex64.optional() },
+    receipt_id: receiptId.optional(), receipt_sha256: hex64.optional(), request_sha256: hex64.optional(),
+    outcome: z.literal('FAILED_AFTER_UNKNOWN_EFFECT').optional(), side_effect_state: z.literal('unknown').optional(),
+    expected_after_sha256: hex64.optional() },
   successStatuses: ['committed'], successRequired: ['root_id', 'path', 'previous_sha256', 'sha256', 'bytes', 'replacements', 'receipt_id', 'receipt_sha256', 'request_sha256']
 });
 export const codingCommandRunOutputSchema = statusContract({

package/src/commander-office-reader-r48.mjs

@@ -140,7 +140,7 @@ function prettyXml(xml){
   }
   return lines.join('\n');
 }
-function docxOutline(xml){
+function docxOutline(xml,files){
   const body=xml.match(/<w:body\b[^>]*>([\s\S]*?)<\/w:body>/)?.[1];
   if(body===undefined) return '[No w:body found in document.xml]';
   const elements=[...body.matchAll(/<w:(p|tbl)\b[\s\S]*?<\/w:\1>/g)].map(m=>({kind:m[1],xml:m[0]}));
@@ -152,6 +152,8 @@ function docxOutline(xml){
       let line=`[${i}] w:p`;
       if(style) line+=` style="${xmlDecode(style)}"`;
       const value=wordText(item.xml);
+      const hasDrawing=item.xml.includes('<w:drawing')||item.xml.includes('<mc:AlternateContent');
+      if(hasDrawing) line+=value?' (+ drawing/image)':` [drawing/image, ${(Buffer.byteLength(item.xml)/1024).toFixed(1)}KB]`;
       if(value) line+='\n  '+value;
       lines.push(line);
     }else{
@@ -163,7 +165,15 @@ function docxOutline(xml){
       }
     }
   }
-  return lines.join('\n');
+  const headersFooters=[];
+  for(const [name,bytes] of [...files.entries()].sort(([a],[b])=>a.localeCompare(b))){
+    if(!/^word\/(?:header|footer)[^/]*\.xml$/i.test(name)) continue;
+    try{
+      const value=wordText(decodeUtf8(bytes,name));
+      headersFooters.push(`${name.slice('word/'.length)}: ${value?`"${value.length>100?value.slice(0,100)+'...':value}"`:'(no text content)'}`);
+    }catch{/* malformed optional part is omitted; document.xml remains authoritative */}
+  }
+  return lines.join('\n')+(headersFooters.length?`\n\nHeaders/Footers:\n${headersFooters.join('\n')}`:'');
 }
 
 export function readDocxBytes(input,{path:displayPath='document.docx',offset=0,length=1000}={}){
@@ -180,11 +190,34 @@ export function readDocxBytes(input,{path:displayPath='document.docx',offset=0,l
     return {content:`[DOCX XML: lines ${start}-${Math.max(start,start+sliced.length-1)} of ${totalLines} (${remaining} remaining)]\n${sliced.join('\n')}`,
       mimeType:'application/xml',metadata:{isDocx:true,lineCount:totalLines},outline:false};
   }
-  const outline=docxOutline(xml);
+  const outline=docxOutline(xml,files);
   const rawSizeKB=(Buffer.byteLength(xml)/1024).toFixed(1);
   return {content:`${outline}\n\nRaw XML: ${totalLines} lines, ${rawSizeKB}KB.`,mimeType:'text/plain',metadata:{isDocx:true,lineCount:totalLines},outline:true};
 }
 
+export function searchDocxTextBytes(input,{pattern,ignoreCase=true,maxResults=500}={}){
+  if(typeof pattern!=='string'||pattern.length<1||pattern.length>4096) throw new Error('DOCX search pattern invalid');
+  if(!Number.isInteger(maxResults)||maxResults<1||maxResults>5000) throw new Error('DOCX search maxResults invalid');
+  const files=unzipOffice(input),needle=ignoreCase?pattern.toLowerCase():pattern,results=[];
+  const names=[...files.keys()].filter(name=>name==='word/document.xml'||/^word\/(?:header|footer)[^/]*\.xml$/i.test(name)).sort((a,b)=>{
+    if(a==='word/document.xml')return -1;if(b==='word/document.xml')return 1;return a.localeCompare(b);
+  });
+  for(const name of names){
+    let xml;
+    try{xml=decodeUtf8(files.get(name),name);}catch{continue;}
+    let line=0;
+    for(const match of xml.matchAll(/<w:t(?:\s[^>]*)?>([^<]*)<\/w:t>/g)){
+      const value=xmlDecode(match[1]??'');if(!value.trim())continue;line++;
+      const haystack=ignoreCase?value.toLowerCase():value,index=haystack.indexOf(needle);
+      if(index<0)continue;
+      const start=Math.max(0,index-50),end=Math.min(value.length,index+needle.length+50);
+      results.push({part:name,line,match:`${start>0?'...':''}${value.slice(start,end)}${end<value.length?'...':''}`});
+      if(results.length>=maxResults)return results;
+    }
+  }
+  return results;
+}
+
 
 export function createDocxBytes(content){
   if(typeof content!=='string') throw new Error('DOCX content must be string');

package/src/commander-pdf-r48.mjs

@@ -110,6 +110,37 @@ export function parseDeadbytePdf(input){
 const MAX_GENERIC_OBJECTS=10000;
 const MAX_GENERIC_STREAM_BYTES=16*1024*1024;
 
+function classicIncrementalObjectOffsets(text){
+  const starts=[...text.matchAll(/startxref\s+(\d+)\s+%%EOF/g)];
+  if(starts.length<2)return new Map();
+  const offsets=new Map(),visited=new Set();
+  let cursor=Number(starts.at(-1)[1]);
+  while(Number.isSafeInteger(cursor)&&cursor>=0&&!visited.has(cursor)){
+    visited.add(cursor);
+    if(text.slice(cursor,cursor+4)!=='xref')return new Map();
+    const trailerAt=text.indexOf('trailer',cursor+4);
+    if(trailerAt<0)return new Map();
+    const lines=text.slice(cursor+4,trailerAt).trim().split(/\r?\n/);
+    for(let i=0;i<lines.length;){
+      const header=lines[i++].trim().match(/^(\d+)\s+(\d+)$/);if(!header)return new Map();
+      const first=Number(header[1]),count=Number(header[2]);
+      if(!Number.isSafeInteger(first)||!Number.isSafeInteger(count)||count<0||count>MAX_GENERIC_OBJECTS)return new Map();
+      for(let n=0;n<count;n++){
+        const entry=lines[i++]?.trim().match(/^(\d{10})\s+(\d{5})\s+([nf])$/);if(!entry)return new Map();
+        if(entry[3]==='n'){
+          const key=`${first+n} ${Number(entry[2])}`;
+          const list=offsets.get(key)??[];list.push(Number(entry[1]));offsets.set(key,list);
+        }
+      }
+    }
+    const trailerEnd=text.indexOf('startxref',trailerAt+7);if(trailerEnd<0)return new Map();
+    const prev=text.slice(trailerAt+7,trailerEnd).match(/\/Prev\s+(\d+)/)?.[1];
+    if(prev===undefined)break;
+    const next=Number(prev);if(!Number.isSafeInteger(next)||next>=cursor)return new Map();cursor=next;
+  }
+  return offsets;
+}
+
 function decodePdfTextBytes(bytes){
   if(bytes.length>=2&&bytes[0]===0xfe&&bytes[1]===0xff){
     let out='';
@@ -186,6 +217,7 @@ function parseGenericPdfObjects(bytes){
   const text=bytes.toString('latin1');
   if(!text.startsWith('%PDF-')) throw new Error('invalid PDF header');
   if(/\/Encrypt\b/.test(text)) throw new Error('encrypted PDF is unsupported');
+  const incrementalOffsets=classicIncrementalObjectOffsets(text);
   const objects=new Map(),header=/(\d+)\s+(\d+)\s+obj\b/g;
   let match,count=0;
   while((match=header.exec(text))){
@@ -193,7 +225,10 @@ function parseGenericPdfObjects(bytes){
     const end=text.indexOf('endobj',header.lastIndex);
     if(end<0) throw new Error(`PDF object ${match[1]} ${match[2]} missing endobj`);
     const key=`${match[1]} ${match[2]}`;
-    if(objects.has(key)) throw new Error(`PDF duplicate object ${key}`);
+    if(objects.has(key)){
+      const revisions=incrementalOffsets.get(key)??[];
+      if(!revisions.includes(objects.get(key).offset)||!revisions.includes(match.index)) throw new Error(`PDF duplicate object ${key}`);
+    }
     objects.set(key,{id:Number(match[1]),generation:Number(match[2]),body:text.slice(header.lastIndex,end),offset:match.index});
     header.lastIndex=end+6;
   }