deadbyte-mcp 0.15.43 → 0.15.45

package/test/r67-release-contract.test.mjs

@@ -0,0 +1,45 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+const sealedRoot=path.join(os.homedir(),'.deadbyte-mcp','releases','v0.15.44-9f500af433df3e77');
+const get=async rel=>JSON.parse(await readFile(path.join(sealedRoot,rel),'utf8'));
+const parent={
+ release_id:'v0.15.43-4c4a64a4c8e9f5a6',
+ manifest_sha256:'4c4a64a4c8e9f5a6e9eecce85fd0007ebcac99121b29c07f1a1fc81d1643cd33',
+ generation_manifest_sha256:'ef3b041e2a87c2e143d4733a98a52d9db80cd16ad7007e112fcb5202e70c77c3'
+};
+test('sealed R67 predecessor preserves its release version, lineage and prepublish evidence',async()=>{
+ const [pkg,bridge,release,prov,matrix,sbom,version]=await Promise.all([
+  get('package.json'),get('bridge/package.json'),
+  get('RELEASE.json'),get('PROVENANCE.json'),get('TEST-MATRIX.json'),get('SBOM.cdx.json'),
+  readFile(path.join(sealedRoot,'src','version.mjs'),'utf8')
+ ]);
+ assert.equal(pkg.version,'0.15.44');
+ assert.equal(bridge.version,pkg.version);
+ assert.match(version,/DEADBYTE_VERSION = '0\.15\.44'/);
+ assert.equal(release.version,pkg.version);
+ assert.equal(release.train,'R67');
+ assert.equal(release.parent.version,'0.15.43');
+ assert.equal(release.parent.release_id,parent.release_id);
+ assert.equal(release.parent.manifest_sha256,parent.manifest_sha256);
+ assert.equal(release.parent.generation_manifest_sha256,parent.generation_manifest_sha256);
+ assert.deepEqual(release.runtime_predecessor,parent);
+ assert.equal(prov.version,pkg.version);
+ assert.equal(prov.parent_release_id,parent.release_id);
+ assert.equal(prov.parent_manifest_sha256,parent.manifest_sha256);
+ assert.equal(prov.parent_generation_manifest_sha256,parent.generation_manifest_sha256);
+ assert.equal(matrix.version,pkg.version);
+ assert.equal(matrix.train,'R67');
+ assert.equal(sbom.metadata.component.version,pkg.version);
+ assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r67:0.15.44');
+ assert.equal(release.r67_native_observation.status,'CANDIDATE_SEALED');
+ assert.equal(release.r67_native_observation.new_public_tools,0);
+ assert.equal(release.r67_native_observation.full_release_gate,'PASS');
+ assert.equal(release.r67_native_observation.current_source_full_shards,'PASS');
+ assert.equal(release.r67_native_observation.isolated_activation_rollback_restore,'PASS');
+ assert.ok(matrix.required.some(x=>x.id==='r67-sharded-full'));
+ assert.match(pkg.scripts['gate:windows'],/gate-windows-r67\.ps1/);
+ assert.match(pkg.scripts['r67:focused:test'],/r67-focused-gate\.mjs/);
+});

package/test/r67-runtime-observation-binding.test.mjs

@@ -0,0 +1,86 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {mkdtemp,mkdir,writeFile,rm} from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import {createMachineRuntime} from '../src/machine-identity.mjs';
+import {independentlyVerifyR67RuntimeObservation} from '../scripts/r67-independent-runtime-observation-verify.mjs';
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const POLICY='a'.repeat(64),GRANT='r67-fixture-grant-1';
+async function fixture(callback){
+ const stateRoot=await mkdtemp(path.join(os.tmpdir(),'r67-owned-observation-'));
+ const release=path.join(stateRoot,'releases','r67'),generation=path.join(stateRoot,'generations','r67');
+ await mkdir(release,{recursive:true});await mkdir(generation,{recursive:true});
+ const releaseBytes=Buffer.from('candidate-r67-release\n'),generationBytes=Buffer.from('candidate-r67-generation\n');
+ await writeFile(path.join(release,'MANIFEST.SHA256'),releaseBytes);
+ await writeFile(path.join(generation,'GENERATION.SHA256'),generationBytes);
+ const releaseHash=sha(releaseBytes),generationHash=sha(generationBytes);
+ const pointer={
+  schema:'deadbyte.active-release.v1',release_id:'v0.15.43-'+releaseHash.slice(0,16),version:'0.15.43',
+  manifest_sha256:releaseHash,release_root:release,generation_root:generation,
+  generation_manifest_sha256:generationHash,launcher_sha256:'1'.repeat(64),
+  config_path:path.join(generation,'controller-config.psd1')
+ };
+ const activePointerPath=path.join(stateRoot,'active-release.json');
+ await writeFile(activePointerPath,JSON.stringify(pointer)+'\n');
+ const runtime=await createMachineRuntime({stateRoot,activePointerPath,assertObservationAuthority:callback});
+ return {runtime,stateRoot,cleanup:()=>rm(stateRoot,{recursive:true,force:true})};
+}
+const grant=()=>({grant_id:GRANT,policy_sha256:POLICY,scope:'native-observe-readonly',authority_generation:4});
+test('R67 isolated machine-owned observation signs actual Windows native process data with generation and scoped standing-grant',async()=>{
+ const phases=[];
+ const x=await fixture(async({phase,operation})=>{phases.push(phase);assert.equal(operation,'process');return grant();});
+ try{
+  const before=await x.runtime.status();
+  const output=await x.runtime.observeNative({args:['process','4']});
+  assert.equal(output.result.status,'ok');
+  assert.equal(output.receipt.machine_id,before.machine_id);
+  assert.equal(output.receipt.generation_manifest_sha256,before.generation_manifest_sha256);
+  assert.equal(output.receipt.authority.grant_id,GRANT);
+  assert.deepEqual(phases,['pre','post']);
+  const check=independentlyVerifyR67RuntimeObservation({
+   receipt:output.receipt,result:output.result,requestArgs:['process','4'],
+   machinePublicSpkiBase64:before.public_key_spki_base64,
+   expectedMachineStatus:before,expectedPolicySha256:POLICY,expectedGrantId:GRANT
+  });
+  assert.equal(check.ok,true,check.reason);
+  assert.equal(check.signature_valid,true);
+ }finally{await x.cleanup();}
+});
+test('R67 runtime observer denies missing authority, changing lease and revoked grant before signing',async()=>{
+ const noAuthority=await fixture(null);
+ try{await assert.rejects(()=>noAuthority.runtime.observeNative({args:['process','4']}),/authority/i);}
+ finally{await noAuthority.cleanup();}
+ let armed=true,rotate=false;
+ const x=await fixture(async({phase})=>{
+  if(phase==='post'&&rotate)armed=false;
+  if(!armed)throw new Error('LOCAL_AUTHORITY_REVOKED');
+  return grant();
+ });
+ try{
+  rotate=true;
+  await assert.rejects(()=>x.runtime.observeNative({args:['process','4']}),/LOCAL_AUTHORITY_REVOKED/);
+  assert.equal(armed,false);
+ }finally{await x.cleanup();}
+});
+test('R67 runtime observation verifier rejects changed result, request, generation, grant and signature',async()=>{
+ const x=await fixture(async()=>grant());
+ try{
+  const before=await x.runtime.status();
+  const xResult=await x.runtime.observeNative({args:['process','4']});
+  const verify=(receipt,result,args=['process','4'],status=before)=>independentlyVerifyR67RuntimeObservation({
+   receipt,result,requestArgs:args,machinePublicSpkiBase64:before.public_key_spki_base64,
+   expectedMachineStatus:status,expectedPolicySha256:POLICY,expectedGrantId:GRANT
+  }).ok;
+  assert.equal(verify(xResult.receipt,xResult.result),true);
+  const corrupt=structuredClone(xResult.result);corrupt.data.processes[0].name+='INJECTED';
+  assert.equal(verify(xResult.receipt,corrupt),false);
+  assert.equal(verify(xResult.receipt,xResult.result,['process','8']),false);
+  assert.equal(verify({...xResult.receipt,generation_manifest_sha256:'0'.repeat(64)},xResult.result),false);
+  assert.equal(verify({...xResult.receipt,authority:{...xResult.receipt.authority,grant_id:'wrong'}},xResult.result),false);
+  assert.equal(verify({...xResult.receipt,attestation:{...xResult.receipt.attestation,signature_base64:'AA=='}},xResult.result),false);
+  const after={...before,identity_generation:before.identity_generation+1};
+  assert.equal(verify(xResult.receipt,xResult.result,['process','4'],after),false);
+ }finally{await x.cleanup();}
+});

package/test/r67-server-observation-wiring.test.mjs

@@ -0,0 +1,12 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+test('R67 server-owned Native Observer is wired to live Coding standing epoch and explicitly opted in',async()=>{
+ const source=await readFile(new URL('../src/mcp-server.mjs',import.meta.url),'utf8');
+ assert.match(source,/import \{ createR67NativeObservationAuthority \} from '\.\/r67-native-observation-authority\.mjs'/);
+ assert.match(source,/let codingPolicy=null;/);
+ assert.match(source,/DEADBYTE_R67_NATIVE_OBSERVE \?\? '0'/);
+ assert.match(source,/getCodingPolicy:\(\)=>codingPolicy,enabled:nativeObserveMode==='1'/);
+ assert.match(source,/createMachineRuntime\(\{stateRoot:runtimeStateRoot,assertObservationAuthority:assertNativeObservationAuthority\}\)/);
+ assert.equal((source.match(/let codingPolicy=null;/g)??[]).length,1);
+});

package/test/r67-signed-receipt.test.mjs

@@ -0,0 +1,66 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {generateKeyPairSync,createHash} from 'node:crypto';
+import {signR67Observation} from '../src/r67-observation-receipt.mjs';
+import {independentlyVerifyR67Receipt} from '../scripts/r67-independent-observation-verify.mjs';
+import {runNativeInspect} from '../src/native-inspector-r67.mjs';
+
+const sha=s=>createHash('sha256').update(s).digest('hex');
+const pair=generateKeyPairSync('ed25519');
+const trustedPublicSpkiBase64=pair.publicKey.export({type:'spki',format:'der'}).toString('base64');
+const other=generateKeyPairSync('ed25519');
+const otherSpki=other.publicKey.export({type:'spki',format:'der'}).toString('base64');
+const requestSha256=sha(Buffer.from(JSON.stringify(['process','4']),'utf8'));
+const executableSha256='c814771dddac8bfb184250b868ddb6ab9f5e0e43613c04c3ed8abe09324ec4db';
+
+test('R67 signs a real Windows native observation and independently verifies exact result bytes',async()=>{
+ const result=await runNativeInspect(['process','4']);
+ assert.equal(result.status,'ok');
+ const receipt=signR67Observation({privateKey:pair.privateKey,publicKey:pair.publicKey,operation:'process',requestSha256,executableSha256,result});
+ const verified=independentlyVerifyR67Receipt({receipt,result,trustedPublicSpkiBase64,requestArgs:['process','4'],expectedExecutableSha256:executableSha256});
+ assert.equal(verified.ok,true,verified.reason);
+ assert.equal(verified.signature_valid,true);
+ assert.equal(verified.signer_key_id,sha(Buffer.from(trustedPublicSpkiBase64,'base64')));
+});
+
+test('R67 independent verifier rejects changed result, changed receipt, alternate signer and malformed encoding',async()=>{
+ const result=await runNativeInspect(['process','4']);
+ const receipt=signR67Observation({privateKey:pair.privateKey,publicKey:pair.publicKey,operation:'process',requestSha256,executableSha256,result});
+ const changedResult=structuredClone(result);
+ changedResult.data.processes[0].name+='INJECTED';
+ assert.equal(independentlyVerifyR67Receipt({receipt,result:changedResult,trustedPublicSpkiBase64,requestArgs:['process','4'],expectedExecutableSha256:executableSha256}).ok,false);
+ const changedReceipt={...receipt,executable_sha256:sha(Buffer.from('ATTACK'))};
+ assert.equal(independentlyVerifyR67Receipt({receipt:changedReceipt,result,trustedPublicSpkiBase64,requestArgs:['process','4'],expectedExecutableSha256:executableSha256}).ok,false);
+ assert.equal(independentlyVerifyR67Receipt({receipt,result,trustedPublicSpkiBase64:otherSpki,requestArgs:['process','4'],expectedExecutableSha256:executableSha256}).ok,false);
+ const forged=signR67Observation({privateKey:other.privateKey,publicKey:other.publicKey,operation:'process',requestSha256,executableSha256,result});
+ assert.equal(independentlyVerifyR67Receipt({receipt:forged,result,trustedPublicSpkiBase64,requestArgs:['process','4'],expectedExecutableSha256:executableSha256}).ok,false);
+ const badSig={...receipt,attestation:{...receipt.attestation,signature_base64:'AAA='}};
+ assert.equal(independentlyVerifyR67Receipt({receipt:badSig,result,trustedPublicSpkiBase64,requestArgs:['process','4'],expectedExecutableSha256:executableSha256}).ok,false);
+});
+
+test('R67 signing fails closed without trusted caller signer or on mismatched public/private key and corrupt data SHA',async()=>{
+ const result=await runNativeInspect(['process','4']);
+ assert.throws(()=>signR67Observation({operation:'process',requestSha256,executableSha256,result}),/trusted runtime/);
+ assert.throws(()=>signR67Observation({privateKey:pair.privateKey,publicKey:other.publicKey,operation:'process',requestSha256,executableSha256,result}),/mismatch/);
+ const altered={...result,data_sha256:sha(Buffer.from('forged'))};
+ assert.throws(()=>signR67Observation({privateKey:pair.privateKey,publicKey:pair.publicKey,operation:'process',requestSha256,executableSha256,result:altered}),/digest invalid/);
+});
+
+test('R67 trusted caller signing is integrated into actual native process inspection, not implicit CLI authority',async()=>{
+ const {result,receipt}=await runNativeInspect(['process','4'],{trustedSigner:{privateKey:pair.privateKey,publicKey:pair.publicKey}});
+ assert.equal(result.status,'ok');
+ assert.equal(receipt.operation,'process');
+ const check=independentlyVerifyR67Receipt({receipt,result,trustedPublicSpkiBase64,requestArgs:['process','4'],expectedExecutableSha256:executableSha256});
+ assert.equal(check.ok,true,check.reason);
+ const untrusted=await runNativeInspect(['process','4']);
+ assert.equal(untrusted.status,'ok');
+ assert.equal(Object.hasOwn(untrusted,'attestation'),false);
+});
+
+test('R67 independent verifier requires exact request argv and trusted executable pin',async()=>{
+ const result=await runNativeInspect(['process','4']);
+ const receipt=signR67Observation({privateKey:pair.privateKey,publicKey:pair.publicKey,operation:'process',requestSha256,executableSha256,result});
+ assert.equal(independentlyVerifyR67Receipt({receipt,result,trustedPublicSpkiBase64,requestArgs:['process','8'],expectedExecutableSha256:executableSha256}).ok,false);
+ assert.equal(independentlyVerifyR67Receipt({receipt,result,trustedPublicSpkiBase64,requestArgs:['process','4'],expectedExecutableSha256:sha(Buffer.from('WRONG EXE'))}).ok,false);
+ assert.equal(independentlyVerifyR67Receipt({receipt,result,trustedPublicSpkiBase64}).ok,false);
+});

package/test/r67-skip-rationale.test.mjs

@@ -0,0 +1,31 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {spawnSync} from 'node:child_process';
+import {fileURLToPath} from 'node:url';
+import path from 'node:path';
+import {parseR67NonpassCases,parseR67TapSummary} from '../src/r67-regression-shards.mjs';
+const root=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const historical=[
+ 'test/r53-release-contract.test.mjs','test/r54-release-contract.test.mjs','test/r55-release-contract.test.mjs',
+ 'test/r56-release-contract.test.mjs','test/r57-release-contract.test.mjs','test/r58-release-contract.test.mjs',
+ 'test/r58-windows-gate.test.mjs','test/r58-bundled-bridge.test.mjs','test/r60-release-contract.test.mjs',
+ 'test/r61-release-contract.test.mjs','test/r62-release-contract.test.mjs','test/r63-release-contract.test.mjs',
+ 'test/r64-release-contract.test.mjs','test/r65-release-contract.test.mjs','test/semantic-multilang.test.mjs'
+];
+test('R67 real TAP from historical release and R35 fixture skips has individual source-derived reasons',()=>{
+ const r=spawnSync(process.execPath,['--test','--test-reporter=tap','--test-concurrency=2',...historical],{
+ cwd:root,encoding:'utf8',windowsHide:true,shell:false,timeout:90000,maxBuffer:16*1024*1024,
+ env:Object.fromEntries(Object.entries(process.env).filter(([key])=>key!=='NODE_TEST_CONTEXT'))
+ });
+ assert.equal(r.error,undefined,r.error?.message);
+ assert.equal(r.status,0,'selected regression exit '+r.status+' output tail '+r.stdout?.slice(-1500));
+ const tap=parseR67TapSummary(r.stdout);
+ assert.ok(tap,'valid full TAP totals; stdout-tail='+String(r.stdout).slice(-1600)+'; stderr-tail='+String(r.stderr).slice(-500));
+ assert.equal(tap.fail,0);
+ const ledger=parseR67NonpassCases(r.stdout);
+ assert.ok(ledger,'nonpass parser output');
+ assert.ok(ledger.expected_nonpass>0,'must exercise real skip path');
+ assert.equal(ledger.fully_classified,true,JSON.stringify(ledger.cases.filter(x=>!x.reason)));
+ assert.equal(ledger.cases.length,ledger.expected_nonpass);
+ for(const c of ledger.cases)assert.match(c.reason,/Historical|historical|fixture|R35|R\d+/);
+});

package/test/r67-tool-annotations.test.mjs

@@ -0,0 +1,21 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {registerMachineTools} from '../src/machine-mcp-tools.mjs';
+test('R67 MCP annotations classify pure observation distinctly from machine revoke, without granting authority',async()=>{
+ const catalog=new Map();
+ const server={registerTool:(name,config,fn)=>catalog.set(name,{config,fn})};
+ let granted=false;
+ const runtime={list:async()=>({status:'ok',machines:[]}),status:async()=>({status:'ok'}),ping:async()=>({status:'ok'}),revoke:async()=>({status:'revoked'})};
+ registerMachineTools(server,{runtime,assertRevokeAuthority:async()=>{if(!granted)throw new Error('LOCAL_DENY');}});
+ for(const name of ['machine_list','machine_status','machine_ping']){
+  const hint=catalog.get(name).config.annotations;
+  assert.equal(hint.readOnlyHint,true,name);
+  assert.equal(hint.destructiveHint,false,name);
+  assert.equal(hint.openWorldHint,false,name);
+ }
+ const rev=catalog.get('machine_revoke');
+ assert.deepEqual(rev.config.annotations,{readOnlyHint:false,destructiveHint:true,idempotentHint:false,openWorldHint:false});
+ const denial=await rev.fn({reason:'check'});
+ assert.ok(denial.isError||denial.structuredContent?.status==='denied','annotations cannot grant revocation');
+ assert.equal(granted,false);
+});

package/test/r67-windows-gate-argv.test.mjs

@@ -0,0 +1,13 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+const root=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+
+test('R67 Windows release gate must not shadow automatic PowerShell $Args when passing node script argv',async()=>{
+ const source=await readFile(path.join(root,'scripts','gate-windows-r67.ps1'),'utf8');
+ assert.doesNotMatch(source,/\[string\[\]\]\$Args\b/i,'PowerShell automatic $Args silently discards function parameters');
+ assert.match(source,/\[string\[\]\]\$NodeArgs\b/);
+ assert.match(source,/\& node @NodeArgs/);
+});

package/test/r69-live-outcome.test.mjs

@@ -0,0 +1,137 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {readFile} from 'node:fs/promises';
+import {classifyRemoteAuditOutcome,createLiveTimelineTracker,createLiveTimelineFilter,createLiveTimelineWriter,formatCompactAuditEvent} from '../src/remote-live-log.mjs';
+
+function pair(status,is_error=false,side_effect_state=null){
+  const tracker=createLiveTimelineTracker({clock:()=>1000,displayMode:'ascii',rootPaths:{local_d:'D:\\'}});
+  const args={root_id:'local_d',path:'TECHNICAL/ProgramingLangPJ/tmp/gfx_r3_dev/runtime/gfx/dbyte_gfx3d.dby'};
+  const start=tracker.observe({event_type:'tool.request',tool:'coding_file_write',request_id:'r69-example-1',args});
+  const done=tracker.observe({event_type:'tool.result',tool:'coding_file_write',request_id:'r69-example-1',
+    outcome:{status,is_error,side_effect_state,duration_ms:1}});
+  return {tracker,start,done};
+}
+
+test('R69 failed, denied and observed_failure never produce a false SUCCEEDED line',()=>{
+  for(const status of ['failed','denied','rejected','blocked','observed_failure','cancelled']){
+    const {tracker,done}=pair(status);
+    assert.match(done,/ERR  status=/,status);
+    assert.doesNotMatch(done,/SUCCEEDED|\bOK\b/,status);
+    assert.match(tracker.summary(),/0 ok \| 1 error/,status);
+  }
+});
+
+test('R69 unavailable and unsupported result envelopes never print mutation SUCCEEDED',()=>{
+  for(const status of ['unavailable','unsupported']){
+    const {tracker,done}=pair(status);
+    assert.match(done,/ERR  status=/,status);
+    assert.doesNotMatch(done,/SUCCEEDED/,status);
+    assert.match(tracker.summary(),/0 ok \| 1 error/,status);
+  }
+});
+
+test('R69 pending tool result requires continuation, never implies effect committed',()=>{
+  for(const status of ['pending','running','input_required','paused','processing','accepted']){
+    const {tracker,done}=pair(status);
+    assert.match(done,/PENDING  status=/,status);
+    assert.doesNotMatch(done,/SUCCEEDED|\bOK\b/,status);
+    assert.match(tracker.summary(),/0 ok \| 0 errors \| 0 unknown \| 1 pending/,status);
+  }
+});
+
+test('R69 unknown side-effect outranks every status; no retry claim',()=>{
+  const {done,tracker}=pair('committed',false,'unknown');
+  assert.match(done,/FAILED_AFTER_UNKNOWN_EFFECT/);
+  assert.match(tracker.summary(),/1 unknown/);
+});
+
+test('R69 human console always retains the operation location in terminal result',()=>{
+  const {start,done}=pair('denied');
+  const absolute='D:\\TECHNICAL\\ProgramingLangPJ\\tmp\\gfx_r3_dev\\runtime\\gfx\\dbyte_gfx3d.dby [root=local_d]';
+  assert.ok(start.includes(absolute));
+  assert.ok(done.includes(absolute));
+  assert.match(done,/ERR  status=denied/);
+  assert.doesNotMatch(done,/SUCCEEDED/);
+});
+
+test('R69 compact audit flags status failure or pending even with is_error=false',()=>{
+  assert.match(formatCompactAuditEvent({event_type:'tool.result',tool:'host_exec',outcome:{is_error:false,status:'denied'}}),/ERR/);
+  assert.match(formatCompactAuditEvent({event_type:'tool.result',tool:'host_exec',outcome:{is_error:false,status:'input_required'}}),/PENDING/);
+});
+
+test('R69 TTY writer obeys runtime terminal resize without rewriting a wrapped start line',()=>{
+  const writes=[];
+  const stream={isTTY:true,columns:32,write(value){writes.push(value);return true;}};
+  const writer=createLiveTimelineWriter({stream,displayMode:'ascii'});
+  writer.write('START',{event_type:'tool.call',request_id:'resize'});
+  stream.columns=5;
+  writer.write('TOO LONG RESULT',{event_type:'tool.result',request_id:'resize'});
+  assert.deepEqual(writes,['START','\n','TOO LONG RESULT\n']);
+  assert.equal(writer.pending(),null);
+  stream.columns=80;
+  writer.write('RUN',{event_type:'tool.call',request_id:'wide'});
+  writer.write('OK',{event_type:'tool.result',request_id:'wide'});
+  assert.equal(writes.at(-1),'\r\x1b[2KOK\n');
+});
+
+
+test('R69 live latency uses fractional milliseconds instead of printing a false 0ms',()=>{
+  const tracker=createLiveTimelineTracker({clock:()=>1000,displayMode:'ascii'});
+  tracker.observe({event_type:'tool.request',tool:'machine_status',request_id:'subms'});
+  const done=tracker.observe({event_type:'tool.result',tool:'machine_status',request_id:'subms',
+    outcome:{is_error:false,duration_ms:0.125}});
+  assert.ok(done.includes('0.125ms'));
+  assert.doesNotMatch(done,/ 0ms /);
+});
+
+test('R69 latency summary includes p99 and discloses bounded sample coverage',()=>{
+  const tracker=createLiveTimelineTracker({clock:()=>1000,displayMode:'ascii'});
+  for(let i=1;i<=100;i++){
+    const id='sample-'+i;
+    tracker.observe({event_type:'tool.request',tool:'machine_status',request_id:id});
+    tracker.observe({event_type:'tool.result',tool:'machine_status',request_id:id,
+      outcome:{is_error:false,duration_ms:i}});
+  }
+  const summary=tracker.summary();
+  assert.ok(summary.includes('p50 51ms'));
+  assert.ok(summary.includes('p95 95ms'));
+  assert.ok(summary.includes('p99 99ms'));
+  assert.ok(summary.includes('sample 100/100'));
+});
+
+test('R69 filter matches status-only errors independent of is_error=false',()=>{
+  const filter=createLiveTimelineFilter('status=error');
+  filter.accept({event_type:'tool.request',tool:'host_exec',request_id:'r69-e',args:{}});
+  assert.equal(filter.accept({event_type:'tool.result',tool:'host_exec',request_id:'r69-e',outcome:{status:'denied',is_error:false}}),true);
+});
+
+test('R69 mismatched terminal tool cannot inherit a mutating START or claim success',()=>{
+  const tracker=createLiveTimelineTracker({clock:()=>1000,displayMode:'ascii'});
+  const start=tracker.observe({event_type:'tool.request',tool:'coding_file_write',request_id:'r69-mismatch',args:{root_id:'core',path:'scratch.txt'}});
+  assert.match(start,/START/);
+  const terminal=tracker.observe({event_type:'tool.result',tool:'machine_ping',request_id:'r69-mismatch',
+    outcome:{status:'ok',is_error:false,duration_ms:1,receipt_sha256s:['a'.repeat(64)]}});
+  assert.match(terminal,/CORRELATION_MISMATCH/);
+  assert.doesNotMatch(terminal,/SUCCEEDED|RECEIPT=/);
+  assert.match(tracker.summary(),/0 ok \| 0 errors \| 1 unknown/);
+});
+
+test('R69 status filter cannot hide a mismatched terminal identity as successful',()=>{
+  const unknown=createLiveTimelineFilter('status=unknown');
+  unknown.accept({event_type:'tool.request',tool:'coding_file_write',request_id:'r69-filter-mismatch',args:{}});
+  assert.equal(unknown.accept({event_type:'tool.result',tool:'machine_ping',request_id:'r69-filter-mismatch',
+    outcome:{status:'ok',is_error:false}}),true);
+});
+
+test('R69 remote replay projection does not record unavailable as ok or input_required as complete',async()=>{
+  const source=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
+  const start=source.indexOf('function auditTimelineRecord(');
+  const end=source.indexOf('async function replayRemoteResults(',start);
+  assert.ok(start>=0&&end>start);
+  const record=new Function('createHash','parseAuditLogLine','classifyRemoteAuditOutcome',`${source.slice(start,end)};return auditTimelineRecord;`)(createHash,()=>null,classifyRemoteAuditOutcome);
+  const base={event_type:'tool.result',request_id:'r69-projection',tool:'coding_file_write',ts:'2026-10-13T00:00:00.000Z'};
+  assert.equal(record('audit.log','bounded-line',{...base,outcome:{status:'unavailable',is_error:false}}).status,'error');
+  assert.equal(record('audit.log','bounded-line',{...base,outcome:{status:'input_required',is_error:false}}).status,'pending');
+});
+

package/test/r70-autonomous-grant-expiry.test.mjs

@@ -0,0 +1,89 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,readFile,rm,writeFile} from 'node:fs/promises';
+import {spawnSync} from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
+import * as auto from '../src/autonomous-policy.mjs';
+
+const H=c=>c.repeat(64);
+const controller=new URL('../controller/deadbyte-controller.ps1',import.meta.url);
+const quote=s=>`'${String(s).replaceAll("'","''")}'`;
+const issued=Date.parse('2026-10-13T03:00:00.000Z');
+const when=n=>new Date(issued+n).toISOString();
+
+test('R70 signed standing grant expiry is bounded, canonical and fail-closed before authority decision',()=>{
+  assert.equal(typeof auto.inspectAutonomousStandingWindow,'function');
+  const base={granted_at_utc:when(0),expires_at_utc:when(1_800_000)};
+  assert.deepEqual(auto.inspectAutonomousStandingWindow(base,new Date(when(300_000))),
+    {ok:true,reason:null,expires_at_utc:when(1_800_000),remaining_ms:1_500_000});
+  for(const [claim,reason,now] of [
+    [{...base,expires_at_utc:when(0)},'expiry-window-invalid',when(30_000)],
+    [{...base,expires_at_utc:when(3_600_001)},'expiry-window-invalid',when(30_000)],
+    [{...base,expires_at_utc:'bad'},'expiry-invalid',when(30_000)],
+    [{...base,expires_at_utc:when(1_800_000)},'expired',when(1_800_000)],
+    [{...base,granted_at_utc:when(700_000)},'not-yet-valid',when(300_000)]
+  ]){
+    const result=auto.inspectAutonomousStandingWindow(claim,new Date(now));
+    assert.equal(result.ok,false);
+    assert.equal(result.reason,reason);
+  }
+  assert.deepEqual(auto.inspectAutonomousStandingWindow({granted_at_utc:when(0)},new Date(when(300_000))),
+    {ok:true,reason:null,expires_at_utc:null,remaining_ms:null});
+});
+
+test('R70 runtime rejects a v2 grant whose Coding policy digest is missing or stale',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r70-coding-lease-'));
+  const leaseFile=path.join(root,'grant.json');
+  try{
+    const policy={policy_sha256:H('a'),coding_policy_sha256:H('b'),root_ids:['core'],
+      lease_file:leaseFile,policy_path:path.join(root,'autonomous-policy.json')};
+    const base={schema:'deadbyte.autonomous-grant.v2',policy_sha256:H('a'),
+      instance_nonce:H('c'),root_ids:['core'],granted_at_utc:when(0),
+      expires_at_utc:when(1_800_000)};
+    for(const candidate of [{...base,coding_policy_sha256:H('d')},base]){
+      await writeFile(leaseFile,JSON.stringify(candidate));
+      const status=await auto.autonomousSessionStatus(policy,new Date(when(300_000)));
+      assert.equal(status.armed,false);
+      assert.equal(status.reason,'coding-policy-digest');
+      await assert.rejects(auto.recheckAutonomousAuthority(policy,{
+        armed:true,instance_nonce:H('c'),root_ids:['core'],standing:true,expires_at_utc:when(1_800_000)
+      },'core',new Date(when(300_000))),/coding-policy-digest/);
+    }
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R70 controller must agree with runtime on expired and malformed signed standing grant',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r70-grant-expiry-'));
+  const grantFile=path.join(root,'autonomous-grant.json');
+  try{
+    const scriptText=await readFile(controller,'utf8');
+    const start=scriptText.indexOf('function Get-AutonomousLeaseStatus(');
+    const end=scriptText.indexOf('function Arm-Autonomous(',start);
+    assert.ok(start>=0&&end>start);
+    const block=scriptText.slice(start,end);
+    const now=Date.now();
+    const records=[
+      {name:'expired',grant:new Date(now-3_600_000),expires:new Date(now-1_800_000),reason:'expired',armed:false},
+      {name:'oversized',grant:new Date(now-300_000),expires:new Date(now+7_200_000),reason:'expiry-window-invalid',armed:false},
+      {name:'valid',grant:new Date(now-300_000),expires:new Date(now+900_000),reason:'standing-grant',armed:true}
+    ];
+    for(const c of records){
+      const lease={schema:'deadbyte.autonomous-grant.v2',policy_sha256:H('a'),coding_policy_sha256:H('b'),
+        instance_nonce:H('c'),root_ids:['core'],granted_at_utc:c.grant.toISOString(),
+        expires_at_utc:c.expires.toISOString()};
+      await writeFile(grantFile,JSON.stringify(lease));
+      const script=`$ErrorActionPreference='Stop';
+function Get-AutonomousPolicyMetadata($Cfg){return [pscustomobject]@{LeaseFile=${quote(grantFile)};Sha256='${H('a')}';CodingPolicySha256='${H('b')}';RootIds=@('core')}}
+function Get-CodingLeaseStatus($Cfg){return [pscustomobject]@{Armed=$true;RootIds=@('core')}}
+function Get-AuthorityEpochStatus($Cfg,$Plane,$File,$Nonce){return [pscustomobject]@{Trusted=$true;Seq=1;EventSha256='${H('d')}'}}
+${block}
+(Get-AutonomousLeaseStatus @{AutonomousPolicyFile='test-fixture'})|ConvertTo-Json -Compress`;
+      const result=spawnSync('powershell',['-NoLogo','-NoProfile','-NonInteractive','-Command',script],{encoding:'utf8',timeout:15000});
+      assert.equal(result.status,0,result.stderr);
+      const out=JSON.parse(result.stdout.trim());
+      assert.equal(out.Armed,c.armed,c.name);
+      assert.equal(out.Reason,c.reason,c.name);
+    }
+  }finally{await rm(root,{recursive:true,force:true});}
+});