deadbyte-mcp 0.15.1 → 0.15.2

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,7 +68,7 @@ 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({
@@ -90,6 +104,102 @@ 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);
+});
+
+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/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);

package/test/release-version.test.mjs

@@ -5,54 +5,113 @@ import { createHash } from 'node:crypto';
 
 const root=new URL('../',import.meta.url);
 const text=rel=>readFile(new URL(rel,root),'utf8');
-const PARENT_RELEASE='v0.15.0-c15fa41719be61b3';
-const PARENT_MANIFEST='c15fa41719be61b3186e49b2367a5f4c057365cfb465102dbefb7d7355f45483';
-const PARENT_GENERATION='6d7429c050b7fe893492e102f00282019116e0c9e54e4f25a5791defa1661d30';
-const PARENT_CLOSURE='533b7e0ff9ded04086dd90ed34e3b87bc427acc3c55c25bb9f4ec66cb448e667';
+const PARENT_RELEASE='v0.15.1-d55f00b5144dc31a';
+const PARENT_MANIFEST='d55f00b5144dc31a7fe39e4dc60d640a94780da6aaeca0918e87636b816d7854';
+const PARENT_GENERATION='00cde7bf540cc2804d679a39040d5b07193c5f8a0d49cac3b882402f8f4e6ad8';
 
-test('R45 current authority agrees on V0.15.1 and preserves exact sealed R44 parent',async()=>{
+test('R46 current authority agrees on V0.15.2 and preserves exact R45 parent identity',async()=>{
   const pkg=JSON.parse(await text('package.json'));
-  const [version,controller,gate,readme,architecture,controllerReadme,deferred,parity,closure,closureVerify,windowsGate,parent,r44Gate,r44Parity,r44Closure]=await Promise.all([
-    text('src/version.mjs'),text('controller/deadbyte-controller.ps1'),text('scripts/gate-windows-r45.ps1'),text('README.txt'),
-    text('docs/ARCHITECTURE.md'),text('controller/README.TXT'),text('scripts/deferred-slot-operation-r45.mjs'),
-    text('scripts/release-parity-r45.mjs'),text('scripts/final-closure-r45.mjs'),text('scripts/final-closure-verify-r45.mjs'),
-    text('scripts/windows-gate-evidence-r45.mjs'),text('R45-PARENT.json'),
-    text('scripts/gate-windows-r44.ps1'),text('scripts/release-parity-r44.mjs'),text('scripts/final-closure-r44.mjs')
+  const release=JSON.parse(await text('RELEASE.json'));
+  const [version,controller,gate,readme,architecture,controllerReadme,deferred,parity,closure,closureVerify,windowsGate,processPolicy]=await Promise.all([
+    text('src/version.mjs'),
+    text('controller/deadbyte-controller.ps1'),
+    text('scripts/gate-windows-r46.ps1'),
+    text('README.txt'),
+    text('docs/ARCHITECTURE.md'),
+    text('controller/README.TXT'),
+    text('scripts/deferred-slot-operation-r46.mjs'),
+    text('scripts/release-parity-r46.mjs'),
+    text('scripts/final-closure-r46.mjs'),
+    text('scripts/final-closure-verify-r46.mjs'),
+    text('scripts/windows-gate-evidence-r46.mjs'),
+    text('controller/deadbyte-process-policy.json')
+  ]);
+
+  assert.equal(pkg.version,'0.15.2');
+  assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r46.ps1');
+  assert.equal(pkg.scripts['self-update:deferred'],'node scripts/deferred-slot-operation-r46.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(pkg.scripts['r46:fileless:test'],"node --test --test-concurrency=1 test/process-policy.test.mjs test/process-policy-refresh.test.mjs test/release-generation.test.mjs test/process-runtime.test.mjs test/process-mcp-tools.test.mjs test/compact-gateway-r36.test.mjs test/capability-ledger-r36.test.mjs test/remote-device-r44.test.mjs test/observation-runtime.test.mjs test/observation-mcp-tools.test.mjs");
+  assert.equal(pkg.scripts['r46:full:test'],'node scripts/full-regression-r46.mjs');
+
+  assert.match(version,/DEADBYTE_VERSION = '0\.15\.2'/);
+  assert.match(controller,/CONTROLLER V0\.15\.2 \/ R46/);
+  assert.match(gate,/DEADBYTE V0\.15\.2 \/ R46 FILELESS POWERSHELL WINDOWS BATCH GATE: PASS/);
+  assert.match(readme,/^DEADBYTE MCP V0\.15\.2 \/ R46 FILELESS POWERSHELL PRODUCT BASELINE$/m);
+  assert.match(readme,/powershell\.exe -Command <source>/);
+  assert.match(architecture,/^# DEADBYTE MCP V0\.15\.2 \/ R46 ARCHITECTURE$/m);
+  assert.match(controllerReadme,/^DEADBYTE MCP V0\.15\.2 \/ R46 CONTROLLER$/m);
+  assert.match(deferred,/--expected-version','0\.15\.2'/);
+  assert.match(parity,/deadbyte\.r46-parity\.v1/);
+  assert.match(parity,/DB_R46_FILELESS_PARITY/);
+  assert.match(parity,/target_repin_verified:true/);
+  assert.match(parity,/DB_R46_REPL_VALUE=42/);
+  assert.match(parity,/raw_input_not_journaled:true/);
+  assert.match(parity,/eviction_verified:true/);
+  assert.match(windowsGate,/full_tool_count:83/);
+  assert.match(windowsGate,/remote_reachability_ttl:true/);
+  assert.match(windowsGate,/observation_search_terminal_ttl:true/);
+  assert.match(windowsGate,/observation_search_hard_cap:128/);
+  assert.match(closure,/deadbyte\.r46-final-closure\.v1/);
+  assert.match(closure,/DEADBYTE-R46-FINAL-CLOSURE-V1/);
+  assert.match(closureVerify,/DEADBYTE-R46-FINAL-CLOSURE-V1/);
+  assert.match(windowsGate,/deadbyte\.r46-windows-gate\.v1/);
+
+  assert.equal(release.version,'0.15.2');
+  assert.equal(release.train,'R46');
+  assert.equal(release.label,'FILELESS POWERSHELL PRODUCT BASELINE');
+  assert.equal(release.parent.release_id,PARENT_RELEASE);
+  assert.equal(release.parent.manifest_sha256,PARENT_MANIFEST);
+  assert.equal(release.parent.generation_manifest_sha256,PARENT_GENERATION);
+  assert.deepEqual(release.capabilities.process_profiles,['ping_hold','powershell','powershell_repl']);
+  assert.equal(release.capabilities.full_tool_count,83);
+  assert.equal(release.capabilities.compact_tool_count,43);
+  assert.equal(release.capabilities.powershell_persistent_repl,true);
+  assert.equal(release.capabilities.process_raw_input_profile_opt_in,true);
+  assert.equal(release.capabilities.powershell_fileless,true);
+  assert.equal(release.capabilities.powershell_source_max_arg_bytes,8192);
+
+  const policy=JSON.parse(processPolicy);
+  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_repl.prefix_args,['-NoLogo','-NoProfile','-NonInteractive']);
+  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);
+  assert.equal(policy.profiles.powershell.transport,'pipe');
+});
+
+test('R46 leaves sealed R45 release artifacts historical and unchanged in identity',async()=>{
+  const [gate,deferred,parity,closure,closureVerify,finalizer,parent]=await Promise.all([
+    text('scripts/gate-windows-r45.ps1'),
+    text('scripts/deferred-slot-operation-r45.mjs'),
+    text('scripts/release-parity-r45.mjs'),
+    text('scripts/final-closure-r45.mjs'),
+    text('scripts/final-closure-verify-r45.mjs'),
+    text('scripts/finalize-r45.mjs'),
+    text('R45-PARENT.json')
   ]);
-  assert.equal(pkg.version,'0.15.1');
-  assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r45.ps1');
-  assert.equal(pkg.scripts['r45:parent:verify'],'node scripts/verify-r45-parent.mjs');
-  assert.equal(pkg.scripts['r45:full:test'],'node scripts/full-regression-r45.mjs');
-  assert.equal(pkg.scripts['self-update:deferred'],'node scripts/deferred-slot-operation-r45.mjs');
-  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['finalize:r45'],'node scripts/finalize-r45.mjs');
-  assert.match(version,/DEADBYTE_VERSION = '0\.15\.1'/);
-  assert.match(controller,/CONTROLLER V0\.15\.1 \/ R45/);
   assert.match(gate,/DEADBYTE V0\.15\.1 \/ R45 MACHINE FREEDOM WINDOWS BATCH GATE: PASS/);
-  assert.match(readme,/^DEADBYTE MCP V0\.15\.1 \/ R45 MACHINE FREEDOM FINAL BASELINE$/m);
-  assert.match(architecture,/^# DEADBYTE MCP V0\.15\.1 \/ R45 ARCHITECTURE$/m);
-  assert.match(controllerReadme,/^DEADBYTE MCP V0\.15\.1 \/ R45 CONTROLLER$/m);
   assert.match(deferred,/--expected-version','0\.15\.1'/);
-  assert.match(parity,/R45_PREDECESSOR_RELEASE_ID='v0\.15\.0-c15fa41719be61b3'/);
-  assert.match(parity,new RegExp(PARENT_MANIFEST));
-  assert.match(parity,/tool_count===82/);assert.match(parity,/tool_count===43/);
-  assert.match(closure,/version:'0\.15\.1'/);assert.match(closure,/DEADBYTE-R45-FINAL-CLOSURE-V1/);
-  assert.match(closureVerify,/R45_FULL_TOOL_COUNT=82/);assert.match(closureVerify,/R45_COMPACT_TOOL_COUNT=43/);
-  assert.match(windowsGate,/deadbyte\.r45-windows-gate\.v1/);
+  assert.match(parity,/deadbyte\.r45-parity\.v1/);
+  assert.match(closure,/version:'0\.15\.1'/);
+  assert.match(closure,/DEADBYTE-R45-FINAL-CLOSURE-V1/);
+  assert.match(closureVerify,/R45_FULL_TOOL_COUNT=82/);
+  assert.match(finalizer,/EXPECTED_VERSION='0\.15\.1'/);
   const parentRecord=JSON.parse(parent);
-  assert.equal(parentRecord.parent_release_id,PARENT_RELEASE);
-  assert.equal(parentRecord.parent_manifest_sha256,PARENT_MANIFEST);
-  assert.equal(parentRecord.parent_generation_manifest_sha256,PARENT_GENERATION);
-  assert.equal(parentRecord.parent_final_closure_sha256,PARENT_CLOSURE);
-  assert.match(r44Gate,/DEADBYTE V0\.15\.0 \/ R44 REMOTE AGENT SKILL WINDOWS BATCH GATE: PASS/);
-  assert.match(r44Parity,/deadbyte\.r44-parity\.v1/);
-  assert.match(r44Closure,/version:'0\.15\.0'/);
+  assert.equal(parentRecord.parent_release_id,'v0.15.0-c15fa41719be61b3');
 });
 
-test('R45 keeps ONLINE reuse and explicit Desktop authority',async()=>{
-  const [cli,controller]=await Promise.all([text('src/deadbyte-cli.mjs'),text('controller/deadbyte-controller.ps1')]);
+test('R46 keeps ONLINE reuse, explicit Desktop authority, and semantic config pin',async()=>{
+  const [cli,controller,semantic]=await Promise.all([
+    text('src/deadbyte-cli.mjs'),
+    text('controller/deadbyte-controller.ps1'),
+    text('controller/deadbyte-semantic-lsp-config.json')
+  ]);
   assert.match(cli,/controllerRuntimeReady/);
   assert.match(cli,/Runtime already ONLINE; reusing verified bridge\/cloud\/supervisor/);
   const start=controller.indexOf('function Recover-AutonomousSupervisor'),end=controller.indexOf('function Show-State',start);
@@ -62,9 +121,5 @@ test('R45 keeps ONLINE reuse and explicit Desktop authority',async()=>{
   assert.match(block,/\$hostStatus\s*=\s*Get-HostArmStatus/);
   assert.match(controller,/armdesktop/);
   assert.match(controller,/disarmdesktop/);
-});
-
-test('semantic config remains byte-pinned across R45 machine-freedom work',async()=>{
-  const semantic=await text('controller/deadbyte-semantic-lsp-config.json');
   assert.equal(createHash('sha256').update(Buffer.from(semantic,'utf8')).digest('hex'),'d274b099a298c1033fea8f1e8849751693bbc0448778d619400acb82d4f53a3b');
 });