deadbyte-mcp 0.8.10 → 0.10.0

package/test/native-diff-topology-r36.test.mjs

@@ -0,0 +1,105 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash, randomBytes } from 'node:crypto';
+import { access, mkdtemp, mkdir, readFile, rm, symlink, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { generateTrustKeypair } from '../src/trust.mjs';
+import { createCodingRuntime, loadCodingPolicy } from '../src/coding-plane.mjs';
+import { createMachineFsRuntime } from '../src/machine-fs.mjs';
+import { loadAutonomousPolicy } from '../src/autonomous-policy.mjs';
+import { createNativeDiffRuntime, NATIVE_DIFF_V2_SCHEMA } from '../src/native-diff.mjs';
+
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const exists=file=>access(file).then(()=>true,()=>false);
+async function fixture(){
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r36-topology-'));
+  const project=path.join(root,'project'); const trust=path.join(root,'trust');
+  await mkdir(project); await mkdir(trust);
+  const keys=await generateTrustKeypair({privateKeyPath:path.join(trust,'private.pem'),publicKeyPath:path.join(trust,'public.pem')});
+  const codingPath=path.join(root,'coding-policy.json');
+  await writeFile(codingPath,JSON.stringify({schema:'deadbyte.coding-policy.v1',enabled:true,lease_file:path.join(root,'coding-lease.json'),evidence_dir:path.join(root,'coding-evidence'),roots:{project:{path:project,read:true,write:true,exec:false,deny_paths:[]}},commands:{},max_read_bytes:524288,max_write_bytes:2097152}));
+  const codingPolicy=await loadCodingPolicy(codingPath);
+  await writeFile(codingPolicy.lease_file,JSON.stringify({schema:'deadbyte.coding-lease.v1',policy_sha256:codingPolicy.policy_sha256,instance_nonce:randomBytes(32).toString('hex'),root_ids:['project'],armed_at_utc:new Date().toISOString(),expires_at_utc:new Date(Date.now()+3600000).toISOString()}));
+  const autoPath=path.join(root,'autonomous-policy.json');
+  await writeFile(autoPath,JSON.stringify({schema:'deadbyte.autonomous-policy.v1',enabled:true,lease_file:path.join(root,'auto-lease.json'),evidence_dir:path.join(root,'auto-evidence'),root_ids:['project'],coding_policy_sha256:codingPolicy.policy_sha256,planner:{backend:'client_sampling',max_tokens:2048},profiles:{},limits:{max_files_per_diff:12,max_diff_bytes:1048576}}));
+  const policy=await loadAutonomousPolicy(autoPath,codingPolicy);
+  await writeFile(policy.lease_file,JSON.stringify({schema:'deadbyte.autonomous-lease.v1',policy_sha256:policy.policy_sha256,instance_nonce:randomBytes(32).toString('hex'),root_ids:['project'],armed_at_utc:new Date().toISOString(),expires_at_utc:new Date(Date.now()+1800000).toISOString()}));
+  const codingRuntime=createCodingRuntime({policy:codingPolicy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
+  const machineFsRuntime=createMachineFsRuntime({policy:codingPolicy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
+  const nativeDiff=createNativeDiffRuntime({policy,codingRuntime,machineFsRuntime,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
+  return {root,project,keys,policy,codingRuntime,machineFsRuntime,nativeDiff};
+}
+
+test('R36 Native Diff V2 commits mkdir write move and independently verifies mixed receipts',async()=>{
+  const f=await fixture(); try{
+    await writeFile(path.join(f.project,'seed.txt'),'seed\n');
+    const seed=await f.machineFsRuntime.stat({rootId:'project',relativePath:'seed.txt',hash:true});
+    const preview=await f.nativeDiff.preview({rootId:'project',title:'topology commit',operations:[
+      {kind:'mkdir',path:'dst'},
+      {kind:'write',path:'dst/new.txt',expected_sha256:'absent',encoding:'utf8',content:'new\n'},
+      {kind:'move',source_path:'seed.txt',destination_path:'dst/seed.txt',expected_source_identity:seed.identity_sha256}
+    ]});
+    assert.equal(preview.schema,NATIVE_DIFF_V2_SCHEMA); assert.equal(preview.operation_count,3);
+    const applied=await f.nativeDiff.apply({diffId:preview.diff_id});
+    assert.equal(applied.status,'committed');
+    assert.equal(await readFile(path.join(f.project,'dst','new.txt'),'utf8'),'new\n');
+    assert.equal(await readFile(path.join(f.project,'dst','seed.txt'),'utf8'),'seed\n');
+    assert.equal(await exists(path.join(f.project,'seed.txt')),false);
+    const verified=await f.nativeDiff.verify({diffId:preview.diff_id});
+    assert.equal(verified.ok,true); assert.equal(verified.current_state_matches,true);
+    assert.equal(verified.operation_receipts_verified,3);
+  } finally {await rm(f.root,{recursive:true,force:true});}
+});
+
+test('R36 Native Diff V2 rolls back mkdir/write when later topology operation fails',async()=>{
+  const f=await fixture(); try{
+    await writeFile(path.join(f.project,'seed.txt'),'seed\n');
+    const seed=await f.machineFsRuntime.stat({rootId:'project',relativePath:'seed.txt',hash:true});
+    const preview=await f.nativeDiff.preview({rootId:'project',title:'topology rollback',operations:[
+      {kind:'mkdir',path:'dst'},
+      {kind:'write',path:'dst/temp.txt',expected_sha256:'absent',encoding:'utf8',content:'temporary\n'},
+      {kind:'move',source_path:'seed.txt',destination_path:'dst/seed.txt',expected_source_identity:seed.identity_sha256}
+    ]});
+    const sabotaged=Object.freeze({...f.machineFsRuntime,move:async()=>{throw new Error('forced topology failure');}});
+    const runtime=createNativeDiffRuntime({policy:f.policy,codingRuntime:f.codingRuntime,machineFsRuntime:sabotaged,signingKeyPath:f.keys.privateKeyPath,verifyKeyPath:f.keys.publicKeyPath});
+    await assert.rejects(runtime.apply({diffId:preview.diff_id}),/rolled back/i);
+    assert.equal(await exists(path.join(f.project,'dst')),false);
+    assert.equal(await readFile(path.join(f.project,'seed.txt'),'utf8'),'seed\n');
+  } finally {await rm(f.root,{recursive:true,force:true});}
+});
+
+test('R36 Native Diff V2 rejects stale move identity and destination collision before mutation',async()=>{
+  const f=await fixture(); try{
+    await writeFile(path.join(f.project,'a.txt'),'one'); await writeFile(path.join(f.project,'b.txt'),'occupied');
+    const state=await f.machineFsRuntime.stat({rootId:'project',relativePath:'a.txt',hash:true});
+    await writeFile(path.join(f.project,'a.txt'),'two');
+    await assert.rejects(f.nativeDiff.preview({rootId:'project',operations:[{kind:'move',source_path:'a.txt',destination_path:'c.txt',expected_source_identity:state.identity_sha256}]}),/identity|precondition/i);
+    const fresh=await f.machineFsRuntime.stat({rootId:'project',relativePath:'a.txt',hash:true});
+    await assert.rejects(f.nativeDiff.preview({rootId:'project',operations:[{kind:'move',source_path:'a.txt',destination_path:'b.txt',expected_source_identity:fresh.identity_sha256}]}),/destination.*absent|collision|precondition/i);
+    assert.equal(await readFile(path.join(f.project,'a.txt'),'utf8'),'two');
+  } finally {await rm(f.root,{recursive:true,force:true});}
+});
+
+test('R36 Native Diff V2 rmdir accepts only exact empty directory identity',async()=>{
+  const f=await fixture(); try{
+    await mkdir(path.join(f.project,'empty')); await mkdir(path.join(f.project,'nonempty')); await writeFile(path.join(f.project,'nonempty','x.txt'),'x');
+    const empty=await f.machineFsRuntime.stat({rootId:'project',relativePath:'empty'});
+    const nonempty=await f.machineFsRuntime.stat({rootId:'project',relativePath:'nonempty'});
+    await assert.rejects(f.nativeDiff.preview({rootId:'project',operations:[{kind:'rmdir',path:'nonempty',expected_source_identity:nonempty.identity_sha256}]}),/empty/i);
+    const preview=await f.nativeDiff.preview({rootId:'project',operations:[{kind:'rmdir',path:'empty',expected_source_identity:empty.identity_sha256}]});
+    assert.equal((await f.nativeDiff.apply({diffId:preview.diff_id})).status,'committed');
+    assert.equal(await exists(path.join(f.project,'empty')),false);
+    assert.equal((await f.nativeDiff.verify({diffId:preview.diff_id})).ok,true);
+  } finally {await rm(f.root,{recursive:true,force:true});}
+});
+
+test('R36 Native Diff V2 denies topology through reparse points',async t=>{
+  const f=await fixture(); try{
+    const outside=path.join(f.root,'outside'); await mkdir(outside);
+    const link=path.join(f.project,'link');
+    try { await symlink(outside,link,process.platform==='win32'?'junction':'dir'); }
+    catch(error){ if(['EPERM','EACCES','ENOSYS'].includes(error?.code)){t.skip(`symlink unavailable: ${error.code}`);return;} throw error; }
+    await assert.rejects(f.nativeDiff.preview({rootId:'project',operations:[{kind:'rmdir',path:'link',expected_source_identity:'0'.repeat(64)}]}),/reparse|symlink/i);
+  } finally {await rm(f.root,{recursive:true,force:true});}
+});

package/test/observation-integration.test.mjs

@@ -35,7 +35,7 @@ test('R32 updater exposes explicit observation enable and threads it into the ca
   assert.match(source, /enableObservation:args\.enableObservation/);
 });
 
-test('R32 exact remote catalog adds six observation tools and disarmed gate requires 68 after named action', async () => {
+test('R34 exact remote catalog keeps observation and disarmed gate bound to the canonical 73-tool surface', async () => {
   const source = await read('../src/remote-mcp-smoke-client.mjs');
   const disarmed = await read('../src/remote-mcp-r24-disarmed-smoke-client.mjs');
   assert.match(source, /const observationTools = \[/);
@@ -43,8 +43,8 @@ test('R32 exact remote catalog adds six observation tools and disarmed gate requ
     assert.match(source, new RegExp(`'${name}'`));
   }
   assert.match(source, /observation_runtime: observationRuntime/);
-  assert.match(disarmed, /listed\.tools\.length !== 68/);
-  assert.match(disarmed, /tool_count:68/);
+  assert.match(disarmed, /R34_EXPECTED_TOOLS/);
+  assert.match(disarmed, /tool_count:R34_EXPECTED_TOOLS\.length/);
 });
 
 test('R32 package and Windows gate include observation live smoke before final manifest verify', async () => {

package/test/package-boundary.test.mjs

@@ -2,6 +2,7 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
+import { readdirSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 
 const root = path.resolve(fileURLToPath(new URL('..', import.meta.url)));
@@ -22,6 +23,11 @@ function packFiles() {
   return entry.files.map(item => item.path.replaceAll('\\', '/')).sort();
 }
 
+test('R36 successor source root contains no nested npm tarball artifacts',()=>{
+  const tarballs=readdirSync(root,{withFileTypes:true}).filter(item=>item.isFile()&&item.name.endsWith('.tgz')).map(item=>item.name).sort();
+  assert.deepEqual(tarballs,[]);
+});
+
 test('R28 package boundary contains only immutable workspace seed files', () => {
   const files = packFiles();
   const workspacePayload = files.filter(rel => rel.startsWith('workspaces/'));

package/test/process-longrun-r36.test.mjs

@@ -0,0 +1,82 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { PROCESS_GRANT_SCHEMA, PROCESS_POLICY_SCHEMA, loadProcessPolicy } from '../src/process-policy.mjs';
+import { createProcessRuntime } from '../src/process-runtime.mjs';
+import { generateTrustKeypair } from '../src/trust.mjs';
+
+const repo=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+const host=path.join(repo,'bin','deadbyte-process-host.exe');
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const sleep=ms=>new Promise(resolve=>setTimeout(resolve,ms));
+
+async function fixture(){
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r36-longrun-'));
+  const project=path.join(root,'project'); const trust=path.join(root,'trust');
+  await mkdir(project); await mkdir(trust);
+  const script=path.join(project,'longrun.mjs');
+  await writeFile(script,`process.stdout.write('chunk-1\\n');\nsetTimeout(()=>process.stdout.write('chunk-2\\n'),180);\nsetTimeout(()=>process.stdout.write('chunk-3\\n'),360);\nsetTimeout(()=>process.exit(0),540);\n`);
+  const grantFile=path.join(root,'process-grant.json'); const stateDir=path.join(root,'state'); const policyPath=path.join(root,'process-policy.json');
+  const raw={schema:PROCESS_POLICY_SCHEMA,enabled:true,grant_file:grantFile,state_dir:stateDir,native_host:{path:host,sha256:sha(await readFile(host))},roots:{core:{path:project,deny_paths:[]}},profiles:{longrun:{executable:process.execPath,executable_sha256:sha(await readFile(process.execPath)),root_ids:['core'],transport:'pipe',prefix_args:[script],max_args:0,max_arg_bytes:256,max_sessions:1,max_input_bytes:4096,max_retained_output_bytes:65536,env_allow:['PATH','TEMP','TMP'],input_actions:{}}}};
+  await writeFile(policyPath,JSON.stringify(raw));
+  const policy=await loadProcessPolicy(policyPath);
+  await writeFile(grantFile,JSON.stringify({schema:PROCESS_GRANT_SCHEMA,policy_sha256:policy.policy_sha256,instance_nonce:'6'.repeat(64),profile_ids:['longrun'],root_ids:['core'],granted_at_utc:new Date().toISOString()}));
+  const keys=await generateTrustKeypair({privateKeyPath:path.join(trust,'private.pem'),publicKeyPath:path.join(trust,'public.pem')});
+  const make=()=>createProcessRuntime({policy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
+  return {root,project,stateDir,policy,keys,make,runtime:make()};
+}
+
+async function waitState(runtime,id,state,timeout=5000){const end=Date.now()+timeout;while(Date.now()<end){const s=await runtime.status({sessionId:id});if(s.state===state)return s;await sleep(30);}throw new Error(`timeout waiting ${state}`);}
+
+test('R36 process runtime publishes terminal state only after durable terminal journal commit', async()=>{
+  const source=await readFile(path.join(repo,'src','process-runtime.mjs'),'utf8');
+  assert.match(source,/const terminalState = session\.terminate_requested \? 'terminated' : 'exited'/);
+  const commit=source.indexOf("await appendEvent(runtime, session, terminalState");
+  const publish=source.indexOf('session.state = terminalState;',commit);
+  assert.ok(commit>=0&&publish>commit,'terminal state must publish after terminal event commit');
+});
+
+test('R36 long process returns before exit and exposes monotonic cursor chunks', {skip:process.platform!=='win32'}, async()=>{
+  const f=await fixture(); try{
+    const startedAt=Date.now();
+    const started=await f.runtime.start({profileId:'longrun',rootId:'core',cwd:'.',args:[]});
+    assert.equal(started.state,'running');
+    assert.ok(Date.now()-startedAt<500,'start waited for child exit');
+    let offset=0; let text=''; let sawPartial=false;
+    const end=Date.now()+5000;
+    while(Date.now()<end){
+      const page=await f.runtime.read({sessionId:started.session_id,offset,maxBytes:8});
+      assert.ok(page.next_offset>=offset); assert.ok(page.next_offset<=page.stream_head);
+      if(page.next_offset<page.stream_head||page.state==='running') sawPartial=true;
+      text+=Buffer.from(page.data_base64,'base64').toString('utf8'); offset=page.next_offset;
+      if(page.state==='exited'&&offset===page.stream_head) break;
+      await sleep(35);
+    }
+    assert.equal(sawPartial,true); assert.match(text,/chunk-1/); assert.match(text,/chunk-2/); assert.match(text,/chunk-3/);
+    const terminal=await waitState(f.runtime,started.session_id,'exited'); assert.equal(terminal.exit_code,0);
+    await assert.rejects(()=>f.runtime.status({sessionId:'f'.repeat(64)}),/unknown process session/i);
+  } finally {await rm(f.root,{recursive:true,force:true});}
+});
+
+test('R36 terminal process session is recovered from signed journal after wrapper restart', {skip:process.platform!=='win32'}, async()=>{
+  const f=await fixture(); try{
+    const started=await f.runtime.start({profileId:'longrun',rootId:'core',cwd:'.',args:[]});
+    await waitState(f.runtime,started.session_id,'exited');
+    const original=await f.runtime.status({sessionId:started.session_id});
+    const checked=await f.runtime.verifyEventJournal({sessionId:started.session_id}); assert.equal(checked.ok,true);
+    const restarted=f.make();
+    const recovered=await restarted.status({sessionId:started.session_id});
+    assert.equal(recovered.state,'exited'); assert.equal(recovered.exit_code,0); assert.equal(recovered.session_id,started.session_id);
+    assert.equal(recovered.journal_head_sha256,original.journal_head_sha256);
+    const listed=await restarted.list(); assert.ok(listed.sessions.some(s=>s.session_id===started.session_id));
+    const page=await restarted.read({sessionId:started.session_id,offset:0,maxBytes:65536});
+    const text=Buffer.from(page.data_base64,'base64').toString('utf8');
+    assert.match(text,/chunk-1/); assert.match(text,/chunk-3/); assert.equal(page.state,'exited');
+    const verified=await restarted.verifyEventJournal({sessionId:started.session_id}); assert.equal(verified.ok,true); assert.equal(verified.head_sha256,recovered.journal_head_sha256);
+    await assert.rejects(()=>restarted.status({sessionId:'e'.repeat(64)}),/unknown process session/i);
+  } finally {await rm(f.root,{recursive:true,force:true});}
+});

package/test/process-release-gate.test.mjs

@@ -5,12 +5,21 @@ import { fileURLToPath } from 'node:url';
 
 const packagePath = fileURLToPath(new URL('../package.json', import.meta.url));
 const gatePath = fileURLToPath(new URL('../scripts/gate-windows.ps1', import.meta.url));
+const processSmokePath = fileURLToPath(new URL('../src/process-smoke-client.mjs', import.meta.url));
 
 test('R31 package exposes the bounded process smoke command', async () => {
   const pkg = JSON.parse(await readFile(packagePath, 'utf8'));
   assert.equal(pkg.scripts['mcp:process:smoke'], 'node src/process-smoke-client.mjs');
 });
 
+test('R36 process smoke isolates grant and recovery state outside the release source tree', async () => {
+  const source = await readFile(processSmokePath, 'utf8');
+  assert.match(source, /smoke-policy\.json/);
+  assert.match(source, /grant_file:\s*path\.join\(smokeTrust,\s*'process-grant\.json'\)/);
+  assert.match(source, /state_dir:\s*path\.join\(smokeTrust,\s*'process-state'\)/);
+  assert.match(source, /DEADBYTE_PROCESS_POLICY:\s*smokePolicyPath/);
+});
+
 test('R31 Windows gate refreshes the native-host policy pin before manifest freeze', async () => {
   const pkg = JSON.parse(await readFile(packagePath, 'utf8'));
   const source = await readFile(gatePath, 'utf8');

package/test/production-docs.test.mjs

@@ -0,0 +1,48 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
+const readme=()=>readFile(path.join(root,'README.txt'),'utf8');
+
+test('production README documents one-command stdio configs for major MCP clients',async()=>{
+  const text=await readme();
+  assert.match(text,/npx -y deadbyte-mcp@0\.10\.0 mcp/);
+  assert.match(text,/CLAUDE DESKTOP/);
+  assert.match(text,/"mcpServers"[\s\S]*?"command"\s*:\s*"npx"[\s\S]*?"-y"[\s\S]*?"deadbyte-mcp@0\.10\.0"[\s\S]*?"mcp"/);
+  assert.match(text,/CURSOR/);
+  assert.match(text,/\.cursor\/mcp\.json/);
+  assert.match(text,/VS CODE/);
+  assert.match(text,/\.vscode\/mcp\.json/);
+  assert.match(text,/"servers"[\s\S]*?"type"\s*:\s*"stdio"/);
+  assert.match(text,/CODEX/);
+  assert.match(text,/\[mcp_servers\.deadbyte\]/);
+  assert.match(text,/command\s*=\s*"npx"/);
+  assert.match(text,/args\s*=\s*\["-y",\s*"deadbyte-mcp@0\.10\.0",\s*"mcp"\]/);
+});
+
+test('production README records tracer bullet, semantic scope, remote UX, safety and document extension',async()=>{
+  const text=await readme();
+  for(const token of ['coding_file_read','coding_text_replace','coding_command_run','coding_receipt_verify']) assert.match(text,new RegExp(token));
+  for(const token of ['coding_files_read','coding_symbol_outline','coding_symbol_definition','coding_symbol_references','coding_symbol_replace']) assert.match(text,new RegExp(token));
+  assert.match(text,/JavaScript\/TypeScript|JS\/TS/);
+  assert.match(text,/does not claim|not claim|limited to/i);
+  assert.match(text,/remote --verbose/);
+  assert.match(text,/compact/i);
+  assert.match(text,/workspace allowlist|coding-policy root/i);
+  assert.match(text,/destructive|standing grant|authority plane/i);
+  assert.match(text,/document adapter/i);
+  assert.match(text,/markdown_to_pdf/);
+});
+
+test('production README contains an evidence-based competitor comparison without pretending semantic breadth parity',async()=>{
+  const text=await readme();
+  assert.match(text,/Desktop Commander/i);
+  assert.match(text,/Serena/i);
+  assert.match(text,/comparison/i);
+  assert.match(text,/signed receipt|Ed25519/i);
+  assert.match(text,/rollback/i);
+  assert.match(text,/semantic breadth|language breadth|broader language/i);
+});

package/test/prompts-resources.test.mjs

@@ -0,0 +1,41 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { Client } from '@modelcontextprotocol/client';
+import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const repoRoot=path.resolve(here,'..');
+const serverPath=path.join(repoRoot,'src','mcp-server.mjs');
+
+test('MCP exposes compact workflow prompts and source-of-truth context resources',async()=>{
+  const client=new Client({name:'deadbyte-prompt-resource-test',version:'0.8.11'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  const transport=new StdioClientTransport({command:process.execPath,args:[serverPath],cwd:repoRoot,env:{...getDefaultEnvironment()},stderr:'pipe'});
+  try{
+    await client.connect(transport);
+    const prompts=await client.listPrompts();
+    const promptNames=prompts.prompts.map(p=>p.name).sort();
+    assert.deepEqual(promptNames,['deadbyte.diagnose','deadbyte.patch','deadbyte.review','deadbyte.run-tests']);
+    const patch=await client.getPrompt({name:'deadbyte.patch',arguments:{goal:'fix the failing parser test'}});
+    const patchText=patch.messages.map(m=>m.content?.text??'').join('\n');
+    assert.match(patchText,/inspect/i); assert.match(patchText,/surgical/i); assert.match(patchText,/verify/i); assert.match(patchText,/fix the failing parser test/);
+    assert.ok(patchText.length<1400,'prompt must remain compact');
+
+    const resources=await client.listResources();
+    const uris=resources.resources.map(r=>r.uri).sort();
+    assert.deepEqual(uris,['deadbyte://architecture','deadbyte://context','deadbyte://surface-profile']);
+    const surface=await client.readResource({uri:'deadbyte://surface-profile'});
+    const surfaceText=surface.contents.map(c=>'text' in c?c.text:'').join('\n');
+    const surfaceState=JSON.parse(surfaceText);
+    assert.equal(surfaceState.schema,'deadbyte.surface-profile.v1');
+    assert.equal(surfaceState.profile,'full');
+    assert.equal(surfaceState.compact_tool_limit,42);
+    const context=await client.readResource({uri:'deadbyte://context'});
+    const contextText=context.contents.map(c=>'text' in c?c.text:'').join('\n');
+    assert.match(contextText,/Machine truth/i); assert.match(contextText,/Authority plane/i); assert.match(contextText,/Loop Supervisor/i);
+    const architecture=await client.readResource({uri:'deadbyte://architecture'});
+    const architectureText=architecture.contents.map(c=>'text' in c?c.text:'').join('\n');
+    assert.match(architectureText,/protocol/i); assert.match(architectureText,/semantic/i); assert.match(architectureText,/telemetry/i);
+  } finally { await client.close().catch(()=>{}); }
+});

package/test/provider-circuit.test.mjs

@@ -0,0 +1,93 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  PROVIDER_CIRCUIT_STATES,
+  classifyProviderFailure,
+  deriveCircuit,
+  providerCallDisposition
+} from '../src/provider-circuit.mjs';
+
+const providerId='openai-compatible:gpt-test';
+const policy=Object.freeze({failure_threshold:3,open_ms:1000,half_open_probe_limit:1});
+const event=(type,created_at_utc,payload={})=>({
+  schema:'deadbyte.autonomous-event.v1',
+  event_sha256:'a'.repeat(64),
+  type,
+  created_at_utc,
+  payload:{provider_id:providerId,...payload}
+});
+
+test('provider circuit state enum is exact and failure classifier is bounded',()=>{
+  assert.deepEqual(PROVIDER_CIRCUIT_STATES,['CLOSED','OPEN','HALF_OPEN','UNAVAILABLE']);
+  assert.equal(classifyProviderFailure(new Error('request timed out')),'timeout');
+  assert.equal(classifyProviderFailure(new Error('fetch failed ECONNRESET')),'transport');
+  assert.equal(classifyProviderFailure(new Error('planner HTTP 429: rate limit')),'rate_limit');
+  assert.equal(classifyProviderFailure(new Error('planner HTTP 401: unauthorized')),'auth');
+  assert.equal(classifyProviderFailure(new Error('planner HTTP response is not JSON')),'invalid_response');
+  assert.equal(classifyProviderFailure(new Error('weird')),'other');
+});
+
+test('CLOSED opens exactly at threshold and OPEN suppresses provider invocation',()=>{
+  const events=[
+    event('provider_call_failed','2026-09-17T00:00:00.000Z',{failure_class:'transport'}),
+    event('provider_call_failed','2026-09-17T00:00:01.000Z',{failure_class:'timeout'}),
+    event('provider_call_failed','2026-09-17T00:00:02.000Z',{failure_class:'rate_limit'})
+  ];
+  const circuit=deriveCircuit(events,providerId,policy,'2026-09-17T00:00:02.500Z');
+  assert.equal(circuit.state,'OPEN');
+  assert.equal(circuit.failure_count,3);
+  assert.equal(circuit.opened_at_utc,'2026-09-17T00:00:02.000Z');
+  assert.equal(circuit.next_probe_at_utc,'2026-09-17T00:00:03.000Z');
+  assert.deepEqual(providerCallDisposition(circuit),{allowed:false,probe:false,reason:'circuit_open'});
+});
+
+test('OPEN becomes HALF_OPEN only at boundary and permits one bounded probe',()=>{
+  const events=[
+    event('provider_call_failed','2026-09-17T00:00:00.000Z',{failure_class:'transport'}),
+    event('provider_call_failed','2026-09-17T00:00:01.000Z',{failure_class:'transport'}),
+    event('provider_call_failed','2026-09-17T00:00:02.000Z',{failure_class:'transport'})
+  ];
+  const before=deriveCircuit(events,providerId,policy,'2026-09-17T00:00:02.999Z');
+  assert.equal(before.state,'OPEN');
+  const half=deriveCircuit(events,providerId,policy,'2026-09-17T00:00:03.000Z');
+  assert.equal(half.state,'HALF_OPEN');
+  assert.deepEqual(providerCallDisposition(half),{allowed:true,probe:true,reason:'half_open_probe'});
+  const consumed=deriveCircuit([...events,event('provider_probe_started','2026-09-17T00:00:03.000Z')],providerId,policy,'2026-09-17T00:00:03.100Z');
+  assert.deepEqual(providerCallDisposition(consumed),{allowed:false,probe:false,reason:'half_open_probe_limit'});
+});
+
+test('HALF_OPEN success closes circuit and failure reopens it from failure time',()=>{
+  const base=[
+    event('provider_call_failed','2026-09-17T00:00:00.000Z',{failure_class:'transport'}),
+    event('provider_call_failed','2026-09-17T00:00:01.000Z',{failure_class:'transport'}),
+    event('provider_call_failed','2026-09-17T00:00:02.000Z',{failure_class:'transport'}),
+    event('provider_probe_started','2026-09-17T00:00:03.000Z')
+  ];
+  const closed=deriveCircuit([...base,event('provider_call_succeeded','2026-09-17T00:00:03.100Z')],providerId,policy,'2026-09-17T00:00:03.100Z');
+  assert.equal(closed.state,'CLOSED');
+  assert.equal(closed.failure_count,0);
+  assert.equal(closed.last_success_at_utc,'2026-09-17T00:00:03.100Z');
+  const reopened=deriveCircuit([...base,event('provider_call_failed','2026-09-17T00:00:03.100Z',{failure_class:'timeout'})],providerId,policy,'2026-09-17T00:00:03.100Z');
+  assert.equal(reopened.state,'OPEN');
+  assert.equal(reopened.opened_at_utc,'2026-09-17T00:00:03.100Z');
+  assert.equal(reopened.next_probe_at_utc,'2026-09-17T00:00:04.100Z');
+});
+
+test('replay is deterministic and malformed authenticated evidence becomes unavailable',()=>{
+  const events=[event('provider_call_failed','2026-09-17T00:00:00.000Z',{failure_class:'timeout'})];
+  const first=deriveCircuit(events,providerId,policy,'2026-09-17T00:00:00.500Z');
+  const replay=deriveCircuit(structuredClone(events),providerId,policy,'2026-09-17T00:00:00.500Z');
+  assert.deepEqual(replay,first);
+  const corrupt=[{...events[0],event_sha256:'bad'}];
+  const unavailable=deriveCircuit(corrupt,providerId,policy,'2026-09-17T00:00:00.500Z');
+  assert.equal(unavailable.state,'UNAVAILABLE');
+  assert.equal(providerCallDisposition(unavailable).allowed,false);
+});
+
+test('events for other providers never affect this provider circuit',()=>{
+  const other=event('provider_call_failed','2026-09-17T00:00:00.000Z',{failure_class:'timeout'});
+  other.payload.provider_id='openai-compatible:other-model';
+  const circuit=deriveCircuit([other],providerId,policy,'2026-09-17T00:00:05.000Z');
+  assert.equal(circuit.state,'CLOSED');
+  assert.equal(circuit.failure_count,0);
+});

package/test/public-autonomous-ingress-budget.test.mjs

@@ -0,0 +1,28 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+
+const sourceUrl = new URL('../src/remote-mcp-autonomous-smoke-client.mjs', import.meta.url);
+
+test('public autonomous smoke chunks resumable goal runs below the 120 second proxy ceiling', async () => {
+  const source = await readFile(sourceUrl, 'utf8');
+  const cycles = /const AUTONOMOUS_RUN_MAX_CYCLES_PER_REQUEST = (\d+);/.exec(source);
+  const timeout = /const AUTONOMOUS_RUN_REQUEST_TIMEOUT_MS = (\d+);/.exec(source);
+
+  assert.ok(cycles, 'smoke client must declare a per-request autonomous cycle budget');
+  assert.ok(timeout, 'smoke client must declare a per-request HTTP timeout budget');
+  assert.equal(Number(cycles[1]), 1, 'one autonomous cycle per public request keeps progress resumable');
+  assert.ok(Number(timeout[1]) > 0 && Number(timeout[1]) < 120000,
+    'public autonomous request timeout must stay below the Cloudflare 120 second read timeout');
+  assert.doesNotMatch(source, /max_cycles\s*:\s*32/,
+    'public smoke must not batch all autonomous cycles into one proxy request');
+  assert.match(source, /max_cycles\s*:\s*AUTONOMOUS_RUN_MAX_CYCLES_PER_REQUEST/);
+  assert.match(source, /ran\.status === 'yielded'/,
+    'public smoke must explicitly resume yielded autonomous state');
+  assert.match(source, /REQUEST_TIMEOUT/,
+    'public smoke must recognize a bounded client timeout without treating durable server work as lost');
+  assert.match(source, /autonomous_goal_status/,
+    'timeout recovery must poll authenticated durable goal state instead of replaying the mutation');
+  assert.match(source, /recoverTimedOutGoal/,
+    'public smoke must use one explicit timeout-recovery path');
+});

package/test/r33-closeout-regression.test.mjs

@@ -86,7 +86,7 @@ test('audit restart reconciles an orphan request with an explicit interrupted re
   }finally{await rm(stateRoot,{recursive:true,force:true});}
 });
 
-test('Windows R33 gate emits manifest-bound machine-readable evidence outside the candidate tree', async()=>{
+test('Windows R36 gate emits manifest-bound machine-readable evidence outside the candidate tree', async()=>{
   const stateRoot=await temp('deadbyte-r33-windows-evidence-');
   try{
     const gate=await readFile(path.join(root,'scripts','gate-windows.ps1'),'utf8');
@@ -99,11 +99,12 @@ test('Windows R33 gate emits manifest-bound machine-readable evidence outside th
     assert.equal(summary.status,'written');
     const evidence=JSON.parse(await readFile(summary.path,'utf8'));
     const manifestSha=sha256(await readFile(path.join(root,'MANIFEST.SHA256')));
-    assert.equal(evidence.schema,'deadbyte.r33-windows-gate.v1');
+    assert.equal(evidence.schema,'deadbyte.r36-windows-gate.v1');
     assert.equal(evidence.status,'passed');
     assert.equal(evidence.exit_code,0);
+    assert.equal(evidence.version,'0.10.0');
     assert.equal(evidence.manifest_sha256,manifestSha);
-    assert.equal(evidence.marker,'DEADBYTE V0.8.10 / R33 WINDOWS BATCH GATE: PASS');
+    assert.equal(evidence.marker,'DEADBYTE V0.10.0 / R36 WINDOWS BATCH GATE: PASS');
     assert.ok(summary.path.startsWith(path.join(stateRoot,'evidence','release')));
   }finally{await rm(stateRoot,{recursive:true,force:true});}
 });

package/test/r33-finalization.test.mjs

@@ -1,17 +1,20 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
-import { R33_EXPECTED_TOOLS } from '../src/remote-mcp-r33-parity-client.mjs';
+import { R34_EXPECTED_TOOLS } from '../src/remote-mcp-r34-parity-client.mjs';
 import { validateParityEvidence } from '../scripts/release-parity.mjs';
 import { verifyFinalClosureObject } from '../scripts/final-closure-verify.mjs';
 
 const root = new URL('../', import.meta.url);
 const text = rel => readFile(new URL(rel, root), 'utf8');
 
-test('R33 public parity catalog is exact and unique', () => {
-  assert.equal(R33_EXPECTED_TOOLS.length, 68);
-  assert.equal(new Set(R33_EXPECTED_TOOLS).size, 68);
-  assert.deepEqual([...R33_EXPECTED_TOOLS].sort(), R33_EXPECTED_TOOLS);
+test('R34 public parity catalog is exact, unique, and includes production coding ergonomics', () => {
+  assert.equal(R34_EXPECTED_TOOLS.length, 73);
+  assert.equal(new Set(R34_EXPECTED_TOOLS).size, 73);
+  assert.deepEqual([...R34_EXPECTED_TOOLS].sort(), R34_EXPECTED_TOOLS);
+  for (const name of ['coding_files_read','coding_symbol_outline','coding_symbol_definition','coding_symbol_references','coding_symbol_replace']) {
+    assert.ok(R34_EXPECTED_TOOLS.includes(name),`missing ${name}`);
+  }
 });
 
 test('release parity and final verifier are package entry points', async () => {
@@ -23,16 +26,17 @@ test('release parity and final verifier are package entry points', async () => {
   assert.equal(typeof verifyFinalClosureObject, 'function');
 });
 
-test('final closure verifier is implementation-independent from production helpers', async () => {
+test('R36 final closure verifier is implementation-independent from production helpers', async () => {
   const verifier = await text('scripts/final-closure-verify.mjs');
   const writer = await text('scripts/final-closure.mjs');
   assert.doesNotMatch(verifier, /from ['"]\.\.\/src\//);
   assert.match(verifier, /DEADBYTE-R27-SLOT-UPDATE-V1/);
   assert.match(verifier, /DEADBYTE-MACHINE-PING-V1/);
-  assert.match(verifier, /DEADBYTE-R33-FINAL-CLOSURE-V1/);
-  assert.match(writer, /pointer\.version==='0\.8\.10'/);
-  assert.match(verifier, /envelope\.body\.version==='0\.8\.10'/);
-  assert.match(verifier, /release_label==='R33 FINAL MACHINE BASELINE'/);
+  assert.match(verifier, /DEADBYTE-R36-FINAL-CLOSURE-V1/);
+  assert.match(writer, /pointer\.version==='0\.10\.0'/);
+  assert.match(verifier, /envelope\.body\.version==='0\.10\.0'/);
+  assert.match(verifier, /release_label==='R36 FINAL MACHINE BASELINE'/);
+  assert.match(verifier, /b95e1ec1d9a7e26a96ef492306c1be4df18c883ff03ab3b6015f677d7429ec8d/);
 });
 
 test('final closure verifier canonicalizes traversal order before exact-tree comparison', async () => {
@@ -41,15 +45,19 @@ test('final closure verifier canonicalizes traversal order before exact-tree com
   assert.match(verifier, /const expected=\[\.\.\.entries\.keys\(\)\]\.sort\(\(a,b\)=>a\.localeCompare\(b,'en'\)\);/);
 });
 
-test('autonomous live gate reuses the canonical R33 68-tool catalog', async () => {
+test('R36 autonomous live gate binds the compact gateway contract instead of the historical 73-tool public catalog', async () => {
   const autonomous = await text('src/remote-mcp-autonomous-smoke-client.mjs');
-  assert.match(autonomous, /import \{ R33_EXPECTED_TOOLS \} from '\.\/remote-mcp-r33-parity-client\.mjs';/);
-  assert.doesNotMatch(autonomous, /const expectedTools\s*=\s*\[/);
-  assert.match(autonomous, /JSON\.stringify\(names\) !== JSON\.stringify\(R33_EXPECTED_TOOLS\)/);
+  assert.match(autonomous, /R36_COMPACT_GATEWAYS/);
+  assert.match(autonomous, /R36_COMPACT_TOOL_LIMIT/);
+  assert.match(autonomous, /names\.length > R36_COMPACT_TOOL_LIMIT/);
+  for (const name of ['autonomous_goal_submit','autonomous_goal_run','autonomous_goal_verify','autonomous_release_gate','native_diff_apply','native_diff_verify']) {
+    assert.match(autonomous,new RegExp(name));
+  }
+  assert.doesNotMatch(autonomous, /R34_EXPECTED_TOOLS/);
 });
 
-test('R33 parity proves coding package tests before package-visible scratch mutation', async () => {
-  const parity = await text('src/remote-mcp-r33-parity-client.mjs');
+test('R34 parity proves coding package tests before package-visible scratch mutation', async () => {
+  const parity = await text('src/remote-mcp-r34-parity-client.mjs');
   const codingTests = parity.indexOf('const tests = structured(');
   const scratchWrite = parity.indexOf('const write = structured(');
   assert.notEqual(codingTests, -1);
@@ -57,8 +65,8 @@ test('R33 parity proves coding package tests before package-visible scratch muta
   assert.ok(codingTests < scratchWrite, 'coding tests must complete before machine-FS scratch mutation');
 });
 
-test('R33 parity isolates scratch mutation and search from the core release tree', async () => {
-  const parity = await text('src/remote-mcp-r33-parity-client.mjs');
+test('R34 parity isolates scratch mutation and search from the core release tree', async () => {
+  const parity = await text('src/remote-mcp-r34-parity-client.mjs');
   assert.match(parity, /const scratchRoot = 'parity_scratch';/);
   assert.match(parity, /machine_fs_write[\s\S]*?root_id:scratchRoot/);
   assert.match(parity, /machine_search_start[\s\S]*?root_id:scratchRoot/);