deadbyte-mcp 0.15.68 → 0.15.70

package/src/r186-owner-anchor.mjs

@@ -0,0 +1,12 @@
+import {createHash,createPublicKey} from 'node:crypto';
+
+export function createR186OwnerAnchor(publicKeyPem){
+ if(typeof publicKeyPem!=='string'||publicKeyPem.length<32||publicKeyPem.length>8192||/PRIVATE KEY/.test(publicKeyPem))
+  throw new Error('R186 owner enrollment requires a public PEM only');
+ let key;try{key=createPublicKey(publicKeyPem);}catch{throw new Error('R186 owner public key invalid');}
+ if(key.asymmetricKeyType!=='ed25519')throw new Error('R186 owner public key must be Ed25519');
+ const canonicalPem=key.export({type:'spki',format:'pem'}).toString();
+ const owner_key_id=createHash('sha256').update(key.export({type:'spki',format:'der'})).digest('hex');
+ return Object.freeze({anchor:Object.freeze({schema:'deadbyte.r186-owner-anchor.v1',owner_key_id}),
+  public_key_pem:canonicalPem});
+}

package/src/r186-owner-consent-preflight.mjs

@@ -0,0 +1,63 @@
+// R186: only a read-only verifier for independently enrolled owner consent.
+// A successful result MUST NOT be treated as an Autonomous grant. The caller
+// must separately prove protected enrollment, single-use consumption and epoch.
+import {createHash,createPublicKey} from 'node:crypto';
+import path from 'node:path';
+import {verifyProjectOwnerApproval} from './r70-owner-approval.mjs';
+
+const SHA=/^[0-9a-f]{64}$/;
+function exact(value,fields,label){
+ if(!value||typeof value!=='object'||Array.isArray(value)||
+    Object.keys(value).length!==fields.length||
+    fields.some(field=>!Object.hasOwn(value,field)))
+   throw new Error('R186 '+label+' invalid');
+}
+export async function verifyR186OwnerConsent({ownerTrust,ownerPublicKeyPem,approval,expected,now=new Date()}={}){
+ exact(ownerTrust,['schema','owner_key_id'],'owner anchor');
+ if(ownerTrust.schema!=='deadbyte.r186-owner-anchor.v1'||
+    typeof ownerTrust.owner_key_id!=='string'||!SHA.test(ownerTrust.owner_key_id))
+   throw new Error('R186 owner anchor schema or fingerprint invalid');
+ if(typeof ownerPublicKeyPem!=='string'||ownerPublicKeyPem.length>8192)
+   throw new Error('R186 owner anchor public key invalid');
+ let pub;
+ try{pub=createPublicKey(ownerPublicKeyPem);}catch{throw new Error('R186 owner anchor public key invalid');}
+ if(pub.asymmetricKeyType!=='ed25519')throw new Error('R186 owner anchor must be Ed25519');
+ const keySha=createHash('sha256').update(pub.export({type:'spki',format:'der'})).digest('hex');
+ if(ownerTrust.owner_key_id!==keySha)
+   throw new Error('R186 owner anchor public key mismatch');
+ const approved=await verifyProjectOwnerApproval({approval,ownerPublicKey:pub,expected,now});
+ return Object.freeze({status:'verified_readonly',authority_granted:false,
+  owner_key_id:keySha,subject_sha256:approved.subject_sha256,
+  root_id:approved.root_id,project_root:approved.project_root,
+  expires_at_utc:approved.expires_at_utc,
+  next_gate:'PROTECTED_OWNER_ENROLLMENT_AND_SINGLE_USE_EPOCH_ISSUANCE_REQUIRED'});
+}
+
+export function verifyR186PolicyRootBinding({
+ codingPolicy,autonomousPolicy,rootId,projectRoot,codingPolicySha256
+}={}){
+ if(!codingPolicy||typeof codingPolicy!=='object'||
+    codingPolicy.schema!=='deadbyte.coding-policy.v1'||codingPolicy.enabled!==true)
+  throw new Error('R186 coding policy schema invalid');
+ if(!autonomousPolicy||typeof autonomousPolicy!=='object'||
+    autonomousPolicy.schema!=='deadbyte.autonomous-policy.v1'||autonomousPolicy.enabled!==true)
+  throw new Error('R186 autonomous policy schema invalid');
+ if(typeof rootId!=='string'||!/^[A-Za-z0-9._-]{1,64}$/.test(rootId)||
+    !Array.isArray(autonomousPolicy.root_ids)||
+    autonomousPolicy.root_ids.length!==1||autonomousPolicy.root_ids[0]!==rootId)
+  throw new Error('R186 Autonomous root vector exceeds owner-reviewed scope');
+ if(typeof codingPolicySha256!=='string'||!SHA.test(codingPolicySha256)||
+    autonomousPolicy.coding_policy_sha256!==codingPolicySha256)
+  throw new Error('R186 coding-policy digest binding mismatch');
+ const bound=codingPolicy.roots?.[rootId]?.path;
+ if(typeof bound!=='string'||typeof projectRoot!=='string'||
+    !path.win32.isAbsolute(bound)||!path.win32.isAbsolute(projectRoot)||
+    bound.startsWith('\\\\')||projectRoot.startsWith('\\\\'))
+  throw new Error('R186 coding project root is not a real absolute drive path');
+ const actual=path.win32.normalize(bound).toLowerCase();
+ const requested=path.win32.normalize(projectRoot).toLowerCase();
+ if(actual!==requested||
+    actual===path.win32.parse(actual).root.toLowerCase())
+  throw new Error('R186 reviewed root must match selected Coding project root');
+ return Object.freeze({root_id:rootId,project_root:bound});
+}

package/src/r186-owner-grant-broker.mjs

@@ -0,0 +1,96 @@
+// Single-use R186 Autonomous grant issuance. This module does not enroll owner
+// keys and accepts no caller-selected authority scope: the policy, reviewed
+// manifest and independently protected owner anchor are the complete subject.
+import {createHash,createPrivateKey,createPublicKey,randomBytes,sign,verify} from 'node:crypto';
+import {mkdir,open,readFile,writeFile} from 'node:fs/promises';
+import path from 'node:path';
+import {canonicalJson} from './canonical-json.mjs';
+import {createAuthorityEpochStore} from './authority-continuity-r65.mjs';
+import {verifyR186OwnerConsent,verifyR186PolicyRootBinding} from './r186-owner-consent-preflight.mjs';
+
+const SHA=/^[0-9a-f]{64}$/;
+const TERMINAL_DOMAIN=Buffer.from('DEADBYTE-R186-OWNER-GRANT-TERMINAL\0','utf8');
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const bytes=value=>Buffer.from(canonicalJson(value),'utf8');
+async function writeExclusive(file,data){
+ await mkdir(path.dirname(file),{recursive:true});
+ const handle=await open(file,'wx',0o600);
+ try{await handle.writeFile(data);await handle.sync();}
+ finally{await handle.close();}
+}
+function insist(condition,message){if(!condition)throw new Error(`R186 owner grant blocked: ${message}`);}
+async function signTerminal(runtimeDir,body){
+ const trustDir=path.join(path.dirname(path.resolve(runtimeDir)),'trust');
+ const [privatePem,publicPem]=await Promise.all([
+  readFile(path.join(trustDir,'ed25519-private.pem')),readFile(path.join(trustDir,'ed25519-public.pem'))]);
+ const privateKey=createPrivateKey(privatePem),publicKey=createPublicKey(publicPem);
+ insist(privateKey.asymmetricKeyType==='ed25519'&&publicKey.asymmetricKeyType==='ed25519','machine receipt key type invalid');
+ const privateKeyId=sha(createPublicKey(privateKey).export({type:'spki',format:'der'}));
+ const publicKeyId=sha(publicKey.export({type:'spki',format:'der'}));
+ insist(privateKeyId===publicKeyId,'machine receipt key pair mismatch');
+ const signature=sign(null,Buffer.concat([TERMINAL_DOMAIN,bytes(body)]),privateKey);
+ insist(verify(null,Buffer.concat([TERMINAL_DOMAIN,bytes(body)]),publicKey,signature),'machine terminal signature self-check failed');
+ return Object.freeze({algorithm:'ed25519',domain:'DEADBYTE-R186-OWNER-GRANT-TERMINAL',key_id:publicKeyId,signature_base64:signature.toString('base64')});
+}
+
+export async function issueR186AutonomousGrant({
+ runtimeDir,grantFile,codingPolicy,codingPolicyBytes,autonomousPolicy,autonomousPolicyBytes,
+ releaseManifestBytes,ownerTrust,ownerPublicKeyPem,approval,now=new Date(),epochStore=null
+}={}){
+ insist(typeof runtimeDir==='string'&&path.isAbsolute(runtimeDir),'runtime directory invalid');
+ insist(typeof grantFile==='string'&&path.isAbsolute(grantFile),'grant path invalid');
+ for(const [name,value] of [['Coding policy',codingPolicyBytes],['Autonomous policy',autonomousPolicyBytes],['release manifest',releaseManifestBytes]])
+  insist(Buffer.isBuffer(value)&&value.length>0,`${name} bytes invalid`);
+ insist(autonomousPolicy?.schema==='deadbyte.autonomous-policy.v1'&&autonomousPolicy.enabled===true,'Autonomous policy invalid');
+ insist(path.resolve(autonomousPolicy.lease_file)===path.resolve(grantFile),'policy grant path mismatch');
+ const runtimePrefix=path.resolve(runtimeDir)+path.sep;
+ insist(path.resolve(grantFile).startsWith(runtimePrefix),'grant path outside runtime');
+ const codingSha=sha(codingPolicyBytes),autonomousSha=sha(autonomousPolicyBytes),manifestSha=sha(releaseManifestBytes);
+ const rootId=Array.isArray(autonomousPolicy.root_ids)&&autonomousPolicy.root_ids.length===1?autonomousPolicy.root_ids[0]:null;
+ const projectRoot=rootId?codingPolicy?.roots?.[rootId]?.path:null;
+ const binding=verifyR186PolicyRootBinding({codingPolicy,autonomousPolicy,rootId,projectRoot,codingPolicySha256:codingSha});
+ const consent=await verifyR186OwnerConsent({ownerTrust,ownerPublicKeyPem,approval,now,expected:{
+  rootId:binding.root_id,projectRoot:binding.project_root,codingPolicySha256:codingSha,
+  autonomousPolicySha256:autonomousSha,reviewedArtifactSha256:manifestSha
+ }});
+ const evidenceDir=path.join(runtimeDir,'owner-consent','r186');
+ const claimPath=path.join(evidenceDir,`${consent.subject_sha256}.claim.json`);
+ const terminalPath=path.join(evidenceDir,`${consent.subject_sha256}.terminal.json`);
+ try{await readFile(terminalPath);throw new Error('R186 owner approval already consumed; replay denied');}
+ catch(error){if(error?.code!=='ENOENT')throw error;}
+ const nonce=randomBytes(32).toString('hex');
+ const claim={schema:'deadbyte.r186-owner-grant-claim.v1',subject_sha256:consent.subject_sha256,
+  owner_key_id:consent.owner_key_id,policy_sha256:autonomousSha,coding_policy_sha256:codingSha,
+  release_manifest_sha256:manifestSha,root_id:binding.root_id,project_root:binding.project_root,
+  grant_instance_nonce:nonce,claimed_at_utc:now.toISOString()};
+ try{await writeExclusive(claimPath,bytes(claim));}
+ catch(error){if(error?.code==='EEXIST')throw new Error('R186 owner approval already consumed or in progress; replay denied');throw error;}
+ const grant={schema:'deadbyte.autonomous-grant.v2',policy_sha256:autonomousSha,
+  coding_policy_sha256:codingSha,instance_nonce:nonce,root_ids:[binding.root_id],
+  granted_at_utc:now.toISOString(),expires_at_utc:consent.expires_at_utc};
+ const grantBytes=bytes(grant);
+ try{await writeExclusive(grantFile,grantBytes);}
+ catch(error){throw Object.assign(new Error(`R186 grant write failed after durable claim: ${error?.message??error}`),{outcome:'OUTCOME_UNKNOWN'});}
+ const store=epochStore??createAuthorityEpochStore({runtimeDir,policyBytes:autonomousPolicyBytes});
+ let head;
+ try{head=await store.append({plane:'autonomous',action:'grant',grantBytes,grantInstanceNonce:nonce,updateId:null});}
+ catch(error){throw Object.assign(new Error(`R186 epoch issuance failed after grant write: ${error?.message??error}`),{outcome:'OUTCOME_UNKNOWN'});}
+ insist(SHA.test(String(head?.event_sha256)),'epoch identity invalid after issuance');
+ const verified=await store.verifyGrant({plane:'autonomous',grantBytes,grantInstanceNonce:nonce,policyBytes:autonomousPolicyBytes});
+ insist(verified?.trusted===true&&verified.event_sha256===head.event_sha256,'grant epoch read-back failed');
+ insist((await readFile(grantFile)).equals(grantBytes),'grant changed after epoch issuance');
+ const terminalBody={schema:'deadbyte.r186-owner-grant-terminal.v1',status:'GRANTED',
+  subject_sha256:consent.subject_sha256,owner_key_id:consent.owner_key_id,
+  claim_sha256:sha(bytes(claim)),grant_sha256:sha(grantBytes),grant_instance_nonce:nonce,
+  policy_sha256:autonomousSha,coding_policy_sha256:codingSha,release_manifest_sha256:manifestSha,
+  root_id:binding.root_id,project_root:binding.project_root,epoch_event_sha256:head.event_sha256,
+  epoch_seq:head.seq,expires_at_utc:consent.expires_at_utc,completed_at_utc:new Date().toISOString()};
+ const attestation=await signTerminal(runtimeDir,terminalBody);
+ const unsigned={body:terminalBody,attestation};
+ const terminal={...unsigned,receipt_sha256:sha(bytes(unsigned))};
+ try{await writeExclusive(terminalPath,bytes(terminal));}
+ catch(error){throw Object.assign(new Error(`R186 terminal receipt write failed: ${error?.message??error}`),{outcome:'OUTCOME_UNKNOWN'});}
+ return Object.freeze({status:'GRANTED',authority_granted:true,subject_sha256:consent.subject_sha256,
+  grant_sha256:terminalBody.grant_sha256,epoch_event_sha256:head.event_sha256,epoch_seq:head.seq,
+  terminal_path:terminalPath,receipt_sha256:terminal.receipt_sha256});
+}

package/src/r186-owner-local-signing.mjs

@@ -0,0 +1,25 @@
+// Human-invoked local signer. Callers receive approval JSON only; the private
+// key is never returned or embedded in a request/receipt.
+import {createHash,createPrivateKey,createPublicKey,sign} from 'node:crypto';
+import {canonicalJson} from './canonical-json.mjs';
+
+const DOMAIN=Buffer.from('DEADBYTE-R70-PROJECT-OWNER-APPROVAL\0','utf8');
+const SHA=/^[0-9a-f]{64}$/;
+const fields=['schema','subject','subject_sha256','owner_signature_present','authority_granted'];
+const hash=bytes=>createHash('sha256').update(bytes).digest('hex');
+export function createR186OwnerApproval({request,privateKeyPem}={}){
+ if(!request||typeof request!=='object'||Array.isArray(request)||Object.keys(request).length!==fields.length||fields.some(k=>!Object.hasOwn(request,k))||
+    request.schema!=='deadbyte.r186-owner-review-request.v1'||request.owner_signature_present!==false||request.authority_granted!==false)
+  throw new Error('R186 owner review request invalid');
+ const subjectSha=hash(Buffer.from(canonicalJson(request.subject),'utf8'));
+ if(!SHA.test(String(request.subject_sha256))||request.subject_sha256!==subjectSha)
+  throw new Error('R186 owner review request subject mismatch');
+ if(typeof privateKeyPem!=='string'||!/PRIVATE KEY/.test(privateKeyPem))throw new Error('R186 owner private key invalid');
+ let privateKey;try{privateKey=createPrivateKey(privateKeyPem);}catch{throw new Error('R186 owner private key invalid');}
+ if(privateKey.asymmetricKeyType!=='ed25519')throw new Error('R186 owner private key must be Ed25519');
+ const publicKey=createPublicKey(privateKey);
+ const owner_key_id=hash(publicKey.export({type:'spki',format:'der'}));
+ const signed={schema:'deadbyte.project-owner-approval.r70.v1',subject_sha256:subjectSha,owner_key_id};
+ const signature_base64=sign(null,Buffer.concat([DOMAIN,Buffer.from(canonicalJson(signed),'utf8')]),privateKey).toString('base64');
+ return Object.freeze({...signed,subject:request.subject,signature_base64});
+}

package/src/r186-owner-request.mjs

@@ -0,0 +1,40 @@
+// Owner-review subject construction only. No keys, signatures or grants.
+import {createHash} from 'node:crypto';
+import path from 'node:path';
+import {canonicalJson} from './canonical-json.mjs';
+
+const SHA=/^[0-9a-f]{64}$/;
+const ROOT=/^[A-Za-z0-9._-]{1,64}$/;
+export function createR186OwnerReviewRequest({
+ rootId,projectRoot,codingPolicySha256,autonomousPolicySha256,
+ reviewedArtifactSha256,now=new Date(),durationMs=600000
+}={}){
+ if(typeof rootId!=='string'||!ROOT.test(rootId))
+  throw new Error('R186 invalid root ID');
+ if(typeof projectRoot!=='string'||!path.win32.isAbsolute(projectRoot)||
+    projectRoot.startsWith('\\\\'))
+  throw new Error('R186 invalid project root');
+ for(const [name,value] of [
+  ['codingPolicySha256',codingPolicySha256],
+  ['autonomousPolicySha256',autonomousPolicySha256],
+  ['reviewedArtifactSha256',reviewedArtifactSha256]
+ ])if(typeof value!=='string'||!SHA.test(value))
+  throw new Error('R186 invalid '+name);
+ if(!(now instanceof Date)||!Number.isFinite(now.getTime())||
+    !Number.isSafeInteger(durationMs)||durationMs<1000||durationMs>3600000)
+  throw new Error('R186 invalid bounded consent duration');
+ const issued_at_utc=now.toISOString();
+ const expires_at_utc=new Date(now.getTime()+durationMs).toISOString();
+ const subject=Object.freeze({
+  schema:'deadbyte.project-authority-subject.r70.v1',
+  scope:'coding_autonomous_native_diff',
+  root_id:rootId,project_root:path.win32.normalize(projectRoot),
+  coding_policy_sha256:codingPolicySha256,
+  autonomous_policy_sha256:autonomousPolicySha256,
+  reviewed_artifact_sha256:reviewedArtifactSha256,
+  issued_at_utc,expires_at_utc
+ });
+ const subject_sha256=createHash('sha256').update(Buffer.from(canonicalJson(subject))).digest('hex');
+ return Object.freeze({schema:'deadbyte.r186-owner-review-request.v1',
+  subject,subject_sha256,owner_signature_present:false,authority_granted:false});
+}

package/src/r186-owner-review-export.mjs

@@ -0,0 +1,49 @@
+// Read-only export of the exact subject a physical owner may review and sign.
+// This boundary neither reads a private key nor creates/changes authority.
+import {createHash} from 'node:crypto';
+import {lstat,open,readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {canonicalJson} from './canonical-json.mjs';
+import {verifyR186PolicyRootBinding} from './r186-owner-consent-preflight.mjs';
+import {createR186OwnerReviewRequest} from './r186-owner-request.mjs';
+
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+async function boundedRegular(file,limit,label){
+ const info=await lstat(file);
+ if(!info.isFile()||info.isSymbolicLink()||info.size<1||info.size>limit)
+  throw new Error(`R186 ${label} is a reparse, symlink or invalid file`);
+ return readFile(file);
+}
+async function writeExclusive(file,bytes){
+ const parent=await lstat(path.dirname(file));
+ if(!parent.isDirectory()||parent.isSymbolicLink())
+  throw new Error('R186 review output parent is a reparse or symlink');
+ const handle=await open(file,'wx',0o600);
+ try{await handle.writeFile(bytes);await handle.sync();}
+ finally{await handle.close();}
+}
+
+export async function writeR186OwnerReviewRequest({
+ rootId,projectRoot,codingPolicyPath,autonomousPolicyPath,manifestPath,outputPath,
+ now=new Date(),durationMs=600000
+}={}){
+ for(const [name,value] of [['project root',projectRoot],['Coding policy',codingPolicyPath],
+  ['Autonomous policy',autonomousPolicyPath],['manifest',manifestPath],['output',outputPath]]){
+  if(typeof value!=='string'||!path.isAbsolute(value))throw new Error(`R186 ${name} path must be absolute`);
+ }
+ const [codingBytes,autonomousBytes,manifestBytes]=await Promise.all([
+  boundedRegular(codingPolicyPath,1024*1024,'Coding policy'),
+  boundedRegular(autonomousPolicyPath,1024*1024,'Autonomous policy'),
+  boundedRegular(manifestPath,512*1024,'release manifest')]);
+ const codingPolicy=JSON.parse(codingBytes.toString('utf8'));
+ const autonomousPolicy=JSON.parse(autonomousBytes.toString('utf8'));
+ const codingPolicySha256=sha(codingBytes);
+ const binding=verifyR186PolicyRootBinding({codingPolicy,autonomousPolicy,rootId,
+  projectRoot,codingPolicySha256});
+ const request=createR186OwnerReviewRequest({rootId:binding.root_id,
+  projectRoot:binding.project_root,codingPolicySha256,
+  autonomousPolicySha256:sha(autonomousBytes),reviewedArtifactSha256:sha(manifestBytes),
+  now,durationMs});
+ await writeExclusive(outputPath,Buffer.from(`${canonicalJson(request)}\n`,'utf8'));
+ return request;
+}

package/src/remote-live-log.mjs

@@ -11,7 +11,7 @@ const LIFECYCLE=Object.freeze({
   session_new:'[SESSION] New foreground session',
   session_restored:'♻️ [SESSION] Previous result stream replayed',
   ready:'✅ [READY] DEADBYTE MCP online',
-  cleanup:'🔐 [AUTH] Revoking session authority...'
+  cleanup:'[SESSION] Closing observation session...'
 });
 const LIFECYCLE_ASCII=Object.freeze({
   device_start:'[DEVICE] Starting DEADBYTE MCP...',
@@ -20,7 +20,7 @@ const LIFECYCLE_ASCII=Object.freeze({
   session_new:'[SESSION] New foreground session',
   session_restored:'[SESSION] Previous result stream replayed',
   ready:'[READY] DEADBYTE MCP online',
-  cleanup:'[AUTH] Revoking session authority...'
+  cleanup:'[SESSION] Closing observation session...'
 });
 
 function safeAtom(value){
@@ -104,13 +104,33 @@ function rootedPath(args,key='path',rootPaths={}){
     if(base){
       const flavor=/^(?:[A-Za-z]:[\\/]|\\\\)/.test(base)?path.win32:path.posix;
       const absolute=p==='.'?flavor.resolve(base):flavor.resolve(base,p);
+      const relative=flavor.relative(flavor.resolve(base),absolute);
+      // A display-only resolver must not misleadingly mark traversal as in-root.
+      if(relative==='..'||relative.startsWith('..'+flavor.sep)||flavor.isAbsolute(relative))
+        return '[outside root='+root+'] '+p;
       return absolute+' [root='+root+']';
     }
+    // We do not invent drive letters when the trusted runtime policy has
+    // not supplied the actual root mapping.
     return root+':'+p;
   }
   if(root) return 'root='+root;
   return p?'path='+p:'';
 }
+function detailedDisplayPaths(args,rootPaths){
+  const safe=sanitizeAuditArgs(args??{});
+  const paths=[];
+  const entry=(key,label)=>{
+    if(!safePathAtom(safe?.[key]))return;
+    const value=rootedPath(safe,key,rootPaths)+(safe.root_id&&!safePathAtom(rootPaths?.[safe.root_id])?' [unresolved root]':'');
+    if(value)paths.push((label?label+': ':'')+value);
+  };
+  if(safe?.source_path&&safe?.destination_path){
+    entry('source_path','FROM');entry('destination_path','TO');
+  }else if(safe?.path)entry('path','');
+  else if(safe?.script_path)entry('script_path','SCRIPT');
+  return paths;
+}
 function displayToolName(tool,args){
   const op=safeAtom(args?.op);
   if(op&&['machine_fs','coding_inspect','process_session','desktop_control','machine_observe'].includes(tool)) return tool+'.'+op;
@@ -399,10 +419,12 @@ export function createLiveTimelineWriter({stream=process.stdout,displayMode='uni
 
 export function defaultForegroundTimelineOptions({verbose=false}={}){
   if(typeof verbose!=='boolean')throw new Error('default live timeline verbosity invalid');
-  return Object.freeze({commanderStyle:!verbose,foldHeartbeats:false});
+  // R176 default: readable emoji timeline with compact heartbeat groups.
+  // Commander/verbose presentation remains explicitly selectable by callers.
+  return Object.freeze({commanderStyle:false,foldHeartbeats:!verbose,prettyStyle:!verbose});
 }
 
-export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,foldHeartbeats=false,heartbeatBurstLimit=10,heartbeatWindowMs=3000,displayMode='unicode',rootPaths={},trace=false,slowCallMs=1000,commanderStyle=false}={}){
+export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,foldHeartbeats=false,heartbeatBurstLimit=10,heartbeatWindowMs=3000,displayMode='unicode',rootPaths={},trace=false,slowCallMs=1000,commanderStyle=false,prettyStyle=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');
@@ -410,6 +432,7 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,fo
   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 prettyStyle!=='boolean') throw new Error('live timeline prettyStyle 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();
@@ -428,6 +451,23 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,fo
     return visual+'  '+displayClock(eventMs(event,clock))+'  '+seq+'['+shortSpanId(event.request_id)+']  '+tool;
   }
   function traceSuffix(meta){return trace&&meta?'  '+traceText(meta,displayMode):'';}
+  function prettyLine(event,tool,tag,detail='',glyph=null,displayPaths=[]){
+    const time=displayClock(eventMs(event,clock)).slice(0,8);
+    const title=tool.length>30?tool.slice(0,29)+'…':tool;
+    // Spaces avoid incorrect console-cell widths for double-width emoji.
+    const icon=glyph??iconForTool(tool,displayMode);
+    const leader=displayMode==='ascii'?' | ':'  │ ';
+    const shortId=shortSpanId(event.request_id);
+    const label=title.padEnd(31,' ');
+    const headline=time+'  '+icon+' '+tag.padEnd(8,' ')+' '+label+
+      leader+'['+shortId+']'+(detail?'  '+clipped(detail,220):'');
+    if(!displayPaths.length)return remoteDisplayText(headline,displayMode);
+    const pathIcon=displayMode==='ascii'?'PATH: ':'📁 ';
+    // Paths are not shortened to an ambiguous basename: retain the Windows
+    // drive, directory tree and policy root. Respect the bounded input limit.
+    const descriptions=displayPaths.map(p=>'   '+pathIcon+p);
+    return remoteDisplayText([headline,...descriptions].join('\n'),displayMode);
+  }
   function resultLine(event,span,sequence){
     const outcome=outcomeClass(event);
     const error=outcome==='error';
@@ -458,6 +498,16 @@ 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(prettyStyle){
+      const tag=unknown?'UNKNOWN':pendingResult?'PENDING':error?(rawStatus==='denied'?'DENIED':'FAIL'):'PASS';
+      const glyph=displayMode==='ascii'?(unknown?'!':error?'X':pendingResult?'~':'+'):
+        unknown?'⚠️':error?'❌':pendingResult?'⏳':'✅';
+      const pathList=span?.display_paths??[];
+      const nonPathSummary=pathList.length?summary.replace(pathList[0],'').trim():summary;
+      const detail=[duration,trace&&span?.trace_meta?traceText(span.trace_meta,displayMode):'',nonPathSummary,statusDetail.trim(),receipt?'receipt='+receipt:'',
+        reason?reason:''].filter(Boolean).join('  |  ');
+      return prettyLine(event,displayTool,tag,detail,glyph,pathList);
+    }
     if(commanderStyle){
       const tag=unknown?'OUTCOME_UNKNOWN':pendingResult?'pending':error?'failed':'completed';
       const state=rawStatus?' status='+rawStatus:'';
@@ -475,6 +525,11 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,fo
     const endClock=displayClock(value.last_ms);
     const range=value.first_ms===value.last_ms?endClock:startClock.slice(0,8)+'–'+endClock.slice(0,8);
     if(value.count>1) foldedHeartbeatLines+=value.count-1;
+    if(prettyStyle){
+      return prettyLine({request_id:'polling',created_at_utc:new Date(value.last_ms).toISOString()},
+        value.tool,'FOLDED','×'+value.count+'  avg '+formatDuration(avg),
+        displayMode==='ascii'?'H':'📡');
+    }
     const marker=displayMode==='ascii'?'OK':'✓';
     return remoteDisplayText(iconForTool(value.tool,displayMode)+'  '+range+'  '+seq+value.tool+' ×'+value.count+'  avg '+formatDuration(avg)+'  '+marker,displayMode);
   }
@@ -512,12 +567,13 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,fo
       const args=event.args??{};
       const displayTool=displayToolName(tool,args);
       const summary=summarizeLiveToolArgs(displayTool,args,{rootPaths});
+      const displayPaths=prettyStyle?detailedDisplayPaths(args,rootPaths):[];
       const traceMeta=traceIdentity(event,args);
       if(pending.size>=MAX_PRESENTATION_IDENTITIES){
         pendingOverflow++;
         return pendingOverflow===1?remoteDisplayText('LIVELOG pending span cap reached; full audit remains on disk',displayMode):null;
       }
-      pending.set(requestId,{request_id:requestId,tool,display_tool:displayTool,summary,trace_meta:traceMeta,started_at_ms:clock()});
+      pending.set(requestId,{request_id:requestId,tool,display_tool:displayTool,summary,display_paths:displayPaths,trace_meta:traceMeta,started_at_ms:clock()});
       peakInFlight=Math.max(peakInFlight,pending.size);
       if(commanderStyle){
         const safeArgs=sanitizeAuditArgs(args);
@@ -527,6 +583,9 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,fo
       }
       if(verbose) return formatRemoteToolCall({...event,tool:displayTool},{clock,displayMode})+traceSuffix(traceMeta);
       if(visibleStart(displayTool)){
+        if(prettyStyle) return prettyLine(event,displayTool,'START',
+          [trace?traceText(traceMeta,displayMode):'',displayPaths.length?summary.replace(displayPaths[0],'').trim():summary].filter(Boolean).join('  |  '),
+          null,displayPaths);
         const startMarker=displayMode==='ascii'?'START':'▶ START';
         return remoteDisplayText(eventPrefix(event,sequence,{displayTool})+traceSuffix(traceMeta)+'  '+startMarker+(summary?'  '+summary:''),displayMode);
       }
@@ -606,6 +665,23 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,fo
     const p50=sorted.length?(sorted.length%2?sorted[(sorted.length-1)/2]:(sorted[sorted.length/2-1]+sorted[sorted.length/2])/2):null;
     const p95=sorted.length?sorted[Math.max(0,Math.ceil(sorted.length*0.95)-1)]:null;
     const p99=sorted.length?sorted[Math.max(0,Math.ceil(sorted.length*0.99)-1)]:null;
+    if(prettyStyle){
+      const ascii=displayMode==='ascii';
+      const lines=[
+        (ascii?'[SUMMARY]':'📊 SESSION')+'  '+resultCount+' calls | '+okCount+' ok | '+
+          errorCount+(errorCount===1?' error | ':' errors | ')+unknownCount+' unknown'+(pendingCount?' | '+pendingCount+' pending':''),
+        (ascii?'   work:':'   🛠 work:')+' '+mutationCount+' mutations | peak '+peakInFlight+' in-flight'+
+          (foldedHeartbeatLines?' | folded '+foldedHeartbeatLines+' heartbeats':''),
+        (ascii?'   timing:':'   ⏱ timing:')+' p50 '+(p50===null?'n/a':formatDuration(p50))+
+          ' | p95 '+(p95===null?'n/a':formatDuration(p95))+
+          ' | p99 '+(p99===null?'n/a':formatDuration(p99))+
+          (slowest?' | slowest '+slowest.tool+' '+formatDuration(slowest.duration_ms):''),
+        (ascii?'   top:':'   🔝 top:')+(top?' '+top:' none')
+      ];
+      if(pendingOverflow)lines.push((ascii?'   WARNING:':'   ⚠️ WARNING:')+
+        ' '+pendingOverflow+' untracked presentation spans; inspect signed audit');
+      return remoteDisplayText(lines.join('\n'),displayMode);
+    }
     return remoteDisplayText((displayMode==='ascii'?'[SUMMARY]':'📊 [SUMMARY]')+' '+resultCount+' calls | '+okCount+' ok | '+
       errorCount+' error'+(errorCount===1?'':'s')+' | '+unknownCount+' unknown'+(pendingCount?' | '+pendingCount+' pending':'')+' | '+mutationCount+' mutation'+(mutationCount===1?'':'s')+
       ' | tool time '+(formatDuration(totalDurationMs)||'0ms')+

package/src/remote-session-guardian.mjs

@@ -8,6 +8,7 @@ import { windowsPowerShellEnvironment } from './runtime-update.mjs';
 import { resolveStateRoot } from './state-root.mjs';
 import { AUTHORITY_PLANES, parseAuthorityObservation, assertAuthorityVector } from './remote-authority.mjs';
 import { readRemoteMarkerSnapshot, deletePinnedRemoteMarker } from './foreground-marker-cas-win32.mjs';
+import {assertObserveOnlyMarker} from './r175-foreground-boundary.mjs';
 
 const CLEANUP=['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost'];
 const TRUSTED_WINDOWS_ROOT='C:\\Windows';
@@ -68,6 +69,9 @@ async function main(){
   const ownerPid=Number(args['owner-pid']);
   const nonce=String(args['session-nonce']||'');
   const ipcOwner=args['owner-channel']==='ipc';
+  const observerGuard=args['authority-scope']==='observe-only';
+  if(args['authority-scope']!==undefined&&!observerGuard)
+    throw new Error('R175 guardian authority scope invalid');
   if(ipcOwner&&typeof process.send!=='function')throw new Error('guardian owner IPC channel missing');
   if(!Number.isInteger(ownerPid)||ownerPid<1) throw new Error('guardian owner pid invalid');
   if(ipcOwner&&process.ppid!==ownerPid)throw new Error('guardian IPC parent does not match declared owner');
@@ -85,6 +89,25 @@ async function main(){
       continue;
     }
 
+    // R179: a missing command-line flag is never permission to downgrade an
+    // observation-only marker to legacy broad authority revocation.
+    if(assertObserveOnlyMarker(marker)&&!observerGuard)
+      throw new Error('R179_OBSERVER_GUARDIAN_SCOPE_DOWNGRADE: owner grants retained');
+    if(observerGuard){
+      // Guardian scope is inherited from the parent process command line.
+      // Marker mismatch can never degrade into legacy unconditional revoke.
+      if(!assertObserveOnlyMarker(marker))
+        throw new Error('R175 observer guardian marker invalid; no grants touched');
+      // Observation-only sessions own the foreground marker, never the
+      // process/coding/host/desktop/autonomous grants or runtime.
+      const current=await readRemoteMarkerSnapshot(markerPath);
+      if(!current)return;
+      if(!markerMatches(current.marker,{ownerPid,nonce})||!assertObserveOnlyMarker(current.marker))return;
+      if(deletePinnedRemoteMarker(markerPath,current.sha256)!=='REMOVED')
+        throw new Error('R175 guardian monitor marker CAS failed; marker retained');
+      return;
+    }
+
     const failed=[];
     for(const command of CLEANUP){
       const latest=await readMarker(markerPath);

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.15.68';
+export const DEADBYTE_VERSION = '0.15.70';
 export const MCP_PROTOCOL_VERSION = '2026-07-28';
 export const RECEIPT_SCHEMA_V1 = 'deadbyte.receipt.v1';
 export const RECEIPT_SCHEMA_V2 = 'deadbyte.receipt.v2';

package/test/helpers/r175-active-pointer.mjs

@@ -0,0 +1,28 @@
+import {createHash} from 'node:crypto';
+import {mkdir,readFile,writeFile} from 'node:fs/promises';
+import path from 'node:path';
+
+const sha256=value=>createHash('sha256').update(value).digest('hex');
+
+export async function installExactActivePointer({stateRoot,packageRoot,launcherPath}){
+  const manifestBytes=await readFile(path.join(packageRoot,'MANIFEST.SHA256'));
+  const manifestSha256=sha256(manifestBytes);
+  const pkg=JSON.parse(await readFile(path.join(packageRoot,'package.json'),'utf8'));
+  const generationRoot=path.join(stateRoot,'generations','test-current');
+  const configPath=path.join(generationRoot,'controller-config.psd1');
+  await mkdir(generationRoot,{recursive:true});
+  await writeFile(configPath,"@{ Label = 'test-current' }\r\n",'utf8');
+  const pointer={
+    schema:'deadbyte.active-release.v1',
+    release_id:`v${pkg.version}-${manifestSha256.slice(0,16)}`,
+    version:pkg.version,
+    manifest_sha256:manifestSha256,
+    release_root:path.resolve(packageRoot),
+    generation_root:generationRoot,
+    generation_manifest_sha256:sha256(await readFile(configPath)),
+    launcher_sha256:sha256(await readFile(launcherPath)),
+    config_path:configPath
+  };
+  await writeFile(path.join(stateRoot,'active-release.json'),`${JSON.stringify(pointer)}\n`,'utf8');
+  return pointer;
+}

package/test/helpers/release-lock.mjs

@@ -0,0 +1,12 @@
+import {readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+export async function readReleaseLock(root){
+  const rootPath=root instanceof URL?fileURLToPath(root):root;
+  for(const relative of ['package-lock.json','docs/R184-package-lock.json']){
+    try{return JSON.parse(await readFile(path.join(rootPath,relative),'utf8'));}
+    catch(error){if(error?.code!=='ENOENT')throw error;}
+  }
+  throw new Error('R184_RELEASE_LOCK_EVIDENCE_MISSING');
+}

package/test/r129-sdk-security-baseline.test.mjs

@@ -3,6 +3,7 @@ import assert from 'node:assert/strict';
 import {readFile} from 'node:fs/promises';
 import path from 'node:path';
 import {fileURLToPath} from 'node:url';
+import {readReleaseLock} from './helpers/release-lock.mjs';
 
 const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
 async function json(file){return JSON.parse(await readFile(path.join(root,file),'utf8'));}
@@ -29,7 +30,7 @@ test('R129 shipped client and server SDK exclude all recorded 2.1.0 security adv
 });
 
 test('R129 lockfile resolves security-fixed SDK packages without prerelease versions',async()=>{
-  const lock=await json('package-lock.json');
+  const lock=await readReleaseLock(root);
   const pins=['@modelcontextprotocol/client','@modelcontextprotocol/server'];
   for(const dep of pins){
     const version=lock.packages?.['node_modules/'+dep]?.version;

package/test/r130-release-security-contract.test.mjs

@@ -4,23 +4,24 @@ import {readFile} from 'node:fs/promises';
 import {fileURLToPath} from 'node:url';
 import path from 'node:path';
 import {DEADBYTE_VERSION} from '../src/version.mjs';
+import {readReleaseLock} from './helpers/release-lock.mjs';
 
 const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
 const read=async file=>JSON.parse(await readFile(path.join(root,file),'utf8'));
-test('current successor retains the R130 security baseline with truthful R173 identity',async()=>{
+test('current successor retains the R130 security baseline with truthful R190 identity',async()=>{
   const [pkg,release,provenance,bom,lock,matrix]=await Promise.all([
     read('package.json'),read('RELEASE.json'),read('PROVENANCE.json'),
-    read('SBOM.cdx.json'),read('package-lock.json'),read('TEST-MATRIX.json')]);
+    read('SBOM.cdx.json'),readReleaseLock(root),read('TEST-MATRIX.json')]);
   assert.equal(pkg.name,'deadbyte-mcp');
   for(const actual of [pkg.version,release.version,provenance.version,matrix.version,bom.metadata.component.version,lock.version,lock.packages[''].version,DEADBYTE_VERSION])
-    assert.equal(actual,'0.15.68');
-  assert.equal(release.train,'R173');
-  assert.equal(matrix.train,'R173');
-  assert.equal(release.source_predecessor.version,'0.15.67');
-  assert.equal(release.source_predecessor.train,'R172');
-  assert.match(release.source_predecessor.source_path,/0\.15\.67-r172-final-remote-recovery/i);
-  assert.equal(release.source_predecessor.manifest_status,'VERIFIED_FINAL_BYTES');
-  assert.equal(release.runtime_predecessor.version,'0.15.61');
+    assert.equal(actual,'0.15.70');
+  assert.equal(release.train,'R190');
+  assert.equal(matrix.train,'R190');
+  assert.equal(release.source_predecessor.version,'0.15.69');
+  assert.equal(release.source_predecessor.train,'R179');
+  assert.match(release.source_predecessor.source_path,/deadbyte-mcp-0\.15\.69\.tgz/i);
+  assert.equal(release.source_predecessor.manifest_status,'PUBLISHED_PREVIEW_MANIFEST_VERIFIED_NOT_ACTIVE');
+  assert.equal(release.runtime_predecessor.version,'0.15.68');
   assert.equal(provenance.r160.source_predecessor_manifest_status,'STALE_REJECTED');
   assert.equal(pkg.dependencies['@modelcontextprotocol/client'],'2.3.1');
   assert.equal(pkg.dependencies['@modelcontextprotocol/server'],'2.3.1');