deadbyte-mcp 0.15.68 → 0.15.70

package/scripts/r178-full-regression.mjs

@@ -0,0 +1,21 @@
+import {spawnSync} from 'node:child_process';
+import {readdirSync,mkdirSync,writeFileSync,readFileSync} from 'node:fs';
+import {createHash} from 'node:crypto';
+import path from 'node:path';
+const root=path.resolve(import.meta.dirname,'..');
+const testRoot=path.join(root,'test');
+const files=readdirSync(testRoot).filter(n=>n.endsWith('.test.mjs')).sort().map(n=>path.join('test',n));
+const outDir=path.resolve(root,'..','..','testing','r178-01569-candidate');
+mkdirSync(outDir,{recursive:true});
+const args=['--test','--test-concurrency=4',...files];
+console.log('R178_TOTAL_TEST_FILES='+files.length);
+const result=spawnSync(process.execPath,args,{cwd:root,encoding:'utf8',windowsHide:true,timeout:300000,maxBuffer:40*1024*1024,
+ env:{...process.env,DEADBYTE_RELEASE_TEST:'1'}});
+const log=String(result.stdout||'')+'\n=== STDERR ===\n'+String(result.stderr||'');
+const fp=path.join(outDir,'R178-FULL-REGRESSION.txt');
+writeFileSync(fp,log);
+console.log('R178_FULL_EXIT='+result.status+' signal='+result.signal+' error='+String(result.error?.code??'none'));
+for(const l of log.split(/\r?\n/).filter(s=>/^(ℹ (tests|pass|fail|skipped|duration_ms)|# (tests|pass|fail|skipped|duration_ms)|✖|not ok)/.test(s)).slice(-30))console.log(l.slice(0,300));
+console.log('R178_EVIDENCE='+fp);
+console.log('R178_EVIDENCE_SHA256='+createHash('sha256').update(readFileSync(fp)).digest('hex'));
+if(result.status!==0)process.exitCode=1;

package/scripts/r178-npm-ci.mjs

@@ -0,0 +1,10 @@
+import {spawnSync} from 'node:child_process';
+import path from 'node:path';
+const root=path.resolve(import.meta.dirname,'..');
+const npm=process.env.npm_execpath||path.join(path.dirname(process.execPath),'node_modules','npm','bin','npm-cli.js');
+const r=spawnSync(process.execPath,[npm,'ci','--ignore-scripts','--no-audit','--no-fund','--prefer-offline'],{cwd:root,encoding:'utf8',timeout:180000,windowsHide:true,maxBuffer:1024*1024});
+console.log('NPM_CI_EXIT='+r.status);
+if(r.error)console.log('NPM_CI_ERROR='+String(r.error.code));
+console.log('NPM_CI_STDOUT='+String(r.stdout||'').slice(-1500));
+console.log('NPM_CI_STDERR='+String(r.stderr||'').slice(-1500));
+if(r.status!==0)process.exitCode=1;

package/scripts/r178-npm-preflight.mjs

@@ -0,0 +1,16 @@
+import {spawnSync} from 'node:child_process';
+import {existsSync} from 'node:fs';
+import path from 'node:path';
+const cwd=path.resolve(import.meta.dirname,'..');
+const npm=process.env.npm_execpath||path.join(path.dirname(process.execPath),'node_modules','npm','bin','npm-cli.js');
+function exec(args,ms=30000){
+  const r=spawnSync(process.execPath,[npm,...args],{cwd,encoding:'utf8',windowsHide:true,timeout:ms,env:{...process.env,npm_config_update_notifier:'false'}});
+  const s=String(r.stdout||'').trim(),e=String(r.stderr||'').trim();
+  return {ok:r.status===0,exit:r.status,error:r.error?.code??null,
+   output:args[0]==='whoami'?(r.status===0?s:'[NOT_AUTHENTICATED]'):String((s||e).slice(0,500)).replace(/https?:\/\/[^\s]+/g,'[url-redacted]')};
+}
+console.log('NODE='+process.version+' npm_cli_available='+existsSync(npm));
+console.log('node_modules_present='+existsSync(path.join(cwd,'node_modules')));
+console.log('NPM_VERSION='+JSON.stringify(exec(['--version'])));
+console.log('NPM_WHOAMI='+JSON.stringify(exec(['whoami'])));
+console.log('NPM_01569_REGISTRY='+JSON.stringify(exec(['view','deadbyte-mcp@0.15.69','version','--json'])));

package/scripts/r178-release-gates-readonly.mjs

@@ -0,0 +1,9 @@
+import {spawnSync} from 'node:child_process';
+import path from 'node:path';
+const root=path.resolve(import.meta.dirname,'..');
+for(const args of [['scripts/release-manifest.mjs','verify'],['scripts/npm-release-r48.mjs','--verify-only']]){
+ const r=spawnSync(process.execPath,args,{cwd:root,encoding:'utf8',timeout:30000,windowsHide:true,maxBuffer:2*1024*1024});
+ console.log('R178_CHECK='+args.join(' ')+' EXIT='+r.status);
+ const out=String(r.stdout||'')+'\n'+String(r.stderr||'');
+ for(const line of out.split(/\r?\n/).filter(x=>/MANIFEST_|FAIL|release identity|version mismatch|not published|PROVENANCE|PUBLISH|READY|error:/i.test(x)).slice(0,12))console.log(line.slice(0,500));
+}

package/scripts/r178-shard-regression.mjs

@@ -0,0 +1,25 @@
+import {spawnSync} from 'node:child_process';
+import {readdirSync,mkdirSync,writeFileSync,readFileSync} from 'node:fs';
+import {createHash} from 'node:crypto';
+import path from 'node:path';
+const root=path.resolve(import.meta.dirname,'..');
+const testRoot=path.join(root,'test');
+const files=readdirSync(testRoot).filter(n=>n.endsWith('.test.mjs')).sort();
+const size=Number(process.argv[3]??16),index=Number(process.argv[2]);
+if(!Number.isInteger(index)||index<0||!Number.isInteger(size)||size<1||size>32)throw Error('invalid shard');
+const selection=files.slice(index*size,(index+1)*size);
+if(!selection.length)throw Error('empty shard');
+const outDir=path.resolve(root,'..','..','testing','r178-01569-candidate');
+mkdirSync(outDir,{recursive:true});
+const testArgs=['--test','--test-concurrency=3',...selection.map(n=>path.join('test',n))];
+const result=spawnSync(process.execPath,testArgs,{cwd:root,encoding:'utf8',windowsHide:true,
+ timeout:26000,maxBuffer:12*1024*1024});
+const log=String(result.stdout||'')+'\n=== STDERR ===\n'+String(result.stderr||'');
+const fp=path.join(outDir,'shard-'+String(index).padStart(2,'0')+'.log');
+writeFileSync(fp,log);
+const sha=createHash('sha256').update(readFileSync(fp)).digest('hex');
+const stat=log.split(/\r?\n/).filter(x=>/^(ℹ (tests|pass|fail|skipped|duration_ms)|# (tests|pass|fail|skipped|duration_ms)|✖|not ok)/.test(x));
+console.log('R178_SHARD='+index+' FILES='+selection.length+' EXIT='+result.status+' TIMEOUT='+Boolean(result.error?.code==='ETIMEDOUT'));
+console.log(stat.slice(-8).map(x=>x.slice(0,300)).join('\n'));
+console.log('EVIDENCE='+fp+' SHA256='+sha);
+if(result.status!==0)process.exitCode=1;

package/scripts/r179-predecessor-registry.mjs

@@ -0,0 +1,24 @@
+import {spawnSync} from 'node:child_process';
+import {mkdtempSync,readdirSync,readFileSync,rmSync} from 'node:fs';
+import {tmpdir} from 'node:os';
+import {createHash} from 'node:crypto';
+import path from 'node:path';
+const npm=process.env.npm_execpath||path.join(path.dirname(process.execPath),'node_modules','npm','bin','npm-cli.js');
+function run(args,timeout=80000){const p=spawnSync(process.execPath,[npm,...args],{encoding:'utf8',shell:false,windowsHide:true,timeout,maxBuffer:3*1024*1024});if(p.error||p.status!==0)throw Error('npm read-only '+args[0]+' failed '+(p.stderr||p.error));return p.stdout.trim();}
+const dir=mkdtempSync(path.join(tmpdir(),'deadbyte-r179-source-'));
+try {
+ const metadata=JSON.parse(run(['view','deadbyte-mcp@0.15.68','dist','--json']));
+ console.log('PREDECESSOR_DIST_TARBALL='+JSON.stringify(metadata.tarball));
+ console.log('PREDECESSOR_DIST_SHASUM='+metadata.shasum);
+ const info=JSON.parse(run(['pack','deadbyte-mcp@0.15.68','--pack-destination',dir,'--ignore-scripts','--json']));
+ if(!Array.isArray(info)||info.length!==1)throw Error('parent npm pack response shape invalid');
+ const file=path.join(dir,info[0].filename);
+ const bytes=readFileSync(file);
+ const sha256=createHash('sha256').update(bytes).digest('hex');
+ const sha1=createHash('sha1').update(bytes).digest('hex');
+ if(sha1!==metadata.shasum)throw Error('parent npm registry SHA-1 identity mismatch');
+ console.log('PREDECESSOR_VERSION=0.15.68');
+ console.log('PREDECESSOR_TARBALL_SHA256='+sha256);
+ console.log('PREDECESSOR_PACKED_BYTES='+bytes.length);
+ console.log('PREDECESSOR_REGISTRY_MATCH=PASS');
+}finally{rmSync(dir,{recursive:true,force:true});}

package/scripts/r179-protected-inventory.ps1

@@ -0,0 +1,21 @@
+$ErrorActionPreference='Stop'
+$root='C:\Program Files'
+$paths=@(
+ 'C:\Program Files\DEADBYTE-R153-Protected-01560-Test',
+ 'C:\Program Files\DEADBYTE-R168-Protected-Test',
+ 'C:\Program Files\DEADBYTE-R174-Test'
+)
+if(Test-Path -LiteralPath $root){
+ Get-ChildItem -LiteralPath $root -Directory -ErrorAction SilentlyContinue |
+ Where-Object {$_.Name -match 'DEADBYTE|R174|R175|R178'} |
+ Select-Object -First 25 | ForEach-Object {
+  $package=Join-Path $_.FullName 'package.json'
+  $ver='missing';if(Test-Path -LiteralPath $package){try{$ver=(Get-Content -Raw -LiteralPath $package|ConvertFrom-Json).version}catch{$ver='invalid'}}
+  $owner=(Get-Acl -LiteralPath $_.FullName).Owner
+  Write-Output ('PROTECTED_CANDIDATE='+$_.FullName+' version='+$ver+' owner='+$owner)
+ }
+}
+$state=Join-Path $HOME '.deadbyte-mcp'
+$a=Get-Content (Join-Path $state 'active-release.json') -Raw|ConvertFrom-Json
+Write-Output ('ACTIVE='+$a.release_id+' version='+$a.version)
+Write-Output ('R179_READONLY_COMPLETE=TRUE')

package/scripts/r186-focused-runner.mjs

@@ -0,0 +1,22 @@
+import {spawnSync} from 'node:child_process';
+import {createHash} from 'node:crypto';
+import {readFileSync,writeFileSync,existsSync} from 'node:fs';
+import path from 'node:path';
+const root=path.resolve(import.meta.dirname,'..');
+const dir=path.resolve(root,'..','..','testing','r186-owner-consent');
+const tests=['test/r186-owner-consent-preflight.test.mjs','test/r186-owner-request.test.mjs',
+ 'test/r70-owner-approval.test.mjs',
+ 'test/r70-controller-owner-issue-boundary.test.mjs',
+ 'test/r70-autonomous-grant-expiry.test.mjs',
+ 'test/r174-owner-webauthn.test.mjs'];
+const result=spawnSync(process.execPath,['--test','--test-concurrency=2',...tests],{
+ cwd:root,encoding:'utf8',windowsHide:true,timeout:60000,maxBuffer:2*1024*1024});
+const s=String(result.stdout??'')+'\n'+String(result.stderr??'');
+const sha=createHash('sha256').update(s).digest('hex');
+const output=path.join(dir,'R186-OWNER-FOCUSED-V2-20261028.log');
+if(existsSync(output))throw Error('R186_FOCUSED_EVIDENCE_ALREADY_EXISTS');
+writeFileSync(output,s,{flag:'wx'});
+for(const line of s.split(/\r?\n/).filter(x=>/^(✔|✖|ℹ (tests|pass|fail|skipped|cancelled))/.test(x)).slice(-45))
+ console.log(line);
+console.log('R186_FOCUSED_EXIT='+result.status+' LOG_SHA256='+sha);
+if(result.status!==0)process.exitCode=1;

package/scripts/r186-owner-anchor-inspect.mjs

@@ -0,0 +1,6 @@
+import {readFile} from 'node:fs/promises';
+import {createR186OwnerAnchor} from '../src/r186-owner-anchor.mjs';
+const [file]=process.argv.slice(2);
+if(process.argv.slice(2).length!==1)throw new Error('usage: r186-owner-anchor-inspect.mjs <owner-public.pem>');
+const out=createR186OwnerAnchor(await readFile(file,'utf8'));
+process.stdout.write(JSON.stringify(out));

package/scripts/r186-owner-consent-check.mjs

@@ -0,0 +1,86 @@
+// R186 read-only inspection of independently enrolled owner authorization.
+// No key enrollment, challenge consumption, grant or policy mutation occurs here.
+// This CLI MUST run from an R89-protected exact release. Any agent-writable
+// source tree or owner public key path is rejected by the native OS ACL audit.
+import {createHash} from 'node:crypto';
+import {readFile,lstat} from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {inspectTrustedInstallation} from '../src/privileged-install-trust-r89.mjs';
+import {parseManifest,verifyManifestTreeExact} from '../src/release-slot.mjs';
+import {verifyR186OwnerConsent,verifyR186PolicyRootBinding} from '../src/r186-owner-consent-preflight.mjs';
+
+const THIS=fileURLToPath(import.meta.url);
+const ROOT=path.resolve(path.dirname(THIS),'..');
+const OWNER_DIR='C:\\Program Files\\DEADBYTE-OwnerTrust';
+const KEY=path.win32.join(OWNER_DIR,'owner-public.pem');
+const ANCHOR=path.win32.join(OWNER_DIR,'owner-anchor.json');
+const SHA=/^[0-9a-f]{64}$/;
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const reject=m=>{throw Error('R186_OWNER_PREFLIGHT_BLOCKED: '+m)};
+async function bounded(file,limit){
+ const st=await lstat(file);
+ if(!st.isFile()||st.isSymbolicLink()||st.size<1||st.size>limit)reject('unsafe input file');
+ return readFile(file);
+}
+async function main(){
+ if(process.platform!=='win32'||process.arch!=='x64')reject('requires Windows x64');
+ // No dynamic owner key paths. Owner trust must have been installed by the
+ // physical owner through an independently approved protected workflow.
+ const args=process.argv.slice(2);
+ if(args.length!==5)reject('usage: <approval-json> <root-id> <project-root> <coding-policy-json> <autonomous-policy-json>');
+ const [approvalPath,rootId,projectRoot,codingPolicyPath,autonomousPolicyPath]=args;
+ if(![approvalPath,projectRoot,codingPolicyPath,autonomousPolicyPath].every(p=>path.win32.isAbsolute(p)))
+  reject('absolute paths required');
+ if(!/^[A-Za-z0-9._-]{1,64}$/.test(rootId))reject('root identity invalid');
+ // Do not trust agent-provided signature keys. R89 rejects writable ancestor,
+ // unsafe owner and any writable ACE on the pin or enrolled public key.
+ const trustedFiles=[
+  process.execPath,THIS,ANCHOR,KEY,
+  path.join(ROOT,'MANIFEST.SHA256'),
+  path.join(ROOT,'src','r186-owner-consent-preflight.mjs'),
+  path.join(ROOT,'src','r70-owner-approval.mjs'),
+  path.join(ROOT,'src','canonical-json.mjs'),
+  path.join(ROOT,'src','release-slot.mjs'),
+  path.join(ROOT,'src','privileged-install-trust-r89.mjs')
+ ];
+ const os=await inspectTrustedInstallation(trustedFiles);
+ if(!os.trusted)reject('owner trust ACL untrusted');
+ const manifestBytes=await bounded(path.join(ROOT,'MANIFEST.SHA256'),512*1024);
+ const manifest=parseManifest(manifestBytes.toString('utf8'));
+ await verifyManifestTreeExact(ROOT,manifest);
+ const codingBytes=await bounded(codingPolicyPath,1024*1024);
+ const autonomousBytes=await bounded(autonomousPolicyPath,1024*1024);
+ const binding=verifyR186PolicyRootBinding({
+  codingPolicy:JSON.parse(codingBytes.toString('utf8')),
+  autonomousPolicy:JSON.parse(autonomousBytes.toString('utf8')),
+  rootId,projectRoot,codingPolicySha256:sha(codingBytes)
+ });
+ const [approvalBuf,trustBuf,keyBuf]=await Promise.all([
+  bounded(approvalPath,64*1024),bounded(ANCHOR,4*1024),bounded(KEY,8*1024)
+ ]);
+ const decision=await verifyR186OwnerConsent({
+  ownerTrust:JSON.parse(trustBuf.toString('utf8')),
+  ownerPublicKeyPem:keyBuf.toString('utf8'),
+  approval:JSON.parse(approvalBuf.toString('utf8')),
+  expected:{
+   rootId:binding.root_id,projectRoot:binding.project_root,
+   codingPolicySha256:sha(codingBytes),
+   autonomousPolicySha256:sha(autonomousBytes),
+   reviewedArtifactSha256:sha(manifestBytes)
+  }
+ });
+ console.log(JSON.stringify({
+  schema:'deadbyte.r186-owner-preflight.v1',
+  status:decision.status,
+  authority_granted:false,
+  owner_key_id:decision.owner_key_id,
+  subject_sha256:decision.subject_sha256,
+  release_manifest_sha256:sha(manifestBytes),
+  os_acl_trusted:true,
+  project_root:decision.project_root,
+  expires_at_utc:decision.expires_at_utc,
+  next_gate:'OWNER_APPROVAL_SINGLE_USE_CONSUMPTION_AND_SIGNED_EPOCH_ISSUANCE'
+ }));
+}
+main().catch(e=>{console.error('R186_OWNER_PREFLIGHT_BLOCKED '+String(e?.message??e).slice(0,300));process.exitCode=2;});

package/scripts/r186-owner-grant-cli.mjs

@@ -0,0 +1,45 @@
+// Protected, fixed-scope R186 grant broker entrypoint. The controller chooses
+// neither a trust key nor an approval path; both are fixed by the contract.
+import {createHash} from 'node:crypto';
+import {lstat,readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {inspectTrustedInstallation} from '../src/privileged-install-trust-r89.mjs';
+import {parseManifest,verifyManifestTreeExact} from '../src/release-slot.mjs';
+import {issueR186AutonomousGrant} from '../src/r186-owner-grant-broker.mjs';
+
+const THIS=fileURLToPath(import.meta.url),ROOT=path.resolve(path.dirname(THIS),'..');
+const OWNER_DIR='C:\\Program Files\\DEADBYTE-OwnerTrust';
+const KEY=path.win32.join(OWNER_DIR,'owner-public.pem');
+const ANCHOR=path.win32.join(OWNER_DIR,'owner-anchor.json');
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const block=m=>{throw new Error(`R186_OWNER_GRANT_BLOCKED: ${m}`);};
+async function bounded(file,limit){const st=await lstat(file);if(!st.isFile()||st.isSymbolicLink()||st.size<1||st.size>limit)block('unsafe input file');return readFile(file);}
+async function main(){
+ if(process.platform!=='win32'||process.arch!=='x64')block('requires Windows x64');
+ const [runtimeDir,codingPolicyPath,autonomousPolicyPath]=process.argv.slice(2);
+ if(process.argv.slice(2).length!==3||![runtimeDir,codingPolicyPath,autonomousPolicyPath].every(p=>path.win32.isAbsolute(p)))
+  block('usage: <runtime-dir> <coding-policy-json> <autonomous-policy-json>');
+ const approvalPath=path.join(runtimeDir,'owner-consent','autonomous-approval.json');
+ const protectedFiles=[process.execPath,THIS,ANCHOR,KEY,path.join(ROOT,'MANIFEST.SHA256'),
+  path.join(ROOT,'src','r186-owner-grant-broker.mjs'),path.join(ROOT,'src','r186-owner-consent-preflight.mjs'),
+  path.join(ROOT,'src','r70-owner-approval.mjs'),path.join(ROOT,'src','authority-continuity-r65.mjs'),
+  path.join(ROOT,'src','epoch-lock-r85.mjs'),path.join(ROOT,'bin','deadbyte-epoch-lock-r85.node')];
+ const trust=await inspectTrustedInstallation(protectedFiles);
+ if(!trust.trusted)block('protected package or owner trust ACL untrusted');
+ const manifestBytes=await bounded(path.join(ROOT,'MANIFEST.SHA256'),512*1024);
+ await verifyManifestTreeExact(ROOT,parseManifest(manifestBytes.toString('utf8')));
+ const [codingBytes,autonomousBytes,approvalBytes,anchorBytes,keyBytes]=await Promise.all([
+  bounded(codingPolicyPath,1024*1024),bounded(autonomousPolicyPath,1024*1024),bounded(approvalPath,64*1024),
+  bounded(ANCHOR,4096),bounded(KEY,8192)]);
+ const autonomous=JSON.parse(autonomousBytes.toString('utf8'));
+ const result=await issueR186AutonomousGrant({runtimeDir,grantFile:autonomous.lease_file,
+  codingPolicy:JSON.parse(codingBytes.toString('utf8')),codingPolicyBytes:codingBytes,
+  autonomousPolicy:autonomous,autonomousPolicyBytes:autonomousBytes,releaseManifestBytes:manifestBytes,
+  ownerTrust:JSON.parse(anchorBytes.toString('utf8')),ownerPublicKeyPem:keyBytes.toString('utf8'),
+  approval:JSON.parse(approvalBytes.toString('utf8'))});
+ if(sha(await readFile(codingPolicyPath))!==sha(codingBytes)||sha(await readFile(autonomousPolicyPath))!==sha(autonomousBytes))
+  block('policy changed during grant transaction; outcome requires reconciliation');
+ process.stdout.write(JSON.stringify(result));
+}
+main().catch(error=>{console.error(String(error?.message??error).slice(0,500));process.exitCode=2;});

package/scripts/r186-owner-key-local.mjs

@@ -0,0 +1,22 @@
+// Owner-operated only. Do not invoke from an agent workflow.
+import {generateKeyPairSync} from 'node:crypto';
+import {mkdir,open,readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {createR186OwnerAnchor} from '../src/r186-owner-anchor.mjs';
+import {createR186OwnerApproval} from '../src/r186-owner-local-signing.mjs';
+
+function args(values){const out={};for(let i=0;i<values.length;i+=2){if(!values[i]?.startsWith('--')||!values[i+1])throw new Error('invalid arguments');out[values[i].slice(2)]=path.resolve(values[i+1]);}return out;}
+async function exclusive(file,data,mode=0o600){await mkdir(path.dirname(file),{recursive:true});const h=await open(file,'wx',mode);try{await h.writeFile(data);await h.sync();}finally{await h.close();}}
+const [command,...rest]=process.argv.slice(2),opt=args(rest);
+if(command==='keygen'){
+ if(!opt['private-out']||!opt['public-out'])throw new Error('usage: keygen --private-out PATH --public-out PATH');
+ const pair=generateKeyPairSync('ed25519'),privatePem=pair.privateKey.export({type:'pkcs8',format:'pem'}).toString();
+ const material=createR186OwnerAnchor(pair.publicKey.export({type:'spki',format:'pem'}).toString());
+ await exclusive(opt['private-out'],privatePem,0o600);await exclusive(opt['public-out'],material.public_key_pem,0o644);
+ console.log(`R186_OWNER_KEY_CREATED public=${opt['public-out']} owner_key_id=${material.anchor.owner_key_id}`);
+}else if(command==='sign'){
+ if(!opt.request||!opt['private-key']||!opt['approval-out'])throw new Error('usage: sign --request PATH --private-key PATH --approval-out PATH');
+ const approval=createR186OwnerApproval({request:JSON.parse(await readFile(opt.request,'utf8')),privateKeyPem:await readFile(opt['private-key'],'utf8')});
+ await exclusive(opt['approval-out'],Buffer.from(JSON.stringify(approval,null,2)+'\n'),0o600);
+ console.log(`R186_OWNER_APPROVAL_CREATED approval=${opt['approval-out']} subject_sha256=${approval.subject_sha256} owner_key_id=${approval.owner_key_id}`);
+}else throw new Error('usage: r186-owner-key-local.mjs <keygen|sign> ...');

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

@@ -0,0 +1,34 @@
+// Protected exact-byte review-request export. No owner key or grant is used.
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {inspectTrustedInstallation} from '../src/privileged-install-trust-r89.mjs';
+import {parseManifest,verifyManifestTreeExact} from '../src/release-slot.mjs';
+import {writeR186OwnerReviewRequest} from '../src/r186-owner-review-export.mjs';
+import {readFile} from 'node:fs/promises';
+
+const THIS=fileURLToPath(import.meta.url),ROOT=path.resolve(path.dirname(THIS),'..');
+const fail=message=>{throw new Error(`R186_OWNER_REVIEW_EXPORT_BLOCKED: ${message}`);};
+async function main(){
+ if(process.platform!=='win32'||process.arch!=='x64')fail('requires Windows x64');
+ const [rootId,projectRoot,codingPolicyPath,autonomousPolicyPath,outputPath]=process.argv.slice(2);
+ if(process.argv.slice(2).length!==5||
+    ![projectRoot,codingPolicyPath,autonomousPolicyPath,outputPath].every(value=>path.win32.isAbsolute(value)))
+  fail('usage: <root-id> <project-root> <coding-policy-json> <autonomous-policy-json> <output-json>');
+ const manifestPath=path.join(ROOT,'MANIFEST.SHA256');
+ const protectedFiles=[process.execPath,THIS,manifestPath,
+  path.join(ROOT,'src','r186-owner-review-export.mjs'),
+  path.join(ROOT,'src','r186-owner-request.mjs'),
+  path.join(ROOT,'src','r186-owner-consent-preflight.mjs'),
+  path.join(ROOT,'src','canonical-json.mjs'),
+  path.join(ROOT,'src','privileged-install-trust-r89.mjs'),
+  path.join(ROOT,'src','release-slot.mjs')];
+ const trust=await inspectTrustedInstallation(protectedFiles);
+ if(!trust.trusted)fail('protected package ACL untrusted');
+ const manifestBytes=await readFile(manifestPath);
+ await verifyManifestTreeExact(ROOT,parseManifest(manifestBytes.toString('utf8')));
+ const request=await writeR186OwnerReviewRequest({rootId,projectRoot,codingPolicyPath,
+  autonomousPolicyPath,manifestPath,outputPath});
+ process.stdout.write(JSON.stringify({status:'REVIEW_REQUEST_EXPORTED',authority_granted:false,
+  owner_signature_present:false,subject_sha256:request.subject_sha256,output_path:outputPath}));
+}
+main().catch(error=>{console.error(String(error?.message??error).slice(0,500));process.exitCode=2;});