deadbyte-mcp 0.15.26 → 0.15.28

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "deadbyte-mcp",
-    "version": "0.15.26",
+    "version": "0.15.28",
     "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-r49.ps1",
+        "gate:windows": "powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r51.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",
@@ -72,7 +72,8 @@
         "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 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"
+        "release:npm": "node scripts/npm-release-r48.mjs",
+        "r51:focused:test": "node --test --test-concurrency=1 test/r51-release-contract.test.mjs test/r51-runtime-coherence.test.mjs test/r51-live-log-polling.test.mjs test/coding-runtime.test.mjs test/remote-live-log-r37.test.mjs"
     },
     "bundleDependencies": [
         "@modelcontextprotocol/server",

package/scripts/deploy-r48.mjs

@@ -8,7 +8,7 @@ import { loadPowerShellDataFile, runSlotUpdateCli } from '../src/runtime-update.
 import { parseActivePointer } from '../src/release-slot.mjs';
 
 const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
-const state=path.join(os.homedir(),'.deadbyte-mcp');
+const state=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
 const sha=async f=>createHash('sha256').update(await readFile(f)).digest('hex');
 const sleep=ms=>new Promise(resolve=>setTimeout(resolve,ms));
 

package/scripts/gate-windows-r50.ps1

@@ -0,0 +1,56 @@
+$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.27 / R50 gate failed at $Name with exit code $LASTEXITCODE" }
+}
+
+function Invoke-NodeTest {
+    param([Parameter(Mandatory)][string]$Name,[Parameter(Mandatory)][string[]]$TestFiles)
+    Write-Host "==== $Name ===="
+    & node.exe --test --test-concurrency=1 @TestFiles
+    if ($LASTEXITCODE -ne 0) { throw "DEADBYTE 0.15.27 / R50 gate failed at $Name with exit code $LASTEXITCODE" }
+}
+
+Invoke-NodeTest 'r50-package-boundary' @('test/package-boundary.test.mjs')
+Invoke-NodeTest 'r50-release-smoke-isolation' @('test/release-smoke-isolation.test.mjs')
+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 'r50-release-focused' @('run','r48:release:test')
+Invoke-NodeTest 'r49-donor-proof' @('test/r49-remote-control-donors.test.mjs')
+Invoke-NodeTest 'r49-desktop-wait' @('test/desktop-runtime-r40.test.mjs','test/desktop-mcp-tools-r40.test.mjs','test/autonomous-desktop-r40.test.mjs')
+Invoke-GateStep 'r49-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-r50.mjs')
+if ($LASTEXITCODE -ne 0) { throw "R50 evidence writer failed with exit code $LASTEXITCODE" }
+Write-Host '==== DEADBYTE 0.15.27 / R50 WINDOWS GATE: PASS ===='

package/scripts/gate-windows-r51.ps1

@@ -0,0 +1,58 @@
+$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.28 / R51 gate failed at $Name with exit code $LASTEXITCODE" }
+}
+
+function Invoke-NodeTest {
+    param([Parameter(Mandatory)][string]$Name,[Parameter(Mandatory)][string[]]$TestFiles)
+    Write-Host "==== $Name ===="
+    & node.exe --test --test-concurrency=1 @TestFiles
+    if ($LASTEXITCODE -ne 0) { throw "DEADBYTE 0.15.28 / R51 gate failed at $Name with exit code $LASTEXITCODE" }
+}
+
+Invoke-NodeTest 'r51-package-boundary' @('test/package-boundary.test.mjs')
+Invoke-NodeTest 'r51-release-smoke-isolation' @('test/release-smoke-isolation.test.mjs')
+Invoke-GateStep 'r51-focused-contracts' @('run','r51:focused:test')
+Invoke-GateStep 'containment-build' @('run','containment:build')
+Invoke-GateStep 'process-policy-refresh' @('run','process:policy:refresh')
+Write-Host "==== desktop-policy-refresh ===="
+& (Join-Path $PSScriptRoot 'init-desktop-policy-r40.ps1')
+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 'r51-release-focused' @('run','r48:release:test')
+Invoke-NodeTest 'r49-donor-proof' @('test/r49-remote-control-donors.test.mjs')
+Invoke-NodeTest 'r49-desktop-wait' @('test/desktop-runtime-r40.test.mjs','test/desktop-mcp-tools-r40.test.mjs','test/autonomous-desktop-r40.test.mjs')
+Invoke-GateStep 'r49-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-r51.mjs')
+if ($LASTEXITCODE -ne 0) { throw "R51 evidence writer failed with exit code $LASTEXITCODE" }
+Write-Host '==== DEADBYTE 0.15.28 / R51 WINDOWS GATE: PASS ===='

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

@@ -0,0 +1,80 @@
+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.27' && release.version === pkg.version && release.train === 'R50', 'R50 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 R50 parent'
+);
+
+const health = await doctor();
+insist(health.status === 'ok' && health.package_version === pkg.version && health.manifest?.verified === true, 'R50 doctor evidence invalid');
+insist(health.policy?.host_v2_ready === true, 'R50 Host policy v2 is not ready');
+
+const evidence = {
+  schema: 'deadbyte.r50-windows-gate.v1',
+  status: 'passed',
+  exit_code: 0,
+  version: pkg.version,
+  train: 'R50',
+  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: {
+    package_boundary: true,
+    release_smoke_isolation: true,
+    full_regression: true,
+    commander_hardening: true,
+    donor_proof: true,
+    desktop_wait: 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, `r50-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 R50 gate evidence identity'
+  );
+}
+
+console.log(JSON.stringify({ status: 'passed', path: target, sha256: sha256(bytes), manifest_sha256: manifestSha256 }));

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

@@ -0,0 +1,84 @@
+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.28' && release.version === pkg.version && release.train === 'R51', 'R51 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 R51 parent'
+);
+
+const health = await doctor();
+insist(health.status === 'ok' && health.package_version === pkg.version && health.manifest?.verified === true, 'R51 doctor evidence invalid');
+insist(health.policy?.host_v2_ready === true, 'R51 Host policy v2 is not ready');
+
+const evidence = {
+  schema: 'deadbyte.r51-windows-gate.v1',
+  status: 'passed',
+  exit_code: 0,
+  version: pkg.version,
+  train: 'R51',
+  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: {
+    package_boundary: true,
+    release_smoke_isolation: true,
+    runtime_coherence: true,
+    coding_command_singleflight: true,
+    foreground_desktop_host_fail_closed: true,
+    livelog_optimizer: true,
+    full_regression: true,
+    commander_hardening: true,
+    donor_proof: true,
+    desktop_wait: 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, `r51-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 R51 gate evidence identity'
+  );
+}
+
+console.log(JSON.stringify({ status: 'passed', path: target, sha256: sha256(bytes), manifest_sha256: manifestSha256 }));

package/src/coding-plane.mjs

@@ -368,6 +368,93 @@ function requestSha(operation, args) {
 export function createCodingRuntime({ policy, signingKeyPath, verifyKeyPath }) {
   if (!policy) throw new Error('coding runtime requires policy');
   if (!signingKeyPath || !verifyKeyPath) throw new Error('coding runtime requires trust key paths');
+  const commandFlights = new Map();
+  const commandResults = new Map();
+  const COMMAND_RESULT_TTL_MS = 5 * 60 * 1000;
+  const COMMAND_RESULT_CACHE_MAX = 16;
+  const COMMAND_FLIGHT_SCHEMA = 'deadbyte.coding-command-flight.v1';
+  const COMMAND_RESULT_SCHEMA = 'deadbyte.coding-command-result.v1';
+  const commandFlightDir = path.join(policy.evidence_dir, 'command-flights');
+  function pruneCommandResults(now = Date.now()) {
+    for (const [key, entry] of commandResults) if (now - entry.completed_at_ms > COMMAND_RESULT_TTL_MS) commandResults.delete(key);
+    while (commandResults.size > COMMAND_RESULT_CACHE_MAX) commandResults.delete(commandResults.keys().next().value);
+  }
+  function commandFlightPaths(executionKey) {
+    const executionKeySha256 = sha256Bytes(Buffer.from(executionKey, 'utf8'));
+    return {
+      executionKeySha256,
+      claimPath: path.join(commandFlightDir, `${executionKeySha256}.claim.json`),
+      resultPath: path.join(commandFlightDir, `${executionKeySha256}.result.json`)
+    };
+  }
+  async function readDurableCommandResult(resultPath, executionKeySha256, request) {
+    let raw;
+    try { raw = JSON.parse(decodeUtf8Strict(await readFile(resultPath))); }
+    catch (error) {
+      if (error?.code === 'ENOENT') return null;
+      throw new Error(`coding command durable result invalid: ${String(error?.message ?? error)}`);
+    }
+    if (raw?.schema !== COMMAND_RESULT_SCHEMA || raw.execution_key_sha256 !== executionKeySha256 || raw.request_sha256 !== request ||
+        !Number.isInteger(raw.completed_at_ms) || !raw.result || typeof raw.result !== 'object' || Array.isArray(raw.result)) {
+      throw new Error('coding command durable result identity invalid');
+    }
+    if (Date.now() - raw.completed_at_ms > COMMAND_RESULT_TTL_MS) {
+      await rm(resultPath, { force: true });
+      return null;
+    }
+    const value = raw.result;
+    if (value.request_sha256 !== request || !RECEIPT_ID_RE.test(value.receipt_id ?? '') || !SHA256_RE.test(value.receipt_sha256 ?? '')) {
+      throw new Error('coding command durable result receipt identity invalid');
+    }
+    const verified = await verifyCodingReceiptFile(policy, verifyKeyPath, value.receipt_id);
+    if (!verified.ok || verified.request_sha256 !== request || verified.receipt_sha256 !== value.receipt_sha256) {
+      throw new Error(`coding command durable result receipt verification failed: ${verified.reason ?? 'identity mismatch'}`);
+    }
+    return { ...value };
+  }
+  async function writeDurableCommandResult(resultPath, executionKeySha256, request, value) {
+    const body = Buffer.from(`${JSON.stringify({ schema:COMMAND_RESULT_SCHEMA, execution_key_sha256:executionKeySha256,
+      request_sha256:request, completed_at_ms:Date.now(), result:value })}\n`, 'utf8');
+    try {
+      const handle = await open(resultPath, 'wx', 0o600);
+      try { await handle.writeFile(body); await handle.sync(); }
+      finally { await handle.close(); }
+    } catch (error) {
+      if (error?.code !== 'EEXIST') throw error;
+      const prior = await readDurableCommandResult(resultPath, executionKeySha256, request);
+      if (!prior || prior.receipt_id !== value.receipt_id || prior.receipt_sha256 !== value.receipt_sha256) {
+        throw new Error('coding command durable result conflict');
+      }
+    }
+  }
+  async function acquireDurableCommandFlight(executionKey, request, waitMs) {
+    await mkdir(commandFlightDir, { recursive: true });
+    const paths = commandFlightPaths(executionKey);
+    const cached = await readDurableCommandResult(paths.resultPath, paths.executionKeySha256, request);
+    if (cached) return { ...paths, owned:false, cached };
+    try {
+      const handle = await open(paths.claimPath, 'wx', 0o600);
+      try {
+        await handle.writeFile(Buffer.from(`${JSON.stringify({ schema:COMMAND_FLIGHT_SCHEMA, execution_key_sha256:paths.executionKeySha256,
+          request_sha256:request, owner_pid:process.pid, started_at_ms:Date.now() })}\n`, 'utf8'));
+        await handle.sync();
+      } finally { await handle.close(); }
+      return { ...paths, owned:true, cached:null };
+    } catch (error) {
+      if (error?.code !== 'EEXIST') throw error;
+    }
+    const deadline = Date.now() + waitMs;
+    for (;;) {
+      const result = await readDurableCommandResult(paths.resultPath, paths.executionKeySha256, request);
+      if (result) return { ...paths, owned:false, cached:result };
+      let claimExists = true;
+      try { await stat(paths.claimPath); }
+      catch (error) { if (error?.code === 'ENOENT') claimExists = false; else throw error; }
+      if (!claimExists) return acquireDurableCommandFlight(executionKey, request, Math.max(100, deadline - Date.now()));
+      if (Date.now() >= deadline) throw new Error('identical coding command is still running in another runtime instance');
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+  }
 
   async function sessionStatus() {
     const status = await codingSessionStatus(policy);
@@ -587,23 +674,67 @@ export function createCodingRuntime({ policy, signingKeyPath, verifyKeyPath }) {
       root_id: rootId, command_id: commandId, script_path: scriptPath, script_sha256: scriptSha256,
       args, cwd, timeout_ms: timeoutMs
     });
-    const started = new Date().toISOString();
-    const result = await runCommandOnce({ rootId, commandId, scriptPath, scriptSha256, args, cwd, timeoutMs, executionDeadlineUtc, preExecutionCheck });
-    const signed = await signCodingReceipt(policy, signingKeyPath, result.lease, {
-      operation: 'coding_command_run', request_sha256: request, root_id: rootId, command_id: commandId,
-      script_path: scriptPath, executable_sha256: result.executable_sha256, script_sha256: result.script_sha256,
-      started_at_utc: started, completed_at_utc: new Date().toISOString(), exit_code: result.exit_code,
-      signal: result.signal, timed_out: result.timed_out, elapsed_ms: result.elapsed_ms,
-      stdout_sha256: result.stdout_sha256, stderr_sha256: result.stderr_sha256
-    }, receiptId);
-    return {
-      status: result.timed_out || result.exit_code !== 0 ? 'observed_failure' : 'passed',
-      root_id: rootId, command_id: commandId, executable_sha256: result.executable_sha256,
-      script_sha256: result.script_sha256, exit_code: result.exit_code, signal: result.signal,
-      timed_out: result.timed_out, timeout_ms: result.timeout_ms, elapsed_ms: result.elapsed_ms,
-      stdout: result.stdout, stderr: result.stderr,
-      receipt_id: signed.receipt.receipt_id, receipt_sha256: signed.receipt.receipt_sha256, request_sha256: request
-    };
+    const executionKey = receiptId === null ? request : `${request}:${receiptId}`;
+    pruneCommandResults();
+    const cached = commandResults.get(executionKey);
+    if (cached) {
+      await assertCodingArmed(policy, rootId);
+      return { ...cached.result };
+    }
+    const inFlight = commandFlights.get(executionKey);
+    if (inFlight) {
+      await assertCodingArmed(policy, rootId);
+      return { ...(await inFlight) };
+    }
+    if (!ID_RE.test(commandId ?? '')) throw new Error('invalid coding command id');
+    const command = policy.commands[commandId];
+    if (!command) throw new Error(`coding command '${commandId}' is not allowed`);
+    if (!command.root_ids.includes(rootId)) throw new Error(`coding command '${commandId}' is not allowed for root '${rootId}'`);
+    if (!Array.isArray(args) || args.length > 64 || args.some(item => typeof item !== 'string' || item.length > 2048 || item.includes('\0'))) {
+      throw new Error('coding command args must be <=64 strings of <=2048 characters');
+    }
+    if (!SHA256_RE.test(scriptSha256 ?? '')) throw new Error('script_sha256 must be lowercase SHA-256');
+    const requestedTimeout = timeoutMs === null ? command.timeout_ms : finiteInteger(timeoutMs, 'timeout_ms', 100, command.timeout_ms, command.timeout_ms);
+    const durable = await acquireDurableCommandFlight(executionKey, request, Math.min(900_000, requestedTimeout + 10_000));
+    if (durable.cached) {
+      await assertCodingArmed(policy, rootId);
+      commandResults.set(executionKey, { completed_at_ms: Date.now(), result: durable.cached });
+      pruneCommandResults();
+      return { ...durable.cached };
+    }
+    const execution = (async () => {
+      const started = new Date().toISOString();
+      const result = await runCommandOnce({ rootId, commandId, scriptPath, scriptSha256, args, cwd, timeoutMs, executionDeadlineUtc, preExecutionCheck });
+      const signed = await signCodingReceipt(policy, signingKeyPath, result.lease, {
+        operation: 'coding_command_run', request_sha256: request, root_id: rootId, command_id: commandId,
+        script_path: scriptPath, executable_sha256: result.executable_sha256, script_sha256: result.script_sha256,
+        started_at_utc: started, completed_at_utc: new Date().toISOString(), exit_code: result.exit_code,
+        signal: result.signal, timed_out: result.timed_out, elapsed_ms: result.elapsed_ms,
+        stdout_sha256: result.stdout_sha256, stderr_sha256: result.stderr_sha256
+      }, receiptId);
+      const value = {
+        status: result.timed_out || result.exit_code !== 0 ? 'observed_failure' : 'passed',
+        root_id: rootId, command_id: commandId, executable_sha256: result.executable_sha256,
+        script_sha256: result.script_sha256, exit_code: result.exit_code, signal: result.signal,
+        timed_out: result.timed_out, timeout_ms: result.timeout_ms, elapsed_ms: result.elapsed_ms,
+        stdout: result.stdout, stderr: result.stderr,
+        receipt_id: signed.receipt.receipt_id, receipt_sha256: signed.receipt.receipt_sha256, request_sha256: request
+      };
+      await writeDurableCommandResult(durable.resultPath, durable.executionKeySha256, request, value);
+      return value;
+    })();
+    commandFlights.set(executionKey, execution);
+    let completedDurably = false;
+    try {
+      const value = await execution;
+      completedDurably = true;
+      commandResults.set(executionKey, { completed_at_ms: Date.now(), result: value });
+      pruneCommandResults();
+      return { ...value };
+    } finally {
+      if (completedDurably && durable.owned) await rm(durable.claimPath, { force: true });
+      if (commandFlights.get(executionKey) === execution) commandFlights.delete(executionKey);
+    }
   }
 
   function percentile(samples, fraction) {