deadbyte-mcp 0.13.0 → 0.15.0

package/test/remote-device-r44.test.mjs

@@ -0,0 +1,104 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { generateKeyPairSync, createHash } from 'node:crypto';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { createRemoteDevicePlaneR44 } from '../src/remote-device-r44.mjs';
+
+const sha=b=>createHash('sha256').update(b).digest('hex');
+function deviceKey(){
+  const {publicKey}=generateKeyPairSync('ed25519');
+  const der=Buffer.from(publicKey.export({type:'spki',format:'der'}));
+  return {spki:der.toString('base64'),deviceId:sha(der)};
+}
+class FakeRelay{
+  constructor(){this.probes=[];this.requests=[];this.drop=false;}
+  async probe(value){this.probes.push(structuredClone(value));return {device_id:value.device_id,epoch:value.epoch,nonce:value.nonce,ready:true};}
+  async request(value){this.requests.push(structuredClone(value));if(this.drop)return null;return {ack:'accepted',request_id:value.request_id,terminal:{status:'completed',result_sha256:'a'.repeat(64)}};}
+}
+
+test('R44 remote device reported online is not reachable until identity-bound probe ACK',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r44-remote-'));
+  const relay=new FakeRelay(), key=deviceKey();
+  try{
+    const plane=await createRemoteDevicePlaneR44({stateDir:root,relay,authorizeCapability:async()=>true});
+    const paired=await plane.pair({publicKeySpkiBase64:key.spki,displayName:'lab'});
+    assert.equal(paired.device_id,key.deviceId);assert.equal(paired.epoch,1);
+    await plane.reportOnline({deviceId:key.deviceId,epoch:1,connectionId:'conn-1'});
+    assert.equal((await plane.status({deviceId:key.deviceId})).reachable,false);
+    await assert.rejects(plane.dispatch({deviceId:key.deviceId,epoch:1,capabilityId:'coding.search',payload:{q:'x'},requestId:'1'.repeat(64)}),/not reachable/);
+    const ready=await plane.probe({deviceId:key.deviceId,epoch:1});
+    assert.equal(ready.reachable,true);assert.equal(relay.probes.length,1);
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R44 remote dispatch is durable-before-send, replay-idempotent and silent drop is terminal',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r44-remote-dispatch-'));
+  const relay=new FakeRelay(), key=deviceKey();
+  try{
+    const plane=await createRemoteDevicePlaneR44({stateDir:root,relay,authorizeCapability:async()=>true});
+    await plane.pair({publicKeySpkiBase64:key.spki,displayName:'lab'});
+    await plane.reportOnline({deviceId:key.deviceId,epoch:1,connectionId:'c'});
+    await plane.probe({deviceId:key.deviceId,epoch:1});
+    const requestId='2'.repeat(64), payload={path:'README.md'};
+    const done=await plane.dispatch({deviceId:key.deviceId,epoch:1,capabilityId:'coding.file_read',payload,requestId});
+    assert.equal(done.state,'completed');assert.equal(relay.requests.length,1);
+    const stored=JSON.parse(await readFile(path.join(root,'remote-devices.json'),'utf8'));
+    assert.equal(stored.requests[requestId].state,'completed');
+    const replay=await plane.dispatch({deviceId:key.deviceId,epoch:1,capabilityId:'coding.file_read',payload,requestId});
+    assert.equal(replay.replay,true);assert.equal(relay.requests.length,1);
+    await assert.rejects(plane.dispatch({deviceId:key.deviceId,epoch:1,capabilityId:'coding.file_read',payload:{path:'other'},requestId}),/request id conflict/);
+
+    relay.drop=true;
+    const droppedId='3'.repeat(64);
+    const dropped=await plane.dispatch({deviceId:key.deviceId,epoch:1,capabilityId:'coding.file_read',payload,requestId:droppedId});
+    assert.equal(dropped.state,'failed');assert.equal(dropped.error_code,'transport_no_ack');
+    const after=JSON.parse(await readFile(path.join(root,'remote-devices.json'),'utf8'));
+    assert.equal(after.requests[droppedId].state,'failed');
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R44 remote routing requires local capability authorization and revoke invalidates epoch',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r44-remote-auth-'));
+  const relay=new FakeRelay(), key=deviceKey();
+  try{
+    const plane=await createRemoteDevicePlaneR44({stateDir:root,relay,authorizeCapability:async({capabilityId})=>capabilityId==='machine.status'});
+    await plane.pair({publicKeySpkiBase64:key.spki,displayName:'lab'});
+    await plane.reportOnline({deviceId:key.deviceId,epoch:1,connectionId:'c'});await plane.probe({deviceId:key.deviceId,epoch:1});
+    await assert.rejects(plane.dispatch({deviceId:key.deviceId,epoch:1,capabilityId:'host.exec',payload:{},requestId:'4'.repeat(64)}),/capability denied/);
+    assert.equal(relay.requests.length,0);
+    const revoked=await plane.revoke({deviceId:key.deviceId,epoch:1});
+    assert.equal(revoked.revoked,true);
+    await assert.rejects(plane.reportOnline({deviceId:key.deviceId,epoch:1,connectionId:'new'}),/revoked|epoch/i);
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R44 credential rotation commits encrypted replacement before supersede callback',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r44-remote-rotate-'));
+  const relay=new FakeRelay(), key=deviceKey(), observed=[];
+  try{
+    const plane=await createRemoteDevicePlaneR44({stateDir:root,relay,authorizeCapability:async()=>true,
+      onCredentialSuperseded:async info=>{
+        const current=JSON.parse(await readFile(path.join(root,'credentials',`${key.deviceId}.json`),'utf8'));
+        observed.push({info,current});
+      }});
+    await plane.pair({publicKeySpkiBase64:key.spki,displayName:'lab'});
+    const one=Buffer.from('encrypted-token-one').toString('base64');
+    const first=await plane.rotateCredential({deviceId:key.deviceId,epoch:1,encryptedBundleBase64:one,expectedPreviousSha256:null});
+    const two=Buffer.from('encrypted-token-two').toString('base64');
+    const second=await plane.rotateCredential({deviceId:key.deviceId,epoch:1,encryptedBundleBase64:two,expectedPreviousSha256:first.credential_sha256});
+    assert.notEqual(second.credential_sha256,first.credential_sha256);
+    assert.equal(observed.length,1);
+    assert.equal(observed[0].current.credential_sha256,second.credential_sha256,'new credential must be durable before supersede');
+    await assert.rejects(plane.rotateCredential({deviceId:key.deviceId,epoch:1,encryptedBundleBase64:one,expectedPreviousSha256:first.credential_sha256}),/precondition/);
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R44 remote state corruption fails closed',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r44-remote-corrupt-'));
+  try{
+    await writeFile(path.join(root,'remote-devices.json'),'{"schema":','utf8');
+    await assert.rejects(createRemoteDevicePlaneR44({stateDir:root,relay:new FakeRelay(),authorizeCapability:async()=>true}),/state JSON invalid/);
+  }finally{await rm(root,{recursive:true,force:true});}
+});

package/test/runtime-self-update.test.mjs

@@ -53,6 +53,29 @@ test('R27 slot-update CLI requires exact stage/development/version/manifest bind
   assert.ok(path.isAbsolute(parsed.developmentRoot));
 });
 
+test('R43 slot authority restore plan carries prior Process grant without restoring Desktop or Host', () => {
+  assert.equal(typeof runtimeUpdate.standingAuthorityRestorePlan,'function');
+  const parsed=runtimeUpdate.parseControllerStatus([
+    'DEADBYTE MCP = ONLINE',
+    'Process plane  : ARMED [standing-grant]',
+    'Coding plane  : ARMED [standing-grant]',
+    'Autonomous     : ARMED [standing-grant]',
+    'Desktop plane : ARMED [standing-grant]',
+    'Host plane    : DISARMED [disarmed]'
+  ].join('\n'));
+  assert.equal(parsed.process_armed,true);
+  const plan=runtimeUpdate.standingAuthorityRestorePlan(parsed,true);
+  assert.deepEqual(plan.commands,['armcoding','armautonomous','armprocess']);
+  assert.deepEqual(plan.expected,{
+    process_armed:true,coding_armed:true,autonomous_armed:true,desktop_armed:false,host_armed:false
+  });
+  const disabled=runtimeUpdate.standingAuthorityRestorePlan(parsed,false);
+  assert.deepEqual(disabled.commands,[]);
+  assert.deepEqual(disabled.expected,{
+    process_armed:false,coding_armed:false,autonomous_armed:false,desktop_armed:false,host_armed:false
+  });
+});
+
 test('R27 development root is outside immutable/runtime state stores', async () => {
   const state=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r27-state-'));
   const dev=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r27-dev-'));
@@ -410,6 +433,25 @@ test('R29 bridge bootstrap rebinds only the pinned external bridge script', asyn
   await assert.rejects(runtimeUpdate.prepareBridgeSpec(config,{root,scriptSha256:hex('f')}),/bridge script SHA-256 mismatch/i);
 });
 
+test('R44 downstream core selection accepts only one exact visible or one opaque child of the verified Bridge', () => {
+  assert.equal(typeof runtimeUpdate.selectCoreProcess,'function');
+  const root=path.resolve('C:/release'),bridgePid=1200;
+  const visible={ProcessId:1300,ParentProcessId:bridgePid,CreationDate:'20260921010000.000000+000',
+    ExecutablePath:'C:\\Program Files\\nodejs\\node.exe',CommandLine:`node "${path.join(root,'src','mcp-server.mjs')}"`};
+  const exact=runtimeUpdate.selectCoreProcess([visible],root,bridgePid);
+  assert.equal(exact.pid,1300);
+  assert.equal(exact.identity_basis,'command_line');
+  const opaque={ProcessId:1301,ParentProcessId:bridgePid,CreationDate:'20260921010100.000000+000',ExecutablePath:null,CommandLine:null};
+  const verifiedBridge={component:'bridge',pid:bridgePid,script_path:'C:\\bridge\\src\\bridge.mjs',script_sha256:hex('a')};
+  const fallback=runtimeUpdate.selectCoreProcess([opaque],root,bridgePid,verifiedBridge);
+  assert.equal(fallback.pid,1301);
+  assert.equal(fallback.identity_basis,'verified_bridge_single_opaque_node_child');
+  assert.throws(()=>runtimeUpdate.selectCoreProcess([opaque],root,bridgePid),/requires verified Bridge script binding/i);
+  assert.throws(()=>runtimeUpdate.selectCoreProcess([opaque,{...opaque,ProcessId:1302}],root,bridgePid,verifiedBridge),/unambiguous downstream core/i);
+  assert.throws(()=>runtimeUpdate.selectCoreProcess([{...visible,CommandLine:'node C:\\other\\server.mjs'}],root,bridgePid),/unambiguous downstream core/i);
+  assert.throws(()=>runtimeUpdate.selectCoreProcess([{...opaque,CreationDate:''}],root,bridgePid,verifiedBridge),/identity incomplete/i);
+});
+
 test('R31 updater threads pinned process policy and machine-FS enable into successor generation', async () => {
   const source=await readFile(new URL('../src/runtime-update.mjs',import.meta.url),'utf8');
   assert.match(source,/prepareProcessPolicyBootstrap\(processPolicyBootstrap\)/);

package/test/skill-mcp-r44.test.mjs

@@ -0,0 +1,38 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { Client } from '@modelcontextprotocol/client';
+import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
+import { mkdtemp, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const repoRoot=path.resolve(here,'..');
+const serverPath=path.join(repoRoot,'src','mcp-server.mjs');
+
+test('R44 compact surface exposes one read-only skill_catalog without authority',async()=>{
+  const state=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r44-skill-mcp-'));
+  const client=new Client({name:'deadbyte-r44-skill-mcp',version:'0.15.0-dev'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  const env={...getDefaultEnvironment(),DEADBYTE_STATE_ROOT:state,DEADBYTE_CAPABILITY_PROFILE:'compact',
+    DEADBYTE_AUDIT_RUNTIME:'0',DEADBYTE_MACHINE_RUNTIME:'0',DEADBYTE_AGENT_RUNTIME:'0',
+    DEADBYTE_PROCESS_RUNTIME:'0',DEADBYTE_CODING_RUNTIME:'0',DEADBYTE_MACHINE_FS_RUNTIME:'0',
+    DEADBYTE_OBSERVATION_RUNTIME:'0',DEADBYTE_DESKTOP_RUNTIME:'0',DEADBYTE_AUTONOMOUS_RUNTIME:'0'};
+  const transport=new StdioClientTransport({command:process.execPath,args:[serverPath],cwd:repoRoot,env,stderr:'pipe'});
+  try{
+    await client.connect(transport);
+    const names=(await client.listTools()).tools.map(t=>t.name).sort();
+    assert.ok(names.includes('skill_catalog'),'R44 skill_catalog missing from compact surface');
+    assert.equal(names.filter(name=>name.startsWith('skill_')).length,1,'skill plane must remain one-tool surface');
+    const listed=await client.callTool({name:'skill_catalog',arguments:{op:'list'}});
+    assert.equal(listed.isError,false,JSON.stringify(listed));
+    assert.equal(listed.structuredContent.status,'ok');
+    assert.equal(listed.structuredContent.op,'list');
+    assert.deepEqual(listed.structuredContent.result.skills,[]);
+    assert.match(listed.structuredContent.result.registry_sha256,/^[0-9a-f]{64}$/);
+    const manifest=await client.callTool({name:'capability_manifest',arguments:{}});
+    const cap=manifest.structuredContent.result.capabilities.find(x=>x.id==='skill.catalog');
+    assert.ok(cap,'skill.catalog capability missing');
+    assert.equal(cap.authority,'none');assert.equal(cap.mutating,false);assert.equal(cap.compact_tool,'skill_catalog');
+  }finally{await client.close().catch(()=>{});await rm(state,{recursive:true,force:true});}
+});

package/test/skill-plane-r44.test.mjs

@@ -0,0 +1,93 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash, createPrivateKey, sign as cryptoSign } from 'node:crypto';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { generateTrustKeypair } from '../src/trust.mjs';
+import { createSkillPlane } from '../src/skill-plane-r44.mjs';
+
+const DOMAIN=Buffer.from('DEADBYTE-SKILL-MANIFEST-V1\0','utf8');
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const canonical=value=>Array.isArray(value)?value.map(canonical):value&&typeof value==='object'
+  ?Object.fromEntries(Object.keys(value).sort().map(key=>[key,canonical(value[key])])):value;
+const canonicalJson=value=>JSON.stringify(canonical(value));
+
+async function fixture(){
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r44-skill-'));
+  const registry=path.join(root,'skills');
+  const trust=path.join(root,'trust');
+  await mkdir(registry,{recursive:true});await mkdir(trust,{recursive:true});
+  const keys=await generateTrustKeypair({privateKeyPath:path.join(trust,'private.pem'),publicKeyPath:path.join(trust,'public.pem')});
+  return {root,registry,keys};
+}
+async function installSkill(f,{name='repo-audit',authorityPlanes=['coding'],requiredCapabilities=['coding.search'],extraBody={}}={}){
+  const dir=path.join(f.registry,name);await mkdir(path.join(dir,'references'),{recursive:true});
+  const skill=`---\nname: ${name}\ndescription: Audit one repository with bounded evidence\nversion: 1.0.0\naudience: agent\n---\n\n# Repo Audit\n\nInspect before mutation.\n`;
+  const ref='Use bounded search and cite exact observed files.\n';
+  await writeFile(path.join(dir,'SKILL.md'),skill,'utf8');
+  await writeFile(path.join(dir,'references','guide.md'),ref,'utf8');
+  const body={
+    schema:'deadbyte.skill-manifest.v1',name,version:'1.0.0',description:'Audit one repository with bounded evidence',audience:'agent',
+    skill_md_sha256:sha(Buffer.from(skill)),resources:[{path:'references/guide.md',sha256:sha(Buffer.from(ref)),kind:'reference'}],
+    required_capabilities:requiredCapabilities,authority_planes:authorityPlanes,
+    provenance:{source:'test-fixture',origin_url:null,source_revision:null},...extraBody
+  };
+  const bodyBytes=Buffer.from(canonicalJson(body),'utf8');
+  const privateKey=createPrivateKey(await readFile(f.keys.privateKeyPath));
+  const envelope={body,body_sha256:sha(bodyBytes),attestation:{algorithm:'ed25519',domain:'DEADBYTE-SKILL-MANIFEST-V1',
+    key_id:f.keys.keyId,signature_base64:cryptoSign(null,Buffer.concat([DOMAIN,bodyBytes]),privateKey).toString('base64')}};
+  envelope.manifest_sha256=sha(Buffer.from(canonicalJson(envelope),'utf8'));
+  await writeFile(path.join(dir,'skill.json'),`${JSON.stringify(envelope,null,2)}\n`,'utf8');
+  return {dir,skill,ref,envelope};
+}
+
+test('R44 skill catalog is metadata-only and load is signature/content bound',async()=>{
+  const f=await fixture();
+  try{
+    await installSkill(f,{});
+    const plane=await createSkillPlane({root:f.registry,verifyKeyPath:f.keys.publicKeyPath});
+    const listed=await plane.list();
+    assert.equal(listed.status,'ok');assert.equal(listed.skills.length,1);
+    assert.equal(listed.skills[0].name,'repo-audit');assert.equal(listed.skills[0].authority_planes[0],'coding');
+    assert.equal('content' in listed.skills[0],false,'catalog must not leak instructions');
+    const loaded=await plane.load({name:'repo-audit'});
+    assert.equal(loaded.status,'ok');assert.match(loaded.content,/Inspect before mutation/);
+    assert.equal(loaded.verified,true);assert.match(loaded.manifest_sha256,/^[0-9a-f]{64}$/);
+    const resource=await plane.readResource({name:'repo-audit',resourcePath:'references/guide.md'});
+    assert.equal(resource.content,'Use bounded search and cite exact observed files.\n');
+    assert.equal(typeof plane.arm,'undefined');assert.equal(typeof plane.renew,'undefined');
+  }finally{await rm(f.root,{recursive:true,force:true});}
+});
+
+test('R44 skill plane fails closed on SKILL.md and resource tampering',async()=>{
+  const f=await fixture();
+  try{
+    const installed=await installSkill(f,{});
+    const plane=await createSkillPlane({root:f.registry,verifyKeyPath:f.keys.publicKeyPath});
+    await writeFile(path.join(installed.dir,'SKILL.md'),'tampered\n','utf8');
+    await assert.rejects(plane.load({name:'repo-audit'}),/SKILL\.md hash mismatch/);
+    await installSkill(f,{});
+    await writeFile(path.join(installed.dir,'references','guide.md'),'tampered\n','utf8');
+    await assert.rejects(plane.readResource({name:'repo-audit',resourcePath:'references/guide.md'}),/resource hash mismatch/);
+  }finally{await rm(f.root,{recursive:true,force:true});}
+});
+
+test('R44 skill plane rejects undeclared payloads, unknown authority and signature drift',async()=>{
+  const f=await fixture();
+  try{
+    const installed=await installSkill(f,{});
+    let plane=await createSkillPlane({root:f.registry,verifyKeyPath:f.keys.publicKeyPath});
+    await writeFile(path.join(installed.dir,'hidden.ps1'),'Write-Host pwn\n','utf8');
+    await assert.rejects(plane.load({name:'repo-audit'}),/undeclared skill file/);
+    await rm(path.join(installed.dir,'hidden.ps1'));
+    await installSkill(f,{authorityPlanes:['root']});
+    await assert.rejects(plane.load({name:'repo-audit'}),/unknown authority plane/);
+    await installSkill(f,{});
+    const env=JSON.parse(await readFile(path.join(installed.dir,'skill.json'),'utf8'));
+    env.body.description='signature drift';
+    await writeFile(path.join(installed.dir,'skill.json'),JSON.stringify(env,null,2)+'\n');
+    plane=await createSkillPlane({root:f.registry,verifyKeyPath:f.keys.publicKeyPath});
+    await assert.rejects(plane.load({name:'repo-audit'}),/body hash mismatch/);
+  }finally{await rm(f.root,{recursive:true,force:true});}
+});

package/test/standing-grants.test.mjs

@@ -4,7 +4,7 @@ import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { loadCodingPolicy, codingSessionStatus } from '../src/coding-plane.mjs';
-import { loadAutonomousPolicy, autonomousSessionStatus } from '../src/autonomous-policy.mjs';
+import { assertAutonomousArmed, loadAutonomousPolicy, autonomousSessionStatus, recheckAutonomousAuthority } from '../src/autonomous-policy.mjs';
 import { loadHostPolicy, assertHostArmed } from '../src/host-plane.mjs';
 import { createHash } from 'node:crypto';
 
@@ -48,6 +48,10 @@ test('autonomous standing grant remains armed until explicit revocation', async
   assert.equal(status.armed, true);
   assert.equal(status.reason, 'standing-grant');
   assert.equal(status.expires_at_utc, null);
+  const initial = await assertAutonomousArmed(policy, 'project', farFuture);
+  const grant = JSON.parse(await import('node:fs/promises').then(fs => fs.readFile(policy.lease_file, 'utf8')));
+  await writeFile(policy.lease_file, JSON.stringify({ ...grant, instance_nonce:'d'.repeat(64) }));
+  await assert.rejects(() => recheckAutonomousAuthority(policy, initial, 'project', farFuture), /autonomous authority changed during operation/);
 });
 test('host standing grant remains armed until explicit revocation', async () => {
   const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-host-standing-'));

package/test/task-contract-r42.test.mjs

@@ -0,0 +1,41 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createR34Fixture } from './helpers/autonomous-r34-fixture.mjs';
+
+const contract={
+  schema:'deadbyte.task-contract.v1',
+  scope:['src/autonomous-*','test/*r42*'],
+  non_goals:['No generic shell','No implicit grant renewal'],
+  constraints:['Preserve R41 compatibility','Use exact preconditions'],
+  evidence_requirements:['Focused tests pass','Signed journal verifies'],
+  risk_level:'high',
+  clarification_policy:'ask_when_blocked',
+  project_default:'lightweight',
+  explicit_override:'structured'
+};
+
+test('R42 task contract is identity-bound and visible to every planner round',async()=>{
+  const f=await createR34Fixture();
+  try {
+    const goal=await f.runtime.submit({submissionId:'r42-task-contract',rootId:'project',title:'Contract',
+      goal:'Implement bounded behavior.',acceptance:'All required evidence passes.',taskContract:contract,maxIterations:8});
+    const status=await f.runtime.status({goalId:goal.goal_id});
+    assert.equal(status.state,'pending');
+    const run=await f.runtime.run({goalId:goal.goal_id,maxCycles:1});
+    assert.equal(run.status,'input_required');
+    assert.match(run.planner_request.prompt,/deadbyte\.task-contract\.v1/);
+    assert.match(run.planner_request.prompt,/No generic shell/);
+    assert.match(run.planner_request.prompt,/Signed journal verifies/);
+    assert.match(run.planner_request.prompt,/"effective_rigor":"agentic"/);
+  } finally { await f.cleanup(); }
+});
+
+test('R42 task contract rejects authority widening fields and invalid risk',async()=>{
+  const f=await createR34Fixture();
+  try {
+    await assert.rejects(f.runtime.submit({submissionId:'r42-task-injected',rootId:'project',title:'Contract',
+      goal:'Reject injection.',acceptance:'Fail closed.',taskContract:{...contract,shell:'cmd.exe'}}),/unknown field|task contract/i);
+    await assert.rejects(f.runtime.submit({submissionId:'r42-task-risk',rootId:'project',title:'Contract',
+      goal:'Reject risk.',acceptance:'Fail closed.',taskContract:{...contract,risk_level:'unbounded'}}),/risk_level/i);
+  } finally { await f.cleanup(); }
+});