deadbyte-mcp 0.8.7

package/src/release-generation.mjs

@@ -0,0 +1,233 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { lstat, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+const HEX64=/^[0-9a-f]{64}$/;
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const jsonBytes=value=>Buffer.from(`${JSON.stringify(value,null,2)}\n`,'utf8');
+const psQuote=value=>`'${String(value??'').replaceAll("'","''")}'`;
+const psBool=value=>value===true?'$true':'$false';
+const renderPsDependencies=dependencies=>{
+  const items=Array.isArray(dependencies)?dependencies:[];
+  if(items.length===0) return ['        Dependencies = @()'];
+  return ['        Dependencies = @(',...items.map(item=>`            @{ Name = ${psQuote(item.Name)}; Path = ${psQuote(item.Path)}; Sha256 = ${psQuote(item.Sha256)} }`),'        )'];
+};
+
+function clone(value){ return structuredClone(value); }
+function canonical(value){
+  if(Array.isArray(value)) return value.map(canonical);
+  if(value&&typeof value==='object') return Object.fromEntries(Object.keys(value).sort().map(key=>[key,canonical(value[key])]));
+  return value;
+}
+function safeRel(rel){
+  if(typeof rel!=='string'||rel.length<1||path.posix.isAbsolute(rel)||rel.split('/').includes('..')||rel.includes('\\')||rel.includes('\0')) {
+    throw new Error(`generation path unsafe: ${rel}`);
+  }
+  return rel;
+}
+
+function generationManifest(files){
+  const lines=[...files.entries()].sort(([a],[b])=>a.localeCompare(b,'en')).map(([rel,bytes])=>`${sha256(bytes)}  ${rel}`);
+  return Buffer.from(`${lines.join('\n')}\n`,'utf8');
+}
+export async function verifyGenerationBundle(root,expectedManifestSha256){
+  const manifestPath=path.join(root,'GENERATION.SHA256');
+  const manifestBytes=await readFile(manifestPath);
+  const manifestSha256=sha256(manifestBytes);
+  if(expectedManifestSha256!==undefined&&manifestSha256!==expectedManifestSha256) throw new Error('generation manifest hash mismatch');
+  const seen=new Set(); let files=0;
+  for(const [index,line] of manifestBytes.toString('utf8').split(/\r?\n/).entries()){
+    if(!line) continue;
+    const match=/^([0-9a-f]{64})  (.+)$/.exec(line); if(!match) throw new Error(`generation manifest line ${index+1} malformed`);
+    const rel=safeRel(match[2]); if(seen.has(rel)) throw new Error(`generation manifest duplicate: ${rel}`); seen.add(rel);
+    const file=path.resolve(root,...rel.split('/')); const boundary=path.relative(path.resolve(root),file);
+    if(boundary.startsWith(`..${path.sep}`)||path.isAbsolute(boundary)) throw new Error(`generation path escapes root: ${rel}`);
+    const stat=await lstat(file); if(!stat.isFile()||stat.isSymbolicLink()) throw new Error(`generation file is not regular: ${rel}`);
+    if(sha256(await readFile(file))!==match[1]) throw new Error(`generation file hash mismatch: ${rel}`);
+    files++;
+  }
+  if(files<1) throw new Error('generation manifest empty');
+  return {files,generation_manifest_sha256:manifestSha256};
+}
+
+function rebindCodingPolicy(raw,{developmentRoot,stateRoot,parityScratchRoot}){
+  const policy=clone(raw);
+  policy.lease_file=path.join(stateRoot,'runtime','coding-grant.json');
+  policy.evidence_dir=path.join(stateRoot,'evidence','coding');
+  if(!policy.roots?.core) throw new Error('coding policy requires core root for R27');
+  policy.roots.core.path=developmentRoot;
+  policy.roots.parity_scratch={path:parityScratchRoot,read:true,write:true,exec:false,deny_paths:[]};
+  return policy;
+}
+async function rebindAutonomousPolicy(raw,{stateRoot,codingPolicy,codingPolicyBytes}){
+  const policy=clone(raw);
+  policy.lease_file=path.join(stateRoot,'runtime','autonomous-grant.json');
+  policy.evidence_dir=path.join(stateRoot,'evidence','autonomous');
+  policy.coding_policy_sha256=sha256(codingPolicyBytes);
+  for(const [id,profile] of Object.entries(policy.profiles??{})){
+    const rel=safeRel(String(profile.script_path).replaceAll('\\','/'));
+    const rootId=String(profile.root_id??'');
+    const rootPath=codingPolicy.roots?.[rootId]?.path;
+    if(typeof rootPath!=='string'||!path.isAbsolute(rootPath)) throw new Error(`profile root invalid: ${id}`);
+    const file=path.resolve(rootPath,...rel.split('/'));
+    const boundary=path.relative(rootPath,file);
+    if(boundary.startsWith(`..${path.sep}`)||path.isAbsolute(boundary)) throw new Error(`profile path escapes coding root: ${id}`);
+    const stat=await lstat(file); if(!stat.isFile()||stat.isSymbolicLink()) throw new Error(`profile script invalid: ${id}`);
+    profile.script_sha256=sha256(await readFile(file));
+  }
+  return policy;
+}
+
+function rebindHostPolicy(raw,{developmentRoot,stateRoot}){
+  if(!raw) return null;
+  const policy=clone(raw);
+  policy.arm_file=path.join(stateRoot,'runtime','host-grant.json');
+  if(policy.roots?.core) policy.roots.core.path=developmentRoot;
+  return policy;
+}
+
+async function rebindProcessPolicy(raw,{developmentRoot,stateRoot,releaseRoot}){
+  if(!raw) return null;
+  const policy=clone(raw);
+  policy.grant_file=path.join(stateRoot,'runtime','process-grant.json');
+  policy.state_dir=path.join(stateRoot,'evidence','process');
+  if(!policy.roots?.core) throw new Error('process policy requires core root');
+  policy.roots.core.path=developmentRoot;
+  const nativeHostPath=path.join(releaseRoot,'bin','deadbyte-process-host.exe');
+  const nativeHostStat=await lstat(nativeHostPath);
+  if(!nativeHostStat.isFile()||nativeHostStat.isSymbolicLink()) throw new Error('process native host invalid in release slot');
+  policy.native_host={path:nativeHostPath,sha256:sha256(await readFile(nativeHostPath))};
+  return policy;
+}
+
+function renderControllerConfig({currentConfig,coreRoot,workspaceRoot,processPolicyPath,codingPolicyPath,autonomousPolicyPath,hostPolicyPath}){
+  const bridge=currentConfig.Bridge??{},cloud=currentConfig.Cloud??{};
+  return [
+    '@{',"    Schema = 'deadbyte.controller.v1'",`    CoreRoot = ${psQuote(coreRoot)}`,
+    `    WorkspaceRoot = ${psQuote(workspaceRoot)}`,
+    `    MachineRuntimeEnabled = ${psBool(currentConfig.MachineRuntimeEnabled!==false)}`,
+    `    AgentRuntimeEnabled = ${psBool(currentConfig.AgentRuntimeEnabled)}`,
+    `    ProcessRuntimeEnabled = ${psBool(currentConfig.ProcessRuntimeEnabled)}`,
+    `    ProcessPolicyFile = ${psQuote(processPolicyPath??'')}`,
+    `    CodingRuntimeEnabled = ${psBool(currentConfig.CodingRuntimeEnabled)}`,
+    `    MachineFsRuntimeEnabled = ${psBool(currentConfig.MachineFsRuntimeEnabled)}`,
+    `    ObservationRuntimeEnabled = ${psBool(currentConfig.ObservationRuntimeEnabled)}`,
+    `    CodingPolicyFile = ${psQuote(codingPolicyPath)}`,
+    `    AutonomousRuntimeEnabled = ${psBool(currentConfig.AutonomousRuntimeEnabled)}`,
+    `    AutonomousPolicyFile = ${psQuote(autonomousPolicyPath)}`,
+    `    HostPolicyFile = ${psQuote(hostPolicyPath??'')}`,
+    '    Bridge = @{',
+    `        FilePath = ${psQuote(bridge.FilePath)}`,
+    `        FileSha256 = ${psQuote(bridge.FileSha256)}`,
+    `        Arguments = ${psQuote(bridge.Arguments)}`,
+    `        WorkingDirectory = ${psQuote(bridge.WorkingDirectory)}`,
+    `        ScriptPath = ${psQuote(bridge.ScriptPath)}`,
+    `        ScriptSha256 = ${psQuote(bridge.ScriptSha256)}`,
+    '    }','    Cloud = @{',
+    `        FilePath = ${psQuote(cloud.FilePath)}`,
+    `        FileSha256 = ${psQuote(cloud.FileSha256)}`,
+    `        Arguments = ${psQuote(cloud.Arguments)}`,
+    `        WorkingDirectory = ${psQuote(cloud.WorkingDirectory)}`,
+    ...(cloud.Transport?[`        Transport = ${psQuote(cloud.Transport)}`]:[]),
+    ...renderPsDependencies(cloud.Dependencies),
+    '    }',
+    `    LocalReadyUri = ${psQuote(currentConfig.LocalReadyUri)}`,
+    `    UrlRegex = ${psQuote(currentConfig.UrlRegex)}`,
+    `    McpUrlFile = ${psQuote(currentConfig.McpUrlFile??'')}`,
+    `    McpUrlFileSha256 = ${psQuote(currentConfig.McpUrlFileSha256??'')}`,
+    `    McpPathFile = ${psQuote(currentConfig.McpPathFile??'')}`,
+    `    StartTimeoutSeconds = ${Number(currentConfig.StartTimeoutSeconds??30)}`,
+    `    ProbeTimeoutSeconds = ${Number(currentConfig.ProbeTimeoutSeconds??3)}`,
+    '}',''
+  ].join('\r\n');
+}
+export async function createGenerationBundle({stateRoot,releaseRoot,developmentRoot,workspaceRoot,releaseId,currentConfig,processPolicy,codingPolicy,autonomousPolicy,hostPolicy}){
+  const state=path.resolve(stateRoot),release=path.resolve(releaseRoot),development=path.resolve(developmentRoot),workspace=path.resolve(workspaceRoot);
+  if(typeof releaseId!=='string'||!/^[A-Za-z0-9._-]{1,96}$/.test(releaseId)) throw new Error('generation release id invalid');
+  if(typeof currentConfig?.Bridge?.FileSha256!=='string'||!HEX64.test(currentConfig.Bridge.FileSha256)) throw new Error('generation Bridge FileSha256 invalid');
+  if(typeof currentConfig?.Cloud?.FileSha256!=='string'||!HEX64.test(currentConfig.Cloud.FileSha256)) throw new Error('generation Cloud FileSha256 invalid');
+  if(currentConfig.Cloud.Transport!==undefined){
+    const transport=String(currentConfig.Cloud.Transport);
+    const expectedDependencies=transport==='deadbyte.named-tunnel.v1'?3:transport==='deadbyte.named-tunnel.v2'?2:null;
+    if(expectedDependencies===null) throw new Error('generation Cloud Transport unsupported');
+    const dependencies=currentConfig.Cloud.Dependencies;
+    if(!Array.isArray(dependencies)||dependencies.length!==expectedDependencies) throw new Error(`generation named tunnel ${transport} requires exactly ${expectedDependencies} dependencies`);
+    const names=new Set();
+    for(const dependency of dependencies){
+      if(typeof dependency?.Name!=='string'||!/^[A-Za-z0-9._-]{1,32}$/.test(dependency.Name)||names.has(dependency.Name)) throw new Error('generation Cloud dependency name invalid');
+      names.add(dependency.Name);
+      if(typeof dependency.Path!=='string'||!path.isAbsolute(dependency.Path)) throw new Error(`generation Cloud dependency path invalid: ${dependency.Name}`);
+      if(typeof dependency.Sha256!=='string'||!HEX64.test(dependency.Sha256)) throw new Error(`generation Cloud dependency hash invalid: ${dependency.Name}`);
+    }
+    if(transport==='deadbyte.named-tunnel.v2'){
+      if(typeof currentConfig.McpUrlFile!=='string'||!path.isAbsolute(currentConfig.McpUrlFile)) throw new Error('generation named tunnel v2 requires absolute McpUrlFile');
+      if(typeof currentConfig.McpUrlFileSha256!=='string'||!HEX64.test(currentConfig.McpUrlFileSha256)) throw new Error('generation named tunnel v2 requires McpUrlFileSha256');
+    }
+  }
+  if(typeof currentConfig?.Bridge?.ScriptPath!=='string'||!path.isAbsolute(currentConfig.Bridge.ScriptPath)) throw new Error('generation Bridge ScriptPath must be absolute');
+  if(typeof currentConfig?.Bridge?.ScriptSha256!=='string'||!HEX64.test(currentConfig.Bridge.ScriptSha256)) throw new Error('generation Bridge ScriptSha256 invalid');
+  const parityScratchRoot=path.join(state,'runtime','r33-parity-scratch');
+  await mkdir(parityScratchRoot,{recursive:true});
+  const parityScratchStat=await lstat(parityScratchRoot);
+  if(!parityScratchStat.isDirectory()||parityScratchStat.isSymbolicLink()) throw new Error('generation parity scratch root invalid');
+  const coding=rebindCodingPolicy(codingPolicy,{developmentRoot:development,stateRoot:state,parityScratchRoot});
+  const codingBytes=jsonBytes(coding);
+  const autonomous=await rebindAutonomousPolicy(autonomousPolicy,{stateRoot:state,codingPolicy:coding,codingPolicyBytes:codingBytes});
+  const autonomousBytes=jsonBytes(autonomous);
+  const host=rebindHostPolicy(hostPolicy,{developmentRoot:development,stateRoot:state});
+  const hostBytes=host?jsonBytes(host):null;
+  const processBound=await rebindProcessPolicy(processPolicy,{developmentRoot:development,stateRoot:state,releaseRoot:release});
+  const processBytes=processBound?jsonBytes(processBound):null;
+  const seedBody=canonical({
+    release_id:releaseId,core_root:release,development_root:development,workspace_root:workspace,
+    machine_runtime_enabled:currentConfig.MachineRuntimeEnabled!==false,
+    agent_runtime_enabled:currentConfig.AgentRuntimeEnabled===true,
+    process_runtime_enabled:currentConfig.ProcessRuntimeEnabled===true,
+    coding_runtime_enabled:currentConfig.CodingRuntimeEnabled===true,
+    machine_fs_runtime_enabled:currentConfig.MachineFsRuntimeEnabled===true,
+    observation_runtime_enabled:currentConfig.ObservationRuntimeEnabled===true,
+    autonomous_runtime_enabled:currentConfig.AutonomousRuntimeEnabled===true,
+    bridge:currentConfig.Bridge??{},cloud:currentConfig.Cloud??{},
+    local_ready_uri:currentConfig.LocalReadyUri??'',url_regex:currentConfig.UrlRegex??'',
+    mcp_url_file:currentConfig.McpUrlFile??'',mcp_url_file_sha256:currentConfig.McpUrlFileSha256??'',mcp_path_file:currentConfig.McpPathFile??'',
+    start_timeout_seconds:Number(currentConfig.StartTimeoutSeconds??30),probe_timeout_seconds:Number(currentConfig.ProbeTimeoutSeconds??3),
+    process_policy_sha256:processBytes?sha256(processBytes):null,
+    coding_policy_sha256:sha256(codingBytes),autonomous_policy_sha256:sha256(autonomousBytes),host_policy_sha256:hostBytes?sha256(hostBytes):null
+  });
+  const generationSeed=sha256(Buffer.from(JSON.stringify(seedBody),'utf8'));
+  const generationId=`${releaseId}-g${generationSeed.slice(0,16)}`;
+  const generationsRoot=path.join(state,'generations');
+  const generationRoot=path.join(generationsRoot,generationId);
+  const processPath=processBytes?path.join(generationRoot,'process-policy.json'):null;
+  const codingPath=path.join(generationRoot,'coding-policy.json');
+  const autonomousPath=path.join(generationRoot,'autonomous-policy.json');
+  const hostPath=host?path.join(generationRoot,'host-policy.json'):null;
+  const configPath=path.join(generationRoot,'controller-config.psd1');
+  const files=new Map([
+    ['coding-policy.json',codingBytes],
+    ['autonomous-policy.json',autonomousBytes],
+    ['controller-config.psd1',Buffer.from(renderControllerConfig({currentConfig,coreRoot:release,workspaceRoot:workspace,processPolicyPath:processPath,codingPolicyPath:codingPath,autonomousPolicyPath:autonomousPath,hostPolicyPath:hostPath}),'utf8')]
+  ]);
+  if(processBytes) files.set('process-policy.json',processBytes);
+  if(hostBytes) files.set('host-policy.json',hostBytes);
+  const manifestBytes=generationManifest(files),manifestSha256=sha256(manifestBytes);
+  if(existsSync(generationRoot)){
+    const verified=await verifyGenerationBundle(generationRoot,manifestSha256);
+    return {generation_id:generationId,generation_seed_sha256:generationSeed,generation_root:generationRoot,generation_manifest_sha256:manifestSha256,config_path:configPath,process_policy_path:processPath,coding_policy_path:codingPath,autonomous_policy_path:autonomousPath,host_policy_path:hostPath,adopted:true,...verified};
+  }
+  await mkdir(generationsRoot,{recursive:true});
+  const staging=path.join(generationsRoot,`.staging-${generationId}-${process.pid}-${randomBytes(4).toString('hex')}`);
+  await mkdir(staging,{recursive:false});
+  try {
+    for(const [rel,bytes] of files) await writeFile(path.join(staging,rel),bytes,{flag:'wx'});
+    await writeFile(path.join(staging,'GENERATION.SHA256'),manifestBytes,{flag:'wx'});
+    await verifyGenerationBundle(staging,manifestSha256);
+    await rename(staging,generationRoot);
+  } catch(error){
+    await rm(staging,{recursive:true,force:true}).catch(()=>{});
+    throw error;
+  }
+  const verified=await verifyGenerationBundle(generationRoot,manifestSha256);
+  return {generation_id:generationId,generation_seed_sha256:generationSeed,generation_root:generationRoot,generation_manifest_sha256:manifestSha256,config_path:configPath,process_policy_path:processPath,coding_policy_path:codingPath,autonomous_policy_path:autonomousPath,host_policy_path:hostPath,adopted:false,...verified};
+}

package/src/release-slot.mjs

@@ -0,0 +1,293 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { lstat, mkdir, open, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+const HEX64=/^[0-9a-f]{64}$/;
+const SEMVER=/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+const POINTER_SCHEMA='deadbyte.active-release.v1';
+
+export const sha256Bytes=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+function safeRelative(rel){
+  if(typeof rel!=='string'||rel.length<1) throw new Error('manifest path empty');
+  const normalized=rel.replaceAll('\\','/');
+  if(path.posix.isAbsolute(normalized)||normalized.split('/').includes('..')||normalized.includes('\0')) {
+    throw new Error(`unsafe manifest path '${normalized}'`);
+  }
+  return normalized;
+}
+
+export function releaseId(version,manifestSha256){
+  if(!SEMVER.test(String(version))) throw new Error('release version must be SemVer');
+  if(!HEX64.test(String(manifestSha256))) throw new Error('release manifest must be lowercase SHA-256');
+  return `v${version}-${manifestSha256.slice(0,16)}`;
+}
+export function parseManifest(text){
+  const entries=new Map();
+  for(const [index,line] of String(text).split(/\r?\n/).entries()){
+    if(!line) continue;
+    const match=/^([0-9a-f]{64})  (.+)$/.exec(line);
+    if(!match) throw new Error(`manifest line ${index+1} malformed`);
+    const rel=safeRelative(match[2]);
+    if(entries.has(rel)) throw new Error(`manifest duplicate path '${rel}'`);
+    entries.set(rel,match[1]);
+  }
+  if(entries.size<1) throw new Error('manifest has no entries');
+  return entries;
+}
+
+async function plainManifestFile(root,rel,label){
+  const rootPath=path.resolve(root);
+  const rootStat=await lstat(rootPath).catch(error=>{throw new Error(`${label} root unavailable: ${error.message}`)});
+  if(!rootStat.isDirectory()||rootStat.isSymbolicLink()) throw new Error(`${label} root must be a real directory`);
+  let cursor=rootPath;
+  const parts=safeRelative(rel).split('/');
+  for(let index=0;index<parts.length;index++){
+    cursor=path.join(cursor,parts[index]);
+    const stat=await lstat(cursor).catch(error=>{throw new Error(`${label} file missing: ${rel}: ${error.message}`)});
+    if(stat.isSymbolicLink()) throw new Error(`${label} symlink is forbidden: ${rel}`);
+    if(index<parts.length-1&&!stat.isDirectory()) throw new Error(`${label} parent is not directory: ${rel}`);
+    if(index===parts.length-1&&!stat.isFile()) throw new Error(`${label} file is not regular: ${rel}`);
+  }
+  return cursor;
+}
+
+export async function verifyManifestTree(root,manifest){
+  for(const [rel,expected] of manifest){
+    const file=await plainManifestFile(root,rel,'manifest');
+    const actual=sha256Bytes(await readFile(file));
+    if(actual!==expected) throw new Error(`hash mismatch: ${rel}`);
+  }
+  return {files:manifest.size};
+}
+
+async function listManifestTreeFiles(root){
+  const base=path.resolve(root), files=[];
+  const walk=async(dir)=>{
+    for(const entry of await readdir(dir,{withFileTypes:true})){
+      const absolute=path.join(dir,entry.name);
+      const rel=path.relative(base,absolute).replaceAll('\\','/');
+      if(entry.isSymbolicLink()) throw new Error(`manifest-tree symlink forbidden: ${rel}`);
+      if(entry.isDirectory()) await walk(absolute);
+      else if(entry.isFile()) { if(rel!=='MANIFEST.SHA256') files.push(rel); }
+      else throw new Error(`manifest-tree unsupported entry: ${rel}`);
+    }
+  };
+  await walk(base);
+  return files.sort((a,b)=>a.localeCompare(b,'en'));
+}
+
+export async function verifyManifestTreeExact(root,manifest){
+  await verifyManifestTree(root,manifest);
+  const actual=await listManifestTreeFiles(root);
+  const expected=[...manifest.keys()].sort((a,b)=>a.localeCompare(b,'en'));
+  for(const rel of actual) if(!manifest.has(rel)) throw new Error(`unexpected manifest-tree file: ${rel}`);
+  for(const rel of expected) if(!actual.includes(rel)) throw new Error(`missing manifest-tree file: ${rel}`);
+  if(actual.length!==expected.length) throw new Error(`manifest-tree file count mismatch: expected=${expected.length} actual=${actual.length}`);
+  return {files:manifest.size};
+}
+export async function copyManifestTree({source,destination,manifest}){
+  await mkdir(destination,{recursive:false});
+  try {
+    for(const [rel] of manifest){
+      const src=await plainManifestFile(source,rel,'candidate');
+      const dst=path.resolve(destination,...safeRelative(rel).split('/'));
+      await mkdir(path.dirname(dst),{recursive:true});
+      await writeFile(dst,await readFile(src),{flag:'wx'});
+    }
+    await verifyManifestTreeExact(destination,manifest);
+    return {files:manifest.size};
+  } catch(error){
+    await rm(destination,{recursive:true,force:true}).catch(()=>{});
+    throw error;
+  }
+}
+
+export async function materializeReleaseSlot({source,stateRoot,version,manifestSha256}){
+  if(!SEMVER.test(String(version))) throw new Error('candidate version must be SemVer');
+  if(!HEX64.test(String(manifestSha256))) throw new Error('candidate manifest must be lowercase SHA-256');
+  const sourceRoot=path.resolve(source),state=path.resolve(stateRoot);
+  const manifestBytes=await readFile(path.join(sourceRoot,'MANIFEST.SHA256'));
+  if(sha256Bytes(manifestBytes)!==manifestSha256) throw new Error('candidate manifest digest mismatch');
+  const manifest=parseManifest(manifestBytes.toString('utf8'));
+  for(const required of [
+    'package.json','controller/deadbyte-controller.ps1','scripts/runtime-self-update.mjs',
+    'bin/deadbyte-exec.exe','bin/contained-transform-worker.exe',
+    'bin/contained-reverse-worker.exe','bin/WORKER-REGISTRY.txt'
+  ]) {
+    if(!manifest.has(required)) throw new Error(`candidate manifest missing required entry: ${required}`);
+  }
+  await verifyManifestTree(sourceRoot,manifest);
+  const pkg=JSON.parse(await readFile(path.join(sourceRoot,'package.json'),'utf8'));
+  if(pkg?.name!=='deadbyte-mcp'||pkg?.version!==version) throw new Error('candidate package identity mismatch');
+  const id=releaseId(version,manifestSha256),releasesRoot=path.join(state,'releases'),releaseRoot=path.join(releasesRoot,id);
+  const verifyFinal=async()=>{
+    const finalManifest=await readFile(path.join(releaseRoot,'MANIFEST.SHA256'));
+    if(sha256Bytes(finalManifest)!==manifestSha256) throw new Error('release slot manifest digest mismatch');
+    const finalEntries=parseManifest(finalManifest.toString('utf8'));
+    if(finalEntries.size!==manifest.size||[...manifest].some(([rel,hash])=>finalEntries.get(rel)!==hash)) throw new Error('release slot manifest entries mismatch');
+    await verifyManifestTreeExact(releaseRoot,finalEntries);
+    const finalPkg=JSON.parse(await readFile(path.join(releaseRoot,'package.json'),'utf8'));
+    if(finalPkg?.name!=='deadbyte-mcp'||finalPkg?.version!==version) throw new Error('release slot package identity mismatch');
+    return {release_id:id,release_root:releaseRoot,manifest_sha256:manifestSha256,files:finalEntries.size};
+  };
+  if(existsSync(releaseRoot)) return {...await verifyFinal(),adopted:true};
+  await mkdir(releasesRoot,{recursive:true});
+  const staging=path.join(releasesRoot,`.staging-${id}-${process.pid}-${randomBytes(4).toString('hex')}`);
+  try {
+    await copyManifestTree({source:sourceRoot,destination:staging,manifest});
+    await writeFile(path.join(staging,'MANIFEST.SHA256'),manifestBytes,{flag:'wx'});
+    await verifyManifestTreeExact(staging,manifest);
+    await rename(staging,releaseRoot);
+  } catch(error){
+    await rm(staging,{recursive:true,force:true}).catch(()=>{});
+    if(existsSync(releaseRoot)) return {...await verifyFinal(),adopted:true};
+    throw error;
+  }
+  return {...await verifyFinal(),adopted:false};
+}
+
+async function atomicJson(file,value){
+  await mkdir(path.dirname(file),{recursive:true});
+  const temp=`${file}.tmp-${process.pid}-${randomBytes(4).toString('hex')}`;
+  const handle=await open(temp,'wx');
+  try { await handle.writeFile(`${JSON.stringify(value,null,2)}\n`,'utf8'); await handle.sync(); }
+  finally { await handle.close(); }
+  try { await rename(temp,file); }
+  catch(error){ await rm(temp,{force:true}).catch(()=>{}); throw error; }
+}
+export function parseActivePointer(text){
+  let value;
+  try { value=JSON.parse(String(text)); } catch(error){ throw new Error(`active pointer JSON invalid: ${error.message}`); }
+  if(!value||typeof value!=='object'||Array.isArray(value)) throw new Error('active pointer must be object');
+  if(value.schema!==POINTER_SCHEMA) throw new Error('active pointer schema mismatch');
+  if(!SEMVER.test(String(value.version))) throw new Error('active pointer version invalid');
+  if(!HEX64.test(String(value.manifest_sha256))) throw new Error('active pointer manifest invalid');
+  if(value.release_id!==releaseId(value.version,value.manifest_sha256)) throw new Error('active pointer release id mismatch');
+  if(!HEX64.test(String(value.generation_manifest_sha256))) throw new Error('active pointer generation manifest invalid');
+  if(!HEX64.test(String(value.launcher_sha256))) throw new Error('active pointer launcher digest invalid');
+  for(const key of ['release_root','generation_root','config_path']) {
+    if(typeof value[key]!=='string'||value[key].length<3) throw new Error(`active pointer ${key} invalid`);
+  }
+  return {
+    schema:POINTER_SCHEMA,
+    release_id:value.release_id,
+    version:value.version,
+    manifest_sha256:value.manifest_sha256,
+    release_root:value.release_root,
+    generation_root:value.generation_root,
+    generation_manifest_sha256:value.generation_manifest_sha256,
+    launcher_sha256:value.launcher_sha256,
+    config_path:value.config_path
+  };
+}
+
+export async function atomicWriteActivePointer(file,pointer){
+  const normalized=parseActivePointer(JSON.stringify(pointer));
+  await atomicJson(file,normalized);
+  const observed=parseActivePointer(await readFile(file,'utf8'));
+  if(JSON.stringify(observed)!==JSON.stringify(normalized)) throw new Error('active pointer readback mismatch');
+  return observed;
+}
+export function renderStableLauncherCmd(){
+  return [
+    '@echo off',
+    'setlocal EnableExtensions DisableDelayedExpansion',
+    'powershell.exe -NoLogo -NoProfile -ExecutionPolicy Bypass -File "%USERPROFILE%\\.deadbyte-mcp\\bin\\DEADBYTE-MCP.ps1" %*',
+    'exit /b %ERRORLEVEL%',
+    ''
+  ].join('\r\n');
+}
+
+export function renderStableLauncherPs1(){
+  return [
+    '#requires -Version 5.1',
+    '[CmdletBinding()]',
+    'param([Parameter(ValueFromRemainingArguments=$true)][string[]]$ControllerArgs)',
+    'Set-StrictMode -Version 3.0',
+    "$ErrorActionPreference = 'Stop'",
+    "$StateRoot = Join-Path $env:USERPROFILE '.deadbyte-mcp'",
+    "$PointerPath = Join-Path $StateRoot 'active-release.json'",
+    "function Fail([string]$m) { throw ('DEADBYTE launcher: ' + $m) }",
+    "if (-not (Test-Path -LiteralPath $PointerPath -PathType Leaf)) { Fail 'active release pointer missing' }",
+    '$p = Get-Content -LiteralPath $PointerPath -Raw -Encoding UTF8 | ConvertFrom-Json',
+    "if ($p.schema -ne 'deadbyte.active-release.v1') { Fail 'active release schema mismatch' }",
+    "if ([string]$p.manifest_sha256 -notmatch '^[0-9a-f]{64}$') { Fail 'active manifest digest invalid' }",
+    "if ([string]$p.generation_manifest_sha256 -notmatch '^[0-9a-f]{64}$') { Fail 'active generation manifest digest invalid' }",
+    "if ([string]$p.launcher_sha256 -notmatch '^[0-9a-f]{64}$') { Fail 'active launcher digest invalid' }",
+    '$launcherHash = (Get-FileHash -LiteralPath $MyInvocation.MyCommand.Path -Algorithm SHA256).Hash.ToLowerInvariant()',
+    "if ($launcherHash -ne [string]$p.launcher_sha256) { Fail 'stable launcher hash mismatch' }",
+    "$expectedId = 'v{0}-{1}' -f [string]$p.version,([string]$p.manifest_sha256).Substring(0,16)",
+    "if ([string]$p.release_id -ne $expectedId) { Fail 'active release id mismatch' }",
+    "$releases = [IO.Path]::GetFullPath((Join-Path $StateRoot 'releases')).TrimEnd('\\') + '\\'",
+    "$generations = [IO.Path]::GetFullPath((Join-Path $StateRoot 'generations')).TrimEnd('\\') + '\\'",
+    '$releaseRoot = [IO.Path]::GetFullPath([string]$p.release_root)',
+    '$generationRoot = [IO.Path]::GetFullPath([string]$p.generation_root)',
+    '$configPath = [IO.Path]::GetFullPath([string]$p.config_path)',
+    "if (-not $releaseRoot.StartsWith($releases,[StringComparison]::OrdinalIgnoreCase)) { Fail 'release root escapes release store' }",
+    "if (-not $generationRoot.StartsWith($generations,[StringComparison]::OrdinalIgnoreCase)) { Fail 'generation root escapes generation store' }",
+    "$expectedConfig = Join-Path $generationRoot 'controller-config.psd1'",
+    "if (-not [string]::Equals($configPath,$expectedConfig,[StringComparison]::OrdinalIgnoreCase)) { Fail 'config path is not generation-bound' }",
+    "$manifest = Join-Path $releaseRoot 'MANIFEST.SHA256'",
+    "$generationManifest = Join-Path $generationRoot 'GENERATION.SHA256'",
+    "$package = Join-Path $releaseRoot 'package.json'",
+    "$controller = Join-Path $releaseRoot 'controller\\deadbyte-controller.ps1'",
+    "foreach ($file in @($manifest,$generationManifest,$package,$controller,$configPath)) { if (-not (Test-Path -LiteralPath $file -PathType Leaf)) { Fail ('required file missing: ' + $file) } }",
+    '$manifestHash = (Get-FileHash -LiteralPath $manifest -Algorithm SHA256).Hash.ToLowerInvariant()',
+    "if ($manifestHash -ne [string]$p.manifest_sha256) { Fail 'active manifest hash mismatch' }",
+    '$generationManifestHash = (Get-FileHash -LiteralPath $generationManifest -Algorithm SHA256).Hash.ToLowerInvariant()',
+    "if ($generationManifestHash -ne [string]$p.generation_manifest_sha256) { Fail 'active generation manifest hash mismatch' }",
+    '$releasePrefix = $releaseRoot.TrimEnd([IO.Path]::DirectorySeparatorChar) + [IO.Path]::DirectorySeparatorChar',
+    '$generationPrefix = $generationRoot.TrimEnd([IO.Path]::DirectorySeparatorChar) + [IO.Path]::DirectorySeparatorChar',
+    '$manifestLines = Get-Content -LiteralPath $manifest -Encoding UTF8',
+    '$manifestPathSet = @{}',
+    'foreach ($line in $manifestLines) {',
+    "    if ([string]::IsNullOrWhiteSpace([string]$line)) { continue }",
+    "    if ([string]$line -notmatch '^([0-9a-f]{64})  (.+)$') { Fail 'release manifest line malformed' }",
+    '    $expectedHash = [string]$Matches[1]',
+    '    $rel = [string]$Matches[2]',
+    "    if ([IO.Path]::IsPathRooted($rel) -or (($rel -split '[\\/]') -contains '..')) { Fail ('unsafe release manifest path: ' + $rel) }",
+    "    $relKey = ($rel -replace '\\\\','/').ToLowerInvariant()",
+    "    if ($manifestPathSet.ContainsKey($relKey)) { Fail ('duplicate release manifest path: ' + $rel) }",
+    '    $manifestPathSet[$relKey] = $true',
+    '    $target = [IO.Path]::GetFullPath((Join-Path $releaseRoot $rel))',
+    "    if (-not $target.StartsWith($releasePrefix,[StringComparison]::OrdinalIgnoreCase)) { Fail ('release manifest path escapes slot: ' + $rel) }",
+    "    if (-not (Test-Path -LiteralPath $target -PathType Leaf)) { Fail ('release file missing: ' + $rel) }",
+    '    $targetItem = Get-Item -LiteralPath $target -Force',
+    "    if (($targetItem.Attributes -band [IO.FileAttributes]::ReparsePoint) -ne 0) { Fail ('release reparse point forbidden: ' + $rel) }",
+    '    $actualHash = (Get-FileHash -LiteralPath $target -Algorithm SHA256).Hash.ToLowerInvariant()',
+    "    if ($actualHash -ne $expectedHash) { Fail ('release file hash mismatch: ' + $rel) }",
+    '}',
+    '$releaseItems = Get-ChildItem -LiteralPath $releaseRoot -Force -Recurse',
+    'foreach ($item in $releaseItems) {',
+    "    if (($item.Attributes -band [IO.FileAttributes]::ReparsePoint) -ne 0) { Fail ('release reparse point forbidden: ' + $item.FullName) }",
+    '    if ($item.PSIsContainer) { continue }',
+    '    if ([string]::Equals($item.FullName,$manifest,[StringComparison]::OrdinalIgnoreCase)) { continue }',
+    "    if (-not $item.FullName.StartsWith($releasePrefix,[StringComparison]::OrdinalIgnoreCase)) { Fail ('release file escapes slot: ' + $item.FullName) }",
+    "    $actualRel = $item.FullName.Substring($releasePrefix.Length).Replace('\\','/')",
+    "    if (-not $manifestPathSet.ContainsKey($actualRel.ToLowerInvariant())) { Fail ('unexpected release file: ' + $actualRel) }",
+    '}',
+    '$generationLines = Get-Content -LiteralPath $generationManifest -Encoding UTF8',
+    'foreach ($line in $generationLines) {',
+    "    if ([string]::IsNullOrWhiteSpace([string]$line)) { continue }",
+    "    if ([string]$line -notmatch '^([0-9a-f]{64})  ([A-Za-z0-9._-]+)$') { Fail 'generation manifest line malformed' }",
+    '    $expectedHash = [string]$Matches[1]',
+    '    $rel = [string]$Matches[2]',
+    '    $target = [IO.Path]::GetFullPath((Join-Path $generationRoot $rel))',
+    "    if (-not $target.StartsWith($generationPrefix,[StringComparison]::OrdinalIgnoreCase)) { Fail ('generation manifest path escapes generation: ' + $rel) }",
+    "    if (-not (Test-Path -LiteralPath $target -PathType Leaf)) { Fail ('generation file missing: ' + $rel) }",
+    '    $actualHash = (Get-FileHash -LiteralPath $target -Algorithm SHA256).Hash.ToLowerInvariant()',
+    "    if ($actualHash -ne $expectedHash) { Fail ('generation file hash mismatch: ' + $rel) }",
+    '}',
+    '$pkg = Get-Content -LiteralPath $package -Raw -Encoding UTF8 | ConvertFrom-Json',
+    "if ([string]$pkg.name -ne 'deadbyte-mcp' -or [string]$pkg.version -ne [string]$p.version) { Fail 'active package identity mismatch' }",
+    '$env:DEADBYTE_STATE_ROOT = $StateRoot',
+    '$env:DEADBYTE_CONTROLLER_CONFIG = $configPath',
+    "$env:DEADBYTE_CONTROLLER_RUNTIME_ROOT = Join-Path $StateRoot 'runtime'",
+    "$powershell = Join-Path $PSHOME 'powershell.exe'",
+    '& $powershell -NoLogo -NoProfile -ExecutionPolicy Bypass -File $controller @ControllerArgs',
+    'exit $LASTEXITCODE',
+    ''
+  ].join('\r\n');
+}