deadbyte-mcp 0.8.10 → 0.10.0

package/src/remote-mcp-smoke-client.mjs

@@ -28,8 +28,9 @@ const agentTools = [
   'agent_task_status', 'agent_task_submit', 'agent_task_verify'
 ];
 const codingTools = [
-  'coding_benchmark_run', 'coding_command_run', 'coding_file_read', 'coding_file_write',
+  'coding_benchmark_run', 'coding_command_run', 'coding_file_read', 'coding_file_write', 'coding_files_read',
   'coding_receipt_verify', 'coding_search', 'coding_session_status', 'coding_stat',
+  'coding_symbol_definition', 'coding_symbol_diagnostics', 'coding_symbol_implementations', 'coding_symbol_outline', 'coding_symbol_references', 'coding_symbol_rename_preview', 'coding_symbol_replace',
   'coding_task_approve', 'coding_task_cancel', 'coding_task_events', 'coding_task_run',
   'coding_task_status', 'coding_task_submit', 'coding_task_verify', 'coding_text_replace', 'coding_tree'
 ];
@@ -38,6 +39,18 @@ const autonomousTools = [
   'autonomous_goal_status', 'autonomous_goal_submit', 'autonomous_goal_verify', 'autonomous_release_gate',
   'autonomous_session_status', 'native_diff_apply', 'native_diff_preview', 'native_diff_verify'
 ];
+const r36CompactTools = [
+  'autonomous_goal_approve','autonomous_goal_cancel','autonomous_goal_events','autonomous_goal_run','autonomous_goal_status','autonomous_goal_submit','autonomous_goal_verify','autonomous_release_gate','autonomous_session_status',
+  'capability_manifest',
+  'coding_benchmark_run','coding_command_run','coding_file_read','coding_file_write','coding_inspect','coding_receipt_verify','coding_session_status','coding_symbol_replace',
+  'coding_task_approve','coding_task_cancel','coding_task_events','coding_task_run','coding_task_status','coding_task_submit','coding_task_verify','coding_text_replace','coding_tree',
+  'evidence_verify',
+  'host_exec','host_file_read','host_file_write',
+  'machine_fs','machine_list','machine_observe','machine_ping','machine_revoke','machine_status',
+  'native_diff_apply','native_diff_preview','native_diff_verify',
+  'process_session'
+].sort();
+if (r36CompactTools.length !== 41) throw new Error(`R36 compact catalog constant drift: ${r36CompactTools.length}`);
 const allowedCatalogs = [];
 for (const machine of [false, true]) for (const host of [false, true]) for (const agent of [false, true]) {
   for (const processPlane of [false, true]) for (const machineFs of [false, true]) for (const observation of [false, true]) for (const codingMode of ['none', 'coding', 'autonomous']) {
@@ -67,13 +80,21 @@ function structured(result, label) {
   if (!result.structuredContent || typeof result.structuredContent !== 'object') throw new Error(`${label} returned no structured object`);
   return result.structuredContent;
 }
+function gateway(result, label) {
+  const value = structured(result, label);
+  if (value.status !== 'ok' || !value.result || typeof value.result !== 'object') {
+    throw new Error(`${label} gateway status=${String(value.status)} error=${String(value.error ?? '')}`);
+  }
+  return value.result;
+}
 
 try {
   await client.connect(transport);
   if (client.getProtocolEra() !== 'modern') throw new Error(`expected modern MCP era, got ${String(client.getProtocolEra())}`);
   const listed = await client.listTools();
   const names = listed.tools.map(t => t.name).sort();
-  const catalogOk = allowedCatalogs.some(expected => JSON.stringify(names) === JSON.stringify(expected));
+  const compactProfile = JSON.stringify(names) === JSON.stringify(r36CompactTools);
+  const catalogOk = compactProfile || allowedCatalogs.some(expected => JSON.stringify(names) === JSON.stringify(expected));
   if (!catalogOk) throw new Error(`tool catalog mismatch: ${JSON.stringify(names)}`);
   for (const tool of listed.tools) {
     if (tool.outputSchema?.type !== 'object' || tool.outputSchema?.additionalProperties !== false || !tool.outputSchema?.properties) {
@@ -89,72 +110,108 @@ try {
   const codingRuntime = codingTools.every(name => names.includes(name));
   const autonomousRuntime = autonomousTools.every(name => names.includes(name));
 
-  const opened = structured(await client.callTool({ name: 'workspace_open', arguments: { workspace_id: 'demo' } }), 'workspace_open');
-  if (opened.status !== 'ok') throw new Error(`workspace_open status=${String(opened.status)}`);
-
-  const proofOutput = `remote-proof.${randomBytes(8).toString('hex')}.txt`;
-  const proof = structured(await client.callTool({
-    name: 'proof_execute', arguments: { workspace_id: 'demo', input: 'input.txt', output: proofOutput }
-  }), 'proof_execute');
-  if (proof.status !== 'passed' || !/^[0-9a-f]{64}$/.test(proof.request_sha256)) throw new Error('remote proof request identity missing');
-  const proofVerify = structured(await client.callTool({
-    name: 'evidence_verify', arguments: { workspace_id: 'demo', receipt_path: proof.receipt_path }
-  }), 'evidence_verify proof');
-  if (proofVerify.ok !== true || proofVerify.signature_valid !== true || proofVerify.receipt_schema !== 'deadbyte.receipt.v2' ||
-      proofVerify.request_sha256 !== proof.request_sha256) throw new Error(`remote proof verify failed: ${JSON.stringify(proofVerify)}`);
-
+  let compact = null;
+  let proofOutput = null;
+  let proof = null;
   let contained = null;
-  if (mode === 'full') {
-    const output = `remote-contained.${randomBytes(8).toString('hex')}.txt`;
-    const exec = structured(await client.callTool({
-      name: 'contained_transform',
-      arguments: { workspace_id: 'demo', input: 'input.txt', output, operation: 'uppercase_ascii' }
-    }), 'contained_transform');
-    if (exec.status !== 'passed' || exec.output_sha256 !== '3e740f6fcf2c6659bc5f99e0706b09f3c127407bbabe74d05285d2e3276946c2' ||
-        !/^[0-9a-f]{64}$/.test(exec.request_sha256)) throw new Error(`remote contained result mismatch: ${JSON.stringify(exec)}`);
-    const verify = structured(await client.callTool({
-      name: 'evidence_verify', arguments: { workspace_id: 'demo', receipt_path: exec.receipt_path }
-    }), 'evidence_verify contained');
-    if (verify.ok !== true || verify.signature_valid !== true || verify.containment_verified !== true ||
-        verify.active_network_denial_verified !== true || verify.receipt_schema !== 'deadbyte.receipt.v2' ||
-        verify.request_sha256 !== exec.request_sha256) throw new Error(`remote contained verification failed: ${JSON.stringify(verify)}`);
-    contained = { output, receipt_sha256: exec.receipt_sha256, request_sha256: exec.request_sha256, output_sha256: exec.output_sha256 };
-  }
   let agent = null;
-  if (mode === 'full' && agentRuntime) {
-    const submissionId = `remote-gate-${randomBytes(8).toString('hex')}`;
-    const submitted = structured(await client.callTool({
-      name: 'agent_task_submit', arguments: {
-        workspace_id: 'demo', submission_id: submissionId, title: 'remote R22 gate',
-        steps: [
-          { step_id: 'proof', kind: 'proof_execute', input: { kind: 'workspace', path: 'input.txt' }, retry_limit: 0 },
-          { step_id: 'contained', kind: 'contained_transform', operation: 'uppercase_ascii', input: { kind: 'step_output', step_id: 'proof' }, retry_limit: 0 }
-        ]
+  if (compactProfile) {
+    const manifest = gateway(await client.callTool({ name: 'capability_manifest', arguments: {} }), 'capability_manifest');
+    if (manifest.schema !== 'deadbyte.capability-manifest.v1' || manifest.profile !== 'compact' ||
+        !Array.isArray(manifest.capabilities) || !/^[0-9a-f]{64}$/.test(String(manifest.ledger_sha256 ?? ''))) {
+      throw new Error('R36 compact capability manifest malformed');
+    }
+    const required = manifest.capabilities.filter(item => item?.production === true && item?.host_only !== true);
+    for (const item of required) {
+      if (typeof item.compact_tool !== 'string' || !names.includes(item.compact_tool)) {
+        throw new Error(`R36 compact capability route missing: ${String(item.id)}`);
+      }
+    }
+    const machine = gateway(await client.callTool({ name: 'machine_observe', arguments: { op: 'machine_status' } }), 'machine_status');
+    const nonce = `remote-smoke-${randomBytes(16).toString('hex')}`;
+    const ping = gateway(await client.callTool({ name: 'machine_observe', arguments: { op: 'machine_ping', nonce } }), 'machine_ping');
+    if (ping.nonce !== nonce || ping.machine_id !== machine.machine_id ||
+        ping.release_id !== machine.release_id || ping.release_manifest_sha256 !== machine.release_manifest_sha256) {
+      throw new Error('R36 compact machine ping binding mismatch');
+    }
+    compact = {
+      profile: 'compact',
+      ledger_sha256: manifest.ledger_sha256,
+      capability_count: manifest.capabilities.length,
+      production_non_host_capabilities: required.length,
+      capability_closure: true,
+      machine_id: machine.machine_id,
+      release_id: machine.release_id,
+      release_manifest_sha256: machine.release_manifest_sha256,
+      ping_signature_valid: ping.signature_valid === true
+    };
+  } else {
+    const opened = structured(await client.callTool({ name: 'workspace_open', arguments: { workspace_id: 'demo' } }), 'workspace_open');
+    if (opened.status !== 'ok') throw new Error(`workspace_open status=${String(opened.status)}`);
+
+    proofOutput = `remote-proof.${randomBytes(8).toString('hex')}.txt`;
+    proof = structured(await client.callTool({
+      name: 'proof_execute', arguments: { workspace_id: 'demo', input: 'input.txt', output: proofOutput }
+    }), 'proof_execute');
+    if (proof.status !== 'passed' || !/^[0-9a-f]{64}$/.test(proof.request_sha256)) throw new Error('remote proof request identity missing');
+    const proofVerify = structured(await client.callTool({
+      name: 'evidence_verify', arguments: { workspace_id: 'demo', receipt_path: proof.receipt_path }
+    }), 'evidence_verify proof');
+    if (proofVerify.ok !== true || proofVerify.signature_valid !== true || proofVerify.receipt_schema !== 'deadbyte.receipt.v2' ||
+        proofVerify.request_sha256 !== proof.request_sha256) throw new Error(`remote proof verify failed: ${JSON.stringify(proofVerify)}`);
+
+    if (mode === 'full') {
+      const output = `remote-contained.${randomBytes(8).toString('hex')}.txt`;
+      const exec = structured(await client.callTool({
+        name: 'contained_transform',
+        arguments: { workspace_id: 'demo', input: 'input.txt', output, operation: 'uppercase_ascii' }
+      }), 'contained_transform');
+      if (exec.status !== 'passed' || exec.output_sha256 !== '3e740f6fcf2c6659bc5f99e0706b09f3c127407bbabe74d05285d2e3276946c2' ||
+          !/^[0-9a-f]{64}$/.test(exec.request_sha256)) throw new Error(`remote contained result mismatch: ${JSON.stringify(exec)}`);
+      const verify = structured(await client.callTool({
+        name: 'evidence_verify', arguments: { workspace_id: 'demo', receipt_path: exec.receipt_path }
+      }), 'evidence_verify contained');
+      if (verify.ok !== true || verify.signature_valid !== true || verify.containment_verified !== true ||
+          verify.active_network_denial_verified !== true || verify.receipt_schema !== 'deadbyte.receipt.v2' ||
+          verify.request_sha256 !== exec.request_sha256) throw new Error(`remote contained verification failed: ${JSON.stringify(verify)}`);
+      contained = { output, receipt_sha256: exec.receipt_sha256, request_sha256: exec.request_sha256, output_sha256: exec.output_sha256 };
+    }
+    if (mode === 'full' && agentRuntime) {
+      const submissionId = `remote-gate-${randomBytes(8).toString('hex')}`;
+      const submitted = structured(await client.callTool({
+        name: 'agent_task_submit', arguments: {
+          workspace_id: 'demo', submission_id: submissionId, title: 'remote R22 gate',
+          steps: [
+            { step_id: 'proof', kind: 'proof_execute', input: { kind: 'workspace', path: 'input.txt' }, retry_limit: 0 },
+            { step_id: 'contained', kind: 'contained_transform', operation: 'uppercase_ascii', input: { kind: 'step_output', step_id: 'proof' }, retry_limit: 0 }
+          ]
+        }
+      }), 'agent_task_submit');
+      const run = structured(await client.callTool({
+        name: 'agent_task_run', arguments: { workspace_id: 'demo', task_id: submitted.task_id, max_steps: 8 }
+      }), 'agent_task_run');
+      if (run.state !== 'succeeded' || run.completed_steps !== 2) throw new Error(`agent task run failed: ${JSON.stringify(run)}`);
+      const verified = structured(await client.callTool({
+        name: 'agent_task_verify', arguments: { workspace_id: 'demo', task_id: submitted.task_id }
+      }), 'agent_task_verify');
+      if (verified.ok !== true || verified.signature_valid !== true || verified.step_receipts_verified !== 2) {
+        throw new Error(`agent task verify failed: ${JSON.stringify(verified)}`);
       }
-    }), 'agent_task_submit');
-    const run = structured(await client.callTool({
-      name: 'agent_task_run', arguments: { workspace_id: 'demo', task_id: submitted.task_id, max_steps: 8 }
-    }), 'agent_task_run');
-    if (run.state !== 'succeeded' || run.completed_steps !== 2) throw new Error(`agent task run failed: ${JSON.stringify(run)}`);
-    const verified = structured(await client.callTool({
-      name: 'agent_task_verify', arguments: { workspace_id: 'demo', task_id: submitted.task_id }
-    }), 'agent_task_verify');
-    if (verified.ok !== true || verified.signature_valid !== true || verified.step_receipts_verified !== 2) {
-      throw new Error(`agent task verify failed: ${JSON.stringify(verified)}`);
+      agent = { task_id: submitted.task_id, plan_sha256: submitted.plan_sha256,
+        task_receipt_sha256: verified.task_receipt_sha256, step_receipts_verified: verified.step_receipts_verified };
     }
-    agent = { task_id: submitted.task_id, plan_sha256: submitted.plan_sha256,
-      task_receipt_sha256: verified.task_receipt_sha256, step_receipts_verified: verified.step_receipts_verified };
   }
   console.log(JSON.stringify({
-    status: 'passed', mode,
+    status: 'passed', mode, profile: compactProfile ? 'compact' : 'legacy-full',
     protocol_revision: '2026-07-28', protocol_era: 'modern', tools: names,
     output_schemas_strict: true,
     machine_runtime: machineRuntime, privileged_host_plane: privilegedHostPlane,
     agent_runtime: agentRuntime, process_runtime: processRuntime,
     machine_fs_runtime: machineFsRuntime, observation_runtime: observationRuntime,
     coding_runtime: codingRuntime, autonomous_runtime: autonomousRuntime,
-    proof: { output: proofOutput, receipt_sha256: proof.receipt_sha256,
-      request_sha256: proof.request_sha256, signature_valid: true },
+    compact,
+    proof: proof ? { output: proofOutput, receipt_sha256: proof.receipt_sha256,
+      request_sha256: proof.request_sha256, signature_valid: true } : null,
     contained, agent
   }, null, 2));
 } finally {

package/src/remote-result-journal.mjs

@@ -0,0 +1,114 @@
+import { lstat, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+export const REMOTE_RESULT_JOURNAL_SCHEMA='deadbyte.remote-result-journal.v1';
+const SESSION=/^[0-9a-f]{24}$/;
+const HASH=/^[0-9a-f]{64}$/;
+const STATUS=new Set(['ok','error']);
+
+function text(value,label,max){
+  if(typeof value!=='string'||value.length<1||value.length>max||value.includes('\0')) throw new Error(`${label} invalid`);
+  return value;
+}
+function iso(value,label){
+  const parsed=Date.parse(value);
+  if(typeof value!=='string'||!Number.isFinite(parsed)) throw new Error(`${label} invalid`);
+  return new Date(parsed).toISOString();
+}
+function validateSession(value){
+  if(typeof value!=='string'||!SESSION.test(value)) throw new Error('remote result session_id invalid');
+  return value;
+}
+function validateEvent(raw,index=null){
+  if(!raw||typeof raw!=='object'||Array.isArray(raw)) throw new Error('remote result event invalid');
+  const seq=raw.seq;
+  if(!Number.isSafeInteger(seq)||seq<1) throw new Error('remote result seq invalid');
+  const sessionId=validateSession(raw.session_id);
+  const requestId=text(raw.request_id,'remote result request_id',256);
+  const tool=text(raw.tool,'remote result tool',128);
+  if(!STATUS.has(raw.status)) throw new Error('remote result status invalid');
+  const observed=iso(raw.observed_at_utc,'remote result observed_at_utc');
+  if(typeof raw.payload_sha256!=='string'||!HASH.test(raw.payload_sha256)) throw new Error('remote result payload_sha256 invalid');
+  if(index!==null&&seq!==index) throw new Error('remote result sequence mismatch');
+  return Object.freeze({session_id:sessionId,seq,request_id:requestId,tool,status:raw.status,
+    observed_at_utc:observed,payload_sha256:raw.payload_sha256});
+}
+function identity(item){return `${item.request_id}\0${item.status}\0${item.payload_sha256}`;}
+export function parseRemoteResultCursor(cursor){
+  if(typeof cursor!=='string') throw new Error('remote result cursor invalid');
+  const match=/^r1:([0-9a-f]{24}):(0|[1-9][0-9]{0,15})$/.exec(cursor);
+  if(!match) throw new Error('remote result cursor invalid');
+  const seq=Number(match[2]);
+  if(!Number.isSafeInteger(seq)||seq<0) throw new Error('remote result cursor invalid');
+  return {session_id:match[1],seq};
+}
+function cursorFor(sessionId,seq){return `r1:${sessionId}:${seq}`;}
+async function requireRegularIfExists(file){
+  try{
+    const info=await lstat(file);
+    if(!info.isFile()||info.isSymbolicLink()) throw new Error('remote result journal must be regular non-symlink file');
+    return true;
+  }catch(error){if(error?.code==='ENOENT') return false;throw error;}
+}
+function validateStored(value,sessionId){
+  if(!value||typeof value!=='object'||Array.isArray(value)||value.schema!==REMOTE_RESULT_JOURNAL_SCHEMA) throw new Error('remote result journal schema invalid');
+  if(value.session_id!==sessionId) throw new Error('remote result journal session mismatch');
+  if(!Array.isArray(value.events)) throw new Error('remote result journal events invalid');
+  let prior=0;
+  const events=value.events.map(raw=>{
+    const event=validateEvent(raw);
+    if(event.session_id!==sessionId||event.seq<=prior) throw new Error('remote result journal sequence invalid');
+    prior=event.seq;return event;
+  });
+  if(!Number.isSafeInteger(value.next_seq)||value.next_seq<1||value.next_seq!==(events.at(-1)?.seq??0)+1) throw new Error('remote result journal next_seq invalid');
+  return {schema:REMOTE_RESULT_JOURNAL_SCHEMA,session_id:sessionId,next_seq:value.next_seq,events};
+}
+async function atomicWrite(file,value){
+  await mkdir(path.dirname(file),{recursive:true});
+  const temp=`${file}.tmp-${process.pid}-${Math.random().toString(16).slice(2)}`;
+  await writeFile(temp,`${JSON.stringify(value)}\n`,{encoding:'utf8',flag:'wx'});
+  await rename(temp,file);
+}
+
+export async function openRemoteResultJournal({filePath,sessionId,maxEntries=2048}={}){
+  const file=path.resolve(text(filePath,'remote result journal path',1024));
+  const sid=validateSession(sessionId);
+  if(!Number.isInteger(maxEntries)||maxEntries<1||maxEntries>100000) throw new Error('remote result maxEntries invalid');
+  let state;
+  if(await requireRegularIfExists(file)){
+    let raw;try{raw=JSON.parse(await readFile(file,'utf8'));}catch{throw new Error('remote result journal JSON invalid');}
+    state=validateStored(raw,sid);
+  }else{
+    state={schema:REMOTE_RESULT_JOURNAL_SCHEMA,session_id:sid,next_seq:1,events:[]};
+    await atomicWrite(file,state);
+  }
+  async function persist(){
+    state.events=state.events.slice(-maxEntries);
+    await atomicWrite(file,state);
+  }
+  return Object.freeze({
+    file_path:file,session_id:sid,
+    cursor(){return cursorFor(sid,state.next_seq-1);},
+    async recordTerminal(input){
+      const candidate=validateEvent({session_id:sid,seq:state.next_seq,...input});
+      const key=identity(candidate);
+      const existing=state.events.find(event=>identity(event)===key);
+      if(existing) return {duplicate:true,event:existing,cursor:cursorFor(sid,state.next_seq-1)};
+      const event=candidate;
+      state.events.push(event);state.next_seq+=1;await persist();
+      return {duplicate:false,event,cursor:cursorFor(sid,event.seq)};
+    },
+    async replayAfter(cursor,{limit=100}={}){
+      if(!Number.isInteger(limit)||limit<1||limit>500) throw new Error('remote result replay limit invalid');
+      const parsed=parseRemoteResultCursor(cursor);
+      if(parsed.session_id!==sid) throw new Error('remote result cursor session mismatch');
+      const first=state.events[0]?.seq??state.next_seq;
+      const last=state.next_seq-1;
+      if(parsed.seq<first-1) throw new Error('cursor_outside_retention');
+      if(parsed.seq>last) throw new Error('remote result cursor ahead of journal');
+      const events=state.events.filter(event=>event.seq>parsed.seq).slice(0,limit);
+      const nextSeq=events.at(-1)?.seq??parsed.seq;
+      return {events:events.map(event=>({...event})),next_cursor:cursorFor(sid,nextSeq),has_more:state.events.some(event=>event.seq>nextSeq)};
+    }
+  });
+}

package/src/runtime-update.mjs

@@ -45,29 +45,33 @@ function normalizePersistentPublicOrigin(value){
   return publicOrigin.origin;
 }
 export function parseUpdateArgs(argv){
-  const out={stage:null,developmentRoot:null,expectedVersion:null,expectedManifest:null,sourceRoot:null,restoreStandingGrants:false,recoverOfflinePredecessor:false,enableMachineFs:false,enableObservation:false,cloudTransport:null,bridgeBootstrap:null,processPolicyBootstrap:null,hostCommandPins:[]};
-  const cloud={},bridge={},processPolicy={},seen=new Set(),hostPinIds=new Set();
+  const out={stage:null,developmentRoot:null,expectedVersion:null,expectedManifest:null,sourceRoot:null,restoreStandingGrants:false,recoverOfflinePredecessor:false,enableMachineFs:false,enableObservation:false,enableAutonomousSupervisor:false,cloudTransport:null,bridgeBootstrap:null,processPolicyBootstrap:null,semanticLspBootstrap:null,hostCommandPins:[]};
+  const cloud={},bridge={},processPolicy={},semanticLsp={},seen=new Set(),hostPinIds=new Set();
   const bridgeFlags=new Map([
     ['--bridge-root','root'],['--bridge-script-sha256','scriptSha256']
   ]);
   const processPolicyFlags=new Map([
     ['--process-policy','path'],['--process-policy-sha256','sha256']
   ]);
+  const semanticLspFlags=new Map([
+    ['--semantic-lsp-config','path'],['--semantic-lsp-config-sha256','sha256']
+  ]);
   const cloudFlags=new Map([
     ['--cloud-cloudflared','cloudflaredPath'],['--cloud-cloudflared-sha256','cloudflaredSha256'],
     ['--cloud-token-file','tokenFilePath'],['--cloud-token-sha256','tokenFileSha256'],
     ['--cloud-child-working-directory','childWorkingDirectory'],['--cloud-public-origin','publicOrigin']
   ]);
-  const valued=new Set(['--stage','--development-root','--expected-version','--expected-manifest','--source-root','--host-command-pin',...bridgeFlags.keys(),...processPolicyFlags.keys(),...cloudFlags.keys()]);
+  const valued=new Set(['--stage','--development-root','--expected-version','--expected-manifest','--source-root','--host-command-pin',...bridgeFlags.keys(),...processPolicyFlags.keys(),...semanticLspFlags.keys(),...cloudFlags.keys()]);
   for(let index=0;index<argv.length;index++){
     const arg=argv[index];
-    if(arg==='--restore-standing-grants'||arg==='--recover-offline-predecessor'||arg==='--enable-machine-fs'||arg==='--enable-observation'){
+    if(arg==='--restore-standing-grants'||arg==='--recover-offline-predecessor'||arg==='--enable-machine-fs'||arg==='--enable-observation'||arg==='--enable-autonomous-supervisor'){
       if(seen.has(arg)) throw new Error(`duplicate self-update argument '${arg}'`);
       seen.add(arg);
       if(arg==='--restore-standing-grants') out.restoreStandingGrants=true;
       else if(arg==='--recover-offline-predecessor') out.recoverOfflinePredecessor=true;
       else if(arg==='--enable-machine-fs') out.enableMachineFs=true;
-      else out.enableObservation=true;
+      else if(arg==='--enable-observation') out.enableObservation=true;
+      else out.enableAutonomousSupervisor=true;
       continue;
     }
     if(arg==='--host-command-pin'){
@@ -91,6 +95,7 @@ export function parseUpdateArgs(argv){
     else if(arg==='--source-root') out.sourceRoot=path.resolve(value);
     else if(bridgeFlags.has(arg)) bridge[bridgeFlags.get(arg)]=value;
     else if(processPolicyFlags.has(arg)) processPolicy[processPolicyFlags.get(arg)]=value;
+    else if(semanticLspFlags.has(arg)) semanticLsp[semanticLspFlags.get(arg)]=value;
     else cloud[cloudFlags.get(arg)]=value;
   }
   if(!out.stage) throw new Error('--stage is required');
@@ -111,6 +116,13 @@ export function parseUpdateArgs(argv){
     if(!HEX64.test(sha256)) throw new Error('process policy SHA-256 must be lowercase hex');
     out.processPolicyBootstrap={path:path.resolve(processPolicy.path),sha256};
   }
+  const semanticLspFields=[...semanticLspFlags.values()],semanticLspPresent=semanticLspFields.filter(key=>semanticLsp[key]!==undefined);
+  if(semanticLspPresent.length!==0&&semanticLspPresent.length!==semanticLspFields.length) throw new Error('semantic LSP config bootstrap requires path plus SHA-256 as one pair');
+  if(semanticLspPresent.length===semanticLspFields.length){
+    const sha256=String(semanticLsp.sha256).toLowerCase();
+    if(!HEX64.test(sha256)) throw new Error('semantic LSP config SHA-256 must be lowercase hex');
+    out.semanticLspBootstrap={path:path.resolve(semanticLsp.path),sha256};
+  }
   const cloudFields=[...cloudFlags.values()],present=cloudFields.filter(key=>cloud[key]!==undefined);
   if(present.length!==0&&present.length!==cloudFields.length) throw new Error('named tunnel bootstrap requires cloud path/hash/token/workdir plus persistent public origin');
   if(present.length===cloudFields.length){
@@ -262,6 +274,30 @@ export async function prepareBridgeSpec(config,bootstrap){
   return next;
 }
 
+export async function prepareAutonomousSupervisorSpec(config,{releaseRoot,enable=false}={}){
+  const next=structuredClone(config);
+  if(!enable) return next;
+  if(next.AutonomousRuntimeEnabled!==true) throw new Error('autonomous supervisor bootstrap requires AutonomousRuntimeEnabled');
+  if(typeof releaseRoot!=='string'||!path.isAbsolute(releaseRoot)) throw new Error('autonomous supervisor release root must be absolute');
+  const release=path.resolve(releaseRoot),script=path.join(release,'src','autonomous-supervisor-host.mjs');
+  const scriptStat=await lstat(script);
+  if(!scriptStat.isFile()||scriptStat.isSymbolicLink()) throw new Error('autonomous supervisor script must be a regular release file');
+  const bridge=next.Bridge;
+  if(!bridge||typeof bridge.FilePath!=='string'||!path.isAbsolute(bridge.FilePath)||!HEX64.test(String(bridge.FileSha256??''))) {
+    throw new Error('autonomous supervisor bootstrap requires pinned Bridge executable identity');
+  }
+  const executable=path.resolve(bridge.FilePath),exeStat=await lstat(executable);
+  if(!exeStat.isFile()||exeStat.isSymbolicLink()) throw new Error('autonomous supervisor executable must be a regular file');
+  const executableSha256=await sha256File(executable);
+  if(executableSha256!==String(bridge.FileSha256)) throw new Error('autonomous supervisor executable pin drift detected');
+  next.AutonomousSupervisorEnabled=true;
+  next.Supervisor={
+    FilePath:executable,FileSha256:executableSha256,Arguments:'src\\autonomous-supervisor-host.mjs',WorkingDirectory:release,
+    ScriptPath:script,ScriptSha256:await sha256File(script)
+  };
+  return next;
+}
+
 function quoteWindowsArgument(value){
   const text=String(value??'');
   if(text.length<1||/["\r\n\0]/.test(text)) throw new Error('named tunnel argument contains unsafe characters');
@@ -285,6 +321,14 @@ export async function prepareProcessPolicyBootstrap(bootstrap){
   return {...pinned,policy};
 }
 
+export async function prepareSemanticLspConfigBootstrap(bootstrap){
+  if(!bootstrap) return null;
+  const pinned=await verifyPinnedRegularFile(bootstrap.path,bootstrap.sha256,'semantic LSP config');
+  const config=await readJson(pinned.path);
+  if(config?.schema!=='deadbyte.semantic-lsp-config.v1'||!Array.isArray(config.servers)) throw new Error('semantic LSP config schema invalid');
+  return {...pinned,config};
+}
+
 async function preparePinnedCommandPolicy(policy,{commandPins=[],schema,label}={}){
   if(!policy) return {policy:null,repinned:[],matchedCommandIds:[]};
   if(policy.schema!==schema||policy.enabled!==true||!policy.commands||typeof policy.commands!=='object'||Array.isArray(policy.commands)) {
@@ -453,6 +497,34 @@ export function runControllerStartNoCapture(ctx,timeoutMs=45000){
   const call=controllerInvocation(ctx,'start');
   return controlResult(call.exe,call.args,{cwd:call.cwd,timeoutMs,stdio:'ignore'});
 }
+export async function readControllerStartFailure(ctx){
+  const file=path.join(ctx.runtime_root,'controller-start-failure.json');
+  let bytes;
+  try { bytes=await readFile(file); }
+  catch(error){ if(error?.code==='ENOENT') return null; throw error; }
+  const text=bytes.toString('utf8').replace(/^\uFEFF/,'');
+  let value;
+  try { value=JSON.parse(text); } catch(error){ throw new Error(`controller start failure evidence JSON invalid: ${error.message}`); }
+  if(value?.schema!=='deadbyte.controller-start-failure.v1'||!['start','resume','restart'].includes(String(value?.command??''))||
+      typeof value?.message!=='string'||value.message.length<1||typeof value?.failed_at_utc!=='string') {
+    throw new Error('controller start failure evidence schema invalid');
+  }
+  return {path:file,sha256:sha256Bytes(bytes),...value};
+}
+export async function preserveControllerStartFailure(ctx,evidenceDir){
+  const evidence=await readControllerStartFailure(ctx);
+  if(!evidence) return null;
+  const source=path.join(ctx.runtime_root,'controller-start-failure.json');
+  const bytes=await readFile(source);
+  const sourceSha256=sha256Bytes(bytes);
+  if(sourceSha256!==evidence.sha256) throw new Error('controller start failure evidence changed before preservation');
+  const destination=path.join(path.resolve(evidenceDir),'controller-start-failure.json');
+  await atomicBytes(destination,bytes);
+  const persistedSha256=sha256Bytes(await readFile(destination));
+  if(persistedSha256!==sourceSha256) throw new Error('preserved controller start failure evidence SHA-256 mismatch');
+  return {path:destination,sha256:persistedSha256,schema:evidence.schema,command:evidence.command,
+    failed_at_utc:evidence.failed_at_utc,message:evidence.message};
+}
 async function readLedger(ctx,name){
   const file=path.join(ctx.runtime_root,`${name}.instance.json`);
   const value=JSON.parse((await readFile(file,'utf8')).replace(/^\uFEFF/,''));
@@ -510,12 +582,20 @@ async function waitCoreGone(runtime,timeoutMs=10000){
 }
 async function startAndVerify(ctx,oldRuntime){
   let start=null;
+  await rm(path.join(ctx.runtime_root,'controller-start-failure.json'),{force:true});
   for(let attempt=1;attempt<=3;attempt+=1){
     start=runControllerStartNoCapture(ctx,45000);
     if(!start.error&&start.status===0) break;
     if(attempt<3) await sleep(1500);
   }
-  if(start.error||start.status!==0) throw new Error(`controller start transport failed status=${start.status} error=${start.error?.message??'none'}`);
+  if(start.error||start.status!==0){
+    let detail='';
+    try {
+      const evidence=await readControllerStartFailure(ctx);
+      if(evidence) detail=` controller=${evidence.message} evidence_sha256=${evidence.sha256}`;
+    } catch(error) { detail=` controller_evidence_error=${error.message}`; }
+    throw new Error(`controller start transport failed status=${start.status} error=${start.error?.message??'none'}${detail}`);
+  }
   let statusText=''; let status=null;
   const started=Date.now();
   while(Date.now()-started<45000){
@@ -715,7 +795,7 @@ function publicPointer(pointer){
     release_root:pointer.release_root,generation_root:pointer.generation_root,generation_manifest_sha256:pointer.generation_manifest_sha256,
     launcher_sha256:pointer.launcher_sha256,config_path:pointer.config_path};
 }
-export async function performSlotUpdate({stage,developmentRoot,expectedVersion,expectedManifest,sourceRoot=null,stateRoot=DEFAULT_STATE_ROOT,restoreStandingGrants=false,recoverOfflinePredecessor=false,cloudTransport=null,bridgeBootstrap=null,processPolicyBootstrap=null,enableMachineFs=false,enableObservation=false,hostCommandPins=[]}){
+export async function performSlotUpdate({stage,developmentRoot,expectedVersion,expectedManifest,sourceRoot=null,stateRoot=DEFAULT_STATE_ROOT,restoreStandingGrants=false,recoverOfflinePredecessor=false,cloudTransport=null,bridgeBootstrap=null,processPolicyBootstrap=null,semanticLspBootstrap=null,enableMachineFs=false,enableObservation=false,enableAutonomousSupervisor=false,hostCommandPins=[]}){
   if(process.platform!=='win32') throw new Error('R27 slot update is Windows-only');
   const state=path.resolve(stateRoot),stageRoot=path.resolve(stage),development=assertDevelopmentRootSafe(developmentRoot,state);
   const key=await loadUpdateKey(state); const updateId=`r27-${expectedManifest.slice(0,16)}-${Date.now().toString(36)}-${randomBytes(4).toString('hex')}`;
@@ -740,6 +820,11 @@ export async function performSlotUpdate({stage,developmentRoot,expectedVersion,e
       control.processPolicy=processBootstrap.policy;
       control.config.ProcessRuntimeEnabled=true;
     }
+    const semanticBootstrap=await prepareSemanticLspConfigBootstrap(semanticLspBootstrap);
+    if(semanticBootstrap){
+      control.config.SemanticLspConfigFile=semanticBootstrap.path;
+      control.config.SemanticLspConfigSha256=semanticBootstrap.sha256;
+    }
     if(enableMachineFs){
       if(control.config.CodingRuntimeEnabled!==true) throw new Error('MachineFsRuntimeEnabled requires CodingRuntimeEnabled');
       control.config.MachineFsRuntimeEnabled=true;
@@ -751,6 +836,7 @@ export async function performSlotUpdate({stage,developmentRoot,expectedVersion,e
     }
     control.config=await prepareBridgeSpec(control.config,bridgeBootstrap);
     control.config=await prepareNamedTunnelCloudSpec(control.config,{releaseRoot:slot.release_root,bootstrap:cloudTransport});
+    control.config=await prepareAutonomousSupervisorSpec(control.config,{releaseRoot:slot.release_root,enable:enableAutonomousSupervisor});
     authorityPreparation=await prepareAuthorityPolicies({hostPolicy:control.hostPolicy,codingPolicy:control.codingPolicy},{commandPins:hostCommandPins});
     control.hostPolicy=authorityPreparation.hostPolicy;
     control.codingPolicy=authorityPreparation.codingPolicy;
@@ -829,6 +915,18 @@ export async function performSlotUpdate({stage,developmentRoot,expectedVersion,e
     return {ok:true,update_id:updateId,state_path:statePath,receipt_path:receiptPath,receipt_sha256:receipt.receipt_sha256,
       pointer:newPointer,new_runtime:newRuntime,final_authority:finalAuthority,workspace_root:workspace.target};
   } catch(error){
+    let controllerStartFailure=null,controllerStartFailurePreservationError=null;
+    if(pointerCommitted&&newCtx){
+      try {
+        controllerStartFailure=await preserveControllerStartFailure(newCtx,evidenceDir);
+        const claimed=/evidence_sha256=([0-9a-f]{64})/.exec(String(error?.message??error));
+        if(claimed&&(!controllerStartFailure||controllerStartFailure.sha256!==claimed[1])) {
+          controllerStartFailurePreservationError=`controller start failure evidence claim mismatch expected=${claimed[1]} preserved=${controllerStartFailure?.sha256??'missing'}`;
+        }
+      } catch(preserveError) {
+        controllerStartFailurePreservationError=String(preserveError?.message??preserveError);
+      }
+    }
     const rollback={attempted:false,new_runtime_stopped:false,pointer_restored:false,launchers_restored:false,workspace_restored:false,
       mcp_url_restored:false,old_runtime_restarted:false,authority_restored:false,errors:[]};
     try {
@@ -866,6 +964,8 @@ export async function performSlotUpdate({stage,developmentRoot,expectedVersion,e
     } catch(rollbackError){ rollback.errors.push(`rollback:${rollbackError.message}`); }
     const failure={schema:FAILURE_SCHEMA,update_id:updateId,release_version:expectedVersion,candidate_manifest_sha256:expectedManifest,
       failed_at_utc:new Date().toISOString(),phase:journal.phase??'unknown',error:{name:error?.name??'Error',code:error?.code??null,message:String(error?.message??error)},
+      controller_start_failure:controllerStartFailure,
+      controller_start_failure_preservation_error:controllerStartFailurePreservationError,
       predecessor_mode:predecessor?.mode??null,prior_pointer:publicPointer(pointerInfo?.pointer??null),attempted_pointer:publicPointer(newPointer),old_runtime:generationTuple(oldRuntime),rollback};
     await writeState(statePath,journal,'failed',{failure,rollback}).catch(()=>{});
     let failureReceipt=null;
@@ -942,8 +1042,8 @@ export async function runSlotUpdateCli(argv=process.argv.slice(2),{stateRoot=DEF
   const args=parseUpdateArgs(argv);
   const result=await performSlotUpdate({stage:args.stage,developmentRoot:args.developmentRoot,expectedVersion:args.expectedVersion,
     expectedManifest:args.expectedManifest,sourceRoot:args.sourceRoot,stateRoot,restoreStandingGrants:args.restoreStandingGrants,recoverOfflinePredecessor:args.recoverOfflinePredecessor,
-    cloudTransport:args.cloudTransport,bridgeBootstrap:args.bridgeBootstrap,processPolicyBootstrap:args.processPolicyBootstrap,enableMachineFs:args.enableMachineFs,
-    enableObservation:args.enableObservation,hostCommandPins:args.hostCommandPins});
+    cloudTransport:args.cloudTransport,bridgeBootstrap:args.bridgeBootstrap,processPolicyBootstrap:args.processPolicyBootstrap,semanticLspBootstrap:args.semanticLspBootstrap,enableMachineFs:args.enableMachineFs,
+    enableObservation:args.enableObservation,enableAutonomousSupervisor:args.enableAutonomousSupervisor,hostCommandPins:args.hostCommandPins});
   console.log(`R27_SLOT_UPDATE_PASS version=${args.expectedVersion}`);
   console.log(`UPDATE_ID ${result.update_id}`); console.log(`RECEIPT_SHA256 ${result.receipt_sha256}`);
   console.log(`STATE_PATH ${result.state_path}`); console.log(`ACTIVE_RELEASE ${result.pointer.release_id}`);

package/src/search-cursor.mjs

@@ -0,0 +1,45 @@
+import { sign as cryptoSign, verify as cryptoVerify } from 'node:crypto';
+import { canonicalJson } from './canonical-json.mjs';
+import { loadPrivateSigningKey, loadPublicVerifyKey } from './trust.mjs';
+
+const DOMAIN=Buffer.from('DEADBYTE-SEARCH-CURSOR-V1\0','utf8');
+const HEX64=/^[0-9a-f]{64}$/;
+const SCHEMA='deadbyte.search-cursor.v1';
+
+function validateBody(body){
+  if(!body||typeof body!=='object'||Array.isArray(body)||body.schema!==SCHEMA) throw new Error('search cursor body invalid');
+  if(!HEX64.test(body.query_sha256??'')) throw new Error('search cursor query identity invalid');
+  if(!HEX64.test(body.snapshot_sha256??'')) throw new Error('search cursor snapshot identity invalid');
+  if(!Number.isInteger(body.offset)||body.offset<0||body.offset>1_000_000) throw new Error('search cursor offset invalid');
+  return {schema:SCHEMA,query_sha256:body.query_sha256,snapshot_sha256:body.snapshot_sha256,offset:body.offset};
+}
+
+export function createSearchCursorCodec({signingKeyPath,verifyKeyPath}){
+  if(!signingKeyPath||!verifyKeyPath) throw new Error('search cursor codec requires signing and verify keys');
+  return Object.freeze({
+    async encode(input){
+      const body=validateBody({...input,schema:SCHEMA});
+      const signing=await loadPrivateSigningKey(signingKeyPath);
+      const bytes=Buffer.from(canonicalJson(body),'utf8');
+      const signature=cryptoSign(null,Buffer.concat([DOMAIN,bytes]),signing.privateKey).toString('base64');
+      const envelope={body,attestation:{algorithm:'ed25519',key_id:signing.keyId,signature_base64:signature}};
+      return Buffer.from(canonicalJson(envelope),'utf8').toString('base64url');
+    },
+    async decode(cursor){
+      if(typeof cursor!=='string'||cursor.length<1||cursor.length>8192) throw new Error('search cursor invalid');
+      let envelope;
+      try{envelope=JSON.parse(Buffer.from(cursor,'base64url').toString('utf8'));}catch{throw new Error('search cursor invalid');}
+      const body=validateBody(envelope?.body);
+      const verifyKey=await loadPublicVerifyKey(verifyKeyPath);
+      const att=envelope?.attestation;
+      if(att?.algorithm!=='ed25519'||att?.key_id!==verifyKey.keyId||typeof att?.signature_base64!=='string') throw new Error('search cursor attestation invalid');
+      const signature=Buffer.from(att.signature_base64,'base64');
+      if(signature.length!==64||signature.toString('base64')!==att.signature_base64) throw new Error('search cursor signature encoding invalid');
+      const bytes=Buffer.from(canonicalJson(body),'utf8');
+      if(!cryptoVerify(null,Buffer.concat([DOMAIN,bytes]),verifyKey.publicKey,signature)) throw new Error('search cursor signature invalid');
+      return body;
+    }
+  });
+}
+
+export const SEARCH_CURSOR_SCHEMA=SCHEMA;