deadbyte-mcp 0.15.68 → 0.15.69

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;});

package/src/deadbyte-cli.mjs

@@ -27,6 +27,7 @@ import {foregroundIdentityMatches,queryForegroundIdentity,validForegroundIdentit
 import {readRemoteMarkerSnapshot,deletePinnedRemoteMarker} from './foreground-marker-cas-win32.mjs';
 import {acquireForegroundSessionLock} from './foreground-session-lock.mjs';
 import { AUTHORITY_PLANES, authorityVector, authorityRestorePlan, parseAuthorityObservation, assertAuthorityVector, assertRuntimeReadyObservation, authorityBanner } from './remote-authority.mjs';
+import {observeOnlyAuthority,assertObserveOnlyMarker,assertMatchingForegroundRelease} from './r175-foreground-boundary.mjs';
 import { decodeRemoteLogBytes, boundedRemoteDiagnostic, readRemoteLogAppend } from './remote-log-decode-r60.mjs';
 import {reconcileStaleMarker,resumeMarkerReconciliation,recoverPublishedMarkerTerminal} from './clean-activation-recovery-r153.mjs';
 import {selectLegacyMarkerEvidence,verifyLocatedLegacyMarkerReceipt} from './legacy-marker-evidence-r159.mjs';
@@ -61,10 +62,10 @@ function printHelp(){
     `  npx -y ${exact} doctor              # verify current package/release truth`,
     `  npx -y ${exact} mcp                 # stdio MCP server for local clients`,
     `  npx -y ${exact} remote              # safe observation-only foreground session`,
-    `  npx -y ${exact} remote --operator   # process/coding/autonomous; explicit owner gates still apply`,
-    `  npx -y ${exact} remote --desktop    # session with Desktop authority; Host remains disarmed`,
-    `  npx -y ${exact} remote --host       # session with Host authority; Desktop remains disarmed`,
-    `  npx -y ${exact} remote --full       # explicit five-plane foreground session`,
+    `  npx -y ${exact} remote --operator   # R175 blocked pending session-owned authority issuance`,
+    `  npx -y ${exact} remote --desktop    # R175 blocked pending session-owned authority issuance`,
+    `  npx -y ${exact} remote --host       # R175 blocked pending session-owned authority issuance`,
+    `  npx -y ${exact} remote --full       # R175 blocked pending session-owned authority issuance`,
     `  npx -y ${exact} remote --resume <cursor> # replay missed results, then reconnect`,
     `  npx -y ${exact} remote --trace           # show trace/span identity without payload detail`,
  
@@ -400,8 +401,8 @@ function timelineFilterEvent(timeline){
 }
 async function tailRemoteLogs(root,signal,{journal=null,offsets=null,activityTracker=null,timelineFilter=null,timelineWriter=null,verbose=false,displayMode='unicode'}={}){
   process.stdout.write(verbose
-    ? '[LOG] Verbose live timeline. Full sanitized request detail enabled; Ctrl+C disconnects and revokes authority.\n'
-    : '[LOG] Live tool calls with individual START/DONE, sanitized arguments and results. Transport hidden; signed audit remains on disk. Ctrl+C disconnects and revokes authority.\n');
+    ? '[LOG] Verbose live timeline. Full sanitized request detail enabled; Ctrl+C disconnects; owner standing grants remain unchanged.\n'
+    : '[LOG] Live tool calls with individual START/DONE, sanitized arguments and results. Transport hidden; signed audit remains on disk. Ctrl+C disconnects; owner standing grants remain unchanged.\n');
   const activeOffsets=offsets??await snapshotRemoteLogOffsets(root);
   const partialLines=new Map();
   let liveFiles=[...activeOffsets.keys()];
@@ -455,7 +456,13 @@ function remoteTag(kind,displayMode){
   return (displayMode==='ascii'?ascii:unicode)[kind];
 }
 function writeRemote(stream,text,displayMode){stream.write(remoteDisplayText(text,displayMode));}
-async function cleanupRemoteSession(ctx,{displayMode='unicode'}={}){
+async function cleanupRemoteSession(ctx,{displayMode='unicode',marker=null}={}){
+  // R175 observation sessions issue no grants and must never revoke owner grants or park runtime.
+  // An invalid R175 marker must fail closed, not fall through to legacy revoke.
+  if(marker!==null){
+    if(!assertObserveOnlyMarker(marker))throw new Error('R175_INVALID_OBSERVE_ONLY_MARKER: no authority cleanup performed');
+    return;
+  }
   const failed=[];
   for(const command of SESSION_CLEANUP){
     try{
@@ -669,6 +676,15 @@ async function recoverRemoteSession(ctx,{displayMode='unicode'}={}){
   const markerPath=remoteSessionMarker(ctx.root);
   const snapshot=await readRemoteMarkerSnapshot(markerPath);
   if(!snapshot) return null;
+  if(assertObserveOnlyMarker(prior)){
+    // Owner and guardian lifetime were verified above. A monitor-only session
+    // owns the CAS marker, not any authority epoch or runtime lifecycle.
+    if(snapshot.marker?.owner_pid!==prior.owner_pid||snapshot.marker?.session_nonce!==prior.session_nonce)
+      throw new Error('R175 observation-only stale marker identity changed; marker retained');
+    if(deletePinnedRemoteMarker(markerPath,snapshot.sha256)!=='REMOVED')
+      throw new Error('R175 observation-only stale marker CAS failed; marker retained');
+    return null;
+  }
   const active=await readActiveRuntimeBinding(ctx.root);
   if(!active)throw new Error(`remote session ownership unverified for stale pid=${ownerPid}; active pointer missing; marker retained`);
   const observed=observedAuthority(ctx);
@@ -740,7 +756,7 @@ async function claimRemoteSession(ctx){
   const dir=path.join(ctx.root,'runtime');await mkdir(dir,{recursive:true});
   const nonce=randomBytes(32).toString('hex');
   const resultSessionId=randomBytes(12).toString('hex');
-  const marker={schema:'deadbyte.remote-session.v2',owner_pid:process.pid,guardian_pid:0,session_nonce:nonce,
+  const marker={schema:'deadbyte.remote-session.v2',authority_scope:'observe-only',owner_pid:process.pid,guardian_pid:0,session_nonce:nonce,
     result_session_id:resultSessionId,started_at_utc:new Date().toISOString()};
   marker.owner_identity=queryForegroundIdentity(process.pid);
   if(!marker.owner_identity)throw new Error('remote foreground identity unavailable');
@@ -749,7 +765,7 @@ async function claimRemoteSession(ctx){
   catch(error){if(error?.code==='EEXIST') throw new Error('remote session already claimed');throw error;}
   let guardian=null;
   try{
-    guardian=spawn(process.execPath,[GUARDIAN_SCRIPT,'--state-root',ctx.root,'--owner-pid',String(process.pid),'--session-nonce',nonce,'--owner-channel','ipc'],{
+    guardian=spawn(process.execPath,[GUARDIAN_SCRIPT,'--state-root',ctx.root,'--owner-pid',String(process.pid),'--session-nonce',nonce,'--owner-channel','ipc','--authority-scope','observe-only'],{
       detached:true,stdio:['ignore','ignore','ignore','ipc'],windowsHide:true,shell:false,env:process.env
     });
     if(!Number.isInteger(guardian.pid)||guardian.pid<1) throw new Error('remote session guardian did not start');
@@ -786,6 +802,10 @@ async function releaseRemoteSession(ctx,marker,{displayMode='unicode'}={}){
     throw new Error('remote session ownership marker replaced before native deletion; marker retained');
 }
 async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,filterExpression='',mode='default',hostCommandPins=[]}={}){
+  // R175: elevated session flags need a distinct signed session-owned lease
+  // issuer before they can safely coexist with owner standing grants.
+  if(mode!=='default') throw new Error('R175_FOREGROUND_OWNER_BOUNDARY: elevated foreground modes require session-owned grants; use explicit remote arm* commands');
+  if(hostCommandPins.length) throw new Error('R175_FOREGROUND_OBSERVE_ONLY: host command repins require an explicit owner action outside foreground logging');
   const display=prepareRemoteConsole();
   const displayMode=display.mode;
   const ctx=await remoteContext();
@@ -793,12 +813,15 @@ async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,fil
   // an EPOCH_NATIVE production runtime. This guard precedes session recovery,
   // marker claims, revocations and any controller startup.
   const active=await readActiveRuntimeBinding(ctx.root);
+  const currentManifestSha256=createHash('sha256')
+    .update(await readFile(path.join(CURRENT_PACKAGE_ROOT,'MANIFEST.SHA256'))).digest('hex');
+  assertMatchingForegroundRelease(active,{version:DEADBYTE_VERSION,manifest_sha256:currentManifestSha256});
   if(active){
     const decision=selectR168OneShotRemotePath({command:'start',active,cliVersion:DEADBYTE_VERSION});
     if(decision.mode==='blocked_version_skew') throw new Error(decision.message);
   }
-  // First installation without an active pointer retains the existing
-  // unbound bootstrap path. A bound older release must never auto-upgrade.
+  // R175 foreground is monitor-only: deployment and upgrades need separate owner action.
+  // Never synchronize runtime or mint/revoke a grant from this path.
   if(displayMode==='ascii') writeRemote(process.stdout,`[DISPLAY] ASCII fallback: ${display.reason}\n`,displayMode);
   if(resumeCursor!==null) await replayRemoteResults(ctx.root,resumeCursor,{displayMode});
   const startupLock=await acquireForegroundSessionLock({root:ctx.root,powershell:ctx.powershell});
@@ -807,9 +830,21 @@ async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,fil
     startupLock.assertHeld();
     await verifyPackageDecisionManifest({root:CURRENT_PACKAGE_ROOT,expectedVersion:DEADBYTE_VERSION});
     startupLock.assertHeld();
-    const migrationContext=await recoverRemoteSession(ctx,{displayMode});
+    // R179: an observation session may recover ONLY its own observation marker.
+    // Legacy migration/revocation is a separately authorized controller action.
+    const staleObserver=await readRemoteSessionMarker(ctx.root);
+    if(staleObserver){
+      if(!assertObserveOnlyMarker(staleObserver))
+        throw new Error('R179_LEGACY_FOREGROUND_RECOVERY_REQUIRES_EXPLICIT_OWNER_COMMAND: no authority touched');
+      await recoverRemoteSession(ctx,{displayMode});
+    }
     startupLock.assertHeld();
-    await synchronizeForegroundRuntime(ctx,{displayMode,migrationContext,hostCommandPins});
+    const pinned=await readActiveRuntimeBinding(ctx.root);
+    assertMatchingForegroundRelease(pinned,{version:DEADBYTE_VERSION,manifest_sha256:currentManifestSha256});
+    for(const field of ['release_id','generation_manifest_sha256','generation_root']){
+      if(pinned[field]!==active[field])
+        throw new Error('R175_FOREGROUND_ACTIVE_DRIFT: no runtime update or grant mutation attempted');
+    }
     startupLock.assertHeld();
     marker=await claimRemoteSession(ctx);
     startupLock.assertHeld();
@@ -838,51 +873,29 @@ async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,fil
     process.stdout.write('[BOOT] Starting local + remote runtime...\n');
     const preflight=invokeController(ctx,'status',{capture:true,allowFailure:true,echoCaptured:false,timeoutMs:REMOTE_STATUS_TIMEOUT_MS});
     let startText=preflight.stdout||'';
-    if(preflight.status===0&&controllerRuntimeReady(preflight.stdout)){
-      process.stdout.write('[BOOT] Runtime already ONLINE; reusing verified bridge/cloud/supervisor.\n');
-    }else{
-      const recovery=preflight.status===0&&controllerRuntimeDegraded(preflight.stdout);
-      process.stdout.write(recovery?'[RECOVERY] Runtime failed readiness; restarting verified owned components...\n':'[BOOT] Starting bridge/runtime...\n');
-      const startCommand=recovery?'restart':'start';
-      const controllerLogDir=path.join(ctx.root,'runtime','logs');
-      await mkdir(controllerLogDir,{recursive:true});
-      const launchOutput={
-        stdout_path:path.join(controllerLogDir,`controller-${startCommand}.stdout.log`),
-        stderr_path:path.join(controllerLogDir,`controller-${startCommand}.stderr.log`)
-      };
-      const launch=invokeController(ctx,startCommand,{allowFailure:true,redirectOutput:launchOutput,timeoutMs:REMOTE_START_TIMEOUT_MS});
-      if(launch.status!==0){
-        const evidence=await readControllerStartFailure(ctx.root,startCommand);
-        const fallback=evidence?'':await readTailBounded(launchOutput.stderr_path,2048);
-        const detail=evidence?`; controller-start-failure: ${evidence.message}`:(fallback?`; controller-stderr: ${fallback}`:'');
-        throw new Error(`remote controller '${startCommand}' failed exit=${launch.status}${detail}`);
-      }
-      const started=invokeController(ctx,'status',{capture:true,echoCaptured:false,timeoutMs:REMOTE_STATUS_TIMEOUT_MS});
-      if(started.status!==0||!controllerRuntimeReady(started.stdout)) throw new Error(`remote controller ${recovery?'restart':'start'} returned without a verified ONLINE runtime`);
-      startText=started.stdout||'';
-    }
+    if(preflight.status!==0||!controllerRuntimeReady(preflight.stdout))
+      throw new Error('R175_FOREGROUND_RUNTIME_NOT_READY: monitoring cannot start or restart a runtime; use explicit remote start');
+    process.stdout.write('[BOOT] Runtime already ONLINE; reusing verified bridge/cloud/supervisor.\n');
     process.stdout.write(`${formatRemoteLifecycle('bridge_connected',{displayMode})}\n`);
     process.stdout.write(`${formatRemoteLifecycle('cloud_connected',{displayMode})}\n`);
-    const desired=authorityVector(mode);
-    const priorAuthority=observedAuthority(ctx);
-    for(const plane of ['host','desktop','autonomous','coding','process'].filter(name=>!desired[name]&&priorAuthority.authority[name].armed)){
-      const command=`disarm${plane}`;
-      writeRemote(process.stdout,`${remoteTag('auth',displayMode)} Revoking unwanted ${plane} authority...\n`,displayMode);
-      invokeController(ctx,command,{capture:true,echoCaptured:false,timeoutMs:REMOTE_STATUS_TIMEOUT_MS});
-    }
-    for(const plane of AUTHORITY_PLANES.filter(name=>desired[name])){
-      const command=`arm${plane}`;
-      writeRemote(process.stdout,`${remoteTag('auth',displayMode)} Arming ${command.slice(3)}...\n`,displayMode);
-      invokeController(ctx,command,{capture:true,echoCaptured:false,timeoutMs:REMOTE_STATUS_TIMEOUT_MS});
-    }
-    const url=startText.match(/^URL\s*:\s*(\S+)/m)?.[1]||'';
-    writeRemote(process.stdout,`${remoteTag('auth',displayMode)} Verifying exact ${mode} authority vector...\n`,displayMode);
+    // Observation is never a grant transition or an expectation that live
+    // owner grants remain frozen for the lifetime of this log session.
     const current=await readActiveRuntimeBinding(ctx.root);
-    const authority=assertAuthorityVector(assertRuntimeReadyObservation(observedAuthority(ctx),{
-      coreRoot:current?.release_root??null
-    }),desired);
+    for(const field of ['release_id','manifest_sha256','generation_manifest_sha256','generation_root'])
+      if(current?.[field]!==active[field])throw new Error('R175_FOREGROUND_ACTIVE_DRIFT: observed release changed');
+    const authority=assertRuntimeReadyObservation(observedAuthority(ctx),{
+      coreRoot:active.release_root
+    });
+    observeOnlyAuthority(authority);
+    const url=startText.match(/^URL\s*:\s*(\S+)/m)?.[1]||'';
+    writeRemote(process.stdout,`${remoteTag('auth',displayMode)} Observing existing grants without ARM or DISARM...\n`,displayMode);
     process.stdout.write('[BOOT] Verifying public signed MCP execution path...\n');
-    invokeController(ctx,'machinetest',{capture:true,echoCaptured:false,timeoutMs:REMOTE_START_TIMEOUT_MS,probeMode:mode==='default'?'revoked':mode});
+    // Signed machine test is safe only for already-disarmed authority vectors.
+    // Do not test against a made-up all-disarmed expectation while owner
+    // grants are live; never revoke them as a way to make that test pass.
+    if(AUTHORITY_PLANES.every(plane=>!authority.authority[plane].armed))
+      invokeController(ctx,'machinetest',{capture:true,echoCaptured:false,timeoutMs:REMOTE_START_TIMEOUT_MS,probeMode:'revoked'});
+    else process.stdout.write('[VERIFY] pre-existing owner grants preserved; revoked-plane probe omitted\n');
     ready=true;
     writeRemote(process.stdout,`${remoteTag('auth',displayMode)} ${authorityBanner(authority)}\n`,displayMode);
     process.stdout.write('[OK] ONLINE\n');
@@ -906,8 +919,8 @@ async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,fil
     process.removeListener('SIGINT',abort);process.removeListener('SIGTERM',abort);
     if(watchStdin){process.stdin.removeListener('end',abort);process.stdin.removeListener('close',abort);process.stdin.pause();}
     process.stdout.write(`${formatRemoteLifecycle('cleanup',{displayMode})}\n`);
-    if(ready||!wasAborted) process.stdout.write('[INFO] Disconnecting; revoking authority...\n');
-    try{await cleanupRemoteSession(ctx,{displayMode});}
+    if(ready||!wasAborted) process.stdout.write('[INFO] Disconnecting; preserving owner standing grants...\n');
+    try{await cleanupRemoteSession(ctx,{displayMode,marker});}
     catch(cleanupError){
       if(sessionError) throw new AggregateError([sessionError,cleanupError],
         `remote activation failed: ${String(sessionError?.message||sessionError)}; cleanup failed, ownership marker retained: ${String(cleanupError?.message||cleanupError)}`);