deadbyte-mcp 0.15.44 → 0.15.46

package/src/launcher-isolation.mjs

@@ -0,0 +1,58 @@
+/** R72: state-root-owned launcher routing. No staging caller may write the user-wide Downloads launcher. */
+import {lstatSync} from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const normalize=file=>process.platform==='win32'?path.resolve(file).toLowerCase():path.resolve(file);
+function contains(parent,child){
+  const rel=path.relative(parent,child);
+  return rel===''||(!path.isAbsolute(rel)&&rel!=='..'&&!rel.startsWith(`..${path.sep}`));
+}
+function assertNoReparseParts(file){
+  let cursor=path.resolve(file);
+  while(true){
+    try{
+      const info=lstatSync(cursor);
+      if(info.isSymbolicLink())throw new Error(`staging launcher boundary is a reparse/symlink: ${cursor}`);
+    }catch(error){if(error?.code!=='ENOENT')throw error;}
+    const parent=path.dirname(cursor);
+    if(parent===cursor)break;
+    cursor=parent;
+  }
+}
+export function canonicalLauncherPaths(stateRoot,{home=os.homedir()}={}){
+  if(typeof stateRoot!=='string'||!path.isAbsolute(stateRoot)||stateRoot.includes('\0'))throw new Error('launcher state root must be absolute');
+  const state=path.resolve(stateRoot),productionState=path.resolve(home,'.deadbyte-mcp');
+  const production=normalize(state)===normalize(productionState);
+  if(!production){
+    if(contains(normalize(productionState),normalize(state))||contains(normalize(state),normalize(productionState)))
+      throw new Error('staging state overlaps production state root');
+    assertNoReparseParts(state);
+    assertNoReparseParts(path.join(state,'bin'));
+    assertNoReparseParts(path.join(state,'launchers'));
+  }
+  const top=production?path.join(home,'Downloads','DEADBYTE-MCP.cmd'):path.join(state,'launchers','DEADBYTE-MCP.cmd');
+  if(!production)assertNoReparseParts(top);
+  return Object.freeze({state,production,top,ps1:path.join(state,'bin','DEADBYTE-MCP.ps1'),cmd:path.join(state,'bin','DEADBYTE-MCP.cmd')});
+}
+export function assertCanonicalLaunchers(stateRoot,launchers){
+  const expected=canonicalLauncherPaths(stateRoot);
+  if(!launchers||typeof launchers!=='object')throw new Error('launcher paths absent');
+  for(const field of ['top','ps1','cmd']){
+    if(typeof launchers[field]!=='string'||!path.isAbsolute(launchers[field])||
+       normalize(launchers[field])!==normalize(expected[field]))
+      throw new Error(`launcher ${field} is not canonical for selected state root`);
+  }
+  return expected;
+}
+/** Relative to bin/ or launchers/, so the entry point always selects its own state root. */
+export function renderStateBoundLauncherCmd(){
+  return [
+    '@echo off',
+    'setlocal EnableExtensions DisableDelayedExpansion',
+    'set "DEADBYTE_STATE_ROOT=%~dp0.."',
+    'powershell.exe -NoLogo -NoProfile -ExecutionPolicy Bypass -File "%DEADBYTE_STATE_ROOT%\\bin\\DEADBYTE-MCP.ps1" %*',
+    'exit /b %ERRORLEVEL%',
+    ''
+  ].join('\r\n');
+}

package/src/native-diff-v2.mjs

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { canonicalJson } from './canonical-json.mjs';
 import { validatePortableRelativePath } from './path-policy.mjs';
 import { loadPrivateSigningKey, loadPublicVerifyKey } from './trust.mjs';
-import { assertAutonomousArmed, recheckAutonomousAuthority } from './autonomous-policy.mjs';
+import { assertAutonomousArmed, autonomousSessionStatus, recheckAutonomousAuthority } from './autonomous-policy.mjs';
 
 export const NATIVE_DIFF_V2_SCHEMA='deadbyte.native-diff.v2';
 export const NATIVE_DIFF_V2_PREIMAGE_SCHEMA='deadbyte.native-diff-preimage.v2';
@@ -107,9 +107,16 @@ export function createNativeDiffV2Runtime({policy,codingRuntime,machineFsRuntime
   if(!machineFsRuntime?.state||!machineFsRuntime?.removeEmptyDir) throw new Error('native diff V2 requires machine fs topology runtime');
   if(!signingKeyPath||!verifyKeyPath) throw new Error('native diff V2 requires trust keys');
 
-  async function materializeOperations(rootId,rawOperations){
-    if(!policy.root_ids.includes(rootId)) throw new Error(`native diff root '${rootId}' is not allowed`);
-    await assertAutonomousArmed(policy,rootId);
+  async function materializeOperations(rootId,rawOperations,{codingOnly=false}={}){
+    if(codingOnly){
+      const lease=await codingRuntime.sessionStatus();
+      if(!lease.armed) throw new Error(`coding plane is disarmed: ${lease.reason}`);
+      if(!lease.root_ids.includes(rootId)||codingRuntime.policy.roots[rootId]?.read!==true)
+        throw new Error(`native diff preview root '${rootId}' is not allowed by Coding lease`);
+    } else {
+      if(!policy.root_ids.includes(rootId)) throw new Error(`native diff root '${rootId}' is not allowed`);
+      await assertAutonomousArmed(policy,rootId);
+    }
     const {normalized,payloadBytes}=normalizeRawOperations(rawOperations,policy);
     const operations=[];
     for(const op of normalized){
@@ -168,7 +175,13 @@ export function createNativeDiffV2Runtime({policy,codingRuntime,machineFsRuntime
   async function preview({rootId,operations:rawOperations,title='',applicationScope=null}){
     if(typeof title!=='string'||title.length>160) throw new Error('native diff title must be <=160 characters');
     if(applicationScope!==null&&!SHA256_RE.test(applicationScope)) throw new Error('native diff application_scope must be SHA-256 or null');
-    const {operations,payloadBytes}=await materializeOperations(rootId,rawOperations);
+    const autonomous=policy.root_ids.includes(rootId)?await autonomousSessionStatus(policy):null;
+    const codingOnly=autonomous?.armed!==true||!autonomous.root_ids?.includes(rootId);
+    const {operations,payloadBytes}=await materializeOperations(rootId,rawOperations,{codingOnly});
+    if(codingOnly) return {status:'preview_only',schema:NATIVE_DIFF_V2_SCHEMA,root_id:rootId,
+      operation_count:operations.length,payload_bytes:payloadBytes,
+      paths:operations.map(op=>op.path??op.source_path),
+      operations:operations.map(({content,old_string,new_string,...op})=>op)};
     const identity={schema:NATIVE_DIFF_V2_SCHEMA,policy_sha256:policy.policy_sha256,coding_policy_sha256:policy.coding_policy_sha256,root_id:rootId,title,operations,...(applicationScope===null?{}:{application_scope:applicationScope})};
     const diffId=sha256Object(identity); const ctx=diffContext(policy,diffId); const signing=await loadPrivateSigningKey(signingKeyPath);
     const envelope=signEnvelope(signing,DIFF_DOMAIN,{...identity,diff_id:diffId,created_at_utc:new Date().toISOString()});

package/src/native-diff.mjs

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { canonicalJson } from './canonical-json.mjs';
 import { validatePortableRelativePath } from './path-policy.mjs';
 import { loadPrivateSigningKey, loadPublicVerifyKey } from './trust.mjs';
-import { assertAutonomousArmed, recheckAutonomousAuthority } from './autonomous-policy.mjs';
+import { assertAutonomousArmed, autonomousSessionStatus, recheckAutonomousAuthority } from './autonomous-policy.mjs';
 import { createNativeDiffV2Runtime, NATIVE_DIFF_V2_SCHEMA } from './native-diff-v2.mjs';
 
 export const NATIVE_DIFF_SCHEMA = 'deadbyte.native-diff.v1';
@@ -102,9 +102,19 @@ function createNativeDiffRuntimeV1({ policy, codingRuntime, signingKeyPath, veri
   if (!policy || !codingRuntime?.policy) throw new Error('native diff runtime requires autonomous and coding policy');
   if (!signingKeyPath || !verifyKeyPath) throw new Error('native diff runtime requires trust keys');
 
-  async function materializeOperations(rootId, rawOperations) {
-    if (!policy.root_ids.includes(rootId)) throw new Error(`native diff root '${rootId}' is not allowed`);
-    await assertAutonomousArmed(policy, rootId);
+  async function materializeOperations(rootId, rawOperations, {codingOnly=false} = {}) {
+    if (codingOnly) {
+      // Preview authorization delegates ONLY to the existing, locally armed
+      // Coding read lease. No Autonomous grant, signer, or target mutation.
+      const lease=await codingRuntime.sessionStatus();
+      if (!lease.armed) throw new Error(`coding plane is disarmed: ${lease.reason}`);
+      if (!lease.root_ids.includes(rootId) || codingRuntime.policy.roots[rootId]?.read !== true) {
+        throw new Error(`native diff preview root '${rootId}' is not allowed by Coding lease`);
+      }
+    } else {
+      if (!policy.root_ids.includes(rootId)) throw new Error(`native diff root '${rootId}' is not allowed`);
+      await assertAutonomousArmed(policy, rootId);
+    }
     const { normalized, payloadBytes } = normalizeRawOperations(rawOperations, policy);
     const operations = [];
     for (const op of normalized) {
@@ -132,7 +142,13 @@ function createNativeDiffRuntimeV1({ policy, codingRuntime, signingKeyPath, veri
   async function preview({ rootId, operations:rawOperations, title = '', applicationScope = null }) {
     if (typeof title !== 'string' || title.length > 160) throw new Error('native diff title must be <=160 characters');
     if (applicationScope !== null && !SHA256_RE.test(applicationScope)) throw new Error('native diff application_scope must be SHA-256 or null');
-    const { operations, payloadBytes } = await materializeOperations(rootId, rawOperations);
+    const autonomous=policy.root_ids.includes(rootId)?await autonomousSessionStatus(policy):null;
+    const codingOnly=autonomous?.armed!==true||!autonomous.root_ids?.includes(rootId);
+    const { operations, payloadBytes } = await materializeOperations(rootId, rawOperations, {codingOnly});
+    if (codingOnly) return {status:'preview_only',schema:NATIVE_DIFF_SCHEMA,root_id:rootId,
+      operation_count:operations.length,payload_bytes:payloadBytes,
+      paths:operations.map(op=>op.path),
+      operations:operations.map(({content,old_string,new_string,...op})=>op)};
     const identity = { schema:NATIVE_DIFF_SCHEMA, policy_sha256:policy.policy_sha256,
       coding_policy_sha256:policy.coding_policy_sha256, root_id:rootId, title, operations,
       ...(applicationScope === null ? {} : { application_scope:applicationScope }) };

package/src/r70-owner-approval.mjs

@@ -0,0 +1,78 @@
+import {createHash,createPublicKey,verify as verifySignature} from 'node:crypto';
+import {lstat,realpath} from 'node:fs/promises';
+import path from 'node:path';
+import {canonicalJson} from './canonical-json.mjs';
+
+const SUBJECT_SCHEMA='deadbyte.project-authority-subject.r70.v1';
+const APPROVAL_SCHEMA='deadbyte.project-owner-approval.r70.v1';
+const SCOPE='coding_autonomous_native_diff';
+const DOMAIN=Buffer.from('DEADBYTE-R70-PROJECT-OWNER-APPROVAL\0','utf8');
+const SHA=/^[0-9a-f]{64}$/;
+const ID=/^[A-Za-z0-9._-]{1,64}$/;
+const SUBJECT_FIELDS=['schema','scope','root_id','project_root','coding_policy_sha256',
+  'autonomous_policy_sha256','reviewed_artifact_sha256','issued_at_utc','expires_at_utc'];
+const APPROVAL_FIELDS=['schema','subject_sha256','owner_key_id','subject','signature_base64'];
+const EXPECTED_FIELDS=['rootId','projectRoot','codingPolicySha256','autonomousPolicySha256','reviewedArtifactSha256'];
+const hash=bytes=>createHash('sha256').update(bytes).digest('hex');
+const samePath=(a,b)=>process.platform==='win32'?a.toLowerCase()===b.toLowerCase():a===b;
+
+function exact(value,fields,label){
+  if(!value||typeof value!=='object'||Array.isArray(value))throw new Error(`${label} invalid`);
+  const keys=Object.keys(value);
+  for(const key of keys)if(!fields.includes(key))throw new Error(`${label} unknown field '${key}'`);
+  for(const key of fields)if(!Object.hasOwn(value,key))throw new Error(`${label} missing field '${key}'`);
+  return value;
+}
+function digest(value,label){if(typeof value!=='string'||!SHA.test(value))throw new Error(`${label} invalid SHA-256`);return value;}
+function instant(value,label){
+  if(typeof value!=='string'||!/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/.test(value))throw new Error(`${label} invalid UTC`);
+  const parsed=Date.parse(value);
+  if(!Number.isFinite(parsed)||new Date(parsed).toISOString()!==value)throw new Error(`${label} invalid UTC`);
+  return parsed;
+}
+
+export async function verifyProjectOwnerApproval({approval,ownerPublicKey,expected,now=new Date()}={}){
+  exact(expected,EXPECTED_FIELDS,'owner approval expected subject');
+  exact(approval,APPROVAL_FIELDS,'owner approval');
+  exact(approval.subject,SUBJECT_FIELDS,'owner approval subject');
+  const subject=approval.subject;
+  if(approval.schema!==APPROVAL_SCHEMA||subject.schema!==SUBJECT_SCHEMA||subject.scope!==SCOPE)throw new Error('owner approval scope/schema mismatch');
+  if(typeof subject.root_id!=='string'||!ID.test(subject.root_id)||subject.root_id!==expected.rootId)throw new Error('owner approval root identity mismatch');
+  if(typeof subject.project_root!=='string'||!path.isAbsolute(subject.project_root)||
+     typeof expected.projectRoot!=='string'||!path.isAbsolute(expected.projectRoot))throw new Error('owner approval root path invalid');
+  let real;
+  try{
+    const entry=await lstat(expected.projectRoot);
+    if(!entry.isDirectory()||entry.isSymbolicLink())throw new Error('not a real directory');
+    real=await realpath(expected.projectRoot);
+  }catch{throw new Error('owner approval project root is not a real directory');}
+  if(!samePath(path.resolve(real),path.resolve(expected.projectRoot))||
+     !samePath(path.resolve(real),path.resolve(subject.project_root)))throw new Error('owner approval real root mismatch');
+  if(digest(subject.coding_policy_sha256,'coding policy')!==digest(expected.codingPolicySha256,'expected coding policy')||
+     digest(subject.autonomous_policy_sha256,'autonomous policy')!==digest(expected.autonomousPolicySha256,'expected autonomous policy')){
+    throw new Error('owner approval policy digest mismatch');
+  }
+  if(digest(subject.reviewed_artifact_sha256,'reviewed artifact')!==digest(expected.reviewedArtifactSha256,'expected reviewed artifact')){
+    throw new Error('owner approval reviewed artifact mismatch');
+  }
+  const issued=instant(subject.issued_at_utc,'owner approval issued time');
+  const expires=instant(subject.expires_at_utc,'owner approval expiry');
+  const observed=now instanceof Date?now.getTime():NaN;
+  if(!Number.isFinite(observed)||expires<=issued||expires-issued>3_600_000)throw new Error('owner approval lifetime invalid');
+  if(observed<issued||observed>=expires)throw new Error('owner approval expired or not yet valid');
+  const subjectSha=hash(Buffer.from(canonicalJson(subject),'utf8'));
+  if(digest(approval.subject_sha256,'owner approval subject')!==subjectSha)throw new Error('owner approval subject hash mismatch');
+  let key;
+  try{key=ownerPublicKey?.type==='public'?ownerPublicKey:createPublicKey(ownerPublicKey);}catch{throw new Error('owner approval public key invalid');}
+  if(key.asymmetricKeyType!=='ed25519')throw new Error('owner approval public key must be Ed25519');
+  const keyId=hash(key.export({type:'spki',format:'der'}));
+  if(digest(approval.owner_key_id,'owner approval key id')!==keyId)throw new Error('owner approval key identity mismatch');
+  if(typeof approval.signature_base64!=='string'||!/^[A-Za-z0-9+/]{86}==$/.test(approval.signature_base64))throw new Error('owner approval signature encoding invalid');
+  const signature=Buffer.from(approval.signature_base64,'base64');
+  const signed={schema:APPROVAL_SCHEMA,subject_sha256:subjectSha,owner_key_id:keyId};
+  if(signature.length!==64||!verifySignature(null,Buffer.concat([DOMAIN,Buffer.from(canonicalJson(signed),'utf8')]),key,signature)){
+    throw new Error('owner approval signature invalid');
+  }
+  return Object.freeze({approved:true,subject_sha256:subjectSha,owner_key_id:keyId,
+    project_root:real,root_id:subject.root_id,scope:SCOPE,expires_at_utc:subject.expires_at_utc});
+}

package/src/remote-authority.mjs

@@ -1,75 +1,75 @@
-import path from 'node:path';
-
-export const AUTHORITY_PLANES=Object.freeze(['process','coding','autonomous','desktop','host']);
-
-export function authorityVector(mode='default'){
-  if(!['default','desktop','host','full'].includes(mode)) throw new Error('remote authority mode invalid');
-  return Object.freeze({
-    process:true,coding:true,autonomous:true,
-    desktop:mode==='desktop'||mode==='full',
-    host:mode==='host'||mode==='full'
-  });
-}
-
-export function authorityRestorePlan(snapshot){
-  const disarm=[],arm=[];
-  for(const plane of AUTHORITY_PLANES){
-    const entry=snapshot?.authority?.[plane];
-    if(!entry||typeof entry.armed!=='boolean') throw new Error(`authority ${plane} observation invalid`);
-    (entry.armed?arm:disarm).push(`${entry.armed?'arm':'disarm'}${plane}`);
-  }
-  return Object.freeze([...disarm,...arm]);
-}
-
-export function parseAuthorityObservation(raw){
-  let value;
-  try{value=typeof raw==='string'?JSON.parse(raw.replace(/^\uFEFF/,'')):raw;}
-  catch{throw new Error('controller observation JSON invalid');}
-  if(value?.schema!=='deadbyte.controller-observation.v1'||!value.authority||typeof value.authority!=='object'||Array.isArray(value.authority))
-    throw new Error('controller observation schema invalid');
-  const authority={};
-  for(const plane of AUTHORITY_PLANES){
-    const entry=value.authority[plane];
-    if(!entry||typeof entry!=='object'||typeof entry.armed!=='boolean'||typeof entry.configured!=='boolean'||typeof entry.reason!=='string')
-      throw new Error(`controller authority ${plane} observation invalid`);
-    const hasEpochSeq=Object.hasOwn(entry,'epoch_seq'),hasEpochSha=Object.hasOwn(entry,'epoch_sha256');
-    if(hasEpochSeq!==hasEpochSha)throw new Error(`controller authority ${plane} epoch observation incomplete`);
-    let epochSeq=null,epochSha256=null;
-    if(hasEpochSeq){
-      if(!Number.isSafeInteger(entry.epoch_seq)||entry.epoch_seq<1||typeof entry.epoch_sha256!=='string'||!/^[0-9a-f]{64}$/.test(entry.epoch_sha256))
-        throw new Error(`controller authority ${plane} epoch observation invalid`);
-      epochSeq=entry.epoch_seq;epochSha256=entry.epoch_sha256;
-    }
-    authority[plane]=Object.freeze({configured:entry.configured,armed:entry.armed,reason:entry.reason.slice(0,128),
-      epoch_seq:epochSeq,epoch_sha256:epochSha256});
-  }
-  return Object.freeze({...value,authority:Object.freeze(authority)});
-}
-
-export function assertAuthorityVector(snapshot,expected){
-  for(const plane of AUTHORITY_PLANES){
-    const entry=snapshot?.authority?.[plane];
-    if(!entry||typeof expected?.[plane]!=='boolean') throw new Error(`authority ${plane} observation or expectation invalid`);
-    if(entry.armed!==expected[plane]) throw new Error(`${plane} authority expected ${expected[plane]?'ARMED':'DISARMED'}; observed ${entry.armed?'ARMED':'DISARMED'} (${entry.reason})`);
-    if(expected[plane]&&!entry.configured) throw new Error(`${plane} authority unconfigured`);
-  }
-  return snapshot;
-}
-
-export function authorityBanner(snapshot){
-  return AUTHORITY_PLANES.map(plane=>`${plane} ${snapshot.authority[plane].armed?'ARMED':'DISARMED'}`).join(' | ');
-}
-
-export function assertRuntimeReadyObservation(snapshot,{coreRoot=null}={}){
-  if(snapshot?.state!=='ONLINE') throw new Error(`runtime state not ONLINE: ${String(snapshot?.state)}`);
-  for(const name of ['bridge','core','cloud']){
-    if(snapshot[name]?.alive!==true||snapshot[name]?.reason!=='verified') throw new Error(`${name} runtime identity unverified`);
-  }
-  if(snapshot.local_ready!==true) throw new Error('local MCP readiness unverified');
-  if(snapshot.supervisor?.running!==true) throw new Error('autonomous supervisor not running');
-  if(coreRoot!==null){
-    if(typeof snapshot.core_root!=='string'||path.win32.resolve(snapshot.core_root).toLowerCase()!==path.win32.resolve(coreRoot).toLowerCase())
-      throw new Error('core root does not match active release');
-  }
-  return snapshot;
-}
+import path from 'node:path';
+
+export const AUTHORITY_PLANES=Object.freeze(['process','coding','autonomous','desktop','host']);
+
+export function authorityVector(mode='default'){
+  if(!['default','operator','desktop','host','full'].includes(mode)) throw new Error('remote authority mode invalid');
+  return Object.freeze({
+    process:mode!=='default',coding:mode!=='default',autonomous:mode!=='default',
+    desktop:mode==='desktop'||mode==='full',
+    host:mode==='host'||mode==='full'
+  });
+}
+
+export function authorityRestorePlan(snapshot){
+  const disarm=[],arm=[];
+  for(const plane of AUTHORITY_PLANES){
+    const entry=snapshot?.authority?.[plane];
+    if(!entry||typeof entry.armed!=='boolean') throw new Error(`authority ${plane} observation invalid`);
+    (entry.armed?arm:disarm).push(`${entry.armed?'arm':'disarm'}${plane}`);
+  }
+  return Object.freeze([...disarm,...arm]);
+}
+
+export function parseAuthorityObservation(raw){
+  let value;
+  try{value=typeof raw==='string'?JSON.parse(raw.replace(/^\uFEFF/,'')):raw;}
+  catch{throw new Error('controller observation JSON invalid');}
+  if(value?.schema!=='deadbyte.controller-observation.v1'||!value.authority||typeof value.authority!=='object'||Array.isArray(value.authority))
+    throw new Error('controller observation schema invalid');
+  const authority={};
+  for(const plane of AUTHORITY_PLANES){
+    const entry=value.authority[plane];
+    if(!entry||typeof entry!=='object'||typeof entry.armed!=='boolean'||typeof entry.configured!=='boolean'||typeof entry.reason!=='string')
+      throw new Error(`controller authority ${plane} observation invalid`);
+    const hasEpochSeq=Object.hasOwn(entry,'epoch_seq'),hasEpochSha=Object.hasOwn(entry,'epoch_sha256');
+    if(hasEpochSeq!==hasEpochSha)throw new Error(`controller authority ${plane} epoch observation incomplete`);
+    let epochSeq=null,epochSha256=null;
+    if(hasEpochSeq){
+      if(!Number.isSafeInteger(entry.epoch_seq)||entry.epoch_seq<1||typeof entry.epoch_sha256!=='string'||!/^[0-9a-f]{64}$/.test(entry.epoch_sha256))
+        throw new Error(`controller authority ${plane} epoch observation invalid`);
+      epochSeq=entry.epoch_seq;epochSha256=entry.epoch_sha256;
+    }
+    authority[plane]=Object.freeze({configured:entry.configured,armed:entry.armed,reason:entry.reason.slice(0,128),
+      epoch_seq:epochSeq,epoch_sha256:epochSha256});
+  }
+  return Object.freeze({...value,authority:Object.freeze(authority)});
+}
+
+export function assertAuthorityVector(snapshot,expected){
+  for(const plane of AUTHORITY_PLANES){
+    const entry=snapshot?.authority?.[plane];
+    if(!entry||typeof expected?.[plane]!=='boolean') throw new Error(`authority ${plane} observation or expectation invalid`);
+    if(entry.armed!==expected[plane]) throw new Error(`${plane} authority expected ${expected[plane]?'ARMED':'DISARMED'}; observed ${entry.armed?'ARMED':'DISARMED'} (${entry.reason})`);
+    if(expected[plane]&&!entry.configured) throw new Error(`${plane} authority unconfigured`);
+  }
+  return snapshot;
+}
+
+export function authorityBanner(snapshot){
+  return AUTHORITY_PLANES.map(plane=>`${plane} ${snapshot.authority[plane].armed?'ARMED':'DISARMED'}`).join(' | ');
+}
+
+export function assertRuntimeReadyObservation(snapshot,{coreRoot=null}={}){
+  if(snapshot?.state!=='ONLINE') throw new Error(`runtime state not ONLINE: ${String(snapshot?.state)}`);
+  for(const name of ['bridge','core','cloud']){
+    if(snapshot[name]?.alive!==true||snapshot[name]?.reason!=='verified') throw new Error(`${name} runtime identity unverified`);
+  }
+  if(snapshot.local_ready!==true) throw new Error('local MCP readiness unverified');
+  if(snapshot.supervisor?.running!==true) throw new Error('autonomous supervisor not running');
+  if(coreRoot!==null){
+    if(typeof snapshot.core_root!=='string'||path.win32.resolve(snapshot.core_root).toLowerCase()!==path.win32.resolve(coreRoot).toLowerCase())
+      throw new Error('core root does not match active release');
+  }
+  return snapshot;
+}

package/src/remote-live-log.mjs

@@ -183,6 +183,7 @@ export function formatRemoteToolCall(event,{clock=()=>Date.now(),displayMode='un
 function formatDuration(ms){
   const value=Number(ms);
   if(!Number.isFinite(value)||value<0) return '';
+  if(value<1) return value===0?'0ms':`${Number(value.toPrecision(3))}ms`;
   if(value<1000) return `${Math.round(value)}ms`;
   return `${(value/1000).toFixed(2)}s`;
 }
@@ -191,7 +192,8 @@ export function formatCompactAuditEvent(event){
   if(!event||typeof event!=='object'||Array.isArray(event)||typeof event.tool!=='string'||!/^[A-Za-z][A-Za-z0-9_.-]{0,127}$/.test(event.tool)) return null;
   if(event.event_type==='tool.request') return `▶ RUN ${event.tool}${summarizeArgs(sanitizeAuditArgs(event.args??{}))}`;
   if(event.event_type==='tool.result'){
-    const marker=event.outcome?.is_error===true?'❌ ERR':'✅ OK';
+    const outcome=outcomeClass(event);
+    const marker=outcome==='unknown'?'⚠ UNKNOWN':outcome==='error'?'❌ ERR':outcome==='pending'?'⏳ PENDING':'✅ OK';
     const duration=formatDuration(event.outcome?.duration_ms);
     return `${marker} ${event.tool}${duration?` ${duration}`:''}`;
   }
@@ -251,9 +253,16 @@ function traceText(meta,displayMode='unicode'){
     (meta.parent_span_id?' parent='+shortTraceValue(meta.parent_span_id,displayMode):'');
 }
 function outcomeClass(event){
-  if(event?.outcome?.side_effect_state==='unknown') return 'unknown';
-  return event?.outcome?.is_error===true?'error':'ok';
-}
+  const outcome=event?.outcome;
+  if(outcome?.side_effect_state==='unknown') return 'unknown';
+  const status=outcome?.status;
+  if(status==='timeout'||status==='timed_out') return 'unknown';
+  if(outcome?.is_error===true||
+     ['failed','denied','rejected','blocked','observed_failure','cancelled','canceled','unavailable','unsupported'].includes(status)) return 'error';
+  if(['pending','running','input_required','paused','processing','accepted'].includes(status)) return 'pending';
+  return 'ok';
+}
+export function classifyRemoteAuditOutcome(event){return outcomeClass(event);}
 function parseFilterExpression(expression){
   if(expression===null||expression===undefined||expression==='') return Object.freeze({});
   if(typeof expression!=='string'||expression.length>512) throw new Error('timeline filter invalid');
@@ -264,7 +273,7 @@ function parseFilterExpression(expression){
     const key=part.slice(0,at).trim();const value=part.slice(at+1).trim();
     if(!['tool','category','status','trace'].includes(key)) throw new Error(`timeline filter key '${key}' unsupported`);
     if(Object.hasOwn(out,key)) throw new Error(`timeline filter key '${key}' repeated`);
-    if(key==='status'&&!['ok','error','unknown'].includes(value)) throw new Error('timeline filter status invalid');
+    if(key==='status'&&!['ok','error','unknown','pending'].includes(value)) throw new Error('timeline filter status invalid');
     if(key==='category'&&!Object.hasOwn(TOOL_ICONS,value)) throw new Error('timeline filter category invalid');
     out[key]=value;
   }
@@ -287,7 +296,7 @@ export function createLiveTimelineFilter(expression=''){
       if(!requestId||!rawTool) return false;
       if(event.event_type==='tool.request'){
         const args=event.args??{};const tool=displayToolName(rawTool,args);const trace=traceIdentity(event,args);
-        const meta={tool,category:categoryForTool(tool),trace_id:trace.trace_id};
+        const meta={tool,raw_tool:rawTool,category:categoryForTool(tool),trace_id:trace.trace_id};
         if(pending.has(requestId))pending.delete(requestId);
         if(pending.size>=MAX_FILTER_IDENTITIES){pending.delete(pending.keys().next().value);evicted++;}
         pending.set(requestId,meta);
@@ -296,7 +305,8 @@ export function createLiveTimelineFilter(expression=''){
       if(event.event_type==='tool.result'){
         const meta=pending.get(requestId)??{tool:rawTool,category:categoryForTool(rawTool),trace_id:traceIdentity(event).trace_id};
         pending.delete(requestId);
-        return baseMatch(meta)&&(!spec.status||spec.status===outcomeClass(event));
+        const status=meta.raw_tool&&meta.raw_tool!==rawTool?'unknown':outcomeClass(event);
+        return baseMatch(meta)&&(!spec.status||spec.status===status);
       }
       return false;
     },
@@ -312,10 +322,20 @@ export function createLiveTimelineWriter({stream=process.stdout,displayMode='uni
   function flush(){
     if(active){stream.write('\n');active=null;}
   }
+  // Inspect terminal width for every emission: resize must not erase a wrapped prior line.
+  // Unknown Unicode cell width falls back to append-only output, never truncation.
+  function fitsOneRow(line){
+    const columns=stream.columns;
+    return /^[\x20-\x7e]*$/.test(line)&&(!Number.isInteger(columns)||line.length<columns);
+  }
   function write(line,{event_type=null,request_id=null}={}){
     if(typeof line!=='string'||!line) return;
     const tty=stream.isTTY===true&&rewrite;
-    if(!tty){stream.write(line+'\n');return;}
+    if(!tty||!fitsOneRow(line)){
+      if(active) flush();
+      stream.write(line+'\n');
+      return;
+    }
     if(active&&event_type==='tool.result'&&request_id&&request_id===active.request_id){
       stream.write('\r\x1b[2K'+line+'\n');active=null;return;
     }
@@ -340,7 +360,7 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,fo
   const MAX_PRESENTATION_IDENTITIES=4096;
   const toolCounts=new Map();
   const durationSamples=[];
-  let resultCount=0,okCount=0,errorCount=0,unknownCount=0,mutationCount=0,totalDurationMs=0,slowest=null,burst=null,foldedHeartbeatLines=0,peakInFlight=0;
+  let resultCount=0,okCount=0,errorCount=0,unknownCount=0,pendingCount=0,mutationCount=0,totalDurationMs=0,durationObservedCount=0,slowest=null,burst=null,foldedHeartbeatLines=0,peakInFlight=0;
   let lastCapability=null,suppressedCapability=0,suppressedCapabilityReported=false;
   let lastSourceSequence=0,pendingOverflow=0;
 
@@ -352,8 +372,10 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,fo
   }
   function traceSuffix(meta){return trace&&meta?'  '+traceText(meta,displayMode):'';}
   function resultLine(event,span,sequence){
-    const error=event.outcome?.is_error===true;
-    const unknown=event.outcome?.side_effect_state==='unknown';
+    const outcome=outcomeClass(event);
+    const error=outcome==='error';
+    const unknown=outcome==='unknown';
+    const pendingResult=outcome==='pending';
     const displayTool=span?.display_tool||event.tool;
     const rawDuration=Number(event.outcome?.duration_ms);
     const duration=Number.isFinite(rawDuration)
@@ -371,6 +393,7 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,fo
       ?shortValue(event.outcome.receipt_sha256s[0],8):'';
     const marker=unknown?'FAILED_AFTER_UNKNOWN_EFFECT':
       error?(displayMode==='ascii'?'ERR':'✗'):
+      pendingResult?'PENDING':
       ['write','edit','run'].includes(category)?(displayMode==='ascii'?'SUCCEEDED':'✅ SUCCEEDED'):
       (displayMode==='ascii'?'OK':'✓');
     const rawStatus=safeAtom(event.outcome?.status);
@@ -402,11 +425,12 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,fo
     const countKey=toolCounts.has(displayTool)||toolCounts.size<256?displayTool:'[other]';
     toolCounts.set(countKey,(toolCounts.get(countKey)??0)+1);
     const outcome=outcomeClass(event);
-    if(outcome==='unknown') unknownCount++;else if(outcome==='error') errorCount++;else okCount++;
+    if(outcome==='unknown') unknownCount++;else if(outcome==='error') errorCount++;else if(outcome==='pending') pendingCount++;else okCount++;
     if(['write','edit','run'].includes(categoryForTool(displayTool))) mutationCount++;
     const duration=Number(event.outcome?.duration_ms);
     if(Number.isFinite(duration)&&duration>=0){
       totalDurationMs+=duration;
+      durationObservedCount++;
       if(durationSamples.length<2048) durationSamples.push(duration);
       if(!slowest||duration>slowest.duration_ms) slowest={tool:displayTool,duration_ms:duration};
     }
@@ -444,6 +468,15 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,fo
       pending.delete(requestId);
       completed.add(requestId);
       if(completed.size>MAX_PRESENTATION_IDENTITIES)completed.delete(completed.values().next().value);
+      if(span&&span.tool!==tool){
+        const mismatchEvent={...event,outcome:{status:'correlation_mismatch',is_error:true,
+          side_effect_state:'unknown',duration_ms:event.outcome?.duration_ms,
+          reason:'CORRELATION_MISMATCH: terminal tool differs from START; inspect signed audit before retry'}};
+        addStats(mismatchEvent,span);
+        const prior=flushBurst();
+        const line=resultLine(mismatchEvent,span,sequence);
+        return prior?[prior,line]:line;
+      }
       addStats(event,span);
       const error=event.outcome?.is_error===true;
       const nowMs=eventMs(event,clock);
@@ -502,10 +535,11 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,fo
     const sorted=[...durationSamples].sort((a,b)=>a-b);
     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;
     return remoteDisplayText((displayMode==='ascii'?'[SUMMARY]':'📊 [SUMMARY]')+' '+resultCount+' calls | '+okCount+' ok | '+
-      errorCount+' error'+(errorCount===1?'':'s')+' | '+unknownCount+' unknown | '+mutationCount+' mutation'+(mutationCount===1?'':'s')+
+      errorCount+' error'+(errorCount===1?'':'s')+' | '+unknownCount+' unknown'+(pendingCount?' | '+pendingCount+' pending':'')+' | '+mutationCount+' mutation'+(mutationCount===1?'':'s')+
       ' | tool time '+(formatDuration(totalDurationMs)||'0ms')+
-      (p50!==null?' | p50 '+formatDuration(p50)+' | p95 '+formatDuration(p95):'')+
+      (p50!==null?' | p50 '+formatDuration(p50)+' | p95 '+formatDuration(p95)+' | p99 '+formatDuration(p99)+' | sample '+durationSamples.length+'/'+durationObservedCount:'')+
       (slowest?' | slowest '+slowest.tool+' '+formatDuration(slowest.duration_ms):'')+
       ' | peak in-flight '+peakInFlight+
       (foldedHeartbeatLines?' | folded '+foldedHeartbeatLines+' heartbeat lines':'')+