deadbyte-mcp 0.15.1 → 0.15.3

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

@@ -13,18 +13,58 @@ 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');
+  const systemRoot = path.join(root, 'Windows');
+  const system32 = path.join(systemRoot, 'System32');
+  const powershellDir = path.join(system32, 'WindowsPowerShell', 'v1.0');
   await mkdir(bin, { recursive: true });
   await mkdir(controller, { recursive: true });
+  await mkdir(powershellDir, { recursive: true });
+
   const hostPath = path.join(bin, 'deadbyte-process-host.exe');
   const hostBytes = Buffer.from('fresh-native-host\n');
+  const cmdPath = path.join(system32, 'cmd.exe');
+  const cmdBytes = Buffer.from('target-cmd\n');
+  const powershellPath = path.join(powershellDir, 'powershell.exe');
+  const powershellBytes = Buffer.from('target-powershell\n');
   await writeFile(hostPath, hostBytes);
+  await writeFile(cmdPath, cmdBytes);
+  await writeFile(powershellPath, powershellBytes);
+
   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:{}}}};
+  const profile = executable => ({
+    executable,
+    executable_sha256:'1'.repeat(64),
+    root_ids:['core'],
+    prefix_args:[],
+    transport:'pipe',
+    max_args:1,
+    max_arg_bytes:8192,
+    max_sessions:1,
+    max_input_bytes:4096,
+    max_retained_output_bytes:4096,
+    env_allow:[],
+    input_actions:{}
+  });
+  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:{
+      ping_hold:profile(cmdPath),
+      powershell:profile(powershellPath),
+      powershell_repl:profile(powershellPath)
+    }
+  };
   await writeFile(policyPath, `${JSON.stringify(policy,null,2)}\n`);
-  return { root, policyPath, hostPath, hostBytes, policy };
+  return {
+    root, policyPath, hostPath, hostBytes, systemRoot,
+    cmdPath, cmdBytes, powershellPath, powershellBytes, 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');
@@ -33,32 +73,69 @@ test('R33 candidate process policy self-binds to the current repository root', a
   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);
+  assert.ok(policy.profiles.ping_hold);
+  assert.ok(policy.profiles.powershell);
+  assert.ok(policy.profiles.powershell_repl);
+  assert.equal(policy.profiles.powershell_repl.allow_raw_input,true);
+  assert.deepEqual(policy.profiles.powershell.prefix_args, ['-NoLogo','-NoProfile','-NonInteractive','-Command']);
+  assert.equal(policy.profiles.powershell.max_args, 1);
+  assert.equal(policy.profiles.powershell.max_arg_bytes, 8192);
 });
 
-test('R31 refresh changes only the native-host digest after the Windows build', async () => {
+test('process policy refresh repins native host and Windows system executables', async () => {
   const f = await fixture();
-  const result = await refreshProcessPolicy({ repoRoot:f.root, policyPath:f.policyPath });
+  const result = await refreshProcessPolicy({ repoRoot:f.root, policyPath:f.policyPath, systemRoot:f.systemRoot });
   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(after.profiles.ping_hold.executable, f.cmdPath);
+  assert.equal(after.profiles.ping_hold.executable_sha256, sha256(f.cmdBytes));
+  assert.equal(after.profiles.powershell.executable, f.powershellPath);
+  assert.equal(after.profiles.powershell.executable_sha256, sha256(f.powershellBytes));
+  assert.equal(after.profiles.powershell_repl.executable, f.powershellPath);
+  assert.equal(after.profiles.powershell_repl.executable_sha256, sha256(f.powershellBytes));
   assert.equal(result.native_host_sha256, sha256(f.hostBytes));
+  assert.equal(result.cmd_executable_sha256, sha256(f.cmdBytes));
+  assert.equal(result.powershell_executable_sha256, sha256(f.powershellBytes));
+  assert.equal(result.powershell_repl_executable_sha256, sha256(f.powershellBytes));
+
   const expected = structuredClone(f.policy);
   expected.native_host.sha256 = sha256(f.hostBytes);
+  expected.profiles.ping_hold.executable_sha256 = sha256(f.cmdBytes);
+  expected.profiles.powershell.executable_sha256 = sha256(f.powershellBytes);
+  expected.profiles.powershell_repl.executable_sha256 = sha256(f.powershellBytes);
   assert.deepEqual(after, expected);
 });
 
-test('R31 refresh fails closed when native-host path is not the candidate bin path', async () => {
+test('process policy 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/);
+  await assert.rejects(
+    () => refreshProcessPolicy({ repoRoot:f.root, policyPath:f.policyPath, systemRoot:f.systemRoot }),
+    /native_host path must equal candidate bin/
+  );
+});
+
+test('process policy refresh fails closed when a system profile path is not target-bound', async () => {
+  const f = await fixture();
+  const raw = JSON.parse(await readFile(f.policyPath,'utf8'));
+  raw.profiles.powershell.executable = process.execPath;
+  await writeFile(f.policyPath, `${JSON.stringify(raw,null,2)}\n`);
+  await assert.rejects(
+    () => refreshProcessPolicy({ repoRoot:f.root, policyPath:f.policyPath, systemRoot:f.systemRoot }),
+    /profile 'powershell' executable path mismatch/
+  );
 });
 
-test('R31 refresh refuses a malformed or disabled process policy', async () => {
+test('process policy 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/);
+  await assert.rejects(
+    () => refreshProcessPolicy({ repoRoot:f.root, policyPath:f.policyPath, systemRoot:f.systemRoot }),
+    /schema\/enabled mismatch/
+  );
 });

package/test/process-runtime.test.mjs

@@ -12,6 +12,7 @@ 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 powershell = 'C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe';
 const sha = bytes => createHash('sha256').update(bytes).digest('hex');
 const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
 
@@ -25,6 +26,7 @@ async function fixture() {
   const policyPath = path.join(root, 'process-policy.json');
   const hostSha = sha(await readFile(host));
   const cmdSha = sha(await readFile(cmd));
+  const powershellSha = sha(await readFile(powershell));
   const raw = {
     schema: PROCESS_POLICY_SCHEMA, enabled: true, grant_file: grantFile, state_dir: stateDir,
     native_host: { path: host, sha256: hostSha },
@@ -47,6 +49,18 @@ async function fixture() {
         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' }
+      },
+      powershell: {
+        executable: powershell, executable_sha256: powershellSha, root_ids: ['core'], transport: 'pipe',
+        prefix_args: ['-NoLogo','-NoProfile','-NonInteractive','-Command'], max_args: 1, max_arg_bytes: 8192,
+        max_sessions: 2, max_input_bytes: 65536, max_retained_output_bytes: 1048576,
+        env_allow: ['PATH','TEMP','TMP','SystemRoot','WINDIR','USERPROFILE','PSModulePath','COMSPEC','PATHEXT'], input_actions: {}
+      },
+      powershell_repl: {
+        executable: powershell, executable_sha256: powershellSha, root_ids: ['core'], transport: 'pipe', allow_raw_input: true,
+        prefix_args: ['-NoLogo','-NoProfile','-NonInteractive'], max_args: 0, max_arg_bytes: 256,
+        max_sessions: 2, max_input_bytes: 65536, max_retained_output_bytes: 4 * 1024 * 1024,
+        env_allow: ['PATH','TEMP','TMP','SystemRoot','WINDIR','USERPROFILE','PSModulePath','COMSPEC','PATHEXT'], input_actions: {}
       }
     }
   };
@@ -54,14 +68,14 @@ async function fixture() {
   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'],
+    instance_nonce: 'a'.repeat(64), profile_ids: ['echo', 'hold', 'conptyhold', 'powershell', 'powershell_repl'], 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,
+    root, project, policy, grantFile, stateDir, keys,
     runtime: createProcessRuntime({ policy, signingKeyPath: keys.privateKeyPath, verifyKeyPath: keys.publicKeyPath })
   };
 }
@@ -83,6 +97,12 @@ test('R31 runtime starts one approved profile and exposes ordered bounded output
   assert.ok(started.child_pid > 0);
   assert.match(started.creation_filetime, /^[0-9]+$/);
   assert.equal(started.profile_id, 'echo');
+  assert.equal(started.stream_id, started.session_id);
+  assert.equal(started.stream_generation, 1);
+  assert.equal(started.stream_next_seq, 1);
+  assert.equal(started.stream_coverage.logical_item_count, 0);
+  assert.equal(started.stream_coverage.retained_item_count, 0);
+  assert.equal(started.stream_coverage.complete, true);
   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);
@@ -90,6 +110,113 @@ test('R31 runtime starts one approved profile and exposes ordered bounded output
   assert.equal(observed.page.truncated, false);
 });
 
+test('R46 runtime executes fileless PowerShell source without ps1 materialization', { skip: process.platform !== 'win32' }, async () => {
+  const f = await fixture();
+  const source = "$ErrorActionPreference='Stop';$before=@(Get-ChildItem -LiteralPath $env:TEMP -Filter '*.ps1' -File -ErrorAction SilentlyContinue|ForEach-Object{$_.FullName});[Console]::WriteLine('DB_FILELESS_PS_TEST');[Console]::WriteLine('PSCommandPath=' + [string]$PSCommandPath);[Console]::WriteLine('InvocationPath=' + [string]$MyInvocation.MyCommand.Path);$after=@(Get-ChildItem -LiteralPath $env:TEMP -Filter '*.ps1' -File -ErrorAction SilentlyContinue|ForEach-Object{$_.FullName});$new=@($after|Where-Object{$_ -notin $before});[Console]::WriteLine('NEW_TEMP_PS1_COUNT=' + $new.Count)";
+  const started = await f.runtime.start({ profileId: 'powershell', rootId: 'core', cwd: '.', args: [source] });
+  const observed = await waitFor(f.runtime, started.session_id, text => text.includes('NEW_TEMP_PS1_COUNT=0'));
+  assert.match(observed.text, /DB_FILELESS_PS_TEST/);
+  assert.match(observed.text, /PSCommandPath=\r?\n/);
+  assert.match(observed.text, /InvocationPath=\r?\n/);
+  assert.match(observed.text, /NEW_TEMP_PS1_COUNT=0/);
+  const deadline = Date.now() + 5000;
+  let status = await f.runtime.status({ sessionId: started.session_id });
+  while (status.state === 'running' && Date.now() < deadline) {
+    await sleep(25);
+    status = await f.runtime.status({ sessionId: started.session_id });
+  }
+  assert.equal(status.state, 'exited');
+  assert.equal(status.exit_code, 0);
+  const verified = await f.runtime.verifyEventJournal({ sessionId: started.session_id });
+  assert.equal(verified.ok, true);
+});
+
+test('R46 process output retention evicts oldest bytes without losing tail identity under multi-megabyte output', { skip: process.platform !== 'win32' }, async () => {
+  const f = await fixture();
+  const source = "[Console]::Write(('A'*2097152));[Console]::WriteLine('DB_RING_TAIL_MARK')";
+  const started = await f.runtime.start({ profileId: 'powershell', rootId: 'core', cwd: '.', args: [source] });
+  const deadline = Date.now() + 10000;
+  let status = await f.runtime.status({ sessionId: started.session_id });
+  while (status.state === 'running' && Date.now() < deadline) {
+    await sleep(25);
+    status = await f.runtime.status({ sessionId: started.session_id });
+  }
+  assert.equal(status.state, 'exited');
+  assert.equal(status.exit_code, 0);
+  assert.ok(status.stream_head > 2 * 1024 * 1024);
+  assert.ok(status.earliest_offset > 0);
+  assert.ok(status.stream_head - status.earliest_offset <= 1024 * 1024);
+  const fromStart = await f.runtime.read({ sessionId: started.session_id, offset: 0, maxBytes: 4096 });
+  assert.equal(fromStart.truncated, true);
+  assert.equal(fromStart.offset, status.earliest_offset);
+  const tail = await f.runtime.read({ sessionId: started.session_id, offset: -4096, maxBytes: 4096 });
+  const tailText = Buffer.from(tail.data_base64, 'base64').toString('utf8');
+  assert.match(tailText, /DB_RING_TAIL_MARK/);
+  const verified = await f.runtime.verifyEventJournal({ sessionId: started.session_id });
+  assert.equal(verified.ok, true);
+  const recoveredRuntime = createProcessRuntime({
+    policy: f.policy,
+    signingKeyPath: f.keys.privateKeyPath,
+    verifyKeyPath: f.keys.publicKeyPath
+  });
+  const recovered = await recoveredRuntime.status({ sessionId: started.session_id });
+  assert.equal(recovered.stream_id, null);
+  assert.equal(recovered.stream_generation, null);
+  assert.equal(recovered.stream_next_seq, null);
+  assert.equal(recovered.stream_coverage, null);
+  assert.ok(recovered.stream_head > 2 * 1024 * 1024);
+});
+
+test('R46 process raw input keeps persistent PowerShell state with bounded wait and tail reads', { skip: process.platform !== 'win32' }, async () => {
+  const f = await fixture();
+  const started = await f.runtime.start({ profileId: 'powershell_repl', rootId: 'core', cwd: '.', args: [] });
+  try {
+    const first = await f.runtime.write({ sessionId: started.session_id, input: "$x=41;[Console]::WriteLine('DB_REPL_SET')", appendNewline: true });
+    assert.equal(first.session.state, 'running');
+    assert.match(first.logical_sha256, /^[0-9a-f]{64}$/);
+    const page1 = await f.runtime.read({ sessionId: started.session_id, offset: 0, maxBytes: 65536, waitMs: 3000, waitFor: 'DB_REPL_SET' });
+    const text1 = Buffer.from(page1.data_base64, 'base64').toString('utf8');
+    assert.match(text1, /DB_REPL_SET/);
+
+    const beforeSecond = (await f.runtime.status({ sessionId: started.session_id })).stream_head;
+    await f.runtime.write({ sessionId: started.session_id, input: "[Console]::WriteLine('DB_REPL_VALUE=' + ($x+1))", appendNewline: true });
+    const waited = await f.runtime.read({ sessionId: started.session_id, offset: beforeSecond, maxBytes: 65536, waitMs: 3000, waitFor: 'DB_REPL_VALUE=42' });
+    const waitedText = Buffer.from(waited.data_base64, 'base64').toString('utf8');
+    assert.equal(waited.wait_satisfied, true);
+    assert.match(waitedText, /DB_REPL_VALUE=42/);
+    const tail = await f.runtime.read({ sessionId: started.session_id, offset: -4096, maxBytes: 4096, waitMs: 0 });
+    const tailText = Buffer.from(tail.data_base64, 'base64').toString('utf8');
+    assert.match(tailText, /DB_REPL_VALUE=42/);
+
+    const journal = await readFile(path.join(f.stateDir, `${started.session_id}.jsonl`), 'utf8');
+    assert.doesNotMatch(journal, /DB_REPL_SET|DB_REPL_VALUE|\$x=41/);
+    const verified = await f.runtime.verifyEventJournal({ sessionId: started.session_id });
+    assert.equal(verified.ok, true);
+    assert.ok(verified.event_count >= 3);
+  } finally {
+    await f.runtime.terminate({ sessionId: started.session_id }).catch(() => {});
+  }
+});
+
+test('R46 raw process input is profile-opt-in, bounded, and rechecks standing authority', { skip: process.platform !== 'win32' }, async () => {
+  const f = await fixture();
+  const hold = await f.runtime.start({ profileId: 'hold', rootId: 'core', cwd: '.', args: [] });
+  try {
+    await assert.rejects(() => f.runtime.write({ sessionId: hold.session_id, input: 'echo forbidden', appendNewline: true }), /does not allow raw input/);
+  } finally {
+    await f.runtime.terminate({ sessionId: hold.session_id }).catch(() => {});
+  }
+
+  const repl = await f.runtime.start({ profileId: 'powershell_repl', rootId: 'core', cwd: '.', args: [] });
+  try {
+    await assert.rejects(() => f.runtime.write({ sessionId: repl.session_id, input: 'x'.repeat(65536), appendNewline: true }), /exceeds profile input bound/);
+    await rm(f.grantFile);
+    await assert.rejects(() => f.runtime.write({ sessionId: repl.session_id, input: 'Write-Output denied', appendNewline: true }), /process plane is disarmed/);
+  } finally {
+    await f.runtime.terminate({ sessionId: repl.session_id }).catch(() => {});
+  }
+});
+
 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: [] });

package/test/process-supervision.test.mjs

@@ -7,7 +7,7 @@ const runtimePath = fileURLToPath(new URL('../src/process-runtime.mjs', import.m
 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 () => {
+test('R46 process supervision is policy-gated and exposes bounded action plus opt-in raw input', async () => {
   const runtimeSource = await readFile(runtimePath, 'utf8');
   const serverSource = await readFile(serverPath, 'utf8');
   const toolsSource = await readFile(toolsPath, 'utf8');
@@ -20,5 +20,7 @@ test('R32 process supervision is policy-gated and registers the bounded named-ac
   assert.match(serverSource, /processRuntime/);
   assert.match(toolsSource, /process_session_action/);
   assert.match(toolsSource, /action_id/);
-  assert.doesNotMatch(toolsSource, /raw_stdin|raw_input/);
+  assert.match(toolsSource, /process_session_write/);
+  assert.match(toolsSource, /append_newline/);
+  assert.doesNotMatch(toolsSource, /caller-selected executable|raw_stdin/);
 });

package/test/production-docs.test.mjs

@@ -9,9 +9,9 @@ const readme=()=>readFile(path.join(root,'README.txt'),'utf8');
 
 test('production README documents one-command stdio configs for major MCP clients',async()=>{
   const text=await readme();
-  assert.match(text,/npx -y deadbyte-mcp@0\.15\.1 mcp/);
+  assert.match(text,/npx -y deadbyte-mcp@0\.15\.2 mcp/);
   assert.match(text,/CLAUDE DESKTOP/);
-  assert.match(text,/"mcpServers"[\s\S]*?"command"\s*:\s*"npx"[\s\S]*?"-y"[\s\S]*?"deadbyte-mcp@0\.15\.1"[\s\S]*?"mcp"/);
+  assert.match(text,/"mcpServers"[\s\S]*?"command"\s*:\s*"npx"[\s\S]*?"-y"[\s\S]*?"deadbyte-mcp@0\.15\.2"[\s\S]*?"mcp"/);
   assert.match(text,/CURSOR/);
   assert.match(text,/\.cursor\/mcp\.json/);
   assert.match(text,/VS CODE/);
@@ -20,7 +20,7 @@ test('production README documents one-command stdio configs for major MCP client
   assert.match(text,/CODEX/);
   assert.match(text,/\[mcp_servers\.deadbyte\]/);
   assert.match(text,/command\s*=\s*"npx"/);
-  assert.match(text,/args\s*=\s*\["-y",\s*"deadbyte-mcp@0\.15\.1",\s*"mcp"\]/);
+  assert.match(text,/args\s*=\s*\["-y",\s*"deadbyte-mcp@0\.15\.2",\s*"mcp"\]/);
 });
 
 test('production README records tracer bullet, semantic scope, remote UX, safety and document extension',async()=>{

package/test/r33-finalization.test.mjs

@@ -19,9 +19,9 @@ test('R34 public parity catalog is exact, unique, and includes production coding
 
 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-r45.mjs');
-  assert.equal(pkg.scripts['release:final:write'], 'node scripts/final-closure-r45.mjs');
-  assert.equal(pkg.scripts['release:final:verify'], 'node scripts/final-closure-verify-r45.mjs');
+  assert.equal(pkg.scripts['release:parity'], 'node scripts/release-parity-r46.mjs');
+  assert.equal(pkg.scripts['release:final:write'], 'node scripts/final-closure-r46.mjs');
+  assert.equal(pkg.scripts['release:final:verify'], 'node scripts/final-closure-verify-r46.mjs');
   assert.equal(typeof validateParityEvidence, 'function');
   assert.equal(typeof verifyFinalClosureObject, 'function');
 });

package/test/r45-finalization.test.mjs

@@ -79,6 +79,6 @@ test('R45 release machinery binds 0.15.1, 82/43 surfaces, Host v2 bootstrap and
   assert.match(finalizer,/host_inline_native/);assert.match(finalizer,/native_hardware_observation/);assert.match(finalizer,/doctor_release_truth/);
   assert.match(evidence,/host_inline_native:true/);assert.match(evidence,/native_hardware_observation:true/);assert.match(evidence,/doctor_release_truth:true/);
   assert.match(manifestSource,/excludedPackagePrefixes = \[[^\]]*'tmp\/'[^\]]*'\.deadbyte-machine-fs-recovery\/'[^\]]*\]/);
-  assert.match(manifestSource,/excludedPackagePaths = new Set\(\['controller\/deadbyte-host-policy\.json'\]\)/);
+  assert.match(manifestSource,/excludedPackagePaths = new Set\(\['controller\/deadbyte-host-policy\.json','controller\/deadbyte-coding-policy\.json'\]\)/);
   assert.match(manifestSource,/excludedPackagePrefixes\.some\(prefix => rel\.startsWith\(prefix\)\)/);
 });

package/test/release-generation.test.mjs

@@ -16,7 +16,12 @@ function command(executable='C:/Windows/System32/cmd.exe'){
 test('R27 generation bundle rebinds authority and mutable state outside the release slot', async () => {
   const base=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r27-generation-'));
   const state=path.join(base,'state'),release=path.join(base,'release'),workspace=path.join(base,'workspace');
-  await mkdir(path.join(release,'scripts'),{recursive:true}); await mkdir(path.join(release,'bin'),{recursive:true}); await mkdir(workspace,{recursive:true});
+  const systemRoot=path.join(base,'Windows'),system32=path.join(systemRoot,'System32');
+  const powershellDir=path.join(system32,'WindowsPowerShell','v1.0');
+  await mkdir(path.join(release,'scripts'),{recursive:true}); await mkdir(path.join(release,'bin'),{recursive:true}); await mkdir(workspace,{recursive:true}); await mkdir(powershellDir,{recursive:true});
+  const cmdPath=path.join(system32,'cmd.exe'),cmdBytes=Buffer.from('target-cmd-bytes\\n');
+  const powershellPath=path.join(powershellDir,'powershell.exe'),powershellBytes=Buffer.from('target-powershell-bytes\\n');
+  await writeFile(cmdPath,cmdBytes); await writeFile(powershellPath,powershellBytes);
   await writeFile(path.join(release,'scripts','gate.ps1'),'Write-Output gate\n');
   await writeFile(path.join(release,'bin','deadbyte-process-host.exe'),'process-host-bytes\n');
   const desktopObserver=Buffer.from('desktop-observer-bytes\n');
@@ -47,7 +52,10 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   const processPolicy={schema:'deadbyte.process-policy.v1',enabled:true,grant_file:'C:/old/process-grant.json',state_dir:'C:/old/process-state',
     native_host:{path:'C:/old/deadbyte-process-host.exe',sha256:'0'.repeat(64)},
     roots:{core:{path:'C:/old/core',deny_paths:['node_modules']}},
-    profiles:{probe:{executable:'C:/Windows/System32/ping.exe',executable_sha256:EXE,root_ids:['core'],prefix_args:['127.0.0.1','-n','2'],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:{}}}};
+    profiles:{
+      ping_hold:{executable:'C:/stale/cmd.exe',executable_sha256:EXE,root_ids:['core'],prefix_args:['/d','/q'],transport:'pipe',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 DEADBYTE_ACTION_PING\\r\\n'}},
+      powershell:{executable:'C:/stale/powershell.exe',executable_sha256:EXE,root_ids:['core'],prefix_args:['-NoLogo','-NoProfile','-NonInteractive','-Command'],transport:'pipe',max_args:1,max_arg_bytes:8192,max_sessions:4,max_input_bytes:65536,max_retained_output_bytes:1048576,env_allow:['PATH','TEMP','TMP','SystemRoot','WINDIR','USERPROFILE','PSModulePath','COMSPEC','PATHEXT'],input_actions:{}}
+    }};
   const desktopPolicy={schema:'deadbyte.desktop-policy.v1',enabled:true,grant_file:'C:/old/desktop-grant.json',evidence_dir:'C:/old/desktop-evidence',
     allowed_input_desktops:['Default'],allowed_actions:['click_primary','key_chord'],
     limits:{max_frame_age_ms:2000,max_frame_bytes:8388608,capture_timeout_ms:5000,input_timeout_ms:2000,ground_timeout_ms:5000,post_observe_timeout_ms:5000,max_preview_bytes:1048576,max_text_bytes:4096},
@@ -59,7 +67,8 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   await writeFile(path.join(development,'scripts','gate-windows-old.ps1'),'Write-Output old-gate\n');
   await writeFile(path.join(development,'scripts','gate-windows-current.ps1'),'Write-Output current-gate\n');
   await writeFile(path.join(development,'package.json'),JSON.stringify({scripts:{'gate:windows':'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-current.ps1'}}));
-  const result=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
+  const build=args=>createGenerationBundle({...args,systemRoot});
+  const result=await build({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
   const verified=await verifyGenerationBundle(result.generation_root,result.generation_manifest_sha256);
   assert.equal(verified.files,7);
   const generatedProcess=JSON.parse(await readFile(result.process_policy_path,'utf8'));
@@ -68,6 +77,11 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   assert.equal(generatedProcess.roots.core.path,path.resolve(development));
   assert.equal(generatedProcess.native_host.path,path.join(path.resolve(release),'bin','deadbyte-process-host.exe'));
   assert.equal(generatedProcess.native_host.sha256,sha(Buffer.from('process-host-bytes\n')));
+  assert.equal(generatedProcess.profiles.ping_hold.executable,cmdPath);
+  assert.equal(generatedProcess.profiles.ping_hold.executable_sha256,sha(cmdBytes));
+  assert.equal(generatedProcess.profiles.powershell.executable,powershellPath);
+  assert.equal(generatedProcess.profiles.powershell.executable_sha256,sha(powershellBytes));
+  assert.deepEqual(generatedProcess.profiles.powershell.prefix_args,['-NoLogo','-NoProfile','-NonInteractive','-Command']);
   const generatedDesktop=JSON.parse(await readFile(result.desktop_policy_path,'utf8'));
   assert.equal(generatedDesktop.grant_file,path.join(path.resolve(state),'runtime','desktop-grant.json'));
   assert.equal(generatedDesktop.evidence_dir,path.join(path.resolve(state),'runtime','desktop-evidence'));
@@ -129,44 +143,44 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   assert.match(path.basename(result.generation_root),/^v0\.8\.3-aaaaaaaaaaaaaaaa-g[0-9a-f]{16}$/);
   const changedConfig=structuredClone(currentConfig);
   changedConfig.Bridge.Arguments='bridge-v2.mjs';
-  const second=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:changedConfig,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
+  const second=await build({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:changedConfig,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
   assert.notEqual(second.generation_root,result.generation_root);
   assert.notEqual(second.generation_seed_sha256,result.generation_seed_sha256);
   const endpointChanged=structuredClone(currentConfig);
   endpointChanged.McpUrlFileSha256='2'.repeat(64);
-  const third=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:endpointChanged,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
+  const third=await build({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:endpointChanged,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
   assert.notEqual(third.generation_root,result.generation_root);
   assert.notEqual(third.generation_seed_sha256,result.generation_seed_sha256);
   const machineDisabled=structuredClone(currentConfig);
   machineDisabled.MachineRuntimeEnabled=false;
-  const fourth=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:machineDisabled,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
+  const fourth=await build({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:machineDisabled,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
   assert.notEqual(fourth.generation_root,result.generation_root);
   assert.notEqual(fourth.generation_seed_sha256,result.generation_seed_sha256);
   const machineFsDisabled=structuredClone(currentConfig);
   machineFsDisabled.MachineFsRuntimeEnabled=false;
-  const fifth=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:machineFsDisabled,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
+  const fifth=await build({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:machineFsDisabled,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
   assert.notEqual(fifth.generation_root,result.generation_root);
   assert.notEqual(fifth.generation_seed_sha256,result.generation_seed_sha256);
   const observationDisabled=structuredClone(currentConfig);
   observationDisabled.ObservationRuntimeEnabled=false;
-  const sixth=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:observationDisabled,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
+  const sixth=await build({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:observationDisabled,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
   assert.notEqual(sixth.generation_root,result.generation_root);
   assert.notEqual(sixth.generation_seed_sha256,result.generation_seed_sha256);
   const desktopDisabled=structuredClone(currentConfig);
   desktopDisabled.DesktopRuntimeEnabled=false;
-  const desktopVariant=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:desktopDisabled,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
+  const desktopVariant=await build({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:desktopDisabled,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
   assert.notEqual(desktopVariant.generation_root,result.generation_root);
   assert.notEqual(desktopVariant.generation_seed_sha256,result.generation_seed_sha256);
   const desktopTampered=structuredClone(desktopPolicy);
   desktopTampered.input.sha256='f'.repeat(64);
-  await assert.rejects(createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy:desktopTampered}),/desktop input helper SHA-256 mismatch/);
+  await assert.rejects(build({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy:desktopTampered}),/desktop input helper SHA-256 mismatch/);
   const semanticConfig2Path=path.join(base,'semantic-lsp-v2.json');
   const semanticConfig2Bytes=Buffer.from(JSON.stringify({schema:'deadbyte.semantic-lsp-config.v1',servers:[{id:'changed'}]})+'\n','utf8');
   await writeFile(semanticConfig2Path,semanticConfig2Bytes);
   const semanticChanged=structuredClone(currentConfig);
   semanticChanged.SemanticLspConfigFile=semanticConfig2Path;
   semanticChanged.SemanticLspConfigSha256=sha(semanticConfig2Bytes);
-  const seventh=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:semanticChanged,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
+  const seventh=await build({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:semanticChanged,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
   assert.notEqual(seventh.generation_root,result.generation_root);
   assert.notEqual(seventh.generation_seed_sha256,result.generation_seed_sha256);
   await verifyGenerationBundle(result.generation_root,result.generation_manifest_sha256);