deadbyte-mcp 0.15.61 → 0.15.62

package/scripts/npm-release-readiness-r163.mjs

@@ -0,0 +1,67 @@
+/** R163 0.15.62 publication fence. No evidence generation or authority mutation. */
+import {createHash} from 'node:crypto';
+import {readFile,lstat} from 'node:fs/promises';
+import path from 'node:path';
+
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const parent='v0.15.61-055d1ff0aa99e60b';
+const parentManifest='055d1ff0aa99e60bbf9e9f136b02ebd4fffb8391712560f7607cff30af94dcdf';
+const parentGen='f940e794daac2dda097a66301c4b85c4b29a2df7c669e549503c05a2a55ff6c4';
+const reject=(m)=>{throw new Error('PUBLISH_BLOCKED R163 '+m);};
+const hex=x=>typeof x==='string'&&/^[0-9a-f]{64}$/.test(x);
+const readJson=async f=>JSON.parse(await readFile(f,'utf8'));
+async function checkedEvidenceFile(file,digest,{allowEmpty=false}={}){
+  if(!hex(digest))reject('missing exact evidence digest');
+  const info=await lstat(file).catch(()=>reject('evidence file missing '+file));
+  if(!info.isFile()||info.isSymbolicLink()||(!allowEmpty&&info.size<1)||info.size>16*1024*1024)reject('invalid evidence file');
+  const bytes=await readFile(file);
+  if(sha(bytes)!==digest)reject('evidence SHA-256 mismatch '+file);
+  return bytes;
+}
+function boundedEvidence(root,relative){
+  if(typeof relative!=='string'||!relative||relative.includes('\\'))reject('invalid evidence relative path');
+  const p=path.resolve(root,relative),r=path.relative(root,p);
+  if(!r||r.startsWith('..')||path.isAbsolute(r))reject('evidence path escape');
+  return p;
+}
+export async function assertR163NpmPublishReady(release,{root,evidenceRoot=process.env.DEADBYTE_R163_CLOSURE_ROOT}={}){
+  if(release?.name!=='deadbyte-mcp'||release?.version!=='0.15.62'||release?.train!=='R160'||release?.r163?.publication_mode!=='PUBLISH_ONLY')reject('release metadata not R163-closed');
+  if(release?.parent?.release_id!==parent||release?.parent?.manifest_sha256!==parentManifest||release?.parent?.generation_manifest_sha256!==parentGen||release?.runtime_predecessor?.release_id!==parent)reject('active predecessor lineage mismatch');
+  if(!root||!path.isAbsolute(root))reject('candidate root missing');
+  if(!evidenceRoot||!path.isAbsolute(evidenceRoot))reject('closure evidence path missing');
+  const testRoot=path.resolve(root,'..','..','testing','r163-release-closure');
+  const evidence=path.resolve(evidenceRoot);
+  const relative=path.relative(testRoot,evidence);
+  if(!relative||relative.startsWith('..')||path.isAbsolute(relative))reject('evidence outside bounded R163 testing root');
+  for(const p of [testRoot,evidence]){const st=await lstat(p).catch(()=>reject('evidence directory absent'));if(!st.isDirectory()||st.isSymbolicLink())reject('evidence directory is reparse/symlink');}
+  const closurePath=path.join(evidence,'closure.json');
+  const closureInfo=await lstat(closurePath).catch(()=>reject('closure missing'));
+  if(!closureInfo.isFile()||closureInfo.isSymbolicLink()||closureInfo.size<1||closureInfo.size>1024*1024)reject('closure file not regular/bounded');
+  const closure=await readJson(closurePath).catch(()=>reject('closure missing/invalid'));
+  if(closure?.schema!=='deadbyte.r163-release-closure.v1'||closure?.version!=='0.15.62'||closure?.status!=='PASS'||closure?.production_release_id!==parent)reject('closure subject/status mismatch');
+  const manifestSha=sha(await readFile(path.join(root,'MANIFEST.SHA256')));
+  if(closure.source_manifest_sha256!==manifestSha)reject('final manifest differs from closure');
+  const files=closure?.files;
+  if(!files||!['protected_receipt','protected_stdout','protected_stderr','verify_receipt','verify_stdout','verify_stderr'].every(k=>files[k]&&typeof files[k].path==='string'&&hex(files[k].sha256)))reject('required receipts missing');
+  const data={};
+  for(const [key,info] of Object.entries(files)) data[key]=await checkedEvidenceFile(boundedEvidence(testRoot,info.path),info.sha256,{allowEmpty:key.endsWith('_stderr')});
+  let protectedReceipt,verifyReceipt;
+  try{protectedReceipt=JSON.parse(data.protected_receipt);verifyReceipt=JSON.parse(data.verify_receipt);}
+  catch{reject('gate receipts invalid JSON');}
+  if(protectedReceipt?.schema!=='deadbyte.r163-protected-windows-gate.v1'||protectedReceipt?.stage!=='full'||protectedReceipt?.exit_code!==0||protectedReceipt?.source_manifest_sha256!==manifestSha||protectedReceipt?.active_release_id!==parent)reject('protected gate missing or unbound');
+  if(protectedReceipt.stdout_sha256!==sha(data.protected_stdout)||protectedReceipt.stderr_sha256!==sha(data.protected_stderr))reject('protected log mismatch');
+  const stdout=data.protected_stdout.toString('utf8');
+  const counts=Object.fromEntries(['tests','pass','fail','skipped'].map(k=>[k,Number(new RegExp('^# '+k+' (\\d+)\\s*$','m').exec(stdout)?.[1]??NaN)]));
+  if(counts.tests<1951||counts.pass<1902||counts.fail!==0||counts.skipped!==49||counts.pass+counts.skipped!==counts.tests||/^not ok\s+\d+/m.test(stdout))reject('full regression totals mismatch');
+  if(!/^ok\s+\d+\s+-\s+R163 isolated immutable slot activates, rolls back, and restores 0\.15\.62/m.test(stdout))reject('R163 live rollback proof missing');
+  const skips=stdout.split(/\r?\n/).filter(x=>/^ok\s+\d+\s+-.*# SKIP/.test(x));
+  if(skips.length!==49||skips.some(x=>!/historical|R35 external semantic backend|POSIX|R100 POSIX/i.test(x)))reject('unexpected unclassified skipped test');
+  if(verifyReceipt?.schema!=='deadbyte.r163-release-verify.v1'||verifyReceipt?.status!=='PASS'||verifyReceipt?.version!=='0.15.62'||verifyReceipt?.source_manifest_sha256!==manifestSha||verifyReceipt?.production_release_id!==parent||verifyReceipt?.exit_code!==0)reject('verify-only receipt subject/status mismatch');
+  if(verifyReceipt.stdout_sha256!==sha(data.verify_stdout)||verifyReceipt.stderr_sha256!==sha(data.verify_stderr))reject('verify-only transcript hash mismatch');
+  const vout=data.verify_stdout.toString('utf8');
+  if(!vout.includes('VERIFY-ONLY PIPELINE PASS')||!vout.includes('Artifact isolation gate PASS')||!vout.includes('VERIFIED_TARBALL '))reject('npm verify-only output missing');
+  const tarLine=vout.split(/\r?\n/).find(x=>x.startsWith('VERIFIED_TARBALL '));
+  try{const p=JSON.parse(tarLine.slice('VERIFIED_TARBALL '.length));if(p.filename!=='deadbyte-mcp-0.15.62.tgz'||!hex(p.sha256)||p.bytes<1)reject('npm tarball identity invalid');}
+  catch{reject('npm tarball evidence invalid');}
+  return Object.freeze({status:'R163_RELEASE_READY_EVIDENCE_BOUND',version:'0.15.62',manifest_sha256:manifestSha,checks:6});
+}

package/src/autonomous-supervisor.mjs

@@ -24,7 +24,7 @@ async function listGoalIds(policy) {
 export function startAutonomousSupervisor({ runtime, policy = runtime?.policy,
   idleDelayMs = 750, maxCycles = 32, logger = console, continuous = true } = {}) {
   if (!runtime || !policy) throw new Error('autonomous supervisor requires runtime + policy');
-  const providerBacked = ['openai_compatible','openai_responses'].includes(policy.planner.backend);
+  const providerBacked = ['openai_compatible','openai_responses','codex_app_server'].includes(policy.planner.backend);
   if (!Number.isInteger(idleDelayMs) || idleDelayMs < 25 || idleDelayMs > 60_000) {
     throw new Error('autonomous supervisor idleDelayMs out of range');
   }
@@ -41,6 +41,10 @@ export function startAutonomousSupervisor({ runtime, policy = runtime?.policy,
     let runnable = 0;
     for (const goalId of await listGoalIds(policy)) {
       if (abort.signal.aborted) break;
+      // A known retry deadline is authoritative until elapsed. Avoid
+      // polling goal state again just to rediscover the same backoff.
+      const pendingRetry=failures.get(goalId);
+      if (pendingRetry && Date.now() < pendingRetry.retry_at) continue;
       let status;
       try { status = await runtime.status({ goalId }); }
       catch (error) { logger.warn?.(`DEADBYTE supervisor status ${goalId}: ${String(error)}`); continue; }
@@ -61,9 +65,10 @@ export function startAutonomousSupervisor({ runtime, policy = runtime?.policy,
           failures.delete(goalId); continue;
         }
       }
-      runnable += 1;
       const failure = failures.get(goalId);
       if (failure && Date.now() < failure.retry_at) continue;
+      // Only an eligible dispatch is runnable. Backoff is not useful work.
+      runnable += 1;
       try {
         const result = await runtime.run({ goalId, maxCycles });
         if (result.status === 'paused' && result.reason === 'provider_circuit_open') {
@@ -89,10 +94,22 @@ export function startAutonomousSupervisor({ runtime, policy = runtime?.policy,
     return runnable;
   }
 
+  // One supervisor, one in-flight scan. A manual scan and the polling
+  // loop must never race to dispatch the same durable goal.
+  let inFlightPass=null;
+  function scanOnce(){
+    if(inFlightPass)return inFlightPass;
+    const task=pass();
+    inFlightPass=task;
+    const clear=()=>{if(inFlightPass===task)inFlightPass=null;};
+    task.then(clear,clear);
+    return task;
+  }
+
   const done = continuous ? (async () => {
     while (!abort.signal.aborted) {
       let runnable = 0;
-      try { runnable = await pass(); }
+      try { runnable = await scanOnce(); }
       catch (error) { logger.error?.(`DEADBYTE supervisor scan failed: ${String(error)}`); }
       if (abort.signal.aborted) break;
       await delay(runnable > 0 ? 25 : idleDelayMs, abort.signal);
@@ -103,7 +120,7 @@ export function startAutonomousSupervisor({ runtime, policy = runtime?.policy,
     get running() { return !abort.signal.aborted; },
     get passes() { return passes; },
     failures,
-    async scanNow() { return pass(); },
+    async scanNow() { return scanOnce(); },
     async stop() { abort.abort(); await done; }
   });
 }

package/src/deadbyte-cli.mjs

@@ -16,7 +16,7 @@ import { exportOfflineDiagnostics } from './r67-diagnostic-export.mjs';
 import { verifyOfflineDiagnosticsZip } from './r67-diagnostics-verify.mjs';
 import { parseActivePointer } from './release-slot.mjs';
 import { printDoctor } from './doctor-r45.mjs';
-import { classifyRemoteAuditOutcome, createLiveTimelineFilter, createLiveTimelineTracker, createLiveTimelineWriter, formatCompactAuditEvent, formatRemoteLifecycle, formatRemoteToolCall, formatRuntimeDiagnosticLine, selectLiveLogNames } from './remote-live-log.mjs';
+import { classifyRemoteAuditOutcome, createLiveTimelineFilter, createLiveTimelineTracker, createLiveTimelineWriter, defaultForegroundTimelineOptions, formatRemoteLogResetNotice, formatCompactAuditEvent, formatRemoteLifecycle, formatRemoteToolCall, formatRuntimeDiagnosticLine, selectLiveLogNames } from './remote-live-log.mjs';
 import { prepareRemoteConsole, remoteDisplayText } from './remote-console.mjs';
 import { ensureRuntimeCoherence } from './runtime-coherence.mjs';
 import { windowsPowerShellEnvironment } from './runtime-update.mjs';
@@ -27,7 +27,9 @@ import {acquireForegroundSessionLock} from './foreground-session-lock.mjs';
 import { AUTHORITY_PLANES, authorityVector, authorityRestorePlan, parseAuthorityObservation, assertAuthorityVector, assertRuntimeReadyObservation, authorityBanner } from './remote-authority.mjs';
 import { decodeRemoteLogBytes, boundedRemoteDiagnostic, readRemoteLogAppend } from './remote-log-decode-r60.mjs';
 import {reconcileStaleMarker,resumeMarkerReconciliation,recoverPublishedMarkerTerminal} from './clean-activation-recovery-r153.mjs';
+import {selectLegacyMarkerEvidence,verifyLocatedLegacyMarkerReceipt} from './legacy-marker-evidence-r159.mjs';
 import {normalizeHostCommandPins,encodeHostCommandPins} from './host-command-pins-r154.mjs';
+import {verifyPackageDecisionManifest} from './package-identity-r160.mjs';
 
 const REMOTE_COMMANDS=new Set([
   'menu','start','resume','park','stop','restart','status','url','test','fulltest','toggle','clean','machinetest',
@@ -63,6 +65,7 @@ function printHelp(){
     `  npx -y ${exact} remote --full       # explicit five-plane foreground session`,
     `  npx -y ${exact} remote --resume <cursor> # replay missed results, then reconnect`,
     `  npx -y ${exact} remote --trace           # show trace/span identity without payload detail`,
+ 
     `  npx -y ${exact} remote --filter <expr>   # presentation filter: tool/category/status/trace`,
     `  npx -y ${exact} remote status`,
     `  npx -y ${exact} remote restart`,
@@ -396,7 +399,7 @@ function timelineFilterEvent(timeline){
 async function tailRemoteLogs(root,signal,{journal=null,offsets=null,activityTracker=null,timelineFilter=null,timelineWriter=null,verbose=false,displayMode='unicode'}={}){
   process.stdout.write(verbose
     ? '[LOG] Verbose live timeline. Full sanitized request detail enabled; Ctrl+C disconnects and revokes authority.\n'
-    : '[LOG] Human live timeline. Transport IN/OUT hidden; full replay/audit detail remains on disk. START/DONE retained; heartbeat bursts folded; Ctrl+C disconnects and revokes authority.\n');
+    : '[LOG] Live tool calls with individual START/DONE, sanitized arguments and results. Transport hidden; signed audit remains on disk. Ctrl+C disconnects and revokes authority.\n');
   const activeOffsets=offsets??await snapshotRemoteLogOffsets(root);
   const partialLines=new Map();
   let liveFiles=[...activeOffsets.keys()];
@@ -413,7 +416,7 @@ async function tailRemoteLogs(root,signal,{journal=null,offsets=null,activityTra
       activeOffsets.set(file,next.cursor);
       if(next.reset){
         partialLines.delete(file);
-        process.stderr.write('[LIVELOG] STREAM_RESET '+path.basename(file)+' — '+next.resetReason+'; check audit continuity before trusting coverage\n');
+        process.stderr.write(formatRemoteLogResetNotice(file,next.resetReason)+'\n');
       }
       if(!next.text)continue;
       const lines=((partialLines.get(file)??'')+next.text).split(/\r?\n/);
@@ -513,64 +516,79 @@ async function publishExclusiveJson(file,value){
   }
   return {path:file,sha256:createHash('sha256').update(bytes).digest('hex')};
 }
+async function readMarkerRecoveryAuthority(ctx,active){
+  const grantField={process:'grant_file',coding:'lease_file',autonomous:'lease_file',desktop:'grant_file',host:'arm_file'};
+  const policySha256={},grantPresence={};
+  for(const plane of AUTHORITY_PLANES){
+    const policyFile=path.join(active.generation_root,`${plane}-policy.json`),info=await lstat(policyFile);
+    if(!info.isFile()||info.isSymbolicLink()||path.resolve(path.dirname(policyFile)).toLowerCase()!==path.resolve(active.generation_root).toLowerCase())
+      throw new Error(`marker reconciliation ${plane} policy identity invalid`);
+    const bytes=await readFile(policyFile),policy=JSON.parse(bytes.toString('utf8').replace(/^\uFEFF/,''));
+    policySha256[plane]=createHash('sha256').update(bytes).digest('hex');
+    const grant=policy?.[grantField[plane]];
+    if(typeof grant!=='string'||!path.isAbsolute(grant)||
+      path.resolve(path.dirname(grant)).toLowerCase()!==path.resolve(ctx.root,'runtime').toLowerCase())
+      throw new Error(`marker reconciliation ${plane} grant path invalid`);
+    try{await lstat(grant);grantPresence[plane]=true;}
+    catch(error){if(error?.code==='ENOENT')grantPresence[plane]=false;else throw error;}
+  }
+  return {policySha256,grantPresence};
+}
 async function recoverRemoteSession(ctx,{displayMode='unicode'}={}){
   let prior=await readRemoteSessionMarker(ctx.root);
   const evidenceDir=path.join(ctx.root,'evidence','legacy-migration');
-  const locatorPath=path.join(evidenceDir,'r153-pending-migration.json');
   if(!prior){
-    try{
-      const locator=JSON.parse(await readFile(locatorPath,'utf8'));
-      if(locator?.schema!=='deadbyte.r153-pending-migration.v1'||
-        typeof locator.receipt_path!=='string'||!path.isAbsolute(locator.receipt_path)||
-        path.resolve(path.dirname(locator.receipt_path)).toLowerCase()!==path.resolve(evidenceDir).toLowerCase()||
-        !/^[0-9a-f]{64}$/.test(String(locator.receipt_sha256??'')))throw new Error('pending migration locator invalid');
-      const bytes=await readFile(locator.receipt_path);
-      if(createHash('sha256').update(bytes).digest('hex')!==locator.receipt_sha256)
-        throw new Error('pending migration receipt hash mismatch');
-      return {state:'MARKER_RECONCILED',receipt_path:locator.receipt_path,
-        receipt_sha256:locator.receipt_sha256};
-    }catch(error){if(error?.code!=='ENOENT')throw error;}
+    const activePointer=await readActiveRuntimeBinding(ctx.root);
+    // A historical terminal is not an uncompleted migration. Ignore only
+    // when the installed release identity matches the CLI's manifest identity;
+    // this path grants no authority and publishes no recovery evidence.
+    const currentManifestSha256=createHash('sha256').update(
+      await readFile(path.join(CURRENT_PACKAGE_ROOT,'MANIFEST.SHA256'))).digest('hex');
+    const historyAllowed=activePointer?.version===DEADBYTE_VERSION&&
+      activePointer?.manifest_sha256===currentManifestSha256&&
+      activePointer?.release_id===('v'+DEADBYTE_VERSION+'-'+currentManifestSha256.slice(0,16));
+    const selected=await selectLegacyMarkerEvidence({evidenceDir,activePointer,
+      allowCompletedHistory:historyAllowed});
+    if(selected.kind==='none')return null;
+    if(selected.kind==='completed_history_ambiguous'){
+      if(!historyAllowed)throw new Error('R159 completed history cannot be reused across a release change');
+      // Nothing is pending: do not select an arbitrary completed receipt.
+      // A future upgrade still requires its own exact signed migration proof.
+      return null;
+    }
+    if(selected.kind==='located'){
+      const readback=await readActiveRuntimeBinding(ctx.root);
+      for(const key of ['release_id','version','manifest_sha256','generation_manifest_sha256'])
+        if(readback?.[key]!==activePointer?.[key])
+          throw new Error('R159 active release changed during located marker verification');
+      const {policySha256}=await readMarkerRecoveryAuthority(ctx,readback);
+      const verified=await verifyLocatedLegacyMarkerReceipt({located:selected,pointer:readback,policySha256});
+      const finalPointer=await readActiveRuntimeBinding(ctx.root);
+      for(const key of ['release_id','version','manifest_sha256','generation_manifest_sha256'])
+        if(finalPointer?.[key]!==readback?.[key])
+          throw new Error('R160 active release changed after located marker verification');
+      return verified;
+    }
+    // Completed historical receipts are not a pending migration for an
+    // already-online current release. Keep bytes and their SHA untouched.
+    if(selected.kind==='completed'&&observedAuthority(ctx).state==='ONLINE')return null;
+    if(selected.kind==='pending'&&observedAuthority(ctx).state!=='OFFLINE')
+      throw new Error('R159 pending marker reconciliation requires an offline runtime');
     // Crash recovery for the narrow window after marker CAS deletion and
     // before terminal receipt publication. Never infer completion from the
     // missing marker alone: require exactly one durable intent and re-observe
     // the full predecessor/policy/grant/runtime subject.
-    let entries=[];
-    try{entries=await readdir(evidenceDir,{withFileTypes:true});}
-    catch(error){if(error?.code==='ENOENT')return null;throw error;}
-    const candidates=[];
-    for(const entry of entries){
-      const match=/^marker-([0-9a-f]{64})\.intent\.json$/.exec(entry.name);
-      if(!match||!entry.isFile())continue;
-      const terminal=path.join(evidenceDir,`marker-${match[1]}.terminal.json`);
-      let terminalExists=true;
-      try{await lstat(terminal);}
-      catch(error){if(error?.code==='ENOENT')terminalExists=false;else throw error;}
-      candidates.push({markerSha256:match[1],intent:path.join(evidenceDir,entry.name),terminal,terminalExists});
-    }
-    if(candidates.length===0)return null;
-    if(candidates.length!==1)throw new Error('multiple unlocated marker reconciliation claims; manual reconciliation required');
-    const pending=candidates[0],intentInfo=await lstat(pending.intent);
+    const pending=selected.pending,intentInfo=await lstat(selected.pending.intent);
     if(!intentInfo.isFile()||intentInfo.isSymbolicLink())throw new Error('marker reconciliation intent is not a regular file');
     const intentBytes=await readFile(pending.intent),intent=JSON.parse(intentBytes.toString('utf8').replace(/^\uFEFF/,''));
     if(intent.marker_sha256!==pending.markerSha256)throw new Error('marker reconciliation intent filename identity mismatch');
     const active=await readActiveRuntimeBinding(ctx.root);
     if(!active)throw new Error('marker reconciliation predecessor pointer missing');
+    for(const key of ['release_id','version','manifest_sha256','generation_manifest_sha256'])
+      if(active[key]!==activePointer?.[key])
+        throw new Error('R159 active release changed during marker recovery');
     const observed=observedAuthority(ctx);
-    const grantField={process:'grant_file',coding:'lease_file',autonomous:'lease_file',desktop:'grant_file',host:'arm_file'};
-    const policySha256={},grantPresence={};
-    for(const plane of AUTHORITY_PLANES){
-      const policyFile=path.join(active.generation_root,`${plane}-policy.json`),info=await lstat(policyFile);
-      if(!info.isFile()||info.isSymbolicLink()||path.resolve(path.dirname(policyFile)).toLowerCase()!==path.resolve(active.generation_root).toLowerCase())
-        throw new Error(`marker reconciliation ${plane} policy identity invalid`);
-      const bytes=await readFile(policyFile),policy=JSON.parse(bytes.toString('utf8').replace(/^\uFEFF/,''));
-      policySha256[plane]=createHash('sha256').update(bytes).digest('hex');
-      const grant=policy?.[grantField[plane]];
-      if(typeof grant!=='string'||!path.isAbsolute(grant)||
-        path.resolve(path.dirname(grant)).toLowerCase()!==path.resolve(ctx.root,'runtime').toLowerCase())
-        throw new Error(`marker reconciliation ${plane} grant path invalid`);
-      try{await lstat(grant);grantPresence[plane]=true;}
-      catch(error){if(error?.code==='ENOENT')grantPresence[plane]=false;else throw error;}
-    }
+    const {policySha256,grantPresence}=await readMarkerRecoveryAuthority(ctx,active);
     if(await readRemoteMarkerSnapshot(remoteSessionMarker(ctx.root))!==null)
       throw new Error('marker reconciliation marker reappeared');
     const intentSha256=createHash('sha256').update(intentBytes).digest('hex');
@@ -589,7 +607,7 @@ async function recoverRemoteSession(ctx,{displayMode='unicode'}={}){
     }
     const locator={schema:'deadbyte.r153-pending-migration.v1',receipt_path:pending.terminal,
       receipt_sha256:reconciled.receipt_sha256,marker_sha256:reconciled.marker_sha256};
-    await publishExclusiveJson(locatorPath,locator);
+    await publishExclusiveJson(path.join(evidenceDir,'marker-'+reconciled.marker_sha256+'.locator.json'),locator);
     writeRemote(process.stdout,`${remoteTag('recovery',displayMode)} Interrupted marker reconciliation completed (${reconciled.marker_sha256.slice(0,12)}).\n`,displayMode);
     return {...reconciled,receipt_path:pending.terminal};
   }
@@ -692,7 +710,7 @@ async function recoverRemoteSession(ctx,{displayMode='unicode'}={}){
     deleteIfHash:async expected=>deletePinnedRemoteMarker(markerPath,expected)});
   const locator={schema:'deadbyte.r153-pending-migration.v1',receipt_path:terminalPath,
     receipt_sha256:reconciled.receipt_sha256,marker_sha256:reconciled.marker_sha256};
-  await publishExclusiveJson(locatorPath,locator);
+  await publishExclusiveJson(path.join(evidenceDir,'marker-'+reconciled.marker_sha256+'.locator.json'),locator);
   writeRemote(process.stdout,`${remoteTag('recovery',displayMode)} Stale session evidence reconciled (${reconciled.marker_sha256.slice(0,12)}).\n`,displayMode);
   return {...reconciled,receipt_path:terminalPath};
 }
@@ -754,6 +772,8 @@ async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,fil
   const startupLock=await acquireForegroundSessionLock({root:ctx.root,powershell:ctx.powershell});
   let marker;
   try{
+    startupLock.assertHeld();
+    await verifyPackageDecisionManifest({root:CURRENT_PACKAGE_ROOT,expectedVersion:DEADBYTE_VERSION});
     startupLock.assertHeld();
     const migrationContext=await recoverRemoteSession(ctx,{displayMode});
     startupLock.assertHeld();
@@ -766,7 +786,7 @@ async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,fil
     filePath:remoteResultJournalPath(ctx.root,marker.result_session_id),sessionId:marker.result_session_id,maxEntries:2048
   });
   const rootPaths=await readLiveRootPaths(ctx.root);
-  const activityTracker=createLiveTimelineTracker({verbose,displayMode,rootPaths,trace,foldHeartbeats:!verbose});
+  const activityTracker=createLiveTimelineTracker({verbose,displayMode,rootPaths,trace,...defaultForegroundTimelineOptions({verbose})});
   const timelineFilter=filterExpression?createLiveTimelineFilter(filterExpression):null;
   const timelineWriter=createLiveTimelineWriter({stream:process.stdout,displayMode,rewrite:false});
   const aborter=new AbortController();

package/src/legacy-marker-evidence-r159.mjs

@@ -0,0 +1,128 @@
+import {readdir,lstat,readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {createHash} from 'node:crypto';
+import {verifyMarkerReconciliationReceipt} from './clean-activation-recovery-r153.mjs';
+
+const H=/^[0-9a-f]{64}$/;
+const digest=b=>createHash('sha256').update(b).digest('hex');
+function samePredecessor(a,b){
+  return !!a&&!!b&&['release_id','version','manifest_sha256','generation_manifest_sha256']
+    .every(k=>typeof a[k]==='string'&&a[k]===b[k]);
+}
+async function regular(file){
+  const st=await lstat(file);
+  if(!st.isFile()||st.isSymbolicLink())throw new Error('R159 evidence file must be regular and not a link');
+}
+function strictJson(bytes,label){
+  let result;
+  try{result=JSON.parse(bytes.toString('utf8').replace(/^\uFEFF/,''));}
+  catch{throw new Error('R159 '+label+' invalid JSON');}
+  if(!result||typeof result!=='object'||Array.isArray(result))
+    throw new Error('R159 '+label+' invalid object');
+  return result;
+}
+// Examine ONLY local immutable receipt candidates. It must never infer a live
+// process state, delete a marker, grant an authority plane, or mutate evidence.
+export async function selectLegacyMarkerEvidence({evidenceDir,activePointer,allowCompletedHistory=false}){
+  if(typeof evidenceDir!=='string'||!path.isAbsolute(evidenceDir))
+    throw new Error('R159 evidence root must be absolute');
+  let entries;
+  try{entries=await readdir(evidenceDir,{withFileTypes:true});}
+  catch(e){if(e?.code==='ENOENT')return {kind:'none'};throw e;}
+  if(entries.length>4096)throw new Error('R159 evidence inventory exceeds bounded scan');
+  const fileSet=new Map(entries.map(e=>[e.name,e]));
+  const locatorPath=path.join(evidenceDir,'r153-pending-migration.json');
+  let located=null;
+  const locatorEntry=fileSet.get('r153-pending-migration.json');
+  if(locatorEntry){
+    if(!locatorEntry.isFile()||locatorEntry.isSymbolicLink())
+      throw new Error('R159 locator is not regular');
+    await regular(locatorPath);
+    const locator=strictJson(await readFile(locatorPath),'legacy locator');
+    if(locator.schema!=='deadbyte.r153-pending-migration.v1'||
+        !H.test(String(locator.marker_sha256??''))||
+        !H.test(String(locator.receipt_sha256??''))||
+        typeof locator.receipt_path!=='string')
+      throw new Error('R159 legacy locator schema invalid');
+    const expected=path.join(evidenceDir,'marker-'+locator.marker_sha256+'.terminal.json');
+    if(path.resolve(locator.receipt_path).toLowerCase()!==path.resolve(expected).toLowerCase())
+      throw new Error('R159 legacy locator receipt path mismatch');
+    await regular(expected);
+    const raw=await readFile(expected);
+    if(digest(raw)!==locator.receipt_sha256)
+      throw new Error('R159 legacy locator receipt hash mismatch');
+    const terminal=strictJson(raw,'located terminal');
+    if(terminal.schema!=='deadbyte.r153-marker-reconciliation.v1'||
+       terminal.state!=='MARKER_RECONCILED'||terminal.marker_sha256!==locator.marker_sha256)
+      throw new Error('R159 located terminal identity mismatch');
+    if(samePredecessor(terminal.predecessor,activePointer))
+      located={kind:'located',receiptPath:expected,receiptSha256:locator.receipt_sha256,
+        markerSha256:locator.marker_sha256};
+  }
+  const candidates=[];
+  for(const entry of entries){
+    const match=/^marker-([a-f0-9]{64})\.intent\.json$/.exec(entry.name);
+    if(!match)continue;
+    if(!entry.isFile()||entry.isSymbolicLink())throw new Error('R159 intent is not regular');
+    const intent=path.join(evidenceDir,entry.name);
+    await regular(intent);
+    const intentBytes=await readFile(intent),value=strictJson(intentBytes,'recovery intent');
+    if(value.schema!=='deadbyte.r153-marker-reconciliation-intent.v1'||
+       value.state!=='RECONCILIATION_CLAIMED'||value.marker_sha256!==match[1])
+      throw new Error('R159 intent filename/identity mismatch');
+    if(!samePredecessor(value.predecessor,activePointer))continue;
+    const terminal=path.join(evidenceDir,'marker-'+match[1]+'.terminal.json');
+    const terminalEntry=fileSet.get(path.basename(terminal));
+    let terminalExists=false;
+    if(terminalEntry){
+      if(!terminalEntry.isFile()||terminalEntry.isSymbolicLink())
+        throw new Error('R159 terminal is not regular');
+      await regular(terminal);
+      const parsed=strictJson(await readFile(terminal),'current terminal');
+      if(parsed.schema!=='deadbyte.r153-marker-reconciliation.v1'||
+         parsed.state!=='MARKER_RECONCILED'||parsed.marker_sha256!==match[1]||
+         parsed.intent_sha256!==digest(intentBytes)||
+         !samePredecessor(parsed.predecessor,activePointer))
+        throw new Error('R159 current terminal intent/subject mismatch');
+      terminalExists=true;
+    }
+    candidates.push({markerSha256:match[1],intent,terminal,terminalExists});
+  }
+  const pending=candidates.filter(c=>!c.terminalExists);
+  if(pending.length>1)throw new Error('R159 multiple matching pending reconciliation claims; manual reconciliation required');
+  if(pending.length===1)return {kind:'pending',pending:pending[0]};
+  if(located){
+    const other=candidates.filter(c=>c.markerSha256!==located.markerSha256);
+    if(other.length)throw new Error('R159 ambiguous multiple current reconciliation receipts');
+    return located;
+  }
+  const completed=candidates.filter(c=>c.terminalExists);
+  if(completed.length>1){
+    // Keep the original fail-closed default. A caller that independently
+    // verifies it is already running the exact installed release may choose
+    // not to reuse any fully completed receipts for a new startup.
+    if(allowCompletedHistory===true)
+      return {kind:'completed_history_ambiguous',count:completed.length};
+    throw new Error('R159 ambiguous multiple completed reconciliation receipts');
+  }
+  if(completed.length===1)return {kind:'completed',pending:completed[0]};
+  return {kind:'none'};
+}
+
+// Selection proves only that the locator and terminal bytes are internally
+// consistent. Adoption is a separate boundary: reread the terminal and bind
+// its R153 proof to the currently observed predecessor and policy generation.
+export async function verifyLocatedLegacyMarkerReceipt({located,pointer,policySha256}){
+  if(located?.kind!=='located'||typeof located.receiptPath!=='string'||
+      !H.test(String(located.receiptSha256??''))||!H.test(String(located.markerSha256??'')))
+    throw new Error('R160 located receipt selection invalid');
+  await regular(located.receiptPath);
+  const raw=await readFile(located.receiptPath);
+  if(digest(raw)!==located.receiptSha256)
+    throw new Error('R160 located terminal changed after selection');
+  const terminal=strictJson(raw,'located terminal readback');
+  verifyMarkerReconciliationReceipt(terminal,{pointer,policySha256,
+    markerSha256:located.markerSha256});
+  return Object.freeze({...terminal,receipt_path:located.receiptPath,
+    receipt_sha256:located.receiptSha256});
+}

package/src/package-identity-r160.mjs

@@ -0,0 +1,61 @@
+import {createHash} from 'node:crypto';
+import {lstat,readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {parseManifest} from './release-slot.mjs';
+
+const SEMVER=/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+export const R160_STARTUP_DECISION_FILES=Object.freeze([
+  'package.json',
+  'src/package-identity-r160.mjs',
+  'src/deadbyte-cli.mjs',
+  'src/legacy-marker-evidence-r159.mjs',
+  'src/clean-activation-recovery-r153.mjs',
+  'src/runtime-coherence.mjs',
+  'src/runtime-update.mjs',
+  'src/release-generation.mjs',
+  'src/release-slot.mjs',
+  'src/remote-authority.mjs',
+  'src/foreground-session-lock.mjs',
+  'src/foreground-marker-cas-win32.mjs',
+  'src/windows-powershell-environment.mjs',
+  'src/state-root.mjs'
+]);
+
+async function regularUnder(root,rel){
+  const absolute=path.resolve(root,...rel.split('/'));
+  const boundary=path.relative(root,absolute);
+  if(boundary.startsWith(`..${path.sep}`)||path.isAbsolute(boundary))
+    throw new Error(`startup decision path escapes package: ${rel}`);
+  let cursor=path.resolve(root);
+  for(const part of rel.split('/')){
+    cursor=path.join(cursor,part);
+    const stat=await lstat(cursor);
+    if(stat.isSymbolicLink())throw new Error(`startup decision link forbidden: ${rel}`);
+  }
+  const stat=await lstat(absolute);
+  if(!stat.isFile())throw new Error(`startup decision file invalid: ${rel}`);
+  return absolute;
+}
+
+export async function verifyPackageDecisionManifest({root,expectedVersion}){
+  if(typeof root!=='string'||!path.isAbsolute(root))throw new Error('startup package root invalid');
+  if(!SEMVER.test(String(expectedVersion??'')))throw new Error('startup package version invalid');
+  const resolved=path.resolve(root),rootStat=await lstat(resolved);
+  if(!rootStat.isDirectory()||rootStat.isSymbolicLink())throw new Error('startup package root must be a real directory');
+  const manifestPath=await regularUnder(resolved,'MANIFEST.SHA256');
+  const manifestBytes=await readFile(manifestPath),manifest=parseManifest(manifestBytes.toString('utf8'));
+  for(const rel of R160_STARTUP_DECISION_FILES){
+    const expected=manifest.get(rel);
+    if(!expected)throw new Error(`startup decision manifest missing: ${rel}`);
+    const actual=sha(await readFile(await regularUnder(resolved,rel)));
+    if(actual!==expected)throw new Error(`startup decision file hash mismatch: ${rel}`);
+  }
+  const pkg=JSON.parse(await readFile(path.join(resolved,'package.json'),'utf8'));
+  if(pkg?.name!=='deadbyte-mcp'||pkg?.version!==expectedVersion)
+    throw new Error('startup package identity mismatch');
+  return Object.freeze({files:R160_STARTUP_DECISION_FILES.length,
+    manifest_sha256:sha(manifestBytes),version:expectedVersion});
+}
+

package/src/release-generation.mjs

@@ -185,6 +185,10 @@ function renderControllerConfig({currentConfig,coreRoot,workspaceRoot,processPol
   const supervisor=currentConfig.Supervisor??{},bridge=currentConfig.Bridge??{},cloud=currentConfig.Cloud??{};
   return [
     '@{',"    Schema = 'deadbyte.controller.v1'",`    CoreRoot = ${psQuote(coreRoot)}`,
+    // A pre-provisioned, OS-owned exact release copy; never auto-discover
+    // an unverified directory or grant authority while creating a generation.
+    ...(typeof currentConfig.AuthorityEpochRoot==='string'&&currentConfig.AuthorityEpochRoot.length>0
+      ?[`    AuthorityEpochRoot = ${psQuote(currentConfig.AuthorityEpochRoot)}`]:[]),
     `    WorkspaceRoot = ${psQuote(workspaceRoot)}`,
     `    MachineRuntimeEnabled = ${psBool(currentConfig.MachineRuntimeEnabled!==false)}`,
     `    AgentRuntimeEnabled = ${psBool(currentConfig.AgentRuntimeEnabled)}`,
@@ -270,6 +274,13 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
   }
   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');
+  // Legacy generations omit Epoch binding. Present values must be explicit
+  // Windows drive-absolute paths, never an implicit writable source.
+  const epochRoot=currentConfig.AuthorityEpochRoot;
+  if(epochRoot!==undefined&&(typeof epochRoot!=='string'||!/^[A-Za-z]:[\\/]/.test(epochRoot)||
+      !path.win32.isAbsolute(epochRoot)||epochRoot.includes('\0')||
+      path.win32.parse(epochRoot).root.toLowerCase()===path.win32.normalize(epochRoot).toLowerCase()))
+    throw new Error('generation AuthorityEpochRoot must be a Windows drive-absolute directory');
   const semanticSource=String(currentConfig.SemanticLspConfigFile??'');
   const semanticExpected=String(currentConfig.SemanticLspConfigSha256??'').toLowerCase();
   if(Boolean(semanticSource)!==Boolean(semanticExpected)) throw new Error('generation semantic LSP config path/SHA must be supplied together');
@@ -316,6 +327,8 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
     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),
     semantic_lsp_config_sha256:semanticConfigSha256,
+    // Changing a protected code origin changes this immutable generation.
+    ...(epochRoot!==undefined?{authority_epoch_root:epochRoot}:{}),
     process_policy_sha256:processBytes?sha256(processBytes):null,
     desktop_policy_sha256:desktopBytes?sha256(desktopBytes):null,
     coding_policy_sha256:sha256(codingBytes),autonomous_policy_sha256:sha256(autonomousBytes),host_policy_sha256:hostBytes?sha256(hostBytes):null

package/src/release-slot.mjs

@@ -205,8 +205,9 @@ export function renderStableLauncherCmd(){
   return [
     '@echo off',
     'setlocal EnableExtensions DisableDelayedExpansion',
+    'if not defined SystemRoot exit /b 1',
     'if not defined DEADBYTE_STATE_ROOT set "DEADBYTE_STATE_ROOT=%USERPROFILE%\\.deadbyte-mcp"',
-    'powershell.exe -NoLogo -NoProfile -ExecutionPolicy Bypass -File "%DEADBYTE_STATE_ROOT%\\bin\\DEADBYTE-MCP.ps1" %*',
+    '"%SystemRoot%\\System32\\WindowsPowerShell\\v1.0\\powershell.exe" -NoLogo -NoProfile -ExecutionPolicy Bypass -File "%DEADBYTE_STATE_ROOT%\\bin\\DEADBYTE-MCP.ps1" %*',
     'exit /b %ERRORLEVEL%',
     ''
   ].join('\r\n');