deadbyte-mcp 0.15.60 → 0.15.62

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,6 +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',
@@ -62,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`,
@@ -114,7 +118,7 @@ async function reportVersionCoherence(root,{displayMode='ascii'}={}){
   writeRemote(process.stderr,`${remoteTag('warn',displayMode)} VERSION SKEW: CLI package ${DEADBYTE_VERSION}; active runtime ${active.version} (${active.release_id})\n`,displayMode);
   return active;
 }
-async function synchronizeForegroundRuntime(ctx,{displayMode='unicode',migrationContext=null,hostCommandPin=null}={}){
+async function synchronizeForegroundRuntime(ctx,{displayMode='unicode',migrationContext=null,hostCommandPins=[]}={}){
   const packageManifestSha256=createHash('sha256').update(await readFile(path.join(CURRENT_PACKAGE_ROOT,'MANIFEST.SHA256'))).digest('hex');
   return ensureRuntimeCoherence({
     cliVersion:DEADBYTE_VERSION,
@@ -182,7 +186,7 @@ async function synchronizeForegroundRuntime(ctx,{displayMode='unicode',migration
             '-ExpectedBootstrapSha256',bootstrapMatch[1],
             '-StdoutPath',stdoutPath,'-StderrPath',stderrPath,
             '-MarkerReceiptPath',migrationContext.receipt_path,'-MarkerReceiptSha256',migrationContext.receipt_sha256,
-            ...(hostCommandPin?['-HostCommandPin',hostCommandPin]:[])],{
+            ...(hostCommandPins.length?['-HostCommandPinsJson',encodeHostCommandPins(hostCommandPins)]:[])],{
             cwd:CURRENT_PACKAGE_ROOT,env:windowsPowerShellEnvironment(process.env),encoding:'utf8',windowsHide:true,shell:false,
             timeout:REMOTE_UPDATE_TIMEOUT_MS,maxBuffer:16*1024*1024
           });
@@ -395,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()];
@@ -412,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/);
@@ -512,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');
@@ -588,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};
   }
@@ -691,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};
 }
@@ -744,7 +763,7 @@ async function releaseRemoteSession(ctx,marker,{displayMode='unicode'}={}){
   if(deletePinnedRemoteMarker(remoteSessionMarker(ctx.root),snapshot.sha256)!=='REMOVED')
     throw new Error('remote session ownership marker replaced before native deletion; marker retained');
 }
-async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,filterExpression='',mode='default',hostCommandPin=null}={}){
+async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,filterExpression='',mode='default',hostCommandPins=[]}={}){
   const display=prepareRemoteConsole();
   const displayMode=display.mode;
   const ctx=await remoteContext();
@@ -753,10 +772,12 @@ 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();
-    await synchronizeForegroundRuntime(ctx,{displayMode,migrationContext,hostCommandPin});
+    await synchronizeForegroundRuntime(ctx,{displayMode,migrationContext,hostCommandPins});
     startupLock.assertHeld();
     marker=await claimRemoteSession(ctx);
     startupLock.assertHeld();
@@ -765,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();
@@ -869,17 +890,16 @@ async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,fil
   }
 }
 async function runRemote(args){
-  let verbose=false,trace=false,filterExpression='',resumeCursor=null,mode='default',hostCommandPin=null;
+  let verbose=false,trace=false,filterExpression='',resumeCursor=null,mode='default';
+  const hostCommandPinValues=[];
   const positional=[];
   for(let index=0;index<args.length;index++){
     const arg=args[index];
     if(arg==='--verbose'||arg==='-v'){verbose=true;continue;}
     if(arg==='--trace'){trace=true;continue;}
     if(arg==='--host-command-pin'){
-      if(hostCommandPin!==null)throw new Error('remote --host-command-pin may be specified once');
       const value=String(args[++index]??'');
-      if(!/^powershell_script=[0-9a-f]{64}$/.test(value))throw new Error('remote --host-command-pin requires powershell_script=lowercase_sha256');
-      hostCommandPin=value;continue;
+      hostCommandPinValues.push(value);continue;
     }
     if(['--operator','--desktop','--host','--full'].includes(arg)){
       if(mode!=='default') throw new Error('remote authority modes are mutually exclusive');
@@ -897,8 +917,11 @@ async function runRemote(args){
     }
     positional.push(arg);
   }
-  const presentation=verbose||trace||Boolean(filterExpression)||resumeCursor!==null||mode!=='default'||hostCommandPin!==null;
-  if(positional.length===0){await runRemoteSession({resumeCursor,verbose,trace,filterExpression,mode,hostCommandPin});return;}
+  let hostCommandPins;
+  try{hostCommandPins=normalizeHostCommandPins(hostCommandPinValues);}
+  catch(error){throw new Error(`remote --host-command-pin ${error.message}`);}
+  const presentation=verbose||trace||Boolean(filterExpression)||resumeCursor!==null||mode!=='default'||hostCommandPins.length>0;
+  if(positional.length===0){await runRemoteSession({resumeCursor,verbose,trace,filterExpression,mode,hostCommandPins});return;}
   if(presentation) throw new Error('remote presentation flags are valid only for foreground session');
   if(positional.length>1) throw new Error('remote accepts one controller command');
   const command=positional[0];if(!REMOTE_COMMANDS.has(command)) throw new Error(`unsupported remote command '${command}'`);

package/src/host-command-pins-r154.mjs

@@ -0,0 +1,34 @@
+const PIN=/^([A-Za-z0-9._-]{1,64})=([0-9a-f]{64})$/;
+const LIMIT=16;
+const REPINNABLE=new Set(['powershell_script','powershell_inline','cmd_script','cmd_inline','node_script','node_inline']);
+
+export function normalizeHostCommandPins(values=[]){
+  if(!Array.isArray(values)||values.length>LIMIT)throw new Error(`host command pin limit is ${LIMIT}`);
+  const seen=new Set(),pins=[];
+  for(const value of values){
+    const match=PIN.exec(String(value??''));
+    if(!match)throw new Error('host command pin contract requires command_id=lowercase_sha256');
+    const [,command_id,sha256]=match;
+    if(!REPINNABLE.has(command_id))throw new Error(`host command '${command_id}' is not repinnable`);
+    if(seen.has(command_id))throw new Error(`duplicate host command pin '${command_id}'`);
+    seen.add(command_id);pins.push(Object.freeze({command_id,sha256}));
+  }
+  pins.sort((a,b)=>a.command_id<b.command_id?-1:a.command_id>b.command_id?1:0);
+  return Object.freeze(pins);
+}
+
+export function encodeHostCommandPins(pins=[]){
+  return JSON.stringify(normalizeHostCommandPins(pins.map(pin=>`${pin.command_id}=${pin.sha256}`))
+    .map(pin=>`${pin.command_id}=${pin.sha256}`));
+}
+
+export function decodeHostCommandPins(encoded='[]'){
+  let values;
+  try{values=JSON.parse(String(encoded));}catch{throw new Error('host command pins JSON invalid');}
+  return normalizeHostCommandPins(values);
+}
+
+export function hostCommandPinArgs(pins=[]){
+  return normalizeHostCommandPins(pins.map(pin=>`${pin.command_id}=${pin.sha256}`))
+    .flatMap(pin=>['--host-command-pin',`${pin.command_id}=${pin.sha256}`]);
+}

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');

package/src/remote-live-log.mjs

@@ -53,6 +53,15 @@ const TOOL_ICONS_ASCII=Object.freeze({read:'R',write:'W',edit:'E',run:'>',verify
 const START_VISIBLE_PATTERNS=[/(?:^|_)file_write$/,/text_replace$/,/symbol_replace$/,/native_diff_(?:apply|preview)$/,
   /(?:command|benchmark)_run$/,/task_run$/,/goal_run$/,/goal_submit$/,/goal_approve$/,/process_session_(?:start|action|terminate)$/,/^desktop_action$/];
 
+export function formatRemoteLogResetNotice(file,reason){
+  const name=String(file).split(/[\\/]/).at(-1);
+  const rawReason=sanitizeAuditArgs(typeof reason==='string'?reason:'unknown');
+  const detail=typeof rawReason==='string'?clipped(rawReason,96):'[REDACTED]';
+  if(/^segment-\d{8}\.jsonl$/.test(name))
+    return '[LIVELOG] AUDIT_STREAM_RESET '+name+' — '+detail+'; verify signed audit continuity before trusting timeline coverage';
+  return '[LIVELOG] RUNTIME_LOG_REOPENED '+name+' — '+detail+'; console diagnostic continuity may have gaps; audit verification is separate';
+}
+
 export function selectLiveLogNames({auditNames=[],runtimeNames=[]}={}){
   if(!Array.isArray(auditNames)||!Array.isArray(runtimeNames)) throw new Error('live log names must be arrays');
   const audit=[...new Set(auditNames.filter(name=>typeof name==='string'&&/^segment-\d{8}\.jsonl$/.test(name)))].sort().slice(-2);
@@ -388,13 +397,19 @@ export function createLiveTimelineWriter({stream=process.stdout,displayMode='uni
     retention(){return Object.freeze({congested,suppressed_since_drain:suppressedSinceDrain,total_suppressed:totalSuppressed});}});
 }
 
-export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,foldHeartbeats=false,heartbeatBurstLimit=10,heartbeatWindowMs=3000,displayMode='unicode',rootPaths={},trace=false,slowCallMs=1000}={}){
+export function defaultForegroundTimelineOptions({verbose=false}={}){
+  if(typeof verbose!=='boolean')throw new Error('default live timeline verbosity invalid');
+  return Object.freeze({commanderStyle:!verbose,foldHeartbeats:false});
+}
+
+export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,foldHeartbeats=false,heartbeatBurstLimit=10,heartbeatWindowMs=3000,displayMode='unicode',rootPaths={},trace=false,slowCallMs=1000,commanderStyle=false}={}){
   if(typeof clock!=='function') throw new Error('live timeline clock must be a function');
   if(!REMOTE_DISPLAY_MODES.includes(displayMode)) throw new Error('remote display mode invalid');
   if(!Number.isInteger(heartbeatBurstLimit)||heartbeatBurstLimit<2||heartbeatBurstLimit>100) throw new Error('heartbeatBurstLimit invalid');
   if(!Number.isInteger(heartbeatWindowMs)||heartbeatWindowMs<250||heartbeatWindowMs>60000) throw new Error('heartbeatWindowMs invalid');
   if(!rootPaths||typeof rootPaths!=='object'||Array.isArray(rootPaths)) throw new Error('live timeline rootPaths invalid');
   if(typeof trace!=='boolean') throw new Error('live timeline trace invalid');
+  if(typeof commanderStyle!=='boolean') throw new Error('live timeline commanderStyle invalid');
   if(typeof foldHeartbeats!=='boolean') throw new Error('live timeline foldHeartbeats invalid');
   if(!Number.isInteger(slowCallMs)||slowCallMs<100||slowCallMs>600000) throw new Error('live timeline slowCallMs invalid');
   const pending=new Map();
@@ -443,6 +458,13 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,fo
     const prefixIcon=unknown?(displayMode==='ascii'?'WARN':'⚠️'):null;
     const evidence=receipt?'  '+(displayMode==='ascii'?'RECEIPT':'🧾 receipt')+(displayMode==='ascii'?'=':'=')+receipt:'';
     const reasonSep=displayMode==='ascii'?' - ':' — ';
+    if(commanderStyle){
+      const tag=unknown?'OUTCOME_UNKNOWN':pendingResult?'pending':error?'failed':'completed';
+      const state=rawStatus?' status='+rawStatus:'';
+      return remoteDisplayText('['+displayClock(eventMs(event,clock)).slice(0,8)+'] '+(unknown?'[WARN]':error?'[FAIL]':'[DONE]')+
+        ' Tool call '+displayTool+' '+tag+' ['+shortSpanId(event.request_id)+']'+traceSuffix(span?.trace_meta)+(duration?' '+duration:'')+state+
+        (reason?reasonSep+reason:'')+evidence,displayMode);
+    }
     return remoteDisplayText(eventPrefix(event,sequence,{displayTool,icon:prefixIcon})+traceSuffix(span?.trace_meta)+(summary?'  '+summary:'')+(duration?'  '+duration:'')+slow+'  '+marker+statusDetail+evidence+(reason?reasonSep+reason:''),displayMode);
   }
   function burstLine(value){
@@ -497,6 +519,12 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,fo
       }
       pending.set(requestId,{request_id:requestId,tool,display_tool:displayTool,summary,trace_meta:traceMeta,started_at_ms:clock()});
       peakInFlight=Math.max(peakInFlight,pending.size);
+      if(commanderStyle){
+        const safeArgs=sanitizeAuditArgs(args);
+        const visible=truncateUtf8(canonicalJson(safeArgs),768);
+        return remoteDisplayText('['+displayClock(eventMs(event,clock)).slice(0,8)+'] [CALL] Received tool call ['+
+          shortSpanId(requestId)+'] '+displayTool+traceSuffix(traceMeta)+' Arguments: '+visible,displayMode);
+      }
       if(verbose) return formatRemoteToolCall({...event,tool:displayTool},{clock,displayMode})+traceSuffix(traceMeta);
       if(visibleStart(displayTool)){
         const startMarker=displayMode==='ascii'?'START':'▶ START';
@@ -526,7 +554,7 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,fo
         const snapshot=event.outcome?.snapshot_id,epoch=event.outcome?.state_epoch;
         if(/^[0-9a-f]{64}$/.test(String(snapshot??''))&&Number.isInteger(epoch)&&epoch>0){
           const identity=`${snapshot}:${epoch}`;
-          if(identity===lastCapability){suppressedCapability++;return null;}
+          if(identity===lastCapability&&!commanderStyle){suppressedCapability++;return null;}
           lastCapability=identity;
           const prior=flushBurst();
           const line=resultLine(event,span,sequence)+`  snapshot=${snapshot.slice(0,8)} epoch=${epoch}`;