deadbyte-mcp 0.8.9 → 0.9.0

package/test/helpers/autonomous-r34-fixture.mjs

@@ -0,0 +1,120 @@
+import { createHash, randomBytes } 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 { createCodingRuntime, loadCodingPolicy } from '../../src/coding-plane.mjs';
+import { loadAutonomousPolicy } from '../../src/autonomous-policy.mjs';
+import { createNativeDiffRuntime } from '../../src/native-diff.mjs';
+import { createAutonomousRuntime } from '../../src/autonomous-runtime.mjs';
+
+const sha = bytes => createHash('sha256').update(bytes).digest('hex');
+const nonce = () => randomBytes(32).toString('hex');
+
+export async function createR34Fixture({authority='armed',withFailingProfile=false,withStatefulProfile=false,codingRuntimeFactory=null,nativeDiffRuntimeFactory=null}={}) {
+  const root = await mkdtemp(path.join(os.tmpdir(),'deadbyte-r34-e2e-'));
+  const project = path.join(root,'project');
+  const trust = path.join(root,'trust');
+  await mkdir(project); await mkdir(trust);
+  const target = path.join(project,'x.txt');
+  await writeFile(target,'x\n');
+  let codingCommands = {};
+  let autonomousProfiles = {};
+  if (withFailingProfile || withStatefulProfile) {
+    const failScript = path.join(project,withStatefulProfile?'stateful-check.mjs':'fail.mjs');
+    const profileSource = withStatefulProfile
+      ? "import { readFileSync } from 'node:fs'; const text=readFileSync(new URL('./x.txt',import.meta.url),'utf8'); if(text!=='y\\n') throw new Error('VERIFY_FAIL'); console.log('VERIFY_PASS');\n"
+      : "throw new Error('VERIFY_FAIL');\n";
+    await writeFile(failScript,profileSource);
+    const nodeHash = sha(await readFile(process.execPath));
+    const failHash = sha(await readFile(failScript));
+    codingCommands = { node_script:{ kind:'script', executable:process.execPath, executable_sha256:nodeHash,
+      root_ids:['project'], prefix_args:[], extensions:['.mjs'], timeout_ms:120000, max_output_bytes:1048576 } };
+    autonomousProfiles = { check:{ kind:'command', root_id:'project', command_id:'node_script', script_path:path.basename(failScript),
+      script_sha256:failHash, args:[], cwd:'.', required_for_release:withStatefulProfile, run_after_mutation:withStatefulProfile,
+      description:withStatefulProfile?'stateful verification requires x.txt=y':'intentional verification failure' } };
+  }
+  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:withFailingProfile||withStatefulProfile,deny_paths:[]}},commands:codingCommands
+  },null,2));
+  const codingPolicy = await loadCodingPolicy(codingPath);
+  const autonomousPath = path.join(root,'autonomous-policy.json');
+  await writeFile(autonomousPath,JSON.stringify({
+    schema:'deadbyte.autonomous-policy.v1',enabled:true,
+    lease_file:path.join(root,'autonomous-lease.json'),evidence_dir:path.join(root,'autonomous-evidence'),
+    root_ids:['project'],coding_policy_sha256:codingPolicy.policy_sha256,
+    planner:{backend:'client_sampling',max_tokens:4096},profiles:autonomousProfiles,
+    limits:{max_iterations:16,max_mutations:8,max_wall_ms:600000,max_context_bytes:262144,
+      max_diff_bytes:262144,max_files_per_diff:4,max_stalled_cycles:2,max_post_replan_stalls:2,max_replans:8}
+  },null,2));
+  const policy = await loadAutonomousPolicy(autonomousPath,codingPolicy);
+  async function arm() {
+    await writeFile(codingPolicy.lease_file,JSON.stringify({schema:'deadbyte.coding-lease.v1',
+      policy_sha256:codingPolicy.policy_sha256,instance_nonce:nonce(),root_ids:['project'],
+      armed_at_utc:new Date().toISOString(),expires_at_utc:new Date(Date.now()+3600000).toISOString()}));
+    await writeFile(policy.lease_file,JSON.stringify({schema:'deadbyte.autonomous-lease.v1',
+      policy_sha256:policy.policy_sha256,instance_nonce:nonce(),root_ids:['project'],
+      armed_at_utc:new Date().toISOString(),expires_at_utc:new Date(Date.now()+3600000).toISOString()}));
+  }
+  async function disarm() {
+    await rm(codingPolicy.lease_file,{force:true});
+    await rm(policy.lease_file,{force:true});
+  }
+  if(authority==='armed') await arm();
+  const baseCodingRuntime = createCodingRuntime({policy:codingPolicy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
+  const codingRuntime = codingRuntimeFactory ? codingRuntimeFactory(baseCodingRuntime) : baseCodingRuntime;
+  const baseNativeDiffRuntime = createNativeDiffRuntime({policy,codingRuntime,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
+  const nativeDiffRuntime = nativeDiffRuntimeFactory ? nativeDiffRuntimeFactory(baseNativeDiffRuntime) : baseNativeDiffRuntime;
+  const createRuntime = ({codingRuntimeOverride=codingRuntime,nativeDiffRuntimeOverride=nativeDiffRuntime}={}) => createAutonomousRuntime({policy,codingRuntime:codingRuntimeOverride,nativeDiffRuntime:nativeDiffRuntimeOverride,
+    signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
+  return {
+    root,project,target,keys,codingPolicy,policy,baseCodingRuntime,codingRuntime,nativeDiffRuntime,createRuntime,runtime:createRuntime(),
+    initial_sha256:sha(await readFile(target)),arm,disarm,
+    cleanup:()=>rm(root,{recursive:true,force:true})
+  };
+}
+
+export async function sendPlannerDecision(runtime,goalId,result,decision,{maxCycles=4}={}) {
+  if(result.status!=='input_required') throw new Error(`planner response requires input_required, got ${result.status}`);
+  return runtime.run({goalId,maxCycles,plannerResponse:{request_id:result.planner_request.request_id,
+    model:'deadbyte-r34-test',raw_text:JSON.stringify(decision)}});
+}
+
+export function planCreateDecision() {
+  return {schema:'deadbyte.autonomous-decision.v2',kind:'plan_create',title:'Repair x.txt',
+    reason:'goal requires verified source repair',steps:[{step_id:'repair',intent:'Inspect, repair, and verify x.txt'}]};
+}
+export function inspectDecision() {
+  return {schema:'deadbyte.autonomous-decision.v2',kind:'inspect',reads:[{path:'x.txt',max_bytes:4096}]};
+}
+export function patchDecision(expectedSha) {
+  return {schema:'deadbyte.autonomous-decision.v2',kind:'act',action:{kind:'patch',operations:[{
+    kind:'replace',path:'x.txt',expected_sha256:expectedSha,old_string:'x',new_string:'y',expected_replacements:1
+  }]}};
+}
+export function stepCompleteDecision(evidence) {
+  return {schema:'deadbyte.autonomous-decision.v2',kind:'step_complete',step_id:'repair',evidence};
+}
+export function finishDecision() {
+  return {schema:'deadbyte.autonomous-decision.v2',kind:'finish',summary:'plan and release evidence complete'};
+}
+
+export async function localSupervisorFixture({ownerPid,ownerIdentity}) {
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r34-supervisor-'));
+  const markerPath=path.join(root,'supervisor-owner.json');
+  if(ownerIdentity) {
+    await writeFile(markerPath,JSON.stringify({
+      schema:'deadbyte.autonomous-supervisor-owner.v1',pid:ownerPid,
+      creation_time_utc:ownerIdentity.creation_time_utc,image_path:ownerIdentity.image_path,
+      image_sha256:ownerIdentity.image_sha256,instance_nonce:'a'.repeat(64),
+      started_at_utc:'2026-09-16T00:00:00.000Z'
+    }));
+  }
+  return {options:{markerPath},markerPath,cleanup:()=>rm(root,{recursive:true,force:true})};
+}

package/test/lsp-stdio-client.test.mjs

@@ -0,0 +1,72 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createLspStdioClient } from '../src/lsp-stdio-client.mjs';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const fixture=path.join(here,'fixtures','lsp-framed-server.mjs');
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const nodeSha=sha256(await readFile(process.execPath));
+const make=(overrides={})=>createLspStdioClient({executablePath:process.execPath,expectedSha256:nodeSha,args:[fixture],cwd:here,env:{},requestTimeoutMs:1000,maxMessageBytes:32768,...overrides});
+
+test('LSP stdio parses split frames and correlates out-of-order responses',async()=>{
+  const client=make();
+  try{
+    const init=await client.initialize({processId:null,rootUri:null,capabilities:{}});
+    assert.equal(init.serverInfo.name,'fixture');
+    const [a,b]=await Promise.all([
+      client.request('queue',{value:'a'}),
+      client.request('queue',{value:'b'})
+    ]);
+    assert.deepEqual(a,{value:'a'});
+    assert.deepEqual(b,{value:'b'});
+    const echo=await client.request('echo',{value:'split'});
+    assert.deepEqual(echo,{value:'split'});
+  } finally { await client.shutdown().catch(()=>{}); }
+});
+
+test('LSP stdio times out one request without retrying it',async()=>{
+  const client=make({requestTimeoutMs:300});
+  try{
+    await client.initialize({processId:null,rootUri:null,capabilities:{}});
+    await assert.rejects(client.request('never',{}),/LSP request timeout.*never/i);
+  } finally { await client.shutdown().catch(()=>{}); }
+});
+
+test('LSP stdio rejects oversized inbound messages',async()=>{
+  const client=make({maxMessageBytes:2048});
+  try{
+    await client.initialize({processId:null,rootUri:null,capabilities:{}});
+    await assert.rejects(client.request('oversize',{}),/exceeds.*2048/i);
+  } finally { await client.shutdown().catch(()=>{}); }
+});
+
+test('LSP stdio rejects outstanding requests when server exits unexpectedly',async()=>{
+  const client=make();
+  await client.initialize({processId:null,rootUri:null,capabilities:{}});
+  await assert.rejects(client.request('crash',{}),/LSP process exited.*9/i);
+});
+
+test('LSP stdio verifies executable identity before spawn',async()=>{
+  assert.throws(()=>createLspStdioClient({executablePath:process.execPath,expectedSha256:'0'.repeat(64),args:[fixture],cwd:here,env:{},requestTimeoutMs:100,maxMessageBytes:2048}),/executable SHA-256 mismatch/i);
+});
+
+test('LSP stdio verifies pinned dependency identities before spawn',async()=>{
+  const fixtureSha=sha256(await readFile(fixture));
+  const client=make({dependencies:[{path:fixture,expectedSha256:fixtureSha}]});
+  try{
+    const init=await client.initialize({processId:null,rootUri:null,capabilities:{}});
+    assert.equal(init.serverInfo.name,'fixture');
+  } finally { await client.shutdown().catch(()=>{}); }
+  assert.throws(()=>make({dependencies:[{path:fixture,expectedSha256:'0'.repeat(64)}]}),/LSP dependency SHA-256 mismatch/i);
+});
+
+test('LSP stdio graceful shutdown is idempotent',async()=>{
+  const client=make();
+  await client.initialize({processId:null,rootUri:null,capabilities:{}});
+  await client.shutdown();
+  await client.shutdown();
+});

package/test/multi-file-read.test.mjs

@@ -0,0 +1,41 @@
+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 { Client } from '@modelcontextprotocol/client';
+import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
+import { generateTrustKeypair } from '../src/trust.mjs';
+import { loadCodingPolicy } from '../src/coding-plane.mjs';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const repoRoot=path.resolve(here,'..');
+const serverPath=path.join(repoRoot,'src','mcp-server.mjs');
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const sha256File=async file=>sha256(await readFile(file));
+async function fixture(){
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-multi-read-')); const project=path.join(root,'project'); const trust=path.join(root,'trust');
+  await mkdir(project); await mkdir(trust); await mkdir(path.join(project,'.git'));
+  await writeFile(path.join(project,'a.txt'),'alpha\n'); await writeFile(path.join(project,'b.txt'),'beta\n'); await writeFile(path.join(project,'c.bin'),Buffer.from([0,1,2,255])); await writeFile(path.join(project,'.git','secret'),'no');
+  const keys=await generateTrustKeypair({privateKeyPath:path.join(trust,'private.pem'),publicKeyPath:path.join(trust,'public.pem')});
+  const policyPath=path.join(root,'coding-policy.json'); const leasePath=path.join(root,'coding-lease.json');
+  await writeFile(policyPath,JSON.stringify({schema:'deadbyte.coding-policy.v1',enabled:true,lease_file:leasePath,evidence_dir:path.join(root,'evidence'),roots:{project:{path:project,read:true,write:true,exec:true,deny_paths:['.git','node_modules']}},commands:{node_script:{kind:'script',executable:process.execPath,executable_sha256:await sha256File(process.execPath),root_ids:['project'],prefix_args:[],extensions:['.mjs','.js'],timeout_ms:30000,max_output_bytes:262144}},max_read_bytes:524288,max_write_bytes:2097152},null,2));
+  const policy=await loadCodingPolicy(policyPath);
+  await writeFile(leasePath,JSON.stringify({schema:'deadbyte.coding-lease.v1',policy_sha256:policy.policy_sha256,instance_nonce:'d'.repeat(64),root_ids:['project'],armed_at_utc:new Date().toISOString(),expires_at_utc:new Date(Date.now()+3600000).toISOString()}));
+  const client=new Client({name:'deadbyte-multi-read-test',version:'0.8.11'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  const transport=new StdioClientTransport({command:process.execPath,args:[serverPath],cwd:repoRoot,env:{...getDefaultEnvironment(),DEADBYTE_SIGNING_KEY:keys.privateKeyPath,DEADBYTE_VERIFY_KEY:keys.publicKeyPath,DEADBYTE_CODING_RUNTIME:'1',DEADBYTE_CODING_POLICY:policyPath},stderr:'pipe'});
+  return {root,client,transport};
+}
+function structured(value){if(value.isError)throw new Error(JSON.stringify(value.structuredContent??value.content));return value.structuredContent;}
+test('coding_files_read reads bounded mixed encodings in one MCP call and fails closed on denied input',async()=>{
+  const f=await fixture(); try{
+    await f.client.connect(f.transport);
+    assert.ok((await f.client.listTools()).tools.some(t=>t.name==='coding_files_read'));
+    const result=structured(await f.client.callTool({name:'coding_files_read',arguments:{root_id:'project',files:[{path:'a.txt',encoding:'utf8'},{path:'b.txt',encoding:'utf8'},{path:'c.bin',encoding:'base64'}],max_total_bytes:64}}));
+    assert.equal(result.status,'ok'); assert.equal(result.files.length,3); assert.equal(result.total_bytes,15); assert.equal(result.files[0].content,'alpha\n'); assert.equal(result.files[2].content,Buffer.from([0,1,2,255]).toString('base64'));
+    const denied=await f.client.callTool({name:'coding_files_read',arguments:{root_id:'project',files:[{path:'a.txt',encoding:'utf8'},{path:'.git/secret',encoding:'utf8'}],max_total_bytes:64}});
+    assert.equal(denied.isError,true); assert.equal(denied.structuredContent.status,'failed'); assert.match(denied.structuredContent.error,/denied by policy/);
+  } finally {await f.client.close().catch(()=>{}); await rm(f.root,{recursive:true,force:true}).catch(()=>{});}
+});

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/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\.9\.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\.9\.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\.9\.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,35 @@
+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']);
+    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 R35 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,11 @@ 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.r35-windows-gate.v1');
     assert.equal(evidence.status,'passed');
     assert.equal(evidence.exit_code,0);
     assert.equal(evidence.manifest_sha256,manifestSha);
-    assert.equal(evidence.marker,'DEADBYTE V0.8.9 / R33 WINDOWS BATCH GATE: PASS');
+    assert.equal(evidence.marker,'DEADBYTE V0.9.0 / R35 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 () => {
@@ -29,10 +32,10 @@ test('final closure verifier is implementation-independent from production helpe
   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\.9'/);
-  assert.match(verifier, /envelope\.body\.version==='0\.8\.9'/);
-  assert.match(verifier, /release_label==='R33 FINAL MACHINE BASELINE'/);
+  assert.match(verifier, /DEADBYTE-R35-FINAL-CLOSURE-V1/);
+  assert.match(writer, /pointer\.version==='0\.9\.0'/);
+  assert.match(verifier, /envelope\.body\.version==='0\.9\.0'/);
+  assert.match(verifier, /release_label==='R35 FINAL MACHINE BASELINE'/);
 });
 
 test('final closure verifier canonicalizes traversal order before exact-tree comparison', async () => {
@@ -41,15 +44,15 @@ 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('autonomous live gate reuses the canonical R34 73-tool 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.match(autonomous, /import \{ R34_EXPECTED_TOOLS \} from '\.\/remote-mcp-r34-parity-client\.mjs';/);
   assert.doesNotMatch(autonomous, /const expectedTools\s*=\s*\[/);
-  assert.match(autonomous, /JSON\.stringify\(names\) !== JSON\.stringify\(R33_EXPECTED_TOOLS\)/);
+  assert.match(autonomous, /JSON\.stringify\(names\) !== JSON\.stringify\(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 +60,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/);

package/test/release-generation.test.mjs

@@ -19,7 +19,11 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   await mkdir(path.join(release,'scripts'),{recursive:true}); await mkdir(path.join(release,'bin'),{recursive:true}); await mkdir(workspace,{recursive:true});
   await writeFile(path.join(release,'scripts','gate.ps1'),'Write-Output gate\n');
   await writeFile(path.join(release,'bin','deadbyte-process-host.exe'),'process-host-bytes\n');
-  const currentConfig={AgentRuntimeEnabled:true,ProcessRuntimeEnabled:true,CodingRuntimeEnabled:true,MachineFsRuntimeEnabled:true,ObservationRuntimeEnabled:true,AutonomousRuntimeEnabled:true,
+  const semanticConfigPath=path.join(base,'semantic-lsp.json');
+  const semanticConfigBytes=Buffer.from(JSON.stringify({schema:'deadbyte.semantic-lsp-config.v1',servers:[]})+'\n','utf8');
+  await writeFile(semanticConfigPath,semanticConfigBytes);
+  const currentConfig={AgentRuntimeEnabled:true,ProcessRuntimeEnabled:true,CodingRuntimeEnabled:true,MachineFsRuntimeEnabled:true,ObservationRuntimeEnabled:true,AutonomousRuntimeEnabled:true,AutonomousSupervisorEnabled:true,SemanticLspConfigFile:semanticConfigPath,SemanticLspConfigSha256:sha(semanticConfigBytes),
+    Supervisor:{FilePath:'C:/node.exe',FileSha256:EXE,Arguments:'src\\autonomous-supervisor-host.mjs',WorkingDirectory:'C:/release',ScriptPath:'C:/release/src/autonomous-supervisor-host.mjs',ScriptSha256:'2'.repeat(64)},
     Bridge:{FilePath:'C:/node.exe',FileSha256:EXE,Arguments:'bridge.mjs',WorkingDirectory:'C:/bridge',ScriptPath:'C:/bridge/bridge.mjs',ScriptSha256:EXE},
     Cloud:{FilePath:'C:/deadbyte-tunnel-host.exe',FileSha256:EXE,Arguments:'"C:/cloudflared.exe" "C:/secret/tunnel-token.txt" "C:/bridge"',WorkingDirectory:'C:/release',Transport:'deadbyte.named-tunnel.v2',Dependencies:[
       {Name:'cloudflared',Path:'C:/cloudflared.exe',Sha256:EXE},{Name:'tunnel-token',Path:'C:/secret/tunnel-token.txt',Sha256:EXE}
@@ -38,7 +42,7 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   const development=path.join(base,'development'); await mkdir(development,{recursive:true}); await mkdir(path.join(development,'scripts'),{recursive:true}); await writeFile(path.join(development,'scripts','gate.ps1'),'Write-Output gate\n');
   const result=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy});
   const verified=await verifyGenerationBundle(result.generation_root,result.generation_manifest_sha256);
-  assert.equal(verified.files,5);
+  assert.equal(verified.files,6);
   const generatedProcess=JSON.parse(await readFile(result.process_policy_path,'utf8'));
   assert.equal(generatedProcess.grant_file,path.join(path.resolve(state),'runtime','process-grant.json'));
   assert.equal(generatedProcess.state_dir,path.join(path.resolve(state),'evidence','process'));
@@ -62,8 +66,11 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   assert.equal(generatedHost.roots.core.path,path.resolve(development));
   assert.notEqual(generatedHost.roots.core.path,path.resolve(release));
   assert.equal(generatedHost.arm_file,path.join(path.resolve(state),'runtime','host-grant.json'));
+  assert.equal(await readFile(result.semantic_config_path,'utf8'),semanticConfigBytes.toString('utf8'));
   const config=await readFile(result.config_path,'utf8');
   assert.match(config,new RegExp(`CoreRoot = '${release.replaceAll('\\','\\\\')}`));
+  assert.match(config,/SemanticLspConfigFile = '/);
+  assert.match(config,new RegExp(`SemanticLspConfigSha256 = '${sha(semanticConfigBytes)}'`));
   assert.doesNotMatch(config,/CoreRoot = ''/);
   assert.match(config,new RegExp(`WorkspaceRoot = '${workspace.replaceAll('\\','\\\\')}`));
   assert.match(config,/MachineRuntimeEnabled = \$true/);
@@ -74,6 +81,10 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   assert.match(config,/ObservationRuntimeEnabled = \$true/);
   assert.match(config,/CodingPolicyFile = '/);
   assert.match(config,/AutonomousPolicyFile = '/);
+  assert.match(config,/AutonomousSupervisorEnabled = \$true/);
+  assert.match(config,/Supervisor = @\{/);
+  assert.match(config,/ScriptPath = 'C:\/release\/src\/autonomous-supervisor-host\.mjs'/);
+  assert.match(config,/ScriptSha256 = '2{64}'/);
   assert.match(config,/HostPolicyFile = '/);
   assert.match(config,/Transport = 'deadbyte\.named-tunnel\.v2'/);
   assert.match(config,/McpUrlFile = 'C:\/mcp-url\.txt'/);
@@ -107,10 +118,20 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   const sixth=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:observationDisabled,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy});
   assert.notEqual(sixth.generation_root,result.generation_root);
   assert.notEqual(sixth.generation_seed_sha256,result.generation_seed_sha256);
+  const semanticConfig2Path=path.join(base,'semantic-lsp-v2.json');
+  const semanticConfig2Bytes=Buffer.from(JSON.stringify({schema:'deadbyte.semantic-lsp-config.v1',servers:[{id:'changed'}]})+'\n','utf8');
+  await writeFile(semanticConfig2Path,semanticConfig2Bytes);
+  const semanticChanged=structuredClone(currentConfig);
+  semanticChanged.SemanticLspConfigFile=semanticConfig2Path;
+  semanticChanged.SemanticLspConfigSha256=sha(semanticConfig2Bytes);
+  const seventh=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:semanticChanged,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy});
+  assert.notEqual(seventh.generation_root,result.generation_root);
+  assert.notEqual(seventh.generation_seed_sha256,result.generation_seed_sha256);
   await verifyGenerationBundle(result.generation_root,result.generation_manifest_sha256);
   await verifyGenerationBundle(second.generation_root,second.generation_manifest_sha256);
   await verifyGenerationBundle(third.generation_root,third.generation_manifest_sha256);
   await verifyGenerationBundle(fourth.generation_root,fourth.generation_manifest_sha256);
   await verifyGenerationBundle(fifth.generation_root,fifth.generation_manifest_sha256);
   await verifyGenerationBundle(sixth.generation_root,sixth.generation_manifest_sha256);
+  await verifyGenerationBundle(seventh.generation_root,seventh.generation_manifest_sha256);
 });