deadbyte-mcp 0.15.43 → 0.15.45

package/scripts/r67-regression-shard-run.mjs

@@ -0,0 +1,70 @@
+import {readdir,mkdir,open,readFile,rename} from 'node:fs/promises';
+import {spawnSync} from 'node:child_process';
+import {createHash} from 'node:crypto';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {createR67ShardPlan,r67ShardTimeoutMs,r67RegressionTreeHash,parseR67TapSummary,parseR67NonpassCases,parseR67FailedCases} from '../src/r67-regression-shards.mjs';
+
+const root=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const action=process.argv[2],operation=process.argv[3],number=process.argv[4];
+if(!['run','status'].includes(action)||!/^[a-z0-9][a-z0-9._-]{5,63}$/.test(operation??'')||!/^(?:0|[1-9][0-9]?)$/.test(number??''))throw new Error('usage: run|status uniqueOperationId index');
+const index=Number(number);
+if(index>=32)throw new Error('R67 shard index must be 0..31');
+const names=(await readdir(path.join(root,'test'))).filter(n=>n.endsWith('.test.mjs')).map(n=>'test/'+n).sort();
+const plan=createR67ShardPlan(names,32),shard=plan.shards[index];
+const hash=b=>createHash('sha256').update(b).digest('hex');
+const evidenceRoot=path.resolve(root,'..','..','testing','0.15.44-r67','regression-shards');
+const directory=path.join(evidenceRoot,operation+'-shard-'+String(index).padStart(2,'0'));
+const intentPath=path.join(directory,'intent.json'),resultPath=path.join(directory,'result.json');
+if(action==='status'){
+ let intent,result;
+ try{intent=JSON.parse(await readFile(intentPath,'utf8'));}catch(error){if(error.code==='ENOENT'){console.log(JSON.stringify({status:'NOT_STARTED',operation,shard_index:index}));process.exit(0);}throw error;}
+ try{result=JSON.parse(await readFile(resultPath,'utf8'));}catch(error){if(error.code==='ENOENT'){console.log(JSON.stringify({status:'RUNNING_OR_OUTCOME_UNKNOWN',operation,shard_index:index,intent}));process.exit(0);}throw error;}
+ const {receipt_sha256,...body}=result;
+ if(receipt_sha256!==hash(Buffer.from(JSON.stringify(body),'utf8')))throw new Error('durable result receipt hash mismatch');
+ console.log(JSON.stringify({status:'COMPLETED_RECORD',operation,shard_index:index,result},null,2));
+ process.exit(0);
+}
+await mkdir(evidenceRoot,{recursive:true});
+await mkdir(directory,{recursive:false}); // EEXIST means NEVER rerun: reconcile existing intent/result
+const startedAt=new Date().toISOString();
+const fileHashes=[];
+for(const name of names)fileHashes.push([name,hash(await readFile(path.join(root,name)))]);
+const test_tree_sha256=hash(Buffer.from(JSON.stringify(fileHashes),'utf8'));
+const sourceTree=await r67RegressionTreeHash(root);
+const intent={schema:'deadbyte.r67-shard-intent.v1',operation,shard_index:index,plan_sha256:plan.plan_sha256,
+ files_sha256:shard.files_sha256,test_tree_sha256,source_tree_sha256:sourceTree.sha256,
+ source_file_count:sourceTree.file_count,started_at_utc:startedAt,files:shard.files};
+const intentHandle=await open(intentPath,'wx',0o600);
+try{await intentHandle.writeFile(JSON.stringify(intent,null,2)+'\n');await intentHandle.sync();}finally{await intentHandle.close();}
+const began=Date.now();
+const configuredTimeoutMs=r67ShardTimeoutMs(shard);
+const child=spawnSync(process.execPath,['--test','--test-reporter=tap','--test-concurrency=2',...shard.files],{
+ cwd:root,encoding:'utf8',windowsHide:true,shell:false,timeout:configuredTimeoutMs,maxBuffer:16*1024*1024
+});
+const output=String(child.stdout||''),stderr=String(child.stderr||'');
+const tap=parseR67TapSummary(output);
+const nonpass=parseR67NonpassCases(output);
+const failures=parseR67FailedCases(output);
+const testCount=tap?.tests??null,passed=tap?.pass??null,failed=tap?.fail??null;
+let status='OUTCOME_UNKNOWN';
+if(!child.error&&Number.isInteger(child.status)&&tap!==null){
+ status=(child.status===0&&failed===0&&testCount>=shard.files.length)?'PASS':'FAILED';
+}
+const body={schema:'deadbyte.r67-shard-result.v2',operation_id:operation,shard_index:index,
+ plan_sha256:plan.plan_sha256,files_sha256:shard.files_sha256,test_tree_sha256,
+ source_tree_sha256:sourceTree.sha256,source_file_count:sourceTree.file_count,
+ status,exit_code:child.status,test_count:testCount,passed,failed,
+ skipped:tap?.skipped??null,cancelled:tap?.cancelled??null,todo:tap?.todo??null,
+ ...(nonpass?{nonpass_cases:nonpass.cases,nonpass_fully_classified:nonpass.fully_classified}:{}),
+ failure_cases:failures.cases,failure_cases_complete:failures.complete,
+ timed_out:child.error?.code==='ETIMEDOUT',failure_reason:child.error?.code??null,
+ elapsed_ms:Date.now()-began,configured_timeout_ms:configuredTimeoutMs,finished_at_utc:new Date().toISOString(),
+ stdout_sha256:hash(Buffer.from(output,'utf8')),stderr_sha256:hash(Buffer.from(stderr,'utf8'))};
+const receipt={...body,receipt_sha256:hash(Buffer.from(JSON.stringify(body),'utf8'))};
+const temporary=path.join(directory,'result.tmp-'+process.pid);
+const h=await open(temporary,'wx',0o600);
+try{await h.writeFile(JSON.stringify(receipt,null,2)+'\n');await h.sync();}finally{await h.close();}
+await rename(temporary,resultPath);
+console.log(JSON.stringify({status,receipt_path:resultPath,receipt},null,2));
+if(status!=='PASS')process.exitCode=1;

package/scripts/r67-run-shard-batch.mjs

@@ -0,0 +1,18 @@
+import {spawnSync} from 'node:child_process';
+import {readFile} from 'node:fs/promises';
+import {fileURLToPath} from 'node:url';
+import path from 'node:path';
+const root=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const op=process.argv[2],start=Number(process.argv[3]),end=Number(process.argv[4]);
+if(!/^[a-z0-9][a-z0-9._-]{5,63}$/.test(op??'')||!Number.isInteger(start)||!Number.isInteger(end)||start<0||end>32||end<=start||end-start>8)throw Error('usage: operation id, start, end (max eight)');
+const runner=path.join(root,'scripts','r67-regression-shard-run.mjs');
+const results=[];
+for(let i=start;i<end;i++){
+ const found=spawnSync(process.execPath,[runner,'run',op,String(i)],{cwd:root,encoding:'utf8',shell:false,windowsHide:true,timeout:220000,maxBuffer:256*1024});
+ const receiptPath=path.resolve(root,'..','..','testing','0.15.44-r67','regression-shards',op+'-shard-'+String(i).padStart(2,'0'),'result.json');
+ let body=null;try{body=JSON.parse(await readFile(receiptPath,'utf8'));}catch{}
+ results.push({shard_index:i,transport_exit:found.status,child_error:found.error?.code??null,recorded_status:body?.status??'MISSING',test_count:body?.test_count??null,passed:body?.passed??null,skipped:body?.skipped??null,nonpass_classified:body?.nonpass_fully_classified??null,source_tree_sha256:body?.source_tree_sha256??null,receipt_sha256:body?.receipt_sha256??null});
+ if(!body){break;}
+}
+console.log(JSON.stringify({schema:'deadbyte.r67-batch-progress.v1',operation_id:op,results},null,2));
+if(results.length!==end-start||results.some(r=>r.recorded_status!=='PASS'))process.exitCode=2;

package/scripts/r67-stage-candidate.mjs

@@ -0,0 +1,30 @@
+import {readFile,writeFile,stat,lstat,mkdir,copyFile} from 'node:fs/promises';
+import {createHash} from 'node:crypto';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+const candidate=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const parent=path.join(path.dirname(candidate),'deadbyte-mcp-0.15.43-r66');
+const EXPECT='4c4a64a4c8e9f5a6e9eecce85fd0007ebcac99121b29c07f1a1fc81d1643cd33';
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const manifest=await readFile(path.join(parent,'MANIFEST.SHA256'));
+if(sha(manifest)!==EXPECT)throw new Error('R67 parent manifest SHA mismatch');
+const rows=manifest.toString('utf8').trimEnd().split(/\r?\n/).map(line=>{const m=/^([a-f0-9]{64})  (.+)$/.exec(line);if(!m)throw new Error('bad manifest row');return {sha:m[1],rel:m[2]};});
+const seen=new Set();
+let copied=0,bytes=0;
+for(const {sha:want,rel} of rows){
+ if(rel.startsWith('/')||rel.includes('\\')||rel.split('/').some(x=>!x||x==='.'||x==='..')||seen.has(rel))throw new Error('unsafe or duplicate parent path: '+rel);
+ seen.add(rel);
+ const src=path.join(parent,...rel.split('/'));const info=await lstat(src);
+ if(!info.isFile()||info.isSymbolicLink())throw new Error('non-file predecessor: '+rel);
+ const data=await readFile(src);if(sha(data)!==want)throw new Error('source drift: '+rel);
+ const dst=path.join(candidate,...rel.split('/'));
+ await mkdir(path.dirname(dst),{recursive:true});
+ try{const existing=await readFile(dst);if(sha(existing)!==want)throw new Error('destination differs: '+rel);}catch(e){if(e.code!=='ENOENT')throw e;await copyFile(src,dst);}
+ if(sha(await readFile(dst))!==want)throw new Error('copy differs: '+rel);
+ copied++;bytes+=data.length;
+}
+await writeFile(path.join(candidate,'MANIFEST.SHA256'),manifest,{flag:'wx'});
+const proof={schema:'deadbyte.r67-candidate-parent.v1',parent_release_id:'v0.15.43-4c4a64a4c8e9f5a6',parent_manifest_sha256:EXPECT,source_directory:parent,candidate_directory:candidate,copied_files:copied,copied_bytes:bytes,mutation:false};
+await mkdir(path.join(candidate,'docs'),{recursive:true});
+await writeFile(path.join(candidate,'docs','R67-CANDIDATE-PARENT.json'),JSON.stringify(proof,null,2)+'\n',{flag:'wx'});
+console.log(JSON.stringify({status:'STAGED',copied_files:copied,copied_bytes:bytes,parent_manifest_sha256:EXPECT,candidate},null,2));

package/scripts/r67-verify-parent-ping.mjs

@@ -0,0 +1,22 @@
+import {readFile} from 'node:fs/promises';
+import {createHash,createPublicKey,verify as edVerify} from 'node:crypto';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+const root=path.resolve(fileURLToPath(new URL('../../..',import.meta.url)));
+const receiptFile=path.join(root,'testing','0.15.44-r67','R67-PRODUCTION-BASELINE.json');
+const receipt=JSON.parse(await readFile(receiptFile,'utf8'));
+const ping=receipt.signed_ping;
+const spki=Buffer.from(receipt.machine.public_key_spki_base64,'base64');
+const keyId=createHash('sha256').update(spki).digest('hex');
+const {attestation,...body}=ping;
+const sorted=v=>Array.isArray(v)?v.map(sorted):v!==null&&typeof v==='object'?Object.fromEntries(Object.keys(v).sort().map(k=>[k,sorted(v[k])])):v;
+const message=Buffer.concat([Buffer.from('DEADBYTE-MACHINE-PING-V1\0','utf8'),Buffer.from(JSON.stringify(sorted(body)),'utf8')]);
+const digest=createHash('sha256').update(message).digest('hex');
+const key=createPublicKey({key:spki,format:'der',type:'spki'});
+const signature=Buffer.from(attestation.signature_base64,'base64');
+const valid=key.asymmetricKeyType==='ed25519'&&signature.length===64&&attestation.key_id===keyId&&ping.machine_id===keyId&&receipt.machine.machine_id===keyId&&edVerify(null,message,key,signature);
+const prior=receipt.independent_verification?.signed_message_sha256??null;
+const ok=valid&&digest===prior;
+const result={schema:'deadbyte.r67-independent-baseline-check.v1',status:ok?'PASS':'FAIL',ed25519_valid:valid,key_identity_matches:keyId===ping.machine_id,message_sha256:digest,claimed_message_sha256:prior,release_id:ping.release_id};
+console.log(JSON.stringify(result,null,2));
+if(!ok)process.exitCode=1;

package/scripts/release-manifest.mjs

@@ -59,6 +59,7 @@ function npmPackFiles() {
     const raw = item?.path;
     if (typeof raw !== 'string' || raw.length < 1) throw new Error('npm pack file path invalid');
     const rel = raw.replaceAll('\\','/');
+    if (/\.tgz$/i.test(rel)) throw new Error(`npm archive self-inclusion forbidden: ${rel}; exclude existing tarballs from the npm package surface`);
     if (rel === manifestName || excludedPackagePaths.has(rel) || excludedPackagePrefixes.some(prefix => rel.startsWith(prefix))) continue;
     if (path.posix.isAbsolute(rel) || rel.split('/').includes('..') || rel.includes('\0')) {
       throw new Error(`unsafe package path '${rel}'`);

package/scripts/verify-r70-full-regression.ps1

@@ -0,0 +1,72 @@
+#requires -Version 5.1
+# R70 verifier artifact: runs the candidate test suite without altering release manifests.
+param([switch]$SelfTest)
+Set-StrictMode -Version Latest
+$ErrorActionPreference = 'Continue'
+Set-Location -LiteralPath (Split-Path -Parent $PSScriptRoot)
+$timer = [System.Diagnostics.Stopwatch]::StartNew()
+if ($SelfTest) {
+    $lines = @('tests 1', 'pass 0', 'fail 1', 'skipped 0', 'hash mismatch: SYNTHETIC_TEST')
+    $exitCode = 1
+} else {
+    $lines = @(& npm.cmd test 2>&1 | ForEach-Object { [string]$_ })
+    $exitCode = [int]$LASTEXITCODE
+}
+$timer.Stop()
+$utf8 = New-Object System.Text.UTF8Encoding($false)
+$stdoutBytes = $utf8.GetBytes(($lines -join "`n"))
+$sha = [System.Security.Cryptography.SHA256]::Create()
+try {
+    $hash = ([BitConverter]::ToString($sha.ComputeHash($stdoutBytes))).Replace('-', '').ToLowerInvariant()
+} finally {
+    $sha.Dispose()
+}
+Write-Output 'R70_FULL_TEST_SCHEMA=deadbyte.verifier-output.r70.v1'
+Write-Output ('R70_FULL_TEST_EXIT_CODE=' + $exitCode)
+Write-Output ('R70_FULL_TEST_ELAPSED_MS=' + [math]::Round($timer.Elapsed.TotalMilliseconds))
+Write-Output ('R70_FULL_TEST_STDOUT_SHA256=' + $hash)
+Write-Output ('R70_FULL_TEST_LINE_COUNT=' + $lines.Count)
+$selected = @($lines | Where-Object {
+    $_ -match '(?i)(?:^|\s)(?:tests|pass|fail|skipped|cancelled|duration_ms)\s+[0-9.]+' -or
+    $_ -match '^✖' -or
+    $_ -match '^  (Error|AssertionError|SyntaxError):' -or
+    $_ -match 'hash mismatch:' -or
+    $_ -match '^# (tests|pass|fail|skipped) '
+})
+$summary = @($selected | Select-Object -Last 140 | ForEach-Object {
+    if ($_.Length -gt 512) { $_.Substring(0, 512) } else { $_ }
+})
+$artifactDir = Join-Path (Get-Location).Path 'testing\r70-verifier'
+if (-not (Test-Path -LiteralPath $artifactDir -PathType Container)) {
+    New-Item -ItemType Directory -Path $artifactDir -Force | Out-Null
+}
+$artifact = Join-Path $artifactDir ('result-{0}-{1}.json' -f (Get-Date -Format 'yyyyMMdd-HHmmss'), [Guid]::NewGuid().ToString('N'))
+$stdoutPath = [System.IO.Path]::ChangeExtension($artifact, '.stdout.txt')
+$stdoutStream = New-Object System.IO.FileStream($stdoutPath, [System.IO.FileMode]::CreateNew, [System.IO.FileAccess]::Write, [System.IO.FileShare]::None)
+try { $stdoutStream.Write($stdoutBytes, 0, $stdoutBytes.Length); $stdoutStream.Flush($true) } finally { $stdoutStream.Dispose() }
+$record = [ordered]@{
+    schema = 'deadbyte.r70-full-regression-result.v1'
+    mode = if ($SelfTest) { 'synthetic-selftest' } else { 'candidate-full-regression' }
+    created_at_utc = [DateTime]::UtcNow.ToString('o')
+    exit_code = $exitCode
+    elapsed_ms = [math]::Round($timer.Elapsed.TotalMilliseconds)
+    stdout_sha256 = $hash
+    stdout_path = $stdoutPath
+    total_line_count = $lines.Count
+    summary = $summary
+}
+$json = ($record | ConvertTo-Json -Depth 5 -Compress) + "`n"
+$bytes = $utf8.GetBytes($json)
+$stream = New-Object System.IO.FileStream($artifact, [System.IO.FileMode]::CreateNew, [System.IO.FileAccess]::Write, [System.IO.FileShare]::None)
+try { $stream.Write($bytes, 0, $bytes.Length); $stream.Flush($true) } finally { $stream.Dispose() }
+$artifactHashAlgorithm = [System.Security.Cryptography.SHA256]::Create()
+try {
+    $artifactStream = [System.IO.File]::OpenRead($artifact)
+    try { $artifactSha = ([BitConverter]::ToString($artifactHashAlgorithm.ComputeHash($artifactStream))).Replace('-', '').ToLowerInvariant() }
+    finally { $artifactStream.Dispose() }
+} finally { $artifactHashAlgorithm.Dispose() }
+Write-Output ('R70_FULL_TEST_ARTIFACT=' + $artifact)
+Write-Output ('R70_FULL_TEST_ARTIFACT_SHA256=' + $artifactSha)
+foreach ($line in $summary) { Write-Output $line }
+if ($SelfTest) { exit 0 }
+exit $exitCode

package/src/activation-continuity-engine-r65.mjs

@@ -2,6 +2,7 @@ import {createHash,randomBytes} from 'node:crypto';
 import {open,readFile,rm} from 'node:fs/promises';
 import path from 'node:path';
 import {canonicalJson} from './canonical-json.mjs';
+import {decodeUtf8Strict} from './text-policy.mjs';
 import {
   captureStandingGrant,compareSecurityEnvelopes,createAuthorityEpochStore,deriveSecurityEnvelope
 } from './authority-continuity-r65.mjs';
@@ -17,7 +18,7 @@ const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
 const plain=value=>value&&typeof value==='object'&&!Array.isArray(value);
 
 function parseJson(bytes,label){
-  try{return JSON.parse(bytes.toString('utf8'));}
+  try{return JSON.parse(decodeUtf8Strict(bytes));}
   catch{throw new Error(`${label} JSON invalid`);}
 }
 function inside(root,target){

package/src/authority-continuity-r65.mjs

@@ -207,6 +207,10 @@ const DURABLE_EPOCH_ACTIONS=new Set(['grant','transaction_revoke','user_revoke',
 const DURABLE_EPOCH_SCHEMA='deadbyte.authority-epoch-event.r65.v1';
 const DURABLE_HEAD_SCHEMA='deadbyte.authority-epoch-head.r65.v1';
 const DURABLE_EPOCH_DOMAIN=Buffer.from('DEADBYTE-AUTHORITY-DURABLE-EPOCH-R65-V1\0','utf8');
+// Cache parsed public keys by the exact bytes read from disk, never by path.
+// A changed trust file is re-read and yields a different entry immediately.
+const DURABLE_PUBLIC_KEY_CACHE_LIMIT=8;
+const durablePublicKeys=new Map();
 const RESTORE_BINDING_FIELDS=Object.freeze(['prior_grant_sha256','prior_grant_instance_nonce','predecessor_policy_envelope_sha256','successor_policy_envelope_sha256','candidate_manifest_sha256','continuity_subject_sha256']);
 function normalizeRestoreBinding(value,{required=false}={}){
   if(value===undefined||value===null){if(required)throw new Error('authority epoch transaction restore binding required');return null;}
@@ -218,9 +222,19 @@ function normalizeRestoreBinding(value,{required=false}={}){
 
 async function durableEpochKeys(runtimeDir,{privateRequired=false}={}){
   const trust=path.join(path.dirname(path.resolve(runtimeDir)),'trust');
-  const publicKey=createPublicKey(await readFile(path.join(trust,'ed25519-public.pem')));
-  if(publicKey.asymmetricKeyType!=='ed25519')throw new Error('authority epoch trust public key invalid');
-  const keyId=hashBytes(Buffer.from(publicKey.export({format:'der',type:'spki'})));
+  const publicBytes=await readFile(path.join(trust,'ed25519-public.pem'));
+  const publicSha=hashBytes(publicBytes);
+  let cached=durablePublicKeys.get(publicSha);
+  if(!cached){
+    const publicKey=createPublicKey(publicBytes);
+    if(publicKey.asymmetricKeyType!=='ed25519')throw new Error('authority epoch trust public key invalid');
+    const keyId=hashBytes(Buffer.from(publicKey.export({format:'der',type:'spki'})));
+    cached={publicKey,keyId};
+    if(durablePublicKeys.size>=DURABLE_PUBLIC_KEY_CACHE_LIMIT)
+      durablePublicKeys.delete(durablePublicKeys.keys().next().value);
+    durablePublicKeys.set(publicSha,cached);
+  }
+  const {publicKey,keyId}=cached;
   if(!privateRequired)return {publicKey,keyId};
   const privateKey=createPrivateKey(await readFile(path.join(trust,'ed25519-private.pem')));
   if(privateKey.asymmetricKeyType!=='ed25519'||
@@ -315,7 +329,14 @@ async function readDurableHead(runtimeDir,plane){
   if(head.action!=='transaction_restore'&&headRestoreBinding!==null)throw new Error('authority epoch unexpected restore binding');
   const expectedName=durableEventName(head.seq,head.event_sha256);
   if(head.event_file!==expectedName)throw new Error('authority epoch head event name mismatch');
-  const eventNames=await readdir(path.join(dir,'events'));
+  // These are independent observations of one immutable event identity.
+  // Read them concurrently, then validate the complete set before trusting
+  // the head. The head remains freshly read on every authority decision.
+  const [eventNames,eventRead,keys]=await Promise.all([
+    readdir(path.join(dir,'events')),
+    readFile(path.join(dir,'events',head.event_file)).then(bytes=>({bytes}),()=>({bytes:null})),
+    durableEpochKeys(runtimeDir)
+  ]);
   if(eventNames.length>10000)throw new Error('authority epoch event budget exceeded');
   for(const name of eventNames){
     const match=/^(\d{16})-([0-9a-f]{64})\.json$/.exec(name);
@@ -324,13 +345,12 @@ async function readDurableHead(runtimeDir,plane){
     if(!Number.isSafeInteger(seq)||seq>head.seq||(seq===head.seq&&name!==head.event_file))
       throw new Error('authority epoch head replay or incomplete write');
   }
-  let eventBytes;
-  try{eventBytes=await readFile(path.join(dir,'events',head.event_file));}
-  catch{throw new Error('authority epoch event missing');}
+  const eventBytes=eventRead.bytes;
+  if(!eventBytes)throw new Error('authority epoch event missing');
   if(hashBytes(eventBytes)!==head.event_sha256)throw new Error('authority epoch event hash mismatch');
   let event;
   try{event=JSON.parse(decodeUtf8Strict(eventBytes));}catch{throw new Error('authority epoch event invalid');}
-  const {publicKey,keyId}=await durableEpochKeys(runtimeDir);
+  const {publicKey,keyId}=keys;
   if(!verifyDurableEvent(event,publicKey,keyId))throw new Error('authority epoch event signature invalid');
   for(const key of ['schema','plane','seq','action','update_id','grant_sha256','grant_instance_nonce','previous_event_sha256']){
     const expected=key==='schema'?DURABLE_EPOCH_SCHEMA:head[key];

package/src/autonomous-mcp-tools.mjs

@@ -48,7 +48,7 @@ export function registerAutonomousTools(server,{ autonomousRuntime, nativeDiffRu
     catch(error){ return fail(autonomousSessionStatusOutputSchema,error); } });
 
   server.registerTool('native_diff_preview',{
-    description:'Create a signed content-addressed DEADBYTE Native Diff v1 after validating exact file SHA-256 preconditions. No Git metadata is used.',
+    description:'Validate exact file SHA-256 preconditions. With Coding read authority alone, return a read-only preview_only result that cannot be applied; a signed applicable diff additionally requires Autonomous authority. No Git metadata is used.',
     inputSchema:z.strictObject({ root_id:id, title:z.string().max(160).default(''), operations:z.array(nativeOperation).min(1).max(32) }),
     outputSchema:nativeDiffPreviewOutputSchema
   },async({root_id,title,operations})=>{ try { return result(nativeDiffPreviewOutputSchema,

package/src/autonomous-output-contracts.mjs

@@ -83,10 +83,13 @@ export const autonomousSessionStatusOutputSchema = statusContract({
 });
 
 export const nativeDiffPreviewOutputSchema = statusContract({
-  statuses:['ready','failed'], success:['ready'], required:['diff_id','root_id','operation_count','payload_bytes','paths','operations'],
+  statuses:['ready','preview_only','failed'], success:['ready','preview_only'], required:['root_id','operation_count','payload_bytes','paths','operations'],
   shape:{ schema:z.enum(['deadbyte.native-diff.v1','deadbyte.native-diff.v2']).optional(), diff_id:hex64.optional(), root_id:z.string().min(1).max(64).optional(), operation_count:z.number().int().min(1).max(32).optional(),
     payload_bytes:z.number().int().min(0).optional(), paths:z.array(z.string()).max(64).optional(),
     operations:z.array(jsonObject).max(32).optional() }
+}).superRefine((value,ctx)=>{
+  if(value.status==='ready'&&value.diff_id===undefined) ctx.addIssue({code:'custom',path:['diff_id'],message:'signed ready diff requires diff_id'});
+  if(value.status==='preview_only'&&value.diff_id!==undefined) ctx.addIssue({code:'custom',path:['diff_id'],message:'coding-only preview must not have an applicable diff_id'});
 });
 export const nativeDiffApplyOutputSchema = statusContract({
   statuses:['committed','existing','failed'], success:['committed','existing'],

package/src/autonomous-policy.mjs

@@ -80,11 +80,11 @@ function normalizePlanner(raw,codingPolicy,rootIds) {
   }
   return provider;
 }
-function normalizeProfile(id, raw, codingPolicy) {
+function normalizeProfile(id, raw, codingPolicy, rootIds) {
   if (!ID_RE.test(id)) throw new Error(`invalid autonomous profile '${id}'`);
   if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw new Error(`autonomous profile '${id}' malformed`);
   if (!['command','benchmark'].includes(raw.kind)) throw new Error(`autonomous profile '${id}' kind invalid`);
-  if (!ID_RE.test(raw.root_id ?? '') || !codingPolicy.roots[raw.root_id]) throw new Error(`autonomous profile '${id}' root invalid`);
+  if (!ID_RE.test(raw.root_id ?? '') || !codingPolicy.roots[raw.root_id] || !rootIds.includes(raw.root_id)) throw new Error(`autonomous profile '${id}' root invalid`);
   if (!ID_RE.test(raw.command_id ?? '') || !codingPolicy.commands[raw.command_id]) throw new Error(`autonomous profile '${id}' command invalid`);
   validatePortableRelativePath(raw.script_path);
   if (!SHA256_RE.test(raw.script_sha256 ?? '')) throw new Error(`autonomous profile '${id}' script hash invalid`);
@@ -130,7 +130,7 @@ export async function loadAutonomousPolicy(policyPath, codingPolicy) {
   const rootIds = Array.isArray(raw.root_ids) ? [...new Set(raw.root_ids)] : [];
   if (rootIds.length < 1 || rootIds.some(id => !ID_RE.test(id) || !codingPolicy.roots[id])) throw new Error('autonomous root_ids invalid');
   const profiles = {};
-  for (const [id, value] of Object.entries(raw.profiles ?? {})) profiles[id] = normalizeProfile(id, value, codingPolicy);
+  for (const [id, value] of Object.entries(raw.profiles ?? {})) profiles[id] = normalizeProfile(id, value, codingPolicy, rootIds);
   const limits = raw.limits ?? {};
   const policy = {
     schema: AUTONOMOUS_POLICY_SCHEMA, enabled: true, policy_path: absolute,
@@ -154,6 +154,43 @@ export async function loadAutonomousPolicy(policyPath, codingPolicy) {
   return Object.freeze(policy);
 }
 
+export function inspectAutonomousStandingWindow(lease,now=new Date()){
+  // v2 legacy standing grants have no expiry. New bounded grants must be
+  // checked on every authority observation, including after a runtime restart.
+  if(!lease||typeof lease!=='object'||Array.isArray(lease)){
+    return {ok:false,reason:'expiry-invalid',expires_at_utc:null,remaining_ms:null};
+  }
+  if(!Object.hasOwn(lease,'expires_at_utc')){
+    return {ok:true,reason:null,expires_at_utc:null,remaining_ms:null};
+  }
+  const canonical=value=>typeof value==='string'&&
+    /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3,7}Z$/.test(value);
+  const expiry=lease.expires_at_utc;
+  const issued=lease.granted_at_utc;
+  if(!canonical(expiry)||!canonical(issued)){
+    return {ok:false,reason:'expiry-invalid',expires_at_utc:null,remaining_ms:null};
+  }
+  const end=Date.parse(expiry),start=Date.parse(issued);
+  if(!Number.isFinite(end)||!Number.isFinite(start)){
+    return {ok:false,reason:'expiry-invalid',expires_at_utc:null,remaining_ms:null};
+  }
+  const duration=end-start;
+  if(duration<=0||duration>3_600_000){
+    return {ok:false,reason:'expiry-window-invalid',expires_at_utc:expiry,remaining_ms:null};
+  }
+  const observed=now instanceof Date?now.getTime():NaN;
+  if(!Number.isFinite(observed)){
+    return {ok:false,reason:'clock-invalid',expires_at_utc:expiry,remaining_ms:null};
+  }
+  if(observed<start){
+    return {ok:false,reason:'not-yet-valid',expires_at_utc:expiry,remaining_ms:null};
+  }
+  if(observed>=end){
+    return {ok:false,reason:'expired',expires_at_utc:expiry,remaining_ms:0};
+  }
+  return {ok:true,reason:null,expires_at_utc:expiry,remaining_ms:end-observed};
+}
+
 export async function autonomousSessionStatus(policy, now = new Date()) {
   let lease,leaseBytes;
   try { leaseBytes=await readFile(policy.lease_file); lease = JSON.parse(decodeUtf8Strict(leaseBytes)); }
@@ -164,15 +201,25 @@ export async function autonomousSessionStatus(policy, now = new Date()) {
     return { configured:true, armed:false, reason:'lease-schema', expires_at_utc:null };
   }
   if (lease.policy_sha256 !== policy.policy_sha256) return { configured:true, armed:false, reason:'policy-digest', expires_at_utc:null };
+  // Controller and runtime must agree on the exact Coding authority policy
+  // for every signed v2 Autonomous grant, including after generation changes.
+  if (lease.schema === AUTONOMOUS_GRANT_SCHEMA &&
+      lease.coding_policy_sha256 !== policy.coding_policy_sha256) {
+    return { configured:true, armed:false, reason:'coding-policy-digest', expires_at_utc:null };
+  }
   if (typeof lease.instance_nonce !== 'string' || !SHA256_RE.test(lease.instance_nonce)) return { configured:true, armed:false, reason:'nonce-invalid', expires_at_utc:null };
   const roots = Array.isArray(lease.root_ids) ? [...new Set(lease.root_ids)] : [];
   if (roots.length < 1 || roots.some(id => !policy.root_ids.includes(id))) return { configured:true, armed:false, reason:'roots-invalid', expires_at_utc:null };
   if (lease.schema === AUTONOMOUS_GRANT_SCHEMA) {
+    const window=inspectAutonomousStandingWindow(lease,now);
+    if(!window.ok) return {configured:true,armed:false,reason:window.reason,
+      expires_at_utc:window.expires_at_utc,remaining_ms:window.remaining_ms,
+      standing:false,instance_nonce:lease.instance_nonce,root_ids:roots};
     const epoch=await verifyStandingGrantEpoch({plane:'autonomous',grantFile:policy.lease_file,grantBytes:leaseBytes,grantInstanceNonce:lease.instance_nonce,policyPath:policy.policy_path});
-    if(!epoch.trusted)return { configured:true,armed:false,reason:epoch.reason,expires_at_utc:null,
-      remaining_ms:null,standing:false,instance_nonce:lease.instance_nonce,root_ids:roots };
-    return { configured:true, armed:true, reason:'standing-grant', expires_at_utc:null,
-      remaining_ms:null, standing:true, instance_nonce:lease.instance_nonce, root_ids:roots, authority_epoch:epoch };
+    if(!epoch.trusted)return { configured:true,armed:false,reason:epoch.reason,expires_at_utc:window.expires_at_utc,
+      remaining_ms:window.remaining_ms,standing:false,instance_nonce:lease.instance_nonce,root_ids:roots };
+    return { configured:true, armed:true, reason:'standing-grant', expires_at_utc:window.expires_at_utc,
+      remaining_ms:window.remaining_ms, standing:true, instance_nonce:lease.instance_nonce, root_ids:roots, authority_epoch:epoch };
   }
   const expires = Date.parse(lease.expires_at_utc);
   if (!Number.isFinite(expires)) return { configured:true, armed:false, reason:'expiry-invalid', expires_at_utc:null };

package/src/autonomous-runtime.mjs

@@ -308,7 +308,7 @@ async function executeProfile({ ctx, events, goalId, actionKey, profileId, epoch
       const r34Paused=await pauseR34Ambiguous(checked.reason ?? error);
       if (r34Paused) return r34Paused;
       await appendEvent(ctx,events,signingKeyPath,'goal_paused',{ reason:'profile_execution_without_receipt', profile_id:profileId,
-        action_key:actionKey, detail:truncated(error) });
+        action_key:actionKey, receipt_id:receiptId, request_sha256:requestSha256, detail:truncated(error,512) });
       return { status:'paused', observation:null, existing:false };
     }
     result = null;

package/src/capability-ledger.mjs

@@ -152,7 +152,7 @@ export const R36_CAPABILITY_ENTRIES=Object.freeze([
   gateway('desktop.action','desktop_action','desktop_control','action','DEADBYTE_DESKTOP_RUNTIME','desktop',{mutating:true,receipt_class:'desktop'}),
 
   direct('autonomous.session_status','autonomous_session_status','DEADBYTE_AUTONOMOUS_RUNTIME','autonomous',{receipt_class:'autonomous'}),
-  direct('native_diff.preview','native_diff_preview','DEADBYTE_AUTONOMOUS_RUNTIME','autonomous',{mutating:true,receipt_class:'native_diff'}),
+  direct('native_diff.preview','native_diff_preview','DEADBYTE_AUTONOMOUS_RUNTIME','coding',{receipt_class:'native_diff'}),
   direct('native_diff.apply','native_diff_apply','DEADBYTE_AUTONOMOUS_RUNTIME','autonomous',{mutating:true,receipt_class:'native_diff'}),
   direct('native_diff.verify','native_diff_verify','DEADBYTE_AUTONOMOUS_RUNTIME','autonomous',{receipt_class:'verification'}),
   direct('autonomous.goal_submit','autonomous_goal_submit','DEADBYTE_AUTONOMOUS_RUNTIME','autonomous',{mutating:true,receipt_class:'autonomous'}),

package/src/capability-resolver.mjs

@@ -3,7 +3,8 @@ import { assertHostArmed } from './host-plane.mjs';
 
 const CODING_ARMED_READ_CAPABILITIES = new Set([
   'coding.tree','coding.stat','coding.search','coding.files_read','coding.file_read',
-  'semantic.outline','semantic.definition','semantic.references','semantic.diagnostics','semantic.implementations','semantic.rename_preview'
+  'semantic.outline','semantic.definition','semantic.references','semantic.diagnostics','semantic.implementations','semantic.rename_preview',
+  'native_diff.preview'
 ]);
 
 export const CAPABILITY_STATES = Object.freeze({

package/src/commander-compat-runtime.mjs

@@ -20,7 +20,7 @@ const CONTRACTS = Object.freeze({
   get_recent_tool_calls:{native:'operation_history.recent',required:[],mutation:false},
   get_usage_stats:{native:'operation_history.stats',required:[],mutation:false},
   give_feedback_to_desktop_commander:{native:'commander.feedback',required:['message'],mutation:true},
-  host_exec:{native:'host.exec',required:['command_id','root_id','script_path','script_sha256'],mutation:true},
+  host_exec:{native:'host.exec',required:['root_id'],mutation:true},
   host_file_read:{native:'host.file_read',required:['path'],mutation:false},
   host_file_write:{native:'host.file_write',required:['path','content','expected_sha256'],mutation:true},
   interact_with_process:{native:'process.input',required:['session_id','input'],mutation:true},
@@ -53,13 +53,41 @@ export function commanderCompatibilityContract(name) {
   return CONTRACTS[name] ?? {native:DEADBYTE_NATIVE_TOOLS[name] ?? null,required:[],mutation:false};
 }
 
+function validateHostExecRequest(args) {
+  const mode=args.mode??'script';
+  const common=['mode','root_id','cwd','timeout_ms'];
+  let required, allowed;
+  if(mode==='script'){
+    required=['root_id','command_id','script_path','script_sha256'];
+    allowed=[...common,'command_id','script_path','script_sha256','args'];
+  }else if(mode==='inline'){
+    required=['root_id','command_id','command'];
+    allowed=[...common,'command_id','command'];
+  }else if(mode==='native'){
+    required=['root_id','executable','executable_sha256'];
+    allowed=[...common,'executable','executable_sha256','args'];
+  }else{
+    throw new Error('host_exec mode must be script, inline, or native');
+  }
+  const missing=required.filter(k=>!own(args,k)||args[k]===undefined||args[k]===null||args[k]==='');
+  if(missing.length) throw new Error(`missing required fields: ${missing.join(', ')}`);
+  const unknown=Object.keys(args).filter(k=>!allowed.includes(k));
+  if(unknown.length) throw new Error(`host_exec ${mode} unexpected fields: ${unknown.join(', ')}`);
+  const id=/^[A-Za-z0-9._-]{1,64}$/;
+  if(typeof args.root_id!=='string'||!id.test(args.root_id)) throw new Error('host_exec root_id invalid');
+  if(mode!=='native'&&(typeof args.command_id!=='string'||!id.test(args.command_id))) throw new Error('host_exec command_id invalid');
+  if(mode==='inline'&&(typeof args.command!=='string'||args.command.length>262144||args.command.includes(String.fromCharCode(0)))) throw new Error('host_exec inline command invalid');
+  if(mode==='script'&&!/^[0-9a-f]{64}$/.test(args.script_sha256)) throw new Error('host_exec script_sha256 invalid');
+  if(mode==='native'&&!/^[0-9a-f]{64}$/.test(args.executable_sha256)) throw new Error('host_exec executable_sha256 invalid');
+}
+
 export function validateCommanderRequest(name,args={}) {
   const c=commanderCompatibilityContract(name);
   if (!args || typeof args!=='object' || Array.isArray(args)) throw new Error('request arguments must be an object');
   const missing=c.required.filter(k=>!own(args,k)||args[k]===undefined||args[k]===null||args[k]==='');
   if(missing.length) throw new Error(`missing required fields: ${missing.join(', ')}`);
   if(c.mutation && !['create_directory','start_process','force_terminate','kill_process','interact_with_process','host_exec'].includes(name) && !('expected_sha256' in args) && !('expected_source_identity' in args)) throw new Error('mutation requires an explicit precondition');
-  if((name==='host_exec') && typeof args.script_sha256!=='string') throw new Error('host_exec requires hash-pinned script');
+  if(name==='host_exec') validateHostExecRequest(args);
   return Object.freeze({commander_tool:name,native_tool:c.native,mutation:c.mutation,args});
 }
 

package/src/deadbyte-cli.mjs

@@ -11,9 +11,12 @@ import { defaultPublicKeyPath } from './trust.mjs';
 import { verifyAuditChain } from './audit-verify.mjs';
 import { openRemoteResultJournal, parseRemoteResultCursor } from './remote-result-journal.mjs';
 import { DEADBYTE_VERSION } from './version.mjs';
+import { runNativeInspect } from './native-inspector-r67.mjs';
+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';
@@ -60,7 +63,14 @@ function printHelp(){
     `  npx -y ${exact} supervisor status`,
     `  npx -y ${exact} supervisor recover`,
     `  npx -y ${exact} audit verify`,
-    `  npx -y ${exact} audit status`,''
+    `  npx -y ${exact} audit status`,
+    `  npx -y ${exact} diagnostics export --output <local.zip> # offline, never uploads`,
+    `  npx -y ${exact} diagnostics verify --input <local.zip>  # local structural/CRC verify`,
+    `  npx -y ${exact} inspect process [limit]       # local native process snapshot`,
+    `  npx -y ${exact} inspect identity PID          # native process creation token`,
+    `  npx -y ${exact} inspect memory self [limit]     # local VirtualQueryEx metadata only`,
+    `  npx -y ${exact} inspect memory PID <creation_filetime> [limit] # PID-reuse guarded`,
+    `  npx -y ${exact} inspect pe <file>            # local native PE32/PE32+ inspection`,''
   ].join('\n'));
 }
 async function remoteContext(){
@@ -260,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;
 }
@@ -286,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;
@@ -681,6 +693,28 @@ async function main(argv){
   if(command==='remote'){await runRemote(rest);return;}
   if(command==='supervisor'){await runSupervisor(rest);return;}
   if(command==='audit'){await runAudit(rest);return;}
+  if(command==='diagnostics'){
+    if(rest.length!==3)throw new Error('diagnostics export --output or verify --input; no network upload supported');
+    if(rest[0]==='export'&&rest[1]==='--output'){
+      const report=await exportOfflineDiagnostics({stateRoot:stateRoot(),outputPath:rest[2]});
+      process.stdout.write(`${JSON.stringify(report)}\n`);
+      return;
+    }
+    if(rest[0]==='verify'&&rest[1]==='--input'){
+      const file=path.resolve(rest[2]);
+      await requireRegular(file,'diagnostic ZIP');
+      const report=verifyOfflineDiagnosticsZip(await readFile(file));
+      process.stdout.write(`${JSON.stringify(report)}\n`);
+      return;
+    }
+    throw new Error('unsupported diagnostics mode; network upload is forbidden');
+  }
+  if(command==='inspect'){
+    const result=await runNativeInspect(rest);
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    if(result.status!=='ok')process.exitCode=2;
+    return;
+  }
   throw new Error(`unknown command '${command}'`);
 }