deadbyte-mcp 0.8.7

package/test/process-policy-refresh.test.mjs

@@ -0,0 +1,64 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { refreshProcessPolicy } from '../scripts/refresh-process-policy.mjs';
+
+const sha256 = bytes => createHash('sha256').update(bytes).digest('hex');
+
+async function fixture() {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-process-refresh-'));
+  const bin = path.join(root, 'bin');
+  const controller = path.join(root, 'controller');
+  await mkdir(bin, { recursive: true });
+  await mkdir(controller, { recursive: true });
+  const hostPath = path.join(bin, 'deadbyte-process-host.exe');
+  const hostBytes = Buffer.from('fresh-native-host\n');
+  await writeFile(hostPath, hostBytes);
+  const policyPath = path.join(controller, 'deadbyte-process-policy.json');
+  const policy = { schema:'deadbyte.process-policy.v1', enabled:true, grant_file:path.join(root,'runtime','grant.json'),
+    state_dir:path.join(root,'state'), native_host:{ path:hostPath, sha256:'0'.repeat(64) },
+    roots:{core:{path:root,deny_paths:[]}}, profiles:{probe:{executable:process.execPath,executable_sha256:'1'.repeat(64),root_ids:['core'],prefix_args:[],max_args:0,max_arg_bytes:256,max_sessions:1,max_input_bytes:4096,max_retained_output_bytes:4096,env_allow:[],input_actions:{}}}};
+  await writeFile(policyPath, `${JSON.stringify(policy,null,2)}\n`);
+  return { root, policyPath, hostPath, hostBytes, policy };
+}
+test('R33 candidate process policy self-binds to the current repository root', async () => {
+  const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+  const policyPath = path.join(repoRoot, 'controller', 'deadbyte-process-policy.json');
+  const policy = JSON.parse(await readFile(policyPath, 'utf8'));
+  assert.equal(policy.grant_file, path.join(repoRoot, 'controller', 'runtime', 'process-grant.json'));
+  assert.equal(policy.state_dir, path.join(repoRoot, 'controller', 'runtime', 'process-state'));
+  assert.equal(policy.native_host.path, path.join(repoRoot, 'bin', 'deadbyte-process-host.exe'));
+  assert.equal(policy.roots.core.path, repoRoot);
+});
+
+test('R31 refresh changes only the native-host digest after the Windows build', async () => {
+  const f = await fixture();
+  const result = await refreshProcessPolicy({ repoRoot:f.root, policyPath:f.policyPath });
+  const after = JSON.parse(await readFile(f.policyPath,'utf8'));
+  assert.equal(after.native_host.path, f.hostPath);
+  assert.equal(after.native_host.sha256, sha256(f.hostBytes));
+  assert.equal(result.native_host_sha256, sha256(f.hostBytes));
+  const expected = structuredClone(f.policy);
+  expected.native_host.sha256 = sha256(f.hostBytes);
+  assert.deepEqual(after, expected);
+});
+
+test('R31 refresh fails closed when native-host path is not the candidate bin path', async () => {
+  const f = await fixture();
+  const raw = JSON.parse(await readFile(f.policyPath,'utf8'));
+  raw.native_host.path = process.execPath;
+  await writeFile(f.policyPath, `${JSON.stringify(raw,null,2)}\n`);
+  await assert.rejects(() => refreshProcessPolicy({ repoRoot:f.root, policyPath:f.policyPath }), /native_host path must equal candidate bin/);
+});
+
+test('R31 refresh refuses a malformed or disabled process policy', async () => {
+  const f = await fixture();
+  const raw = JSON.parse(await readFile(f.policyPath,'utf8'));
+  raw.enabled = false;
+  await writeFile(f.policyPath, `${JSON.stringify(raw,null,2)}\n`);
+  await assert.rejects(() => refreshProcessPolicy({ repoRoot:f.root, policyPath:f.policyPath }), /schema\/enabled mismatch/);
+});

package/test/process-policy.test.mjs

@@ -0,0 +1,118 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { mkdtemp, mkdir, readFile, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  PROCESS_GRANT_SCHEMA,
+  PROCESS_POLICY_SCHEMA,
+  assertProcessArmed,
+  loadProcessPolicy,
+  processSessionStatus
+} from '../src/process-policy.mjs';
+
+const sha = bytes => createHash('sha256').update(bytes).digest('hex');
+
+async function fixture() {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-process-policy-'));
+  const project = path.join(root, 'project');
+  await mkdir(project);
+  const executable = process.execPath;
+  const executableSha = sha(await readFile(executable));
+  const policyPath = path.join(root, 'process-policy.json');
+  const grantFile = path.join(root, 'process-grant.json');
+  const stateDir = path.join(root, 'process-state');  const raw = {
+    schema: PROCESS_POLICY_SCHEMA, enabled: true, grant_file: grantFile, state_dir: stateDir,
+    native_host: { path: executable, sha256: executableSha },
+    roots: { core: { path: project, deny_paths: [] } },
+    profiles: {
+      node: {
+        executable, executable_sha256: executableSha, root_ids: ['core'],
+        prefix_args: [], max_args: 8, max_arg_bytes: 1024,
+        max_sessions: 2, max_input_bytes: 65536, max_retained_output_bytes: 262144,
+        env_allow: ['PATH', 'TEMP', 'TMP'], input_actions: { ping: 'PING\r\n' }
+      }
+    }
+  };
+  await writeFile(policyPath, JSON.stringify(raw));
+  return { root, project, policyPath, grantFile, raw };
+}
+
+test('process policy loads pinned native host, profile and root while grant is absent', async () => {
+  const f = await fixture();
+  const policy = await loadProcessPolicy(f.policyPath);
+  const status = await processSessionStatus(policy);
+  assert.equal(status.configured, true);
+  assert.equal(status.armed, false);
+  assert.equal(status.reason, 'disarmed');
+  assert.deepEqual(status.profile_ids, ['node']);
+  assert.deepEqual(status.root_ids, ['core']);
+});test('process standing grant binds exact policy, profile and root', async () => {
+  const f = await fixture();
+  const policy = await loadProcessPolicy(f.policyPath);
+  await writeFile(f.grantFile, JSON.stringify({
+    schema: PROCESS_GRANT_SCHEMA,
+    policy_sha256: policy.policy_sha256,
+    instance_nonce: 'a'.repeat(64),
+    profile_ids: ['node'],
+    root_ids: ['core'],
+    granted_at_utc: '2026-09-14T00:00:00Z'
+  }));
+  const status = await processSessionStatus(policy);
+  assert.equal(status.armed, true);
+  assert.equal(status.reason, 'standing-grant');
+  assert.deepEqual(status.profile_ids, ['node']);
+  assert.deepEqual(status.root_ids, ['core']);
+  const armed = await assertProcessArmed(policy, 'node', 'core');
+  assert.equal(armed.instance_nonce, 'a'.repeat(64));
+  await assert.rejects(() => assertProcessArmed(policy, 'other', 'core'), /profile 'other' is not included/);
+});
+
+test('process grant with wrong policy digest is disarmed', async () => {
+  const f = await fixture();
+  const policy = await loadProcessPolicy(f.policyPath);
+  await writeFile(f.grantFile, JSON.stringify({ schema: PROCESS_GRANT_SCHEMA,
+    policy_sha256: 'b'.repeat(64), instance_nonce: 'c'.repeat(64),
+    profile_ids: ['node'], root_ids: ['core'], granted_at_utc: '2026-09-14T00:00:00Z' }));
+  const status = await processSessionStatus(policy);
+  assert.equal(status.armed, false);
+  assert.equal(status.reason, 'policy-digest');
+});test('process policy rejects changed pinned executable bytes', async () => {
+  const f = await fixture();
+  f.raw.profiles.node.executable_sha256 = 'd'.repeat(64);
+  await writeFile(f.policyPath, JSON.stringify(f.raw));
+  await assert.rejects(() => loadProcessPolicy(f.policyPath), /executable hash mismatch/);
+});
+
+test('process policy rejects profile roots that are not registered', async () => {
+  const f = await fixture();
+  f.raw.profiles.node.root_ids = ['missing'];
+  await writeFile(f.policyPath, JSON.stringify(f.raw));
+  await assert.rejects(() => loadProcessPolicy(f.policyPath), /root_ids invalid/);
+});
+test('process policy pins named input actions into the policy', async () => {
+  const f = await fixture();
+  const policy = await loadProcessPolicy(f.policyPath);
+  assert.equal(policy.profiles.node.input_actions.ping, 'PING\r\n');
+  assert.equal(policy.profiles.node.transport, 'conpty');
+});
+
+test('process policy accepts explicit pipe transport and rejects unknown transports', async () => {
+  const f = await fixture();
+  f.raw.profiles.node.transport = 'pipe';
+  await writeFile(f.policyPath, JSON.stringify(f.raw));
+  const policy = await loadProcessPolicy(f.policyPath);
+  assert.equal(policy.profiles.node.transport, 'pipe');
+  f.raw.profiles.node.transport = 'other';
+  await writeFile(f.policyPath, JSON.stringify(f.raw));
+  await assert.rejects(() => loadProcessPolicy(f.policyPath), /transport/);
+});
+
+test('process policy rejects named actions larger than the profile input bound', async () => {
+  const f = await fixture();
+  f.raw.profiles.node.max_input_bytes = 4;
+  f.raw.profiles.node.input_actions.ping = '12345';
+  await writeFile(f.policyPath, JSON.stringify(f.raw));
+  await assert.rejects(() => loadProcessPolicy(f.policyPath), /input action too large/);
+});

package/test/process-release-gate.test.mjs

@@ -0,0 +1,41 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+
+const packagePath = fileURLToPath(new URL('../package.json', import.meta.url));
+const gatePath = fileURLToPath(new URL('../scripts/gate-windows.ps1', import.meta.url));
+
+test('R31 package exposes the bounded process smoke command', async () => {
+  const pkg = JSON.parse(await readFile(packagePath, 'utf8'));
+  assert.equal(pkg.scripts['mcp:process:smoke'], 'node src/process-smoke-client.mjs');
+});
+
+test('R31 Windows gate refreshes the native-host policy pin before manifest freeze', async () => {
+  const pkg = JSON.parse(await readFile(packagePath, 'utf8'));
+  const source = await readFile(gatePath, 'utf8');
+  assert.equal(pkg.scripts['process:policy:refresh'], 'node scripts/refresh-process-policy.mjs');
+  assert.match(source, /process-policy-refresh/);
+  assert.match(source, /'process:policy:refresh'/);
+  assert.ok(source.indexOf('containment-build') < source.indexOf('process-policy-refresh'));
+  assert.ok(source.indexOf('process-policy-refresh') < source.indexOf('release-manifest-write'));
+});
+
+test('R31 Windows gate runs process smoke before final manifest verification', async () => {
+  const source = await readFile(gatePath, 'utf8');
+  assert.match(source, /mcp-process-smoke/);
+  assert.match(source, /'mcp:process:smoke'/);
+  assert.ok(source.indexOf('mcp-process-smoke') < source.indexOf('release-manifest-final'));
+});
+
+test('R31 package exposes bounded machine filesystem smoke command', async () => {
+  const pkg = JSON.parse(await readFile(packagePath, 'utf8'));
+  assert.equal(pkg.scripts['mcp:machine-fs:smoke'], 'node src/machine-fs-smoke-client.mjs');
+});
+
+test('R31 Windows gate runs machine filesystem smoke before final manifest verification', async () => {
+  const source = await readFile(gatePath, 'utf8');
+  assert.match(source, /mcp-machine-fs-smoke/);
+  assert.match(source, /'mcp:machine-fs:smoke'/);
+  assert.ok(source.indexOf('mcp-machine-fs-smoke') < source.indexOf('release-manifest-final'));
+});

package/test/process-runtime.test.mjs

@@ -0,0 +1,184 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { PROCESS_GRANT_SCHEMA, PROCESS_POLICY_SCHEMA, loadProcessPolicy } from '../src/process-policy.mjs';
+import { createProcessRuntime } from '../src/process-runtime.mjs';
+import { generateTrustKeypair } from '../src/trust.mjs';
+
+const repo = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const host = path.join(repo, 'bin', 'deadbyte-process-host.exe');
+const cmd = 'C:\\Windows\\System32\\cmd.exe';
+const sha = bytes => createHash('sha256').update(bytes).digest('hex');
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+async function fixture() {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-process-runtime-'));
+  const project = path.join(root, 'project');
+  const trust = path.join(root, 'trust');
+  await mkdir(project); await mkdir(trust);
+  const grantFile = path.join(root, 'process-grant.json');
+  const stateDir = path.join(root, 'process-state');
+  const policyPath = path.join(root, 'process-policy.json');
+  const hostSha = sha(await readFile(host));
+  const cmdSha = sha(await readFile(cmd));
+  const raw = {
+    schema: PROCESS_POLICY_SCHEMA, enabled: true, grant_file: grantFile, state_dir: stateDir,
+    native_host: { path: host, sha256: hostSha },
+    roots: { core: { path: project, deny_paths: [] } },
+    profiles: {
+      echo: {
+        executable: cmd, executable_sha256: cmdSha, root_ids: ['core'],
+        prefix_args: ['/d', '/c'], max_args: 4, max_arg_bytes: 256,
+        max_sessions: 2, max_input_bytes: 4096, max_retained_output_bytes: 65536,
+        env_allow: ['PATH', 'TEMP', 'TMP'], input_actions: {}
+      },
+      hold: {
+        executable: cmd, executable_sha256: cmdSha, root_ids: ['core'], transport: 'pipe',
+        prefix_args: ['/d', '/q'], max_args: 0, max_arg_bytes: 256,
+        max_sessions: 1, max_input_bytes: 4096, max_retained_output_bytes: 65536,
+        env_allow: ['PATH', 'TEMP', 'TMP'], input_actions: { ping: 'echo deadbyteactionping\r\n', exit: 'exit\r\n' }
+      },
+      conptyhold: {
+        executable: cmd, executable_sha256: cmdSha, root_ids: ['core'], transport: 'conpty',
+        prefix_args: ['/d', '/q'], max_args: 0, max_arg_bytes: 256,
+        max_sessions: 1, max_input_bytes: 4096, max_retained_output_bytes: 65536,
+        env_allow: ['PATH', 'TEMP', 'TMP'], input_actions: { ping: 'echo mustnotrun\r\n' }
+      }
+    }
+  };
+  await writeFile(policyPath, JSON.stringify(raw));
+  const policy = await loadProcessPolicy(policyPath);
+  await writeFile(grantFile, JSON.stringify({
+    schema: PROCESS_GRANT_SCHEMA, policy_sha256: policy.policy_sha256,
+    instance_nonce: 'a'.repeat(64), profile_ids: ['echo', 'hold', 'conptyhold'], root_ids: ['core'],
+    granted_at_utc: '2026-09-14T00:00:00Z'
+  }));
+  const keys = await generateTrustKeypair({
+    privateKeyPath: path.join(trust, 'private.pem'), publicKeyPath: path.join(trust, 'public.pem')
+  });
+  return {
+    root, project, policy, grantFile, stateDir,
+    runtime: createProcessRuntime({ policy, signingKeyPath: keys.privateKeyPath, verifyKeyPath: keys.publicKeyPath })
+  };
+}
+
+async function waitFor(runtime, sessionId, predicate, timeoutMs = 5000) {
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    const page = await runtime.read({ sessionId, offset: 0, maxBytes: 65536 });
+    const text = Buffer.from(page.data_base64, 'base64').toString('utf8');
+    if (predicate(text, page)) return { text, page };
+    await sleep(50);
+  }
+  throw new Error('timed out waiting for process output');
+}
+test('R31 runtime starts one approved profile and exposes ordered bounded output', { skip: process.platform !== 'win32' }, async () => {
+  const f = await fixture();
+  const started = await f.runtime.start({ profileId: 'echo', rootId: 'core', cwd: '.', args: ['echo', 'DBR31RUNTIME:42'] });
+  assert.match(started.session_id, /^[0-9a-f]{64}$/);
+  assert.ok(started.child_pid > 0);
+  assert.match(started.creation_filetime, /^[0-9]+$/);
+  assert.equal(started.profile_id, 'echo');
+  const observed = await waitFor(f.runtime, started.session_id, text => text.includes('DBR31RUNTIME:42'));
+  assert.match(observed.text, /DBR31RUNTIME:42/);
+  assert.equal(observed.page.offset, 0);
+  assert.ok(observed.page.next_offset <= observed.page.stream_head);
+  assert.equal(observed.page.truncated, false);
+});
+
+test('R31 runtime lists, reports and terminates only its owned session', { skip: process.platform !== 'win32' }, async () => {
+  const f = await fixture();
+  const started = await f.runtime.start({ profileId: 'hold', rootId: 'core', cwd: '.', args: [] });
+  const status = await f.runtime.status({ sessionId: started.session_id });
+  assert.equal(status.session_id, started.session_id);
+  assert.equal(status.state, 'running');
+  const listed = await f.runtime.list();
+  assert.deepEqual(listed.sessions.map(item => item.session_id), [started.session_id]);
+  const stopped = await f.runtime.terminate({ sessionId: started.session_id });
+  assert.equal(stopped.session_id, started.session_id);
+  assert.equal(stopped.state, 'terminated');
+  await assert.rejects(() => f.runtime.terminate({ sessionId: 'f'.repeat(64) }), /unknown process session/);
+});
+
+test('R31 runtime verifies its signed process event journal', { skip: process.platform !== 'win32' }, async () => {
+  const f = await fixture();
+  const started = await f.runtime.start({ profileId: 'hold', rootId: 'core', cwd: '.', args: [] });
+  await f.runtime.terminate({ sessionId: started.session_id });
+  const verified = await f.runtime.verifyEventJournal({ sessionId: started.session_id });
+  assert.equal(verified.ok, true);
+  assert.ok(verified.event_count >= 2);
+  assert.match(verified.head_sha256, /^[0-9a-f]{64}$/);
+  const status = await f.runtime.status({ sessionId: started.session_id });
+  assert.equal(verified.head_sha256, status.journal_head_sha256);
+});
+
+test('R32 runtime executes one policy-defined named action in the running pipe session', { skip: process.platform !== 'win32' }, async () => {
+  const f = await fixture();
+  const started = await f.runtime.start({ profileId: 'hold', rootId: 'core', cwd: '.', args: [] });
+  try {
+    await waitFor(f.runtime, started.session_id, text => text.includes('>'));
+    await assert.rejects(() => f.runtime.action({ sessionId: started.session_id, actionId: 'missing' }), /not configured/);
+    const acted = await f.runtime.action({ sessionId: started.session_id, actionId: 'ping' });
+    assert.equal(acted.action_id, 'ping');
+    assert.equal(acted.logical_bytes, Buffer.byteLength('echo deadbyteactionping\r\n'));
+    assert.match(acted.logical_sha256, /^[0-9a-f]{64}$/);
+    const observed = await waitFor(f.runtime, started.session_id, text => text.includes('deadbyteactionping'));
+    assert.match(observed.text, /deadbyteactionping/);
+  } finally {
+    await f.runtime.terminate({ sessionId: started.session_id }).catch(() => {});
+  }
+  const verified = await f.runtime.verifyEventJournal({ sessionId: started.session_id });
+  assert.equal(verified.ok, true);
+  assert.ok(verified.event_count >= 3);
+  const journal = await readFile(path.join(f.stateDir, `${started.session_id}.jsonl`), 'utf8');
+  assert.doesNotMatch(journal, /deadbyteactionping/);
+});
+
+test('R32 named actions fail closed for ConPTY and revoked or drifted authority', { skip: process.platform !== 'win32' }, async () => {
+  const conpty = await fixture();
+  const conptySession = await conpty.runtime.start({ profileId: 'conptyhold', rootId: 'core', cwd: '.', args: [] });
+  try {
+    await assert.rejects(
+      () => conpty.runtime.action({ sessionId: conptySession.session_id, actionId: 'ping' }),
+      /require pipe transport/
+    );
+  } finally {
+    await conpty.runtime.terminate({ sessionId: conptySession.session_id }).catch(() => {});
+  }
+
+  const revoked = await fixture();
+  const revokedSession = await revoked.runtime.start({ profileId: 'hold', rootId: 'core', cwd: '.', args: [] });
+  try {
+    await rm(revoked.grantFile);
+    await assert.rejects(
+      () => revoked.runtime.action({ sessionId: revokedSession.session_id, actionId: 'ping' }),
+      /process plane is disarmed: disarmed/
+    );
+    await writeFile(revoked.grantFile, JSON.stringify({
+      schema: PROCESS_GRANT_SCHEMA, policy_sha256: 'b'.repeat(64), instance_nonce: 'a'.repeat(64),
+      profile_ids: ['hold'], root_ids: ['core'], granted_at_utc: '2026-09-14T00:00:00Z'
+    }));
+    await assert.rejects(
+      () => revoked.runtime.action({ sessionId: revokedSession.session_id, actionId: 'ping' }),
+      /process plane is disarmed: policy-digest/
+    );
+  } finally {
+    await revoked.runtime.terminate({ sessionId: revokedSession.session_id }).catch(() => {});
+  }
+});
+
+test('R32 named actions reject sessions after child exit', { skip: process.platform !== 'win32' }, async () => {
+  const f = await fixture();
+  const started = await f.runtime.start({ profileId: 'hold', rootId: 'core', cwd: '.', args: [] });
+  await f.runtime.action({ sessionId: started.session_id, actionId: 'exit' });
+  const end = Date.now() + 5000;
+  while ((await f.runtime.status({ sessionId: started.session_id })).state === 'running' && Date.now() < end) await sleep(25);
+  assert.equal((await f.runtime.status({ sessionId: started.session_id })).state, 'exited');
+  await assert.rejects(() => f.runtime.action({ sessionId: started.session_id, actionId: 'ping' }), /requires a running session/);
+});
+
+

package/test/process-supervision.test.mjs

@@ -0,0 +1,24 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+
+const runtimePath = fileURLToPath(new URL('../src/process-runtime.mjs', import.meta.url));
+const serverPath = fileURLToPath(new URL('../src/mcp-server.mjs', import.meta.url));
+const toolsPath = fileURLToPath(new URL('../src/process-mcp-tools.mjs', import.meta.url));
+
+test('R32 process supervision is policy-gated and registers the bounded named-action tool', async () => {
+  const runtimeSource = await readFile(runtimePath, 'utf8');
+  const serverSource = await readFile(serverPath, 'utf8');
+  const toolsSource = await readFile(toolsPath, 'utf8');
+  assert.doesNotMatch(runtimeSource, /pending the Windows release gate/);
+  assert.match(serverSource, /DEADBYTE_PROCESS_RUNTIME/);
+  assert.match(serverSource, /DEADBYTE_PROCESS_POLICY/);
+  assert.match(serverSource, /loadProcessPolicy/);
+  assert.match(serverSource, /createProcessRuntime/);
+  assert.match(serverSource, /registerProcessTools/);
+  assert.match(serverSource, /processRuntime/);
+  assert.match(toolsSource, /process_session_action/);
+  assert.match(toolsSource, /action_id/);
+  assert.doesNotMatch(toolsSource, /raw_stdin|raw_input/);
+});

package/test/r33-closeout-regression.test.mjs

@@ -0,0 +1,109 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { mkdtemp, mkdir, readFile, rm, writeFile, readdir } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import * as parity from '../scripts/release-parity.mjs';
+import { createToolAudit } from '../src/tool-audit.mjs';
+import { verifyAuditChain } from '../src/audit-verify.mjs';
+import { generateTrustKeypair } from '../src/trust.mjs';
+
+const root = path.resolve(new URL('../', import.meta.url).pathname.replace(/^\/(?:([A-Za-z]:))/,'$1'));
+const sha256 = bytes => createHash('sha256').update(bytes).digest('hex');
+const temp = prefix => mkdtemp(path.join(os.tmpdir(), prefix));
+const run = (command,args,options={}) => new Promise((resolve,reject)=>{
+  const child=spawn(command,args,{...options,stdio:['ignore','pipe','pipe']});
+  const out=[],err=[];
+  child.stdout.on('data',chunk=>out.push(Buffer.from(chunk)));
+  child.stderr.on('data',chunk=>err.push(Buffer.from(chunk)));
+  child.on('error',reject);
+  child.on('exit',code=>resolve({code,stdout:Buffer.concat(out).toString('utf8'),stderr:Buffer.concat(err).toString('utf8')}));
+});
+
+async function allAuditEvents(stateRoot){
+  const dir=path.join(stateRoot,'audit');
+  const names=(await readdir(dir)).filter(name=>/^segment-\d{8}\.jsonl$/.test(name)).sort();
+  const out=[];
+  for(const name of names){
+    const text=await readFile(path.join(dir,name),'utf8');
+    for(const line of text.trim().split(/\r?\n/)) if(line) out.push(JSON.parse(line));
+  }
+  return out;
+}
+
+test('release parity restores a drifted development stage from the immutable active release', async()=>{
+  assert.equal(typeof parity.restoreFrozenStage,'function','release parity must export frozen-stage recovery');
+  const releaseRoot=await temp('deadbyte-r33-release-');
+  const developmentRoot=await temp('deadbyte-r33-development-');
+  try{
+    await mkdir(path.join(releaseRoot,'bin'),{recursive:true});
+    await mkdir(path.join(releaseRoot,'controller'),{recursive:true});
+    await mkdir(path.join(developmentRoot,'bin'),{recursive:true});
+    await mkdir(path.join(developmentRoot,'controller'),{recursive:true});
+    const native=Buffer.from('KNOWN-GOOD-NATIVE\n');
+    const policy=Buffer.from('{"known":"good"}\n');
+    await writeFile(path.join(releaseRoot,'bin','native.exe'),native);
+    await writeFile(path.join(releaseRoot,'controller','policy.json'),policy);
+    const manifest=Buffer.from(`${sha256(native)}  bin/native.exe\n${sha256(policy)}  controller/policy.json\n`,'utf8');
+    await writeFile(path.join(releaseRoot,'MANIFEST.SHA256'),manifest);
+    await writeFile(path.join(developmentRoot,'bin','native.exe'),'DRIFTED\n');
+    await writeFile(path.join(developmentRoot,'controller','policy.json'),'DRIFTED\n');
+    await writeFile(path.join(developmentRoot,'MANIFEST.SHA256'),'dirty manifest\n');
+
+    const result=await parity.restoreFrozenStage({developmentRoot,releaseRoot,expectedManifestSha256:sha256(manifest)});
+    assert.equal(result.status,'restored');
+    assert.equal(result.file_count,2);
+    assert.equal(result.manifest_sha256,sha256(manifest));
+    assert.equal(await readFile(path.join(developmentRoot,'bin','native.exe'),'utf8'),'KNOWN-GOOD-NATIVE\n');
+    assert.equal(await readFile(path.join(developmentRoot,'controller','policy.json'),'utf8'),'{"known":"good"}\n');
+    assert.equal(sha256(await readFile(path.join(developmentRoot,'MANIFEST.SHA256'))),sha256(manifest));
+  }finally{
+    await rm(releaseRoot,{recursive:true,force:true});
+    await rm(developmentRoot,{recursive:true,force:true});
+  }
+});
+
+test('audit restart reconciles an orphan request with an explicit interrupted result', async()=>{
+  const stateRoot=await temp('deadbyte-r33-audit-restart-');
+  try{
+    const keys=await generateTrustKeypair({privateKeyPath:path.join(stateRoot,'trust','private.pem'),publicKeyPath:path.join(stateRoot,'trust','public.pem')});
+    let audit=await createToolAudit({stateRoot,signingKeyPath:keys.privateKeyPath,contextProvider:async()=>({release_id:'v0.8.7-test'})});
+    await audit.recordRequest('coding_command_run',{root_id:'core'});
+    audit=await createToolAudit({stateRoot,signingKeyPath:keys.privateKeyPath,contextProvider:async()=>({release_id:'v0.8.7-test-restarted'})});
+    const verified=await verifyAuditChain({stateRoot,verifyKeyPath:keys.publicKeyPath,requireComplete:true});
+    assert.equal(verified.ok,true,verified.reason);
+    assert.equal(verified.open_request_count,0);
+    assert.equal(verified.request_count,1);
+    assert.equal(verified.result_count,1);
+    const events=await allAuditEvents(stateRoot);
+    assert.equal(events.length,2);
+    assert.equal(events[1].event_type,'tool.result');
+    assert.equal(events[1].request_id,events[0].request_id);
+    assert.equal(events[1].outcome.status,'interrupted');
+    assert.equal(events[1].outcome.side_effect_state,'unknown');
+  }finally{await rm(stateRoot,{recursive:true,force:true});}
+});
+
+test('Windows R33 gate emits manifest-bound machine-readable evidence outside the candidate tree', async()=>{
+  const stateRoot=await temp('deadbyte-r33-windows-evidence-');
+  try{
+    const gate=await readFile(path.join(root,'scripts','gate-windows.ps1'),'utf8');
+    assert.match(gate,/windows-gate-evidence\.mjs/,'gate-windows.ps1 must invoke the evidence writer');
+    const result=await run(process.execPath,[path.join(root,'scripts','windows-gate-evidence.mjs')],{
+      cwd:root,env:{...process.env,DEADBYTE_STATE_ROOT:stateRoot}
+    });
+    assert.equal(result.code,0,result.stderr||result.stdout);
+    const summary=JSON.parse(result.stdout.trim());
+    assert.equal(summary.status,'written');
+    const evidence=JSON.parse(await readFile(summary.path,'utf8'));
+    const manifestSha=sha256(await readFile(path.join(root,'MANIFEST.SHA256')));
+    assert.equal(evidence.schema,'deadbyte.r33-windows-gate.v1');
+    assert.equal(evidence.status,'passed');
+    assert.equal(evidence.exit_code,0);
+    assert.equal(evidence.manifest_sha256,manifestSha);
+    assert.equal(evidence.marker,'DEADBYTE V0.8.7 / R33 WINDOWS BATCH GATE: PASS');
+    assert.ok(summary.path.startsWith(path.join(stateRoot,'evidence','release')));
+  }finally{await rm(stateRoot,{recursive:true,force:true});}
+});

package/test/r33-finalization.test.mjs

@@ -0,0 +1,67 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { R33_EXPECTED_TOOLS } from '../src/remote-mcp-r33-parity-client.mjs';
+import { validateParityEvidence } from '../scripts/release-parity.mjs';
+import { verifyFinalClosureObject } from '../scripts/final-closure-verify.mjs';
+
+const root = new URL('../', import.meta.url);
+const text = rel => readFile(new URL(rel, root), 'utf8');
+
+test('R33 public parity catalog is exact and unique', () => {
+  assert.equal(R33_EXPECTED_TOOLS.length, 68);
+  assert.equal(new Set(R33_EXPECTED_TOOLS).size, 68);
+  assert.deepEqual([...R33_EXPECTED_TOOLS].sort(), R33_EXPECTED_TOOLS);
+});
+
+test('release parity and final verifier are package entry points', async () => {
+  const pkg = JSON.parse(await text('package.json'));
+  assert.equal(pkg.scripts['release:parity'], 'node scripts/release-parity.mjs');
+  assert.equal(pkg.scripts['release:final:write'], 'node scripts/final-closure.mjs');
+  assert.equal(pkg.scripts['release:final:verify'], 'node scripts/final-closure-verify.mjs');
+  assert.equal(typeof validateParityEvidence, 'function');
+  assert.equal(typeof verifyFinalClosureObject, 'function');
+});
+
+test('final closure verifier is implementation-independent from production helpers', async () => {
+  const verifier = await text('scripts/final-closure-verify.mjs');
+  const writer = await text('scripts/final-closure.mjs');
+  assert.doesNotMatch(verifier, /from ['"]\.\.\/src\//);
+  assert.match(verifier, /DEADBYTE-R27-SLOT-UPDATE-V1/);
+  assert.match(verifier, /DEADBYTE-MACHINE-PING-V1/);
+  assert.match(verifier, /DEADBYTE-R33-FINAL-CLOSURE-V1/);
+  assert.match(writer, /pointer\.version==='0\.8\.7'/);
+  assert.match(verifier, /envelope\.body\.version==='0\.8\.7'/);
+  assert.match(verifier, /release_label==='R33 FINAL MACHINE BASELINE'/);
+});
+
+test('final closure verifier canonicalizes traversal order before exact-tree comparison', async () => {
+  const verifier = await text('scripts/final-closure-verify.mjs');
+  assert.match(verifier, /const actual=\(await walk\(root\)\)\.filter\(rel=>rel!==manifestName\)\.sort\(\(a,b\)=>a\.localeCompare\(b,'en'\)\);/);
+  assert.match(verifier, /const expected=\[\.\.\.entries\.keys\(\)\]\.sort\(\(a,b\)=>a\.localeCompare\(b,'en'\)\);/);
+});
+
+test('autonomous live gate reuses the canonical R33 68-tool catalog', async () => {
+  const autonomous = await text('src/remote-mcp-autonomous-smoke-client.mjs');
+  assert.match(autonomous, /import \{ R33_EXPECTED_TOOLS \} from '\.\/remote-mcp-r33-parity-client\.mjs';/);
+  assert.doesNotMatch(autonomous, /const expectedTools\s*=\s*\[/);
+  assert.match(autonomous, /JSON\.stringify\(names\) !== JSON\.stringify\(R33_EXPECTED_TOOLS\)/);
+});
+
+test('R33 parity proves coding package tests before package-visible scratch mutation', async () => {
+  const parity = await text('src/remote-mcp-r33-parity-client.mjs');
+  const codingTests = parity.indexOf('const tests = structured(');
+  const scratchWrite = parity.indexOf('const write = structured(');
+  assert.notEqual(codingTests, -1);
+  assert.notEqual(scratchWrite, -1);
+  assert.ok(codingTests < scratchWrite, 'coding tests must complete before machine-FS scratch mutation');
+});
+
+test('R33 parity isolates scratch mutation and search from the core release tree', async () => {
+  const parity = await text('src/remote-mcp-r33-parity-client.mjs');
+  assert.match(parity, /const scratchRoot = 'parity_scratch';/);
+  assert.match(parity, /machine_fs_write[\s\S]*?root_id:scratchRoot/);
+  assert.match(parity, /machine_search_start[\s\S]*?root_id:scratchRoot/);
+  assert.match(parity, /machine_fs_delete[\s\S]*?root_id:scratchRoot/);
+  assert.doesNotMatch(parity, /machine_fs_(?:write|read|edit_exact|stat|delete)'[^\n]*root_id:'core'/);
+});