deadbyte-mcp 0.15.44 → 0.15.45

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 { createLiveTimelineFilter, createLiveTimelineTracker, createLiveTimelineWriter, formatCompactAuditEvent, formatRemoteLifecycle, formatRemoteToolCall, formatRuntimeDiagnosticLine, selectLiveLogNames } from './remote-live-log.mjs';
+import { classifyRemoteAuditOutcome, createLiveTimelineFilter, createLiveTimelineTracker, createLiveTimelineWriter, 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';
@@ -270,13 +270,15 @@ function auditTimelineRecord(file,line,auditEvent=null){
   if(event.event_type==='tool.request') return {event_type:'tool.call',request_id:event.request_id,tool:event.tool,
     observed_at_utc:observed,arguments:event.args??{},payload_sha256};
   if(event.event_type==='tool.result'){
-    const unknown=event.outcome?.side_effect_state==='unknown';
+    const classified=classifyRemoteAuditOutcome(event);
+    const unknown=classified==='unknown';
     const recoveryReason=unknown&&typeof event.outcome?.recovery?.reason==='string'?event.outcome.recovery.reason:null;
     return {event_type:'tool.result',request_id:event.request_id,tool:event.tool,
-      status:event.outcome?.is_error===true?'error':'ok',observed_at_utc:observed,payload_sha256,
+      status:classified==='pending'?'pending':classified==='ok'?'ok':'error',observed_at_utc:observed,payload_sha256,
       ...(Number.isFinite(Number(event.outcome?.duration_ms))?{duration_ms:Number(event.outcome.duration_ms)}:{}),
       ...(unknown?{side_effect_state:'unknown'}:{}),
-      ...(typeof event.outcome?.reason==='string'&&event.outcome.reason?{reason:event.outcome.reason}:(recoveryReason?{reason:recoveryReason}:{}))};
+      ...(typeof event.outcome?.reason==='string'&&event.outcome.reason?{reason:event.outcome.reason}:(recoveryReason?{reason:recoveryReason}:
+        (classified==='pending'&&typeof event.outcome?.status==='string'?{reason:event.outcome.status}:{})))};
   }
   return null;
 }
@@ -296,9 +298,9 @@ async function replayRemoteResults(root,cursor,{displayMode='unicode'}={}){
         continue;
       }
       const unknown=event.side_effect_state==='unknown';
-      const marker=unknown?'OUTCOME_UNKNOWN':event.status==='error'?(displayMode==='ascii'?'ERR':'✗'):(displayMode==='ascii'?'OK':'✓');
+      const marker=unknown?'OUTCOME_UNKNOWN':event.status==='pending'?'PENDING':event.status==='error'?(displayMode==='ascii'?'ERR':'✗'):(displayMode==='ascii'?'OK':'✓');
       const duration=Number.isFinite(Number(event.duration_ms))?` ${event.duration_ms<1000?Math.round(event.duration_ms)+'ms':(event.duration_ms/1000).toFixed(2)+'s'}`:'';
-      const reason=(event.status==='error'||unknown)&&typeof event.reason==='string'&&event.reason?` — ${event.reason}`:'';
+      const reason=(event.status==='error'||event.status==='pending'||unknown)&&typeof event.reason==='string'&&event.reason?` — ${event.reason}`:'';
       process.stdout.write(remoteDisplayText(`[REPLAY] #${event.seq} ${event.tool}${duration} ${marker}${reason}\n`,displayMode));
     }
     next=page.next_cursor;

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-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':'')+

package/src/remote-result-journal.mjs

@@ -5,7 +5,7 @@ import { sanitizeAuditArgs } from './tool-audit.mjs';
 export const REMOTE_RESULT_JOURNAL_SCHEMA='deadbyte.remote-result-journal.v1';
 const SESSION=/^[0-9a-f]{24}$/;
 const HASH=/^[0-9a-f]{64}$/;
-const STATUS=new Set(['ok','error']);
+const STATUS=new Set(['ok','error','pending']);
 const SIDE_EFFECT_STATES=new Set(['unknown']);
 const EVENT_TYPES=new Set(['tool.call','tool.result']);