deadbyte-mcp 0.8.10 → 0.10.0

package/src/mcp-server.mjs

@@ -24,6 +24,8 @@ import { createProcessRuntime } from './process-runtime.mjs';
 import { registerProcessTools } from './process-mcp-tools.mjs';
 import { createCodingRuntime, loadCodingPolicy } from './coding-plane.mjs';
 import { createCodingTaskRuntime } from './coding-task-runtime.mjs';
+import { createSemanticCodeRuntime } from './semantic-code.mjs';
+import { loadSemanticLspBackends, semanticConfigBindingFromEnv } from './semantic-lsp-config.mjs';
 import { registerCodingTools } from './coding-mcp-tools.mjs';
 import { createMachineFsRuntime } from './machine-fs.mjs';
 import { registerMachineFsTools } from './machine-fs-mcp-tools.mjs';
@@ -36,6 +38,9 @@ import { startAutonomousSupervisor } from './autonomous-supervisor.mjs';
 import { registerAutonomousTools } from './autonomous-mcp-tools.mjs';
 import { createToolAudit, installToolAudit } from './tool-audit.mjs';
 import { createAuditContextProvider } from './audit-context.mjs';
+import { registerOperatorSurface } from './operator-surface.mjs';
+import { capabilityProfileFromEnv, COMPACT_SURFACE_TOOL_LIMIT, R36_CAPABILITY_LEDGER } from './capability-ledger.mjs';
+import { registerCompactGatewayTools } from './compact-gateway-mcp-tools.mjs';
 import {
   containedTransformOutputSchema,
   evidenceVerifyOutputSchema,
@@ -55,6 +60,7 @@ const verifyKeyPath = process.env.DEADBYTE_VERIFY_KEY ?? defaultPublicKeyPath();
 const auditRuntimeMode = process.env.DEADBYTE_AUDIT_RUNTIME ?? '0';
 if (!['0','1'].includes(auditRuntimeMode)) throw new Error('DEADBYTE_AUDIT_RUNTIME must be 0 or 1');
 const runtimeStateRoot = path.resolve(process.env.DEADBYTE_STATE_ROOT || path.join(os.homedir(),'.deadbyte-mcp'));
+const surfaceProfile = capabilityProfileFromEnv(process.env);
 const localPrivilegedPolicyPath = path.join(packageRoot, 'controller', 'deadbyte-host-policy.json');
 let privilegedPolicyPath = process.env.DEADBYTE_PRIVILEGED_POLICY ?? '';
 if (!privilegedPolicyPath) {
@@ -99,6 +105,11 @@ if (codingRuntimeMode === '1' && !codingPolicyPath) throw new Error('DEADBYTE_CO
 const codingPolicy = codingRuntimeMode === '1' ? await loadCodingPolicy(codingPolicyPath) : null;
 const codingRuntime = codingPolicy ? createCodingRuntime({ policy: codingPolicy, signingKeyPath, verifyKeyPath }) : null;
 const codingTaskRuntime = codingRuntime ? createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyKeyPath }) : null;
+const semanticLspBinding = semanticConfigBindingFromEnv(process.env);
+const semanticLsp = codingRuntime && semanticLspBinding
+  ? await loadSemanticLspBackends({ ...semanticLspBinding, codingRuntime })
+  : { backends: [], required_ids: [] };
+let semanticRuntime = null;
 const machineFsRuntimeMode = process.env.DEADBYTE_MACHINE_FS_RUNTIME ?? '0';
 if (!['0','1'].includes(machineFsRuntimeMode)) throw new Error('DEADBYTE_MACHINE_FS_RUNTIME must be 0 or 1');
 if (machineFsRuntimeMode === '1' && !codingPolicy) throw new Error('DEADBYTE_MACHINE_FS_RUNTIME=1 requires DEADBYTE_CODING_RUNTIME=1');
@@ -116,6 +127,10 @@ const observationRuntime = observationRuntimeMode === '1'
 
 const autonomousRuntimeMode = process.env.DEADBYTE_AUTONOMOUS_RUNTIME ?? '0';
 if (!['0','1'].includes(autonomousRuntimeMode)) throw new Error('DEADBYTE_AUTONOMOUS_RUNTIME must be 0 or 1');
+const autonomousSupervisorMode = process.env.DEADBYTE_AUTONOMOUS_SUPERVISOR_MODE ?? 'in_process';
+if (!['in_process','external'].includes(autonomousSupervisorMode)) {
+  throw new Error('DEADBYTE_AUTONOMOUS_SUPERVISOR_MODE must be in_process or external');
+}
 if (autonomousRuntimeMode === '1' && !codingRuntime) throw new Error('DEADBYTE_AUTONOMOUS_RUNTIME=1 requires DEADBYTE_CODING_RUNTIME=1');
 const localAutonomousPolicyPath = path.join(packageRoot,'controller','deadbyte-autonomous-policy.json');
 let autonomousPolicyPath = process.env.DEADBYTE_AUTONOMOUS_POLICY ?? '';
@@ -125,10 +140,12 @@ if (autonomousRuntimeMode === '1' && !autonomousPolicyPath) {
 }
 if (autonomousRuntimeMode === '1' && !autonomousPolicyPath) throw new Error('DEADBYTE_AUTONOMOUS_RUNTIME=1 requires an autonomous policy');
 const autonomousPolicy = autonomousRuntimeMode === '1' ? await loadAutonomousPolicy(autonomousPolicyPath,codingPolicy) : null;
-const nativeDiffRuntime = autonomousPolicy ? createNativeDiffRuntime({ policy:autonomousPolicy,codingRuntime,signingKeyPath,verifyKeyPath }) : null;
+const nativeDiffRuntime = autonomousPolicy ? createNativeDiffRuntime({ policy:autonomousPolicy,codingRuntime,machineFsRuntime,signingKeyPath,verifyKeyPath }) : null;
+semanticRuntime = codingRuntime ? createSemanticCodeRuntime({ codingRuntime, backends: semanticLsp.backends, nativeDiffRuntime }) : null;
 const autonomousRuntime = autonomousPolicy ? createAutonomousRuntime({ policy:autonomousPolicy,codingRuntime,nativeDiffRuntime,
-  machineFsRuntime,observationRuntime,processRuntime,signingKeyPath,verifyKeyPath }) : null;
-const autonomousSupervisor = autonomousRuntime && autonomousPolicy.planner.backend === 'openai_compatible'
+  machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,signingKeyPath,verifyKeyPath }) : null;
+const autonomousSupervisor = autonomousRuntime && autonomousPolicy.planner.backend === 'openai_compatible' &&
+  autonomousSupervisorMode === 'in_process'
   ? startAutonomousSupervisor({ runtime: autonomousRuntime, policy: autonomousPolicy })
   : null;
 void autonomousSupervisor;
@@ -156,10 +173,22 @@ function textResult(schema, object, isError = false) {
   return structuredToolResult(schema, object, isError);
 }
 
+const COMPACT_CODING_DIRECT_TOOLS=new Set([
+  'coding_session_status','coding_tree','coding_symbol_replace','coding_file_read','coding_file_write',
+  'coding_text_replace','coding_command_run','coding_benchmark_run','coding_receipt_verify',
+  'coding_task_submit','coding_task_run','coding_task_status','coding_task_events','coding_task_cancel',
+  'coding_task_approve','coding_task_verify'
+]);
+function filteredToolServer(server,allowed){
+  return {registerTool(name,...args){if(allowed.has(name)) return server.registerTool(name,...args);}};
+}
+
 serveStdio(() => {
   const server = new McpServer({ name: 'deadbyte-mcp', version: DEADBYTE_VERSION });
+  registerOperatorSurface(server,{packageRoot,surfaceProfile,compactToolLimit:COMPACT_SURFACE_TOOL_LIMIT});
   if (toolAudit) installToolAudit(server,toolAudit);
 
+  if (surfaceProfile === 'full') {
   server.registerTool(
     'workspace_open',
     {
@@ -275,6 +304,8 @@ serveStdio(() => {
     }
   );
 
+  }
+
   server.registerTool(
     'evidence_verify',
     {
@@ -305,23 +336,24 @@ serveStdio(() => {
     });
   }
 
-  if (agentRuntime) {
+  if (agentRuntime && surfaceProfile === 'full') {
     registerAgentTools(server, { runtime: agentRuntime, workspacePathFromId });
   }
 
-  if (processRuntime) {
+  if (processRuntime && surfaceProfile === 'full') {
     registerProcessTools(server, { runtime: processRuntime });
   }
 
-  if (codingRuntime && codingTaskRuntime) {
-    registerCodingTools(server, { codingRuntime, taskRuntime: codingTaskRuntime });
+  if (codingRuntime && codingTaskRuntime && semanticRuntime) {
+    const codingServer=surfaceProfile==='full'?server:filteredToolServer(server,COMPACT_CODING_DIRECT_TOOLS);
+    registerCodingTools(codingServer, { codingRuntime, taskRuntime: codingTaskRuntime, semanticRuntime });
   }
 
-  if (machineFsRuntime) {
+  if (machineFsRuntime && surfaceProfile === 'full') {
     registerMachineFsTools(server, { runtime: machineFsRuntime });
   }
 
-  if (observationRuntime) {
+  if (observationRuntime && surfaceProfile === 'full') {
     registerObservationTools(server, { runtime: observationRuntime });
   }
 
@@ -329,6 +361,11 @@ serveStdio(() => {
     registerAutonomousTools(server, { autonomousRuntime, nativeDiffRuntime });
   }
 
+  registerCompactGatewayTools(server,{
+    profile:surfaceProfile,ledger:R36_CAPABILITY_LEDGER,codingRuntime,semanticRuntime,machineFsRuntime,
+    processRuntime,observationRuntime,machineRuntime
+  });
+
   if (hostPolicy) {
     server.registerTool(
       'host_file_read',

package/src/native-diff-v2.mjs

@@ -0,0 +1,337 @@
+import { createHash, sign as cryptoSign, verify as cryptoVerify } from 'node:crypto';
+import { access, mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { canonicalJson } from './canonical-json.mjs';
+import { validatePortableRelativePath } from './path-policy.mjs';
+import { loadPrivateSigningKey, loadPublicVerifyKey } from './trust.mjs';
+import { assertAutonomousArmed } from './autonomous-policy.mjs';
+
+export const NATIVE_DIFF_V2_SCHEMA='deadbyte.native-diff.v2';
+export const NATIVE_DIFF_V2_PREIMAGE_SCHEMA='deadbyte.native-diff-preimage.v2';
+export const NATIVE_DIFF_V2_EVENT_SCHEMA='deadbyte.native-diff-event.v2';
+export const NATIVE_DIFF_V2_RECEIPT_SCHEMA='deadbyte.native-diff-receipt.v2';
+const SHA256_RE=/^[0-9a-f]{64}$/;
+const DIFF_ID_RE=/^[0-9a-f]{64}$/;
+const ZERO_HASH='0'.repeat(64);
+const DIFF_DOMAIN=Buffer.from('DEADBYTE-NATIVE-DIFF-V2\0');
+const PREIMAGE_DOMAIN=Buffer.from('DEADBYTE-NATIVE-DIFF-PREIMAGE-V2\0');
+const EVENT_DOMAIN=Buffer.from('DEADBYTE-NATIVE-DIFF-EVENT-V2\0');
+const RECEIPT_DOMAIN=Buffer.from('DEADBYTE-NATIVE-DIFF-RECEIPT-V2\0');
+const sha256Bytes=bytes=>createHash('sha256').update(bytes).digest('hex');
+const sha256Object=value=>sha256Bytes(Buffer.from(canonicalJson(value),'utf8'));
+const exists=file=>access(file).then(()=>true,()=>false);
+const emptyDirectoryIdentity=()=>sha256Object({kind:'directory',entries:[]});
+
+function signEnvelope(key,domain,body){
+  const bytes=Buffer.from(canonicalJson(body),'utf8');
+  const signature=cryptoSign(null,Buffer.concat([domain,bytes]),key.privateKey).toString('base64');
+  return {...body,attestation:{algorithm:'ed25519',key_id:key.keyId,signature_base64:signature}};
+}
+function verifyEnvelope(key,domain,envelope,label){
+  const {attestation,...body}=envelope??{};
+  if(attestation?.algorithm!=='ed25519'||attestation?.key_id!==key.keyId||typeof attestation?.signature_base64!=='string') throw new Error(`${label} signature metadata mismatch`);
+  const signature=Buffer.from(attestation.signature_base64,'base64');
+  if(signature.length!==64||signature.toString('base64')!==attestation.signature_base64) throw new Error(`${label} signature encoding mismatch`);
+  const bytes=Buffer.from(canonicalJson(body),'utf8');
+  if(!cryptoVerify(null,Buffer.concat([domain,bytes]),key.publicKey,signature)) throw new Error(`${label} signature verification failed`);
+  return body;
+}
+function receiptIdFor(diffId,index,phase){return sha256Object({schema:'deadbyte.native-diff-v2-operation-receipt-id.v1',diff_id:diffId,index,phase}).slice(0,24);}
+function portable(value,label='path'){
+  if(typeof value!=='string') throw new Error(`native diff ${label} invalid`);
+  validatePortableRelativePath(value);
+  return value.replaceAll('\\','/');
+}
+function decodeWriteContent(content,encoding){
+  if(typeof content!=='string') throw new Error('native diff write content must be string');
+  if(encoding==='utf8') return Buffer.from(content,'utf8');
+  if(encoding==='base64'&&/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(content)) return Buffer.from(content,'base64');
+  throw new Error('native diff write encoding invalid');
+}
+function normalizeRawOperations(operations,policy){
+  if(!Array.isArray(operations)||operations.length<1||operations.length>policy.limits.max_files_per_diff) throw new Error(`native diff operations must contain 1-${policy.limits.max_files_per_diff} entries`);
+  let payloadBytes=0; const claimed=new Set();
+  const claim=(value,label)=>{const key=value.toLowerCase();if(claimed.has(key))throw new Error(`native diff topology path repeated '${value}' (${label})`);claimed.add(key);};
+  const normalized=operations.map((raw,index)=>{
+    if(!raw||typeof raw!=='object'||Array.isArray(raw)) throw new Error(`native diff operation ${index} malformed`);
+    if(raw.kind==='move'){
+      const source_path=portable(raw.source_path,'source_path'); const destination_path=portable(raw.destination_path,'destination_path');
+      if(source_path.toLowerCase()===destination_path.toLowerCase()) throw new Error('native diff move source and destination must differ');
+      claim(source_path,'move source'); claim(destination_path,'move destination');
+      if(!SHA256_RE.test(raw.expected_source_identity??'')) throw new Error('native diff move expected_source_identity invalid');
+      const expected_destination_identity=raw.expected_destination_identity??'absent';
+      if(expected_destination_identity!=='absent'&&!SHA256_RE.test(expected_destination_identity)) throw new Error('native diff move expected_destination_identity invalid');
+      if(expected_destination_identity!=='absent') throw new Error('native diff V2 existing-destination replacement is not allowed; use an explicit preconditioned removal before move');
+      return {kind:'move',source_path,destination_path,expected_source_identity:raw.expected_source_identity,expected_destination_identity};
+    }
+    const pathValue=portable(raw.path);
+    claim(pathValue,raw.kind??'unknown');
+    if(raw.kind==='mkdir') return {kind:'mkdir',path:pathValue,expected:'absent'};
+    if(raw.kind==='rmdir'){
+      if(!SHA256_RE.test(raw.expected_source_identity??'')) throw new Error('native diff rmdir expected_source_identity invalid');
+      return {kind:'rmdir',path:pathValue,expected_source_identity:raw.expected_source_identity};
+    }
+    if(raw.kind==='write'){
+      const encoding=raw.encoding??'utf8'; const bytes=decodeWriteContent(raw.content,encoding); payloadBytes+=bytes.length;
+      if(raw.expected_sha256!=='absent'&&!SHA256_RE.test(raw.expected_sha256??'')) throw new Error('native diff write expected_sha256 invalid');
+      return {kind:'write',path:pathValue,content:raw.content,encoding,expected_sha256:raw.expected_sha256,content_sha256:sha256Bytes(bytes)};
+    }
+    if(raw.kind==='replace'){
+      if(!SHA256_RE.test(raw.expected_sha256??'')) throw new Error('native diff replace expected_sha256 invalid');
+      if(typeof raw.old_string!=='string'||raw.old_string.length<1||raw.old_string.length>262144) throw new Error('native diff old_string invalid');
+      if(typeof raw.new_string!=='string'||raw.new_string.length>524288) throw new Error('native diff new_string invalid');
+      const expected_replacements=raw.expected_replacements??1;
+      if(!Number.isInteger(expected_replacements)||expected_replacements<1||expected_replacements>64) throw new Error('native diff expected_replacements invalid');
+      payloadBytes+=Buffer.byteLength(raw.old_string)+Buffer.byteLength(raw.new_string);
+      return {kind:'replace',path:pathValue,expected_sha256:raw.expected_sha256,old_string:raw.old_string,new_string:raw.new_string,expected_replacements,old_sha256:sha256Bytes(Buffer.from(raw.old_string)),new_sha256:sha256Bytes(Buffer.from(raw.new_string))};
+    }
+    if(raw.kind==='delete'){
+      if(!SHA256_RE.test(raw.expected_sha256??'')) throw new Error('native diff delete expected_sha256 invalid');
+      return {kind:'delete',path:pathValue,expected_sha256:raw.expected_sha256};
+    }
+    throw new Error(`native diff operation ${index} kind invalid`);
+  });
+  if(payloadBytes>policy.limits.max_diff_bytes) throw new Error(`native diff payload exceeds ${policy.limits.max_diff_bytes} bytes`);
+  return {normalized,payloadBytes};
+}
+function diffContext(policy,diffId){
+  if(!DIFF_ID_RE.test(diffId??'')) throw new Error('invalid native diff_id');
+  const dir=path.join(policy.evidence_dir,'native-diffs',diffId);
+  return {dir,diffPath:path.join(dir,'diff.json'),preimagePath:path.join(dir,'preimage.json'),eventsDir:path.join(dir,'events'),receiptPath:path.join(dir,'apply-receipt.json')};
+}
+async function writeExclusive(file,value){await writeFile(file,`${canonicalJson(value)}\n`,{flag:'wx'});}
+async function readEnvelope(file,key,domain,label){const parsed=JSON.parse(await readFile(file,'utf8'));verifyEnvelope(key,domain,parsed,label);return parsed;}
+
+export function createNativeDiffV2Runtime({policy,codingRuntime,machineFsRuntime,signingKeyPath,verifyKeyPath}){
+  if(!policy||!codingRuntime?.policy) throw new Error('native diff V2 requires autonomous and coding policy');
+  if(!machineFsRuntime?.state||!machineFsRuntime?.removeEmptyDir) throw new Error('native diff V2 requires machine fs topology runtime');
+  if(!signingKeyPath||!verifyKeyPath) throw new Error('native diff V2 requires trust keys');
+
+  async function materializeOperations(rootId,rawOperations){
+    if(!policy.root_ids.includes(rootId)) throw new Error(`native diff root '${rootId}' is not allowed`);
+    await assertAutonomousArmed(policy,rootId);
+    const {normalized,payloadBytes}=normalizeRawOperations(rawOperations,policy);
+    const operations=[];
+    for(const op of normalized){
+      if(op.kind==='mkdir'){
+        const state=await machineFsRuntime.state({rootId,relativePath:op.path});
+        if(state.exists) throw new Error(`native diff mkdir precondition '${op.path}' expected absent`);
+        operations.push({...op,before_identity_sha256:null,after_identity_sha256:emptyDirectoryIdentity()});
+        continue;
+      }
+      if(op.kind==='move'){
+        const source=await machineFsRuntime.state({rootId,relativePath:op.source_path});
+        const destination=await machineFsRuntime.state({rootId,relativePath:op.destination_path});
+        if(!source.exists||source.identity_sha256!==op.expected_source_identity) throw new Error(`native diff move source identity precondition mismatch '${op.source_path}'`);
+        if(destination.exists) throw new Error(`native diff move destination precondition expected absent '${op.destination_path}'`);
+        operations.push({...op,source_kind:source.kind,before_source_identity_sha256:source.identity_sha256,before_destination_identity_sha256:null,after_source_identity_sha256:null,after_destination_identity_sha256:source.identity_sha256});
+        continue;
+      }
+      if(op.kind==='rmdir'){
+        const state=await machineFsRuntime.state({rootId,relativePath:op.path});
+        if(!state.exists||state.kind!=='directory'||state.identity_sha256!==op.expected_source_identity) throw new Error(`native diff rmdir identity precondition mismatch '${op.path}'`);
+        const page=await machineFsRuntime.list({rootId,relativePath:op.path,limit:1});
+        if(page.entries.length!==0) throw new Error(`native diff rmdir requires empty directory '${op.path}'`);
+        operations.push({...op,before_identity_sha256:state.identity_sha256,after_identity_sha256:null});
+        continue;
+      }
+      const current=await codingRuntime.fileState({rootId,relativePath:op.path});
+      if(op.expected_sha256==='absent'){
+        if(current.exists) throw new Error(`native diff precondition '${op.path}' expected absent, found ${current.sha256}`);
+      }else if(!current.exists||current.sha256!==op.expected_sha256) throw new Error(`native diff precondition '${op.path}' mismatch`);
+      if(op.kind==='write') operations.push({...op,before_sha256:current.sha256,after_sha256:op.content_sha256});
+      else if(op.kind==='delete') operations.push({...op,before_sha256:current.sha256,after_sha256:null});
+      else{
+        const read=await codingRuntime.fileRead({rootId,relativePath:op.path,encoding:'utf8'});
+        const count=read.content.split(op.old_string).length-1;
+        if(count!==op.expected_replacements) throw new Error(`native diff replace '${op.path}' expected ${op.expected_replacements} matches, found ${count}`);
+        const next=read.content.split(op.old_string).join(op.new_string);
+        operations.push({...op,before_sha256:current.sha256,after_sha256:sha256Bytes(Buffer.from(next,'utf8'))});
+      }
+    }
+    const finalPresentPaths=[];
+    for(const op of operations){
+      if(['write','replace','mkdir'].includes(op.kind)) finalPresentPaths.push(op.path);
+      else if(op.kind==='move') finalPresentPaths.push(op.destination_path);
+    }
+    const finalized=operations.map(op=>{
+      if(op.kind!=='mkdir') return op;
+      const terminal_children=finalPresentPaths
+        .filter(candidate=>candidate!==op.path&&path.posix.dirname(candidate)===op.path)
+        .map(candidate=>path.posix.basename(candidate))
+        .sort((a,b)=>a.localeCompare(b,'en'));
+      return {...op,terminal_children};
+    });
+    return {operations:finalized,payloadBytes};
+  }
+
+  async function preview({rootId,operations:rawOperations,title='',applicationScope=null}){
+    if(typeof title!=='string'||title.length>160) throw new Error('native diff title must be <=160 characters');
+    if(applicationScope!==null&&!SHA256_RE.test(applicationScope)) throw new Error('native diff application_scope must be SHA-256 or null');
+    const {operations,payloadBytes}=await materializeOperations(rootId,rawOperations);
+    const identity={schema:NATIVE_DIFF_V2_SCHEMA,policy_sha256:policy.policy_sha256,coding_policy_sha256:policy.coding_policy_sha256,root_id:rootId,title,operations,...(applicationScope===null?{}:{application_scope:applicationScope})};
+    const diffId=sha256Object(identity); const ctx=diffContext(policy,diffId); const signing=await loadPrivateSigningKey(signingKeyPath);
+    const envelope=signEnvelope(signing,DIFF_DOMAIN,{...identity,diff_id:diffId,created_at_utc:new Date().toISOString()});
+    await mkdir(ctx.dir,{recursive:true}); await mkdir(ctx.eventsDir,{recursive:true});
+    if(await exists(ctx.diffPath)){
+      const verifyKey=await loadPublicVerifyKey(verifyKeyPath); const existing=await readEnvelope(ctx.diffPath,verifyKey,DIFF_DOMAIN,'native diff V2');
+      const {created_at_utc:_a,attestation:_b,...a}=existing; const {created_at_utc:_c,attestation:_d,...b}=envelope;
+      if(canonicalJson(a)!==canonicalJson(b)) throw new Error('native diff V2 id collision');
+    }else await writeExclusive(ctx.diffPath,envelope);
+    return {status:'ready',schema:NATIVE_DIFF_V2_SCHEMA,diff_id:diffId,root_id:rootId,operation_count:operations.length,payload_bytes:payloadBytes,
+      paths:operations.flatMap(op=>op.kind==='move'?[op.source_path,op.destination_path]:[op.path]),
+      operations:operations.map(({content,old_string,new_string,...op})=>op)};
+  }
+
+  async function loadDiff(diffId){
+    const ctx=diffContext(policy,diffId); const verifyKey=await loadPublicVerifyKey(verifyKeyPath); const envelope=await readEnvelope(ctx.diffPath,verifyKey,DIFF_DOMAIN,'native diff V2');
+    const {attestation:_a,created_at_utc:_b,diff_id:claimed,...identity}=envelope;
+    if(claimed!==diffId||identity.schema!==NATIVE_DIFF_V2_SCHEMA||identity.policy_sha256!==policy.policy_sha256||identity.coding_policy_sha256!==policy.coding_policy_sha256||sha256Object(identity)!==diffId) throw new Error('native diff V2 identity/hash mismatch');
+    return {ctx,envelope,identity};
+  }
+  async function readEvents(ctx){
+    const verifyKey=await loadPublicVerifyKey(verifyKeyPath); const names=(await readdir(ctx.eventsDir)).filter(x=>/^\d{6}\.json$/.test(x)).sort(); const events=[]; let previous=ZERO_HASH;
+    for(let i=0;i<names.length;i+=1){const expected=`${String(i+1).padStart(6,'0')}.json`;if(names[i]!==expected)throw new Error(`native diff V2 event gap at ${expected}`);const event=await readEnvelope(path.join(ctx.eventsDir,names[i]),verifyKey,EVENT_DOMAIN,'native diff V2 event');const {attestation:_a,event_sha256:claimed,...body}=event;if(event.schema!==NATIVE_DIFF_V2_EVENT_SCHEMA||event.seq!==i+1||event.prev_sha256!==previous||!SHA256_RE.test(claimed??'')||sha256Object(body)!==claimed)throw new Error(`native diff V2 event ${expected} invalid`);events.push(event);previous=claimed;}
+    return events;
+  }
+  async function appendEvent(ctx,events,diffId,type,payload={}){
+    const body={schema:NATIVE_DIFF_V2_EVENT_SCHEMA,diff_id:diffId,seq:events.length+1,created_at_utc:new Date().toISOString(),prev_sha256:events.at(-1)?.event_sha256??ZERO_HASH,type,payload};
+    const signing=await loadPrivateSigningKey(signingKeyPath); const event=signEnvelope(signing,EVENT_DOMAIN,{...body,event_sha256:sha256Object(body)}); await writeExclusive(path.join(ctx.eventsDir,`${String(event.seq).padStart(6,'0')}.json`),event);events.push(event);return event;
+  }
+  async function snapshotFor(rootId,op){
+    if(['write','replace','delete'].includes(op.kind)){
+      const state=await codingRuntime.fileState({rootId,relativePath:op.path});
+      if(state.exists){const read=await codingRuntime.fileRead({rootId,relativePath:op.path,encoding:'base64'});return {kind:op.kind,path:op.path,existed:true,sha256:state.sha256,bytes:read.bytes,content_base64:read.content};}
+      return {kind:op.kind,path:op.path,existed:false,sha256:null,bytes:0,content_base64:null};
+    }
+    if(op.kind==='move'){
+      const source=await machineFsRuntime.state({rootId,relativePath:op.source_path}); const destination=await machineFsRuntime.state({rootId,relativePath:op.destination_path});
+      return {kind:'move',source_path:op.source_path,destination_path:op.destination_path,source_exists:source.exists,source_identity_sha256:source.identity_sha256,destination_exists:destination.exists,destination_identity_sha256:destination.identity_sha256};
+    }
+    const state=await machineFsRuntime.state({rootId,relativePath:op.path});
+    return {kind:op.kind,path:op.path,exists:state.exists,object_kind:state.kind,identity_sha256:state.identity_sha256};
+  }
+  async function snapshotMatchesBefore(rootId,op,snap){
+    if(['write','replace','delete'].includes(op.kind)){
+      const state=await codingRuntime.fileState({rootId,relativePath:op.path}); return snap.existed?state.exists&&state.sha256===snap.sha256:!state.exists;
+    }
+    if(op.kind==='move'){
+      const s=await machineFsRuntime.state({rootId,relativePath:op.source_path}); const d=await machineFsRuntime.state({rootId,relativePath:op.destination_path});
+      return s.exists===snap.source_exists&&s.identity_sha256===snap.source_identity_sha256&&d.exists===snap.destination_exists&&d.identity_sha256===snap.destination_identity_sha256;
+    }
+    const s=await machineFsRuntime.state({rootId,relativePath:op.path}); return s.exists===snap.exists&&s.identity_sha256===snap.identity_sha256;
+  }
+  async function ensurePreimage(ctx,diffId,identity){
+    const verifyKey=await loadPublicVerifyKey(verifyKeyPath);
+    if(await exists(ctx.preimagePath)){const stored=await readEnvelope(ctx.preimagePath,verifyKey,PREIMAGE_DOMAIN,'native diff V2 preimage');const {attestation:_a,preimage_sha256:claimed,...body}=stored;if(body.schema!==NATIVE_DIFF_V2_PREIMAGE_SCHEMA||body.diff_id!==diffId||!SHA256_RE.test(claimed??'')||sha256Object(body)!==claimed)throw new Error('native diff V2 preimage hash mismatch');return stored;}
+    const snapshots=[]; for(const op of identity.operations){const snap=await snapshotFor(identity.root_id,op);if(!(await snapshotMatchesBefore(identity.root_id,op,snap)))throw new Error('native diff V2 preimage changed while capturing');snapshots.push(snap);}
+    const body={schema:NATIVE_DIFF_V2_PREIMAGE_SCHEMA,diff_id:diffId,policy_sha256:policy.policy_sha256,root_id:identity.root_id,created_at_utc:new Date().toISOString(),snapshots};
+    const signing=await loadPrivateSigningKey(signingKeyPath); const envelope=signEnvelope(signing,PREIMAGE_DOMAIN,{...body,preimage_sha256:sha256Object(body)}); await writeExclusive(ctx.preimagePath,envelope); return envelope;
+  }
+
+  async function fileStateMatches(rootId,op,which){const state=await codingRuntime.fileState({rootId,relativePath:op.path});const expected=which==='before'?op.before_sha256:op.after_sha256;return expected===null?!state.exists:state.exists&&state.sha256===expected;}
+  async function topologyStateMatches(rootId,op,which){
+    if(op.kind==='move'){
+      const s=await machineFsRuntime.state({rootId,relativePath:op.source_path}); const d=await machineFsRuntime.state({rootId,relativePath:op.destination_path});
+      if(which==='before') return s.exists&&s.identity_sha256===op.before_source_identity_sha256&&!d.exists;
+      return !s.exists&&d.exists&&d.identity_sha256===op.after_destination_identity_sha256;
+    }
+    const s=await machineFsRuntime.state({rootId,relativePath:op.path}); const expected=which==='before'?op.before_identity_sha256:op.after_identity_sha256;
+    return expected===null?!s.exists:s.exists&&s.identity_sha256===expected;
+  }
+  const stateMatches=(rootId,op,which)=>['write','replace','delete'].includes(op.kind)?fileStateMatches(rootId,op,which):topologyStateMatches(rootId,op,which);
+  async function terminalStateMatches(rootId,op){
+    if(op.kind!=='mkdir') return stateMatches(rootId,op,'after');
+    const state=await machineFsRuntime.state({rootId,relativePath:op.path});
+    if(!state.exists||state.kind!=='directory') return false;
+    const names=[]; let cursor=null;
+    do{
+      const page=await machineFsRuntime.list({rootId,relativePath:op.path,limit:1000,cursor});
+      names.push(...page.entries.map(item=>path.posix.basename(item.path)));
+      cursor=page.next_cursor;
+      if(names.length>4096) return false;
+    }while(cursor!==null);
+    names.sort((a,b)=>a.localeCompare(b,'en'));
+    const expected=[...(op.terminal_children??[])].sort((a,b)=>a.localeCompare(b,'en'));
+    return canonicalJson(names)===canonicalJson(expected);
+  }
+  const receiptClass=op=>['mkdir','move','rmdir'].includes(op.kind)?'machine_fs':'coding';
+  async function verifyOperationReceipt(op,receiptId){return receiptClass(op)==='coding'?codingRuntime.verifyReceiptDetailed(receiptId):machineFsRuntime.verifyReceipt(receiptId);}
+  async function executeOperation(diffId,rootId,op,index,phase='apply'){
+    const receiptId=receiptIdFor(diffId,index,phase); const existing=await verifyOperationReceipt(op,receiptId);
+    if(existing.ok) return {recovered:true,receipt_id:receiptId,receipt_sha256:existing.receipt_sha256,request_sha256:existing.request_sha256,operation:existing.operation,receipt_class:receiptClass(op)};
+    let result;
+    if(op.kind==='write') result=await codingRuntime.fileWrite({rootId,relativePath:op.path,content:op.content,encoding:op.encoding,expectedSha256:op.expected_sha256,receiptId});
+    else if(op.kind==='replace') result=await codingRuntime.textReplace({rootId,relativePath:op.path,oldString:op.old_string,newString:op.new_string,expectedSha256:op.expected_sha256,expectedReplacements:op.expected_replacements,receiptId});
+    else if(op.kind==='delete') result=await codingRuntime.fileDelete({rootId,relativePath:op.path,expectedSha256:op.expected_sha256,receiptId});
+    else if(op.kind==='mkdir') result=await machineFsRuntime.mkdir({rootId,relativePath:op.path,receiptId});
+    else if(op.kind==='move') result=await machineFsRuntime.move({rootId,sourcePath:op.source_path,destinationPath:op.destination_path,expectedSourceIdentity:op.expected_source_identity,receiptId});
+    else result=await machineFsRuntime.removeEmptyDir({rootId,relativePath:op.path,expectedSourceIdentity:op.expected_source_identity,receiptId});
+    const checked=await verifyOperationReceipt(op,receiptId); if(!checked.ok||checked.receipt_sha256!==result.receipt_sha256||checked.request_sha256!==result.request_sha256)throw new Error(`native diff V2 operation receipt verification failed index ${index}`);
+    return {recovered:false,receipt_id:receiptId,receipt_sha256:checked.receipt_sha256,request_sha256:checked.request_sha256,operation:checked.operation,receipt_class:receiptClass(op)};
+  }
+
+  async function rollbackToPreimage(diffId,identity,preimage){
+    const receipts=[];
+    for(let index=identity.operations.length-1;index>=0;index-=1){
+      const op=identity.operations[index]; const snap=preimage.snapshots[index];
+      if(await snapshotMatchesBefore(identity.root_id,op,snap)) continue;
+      if(!(await stateMatches(identity.root_id,op,'after'))) throw new Error(`native diff V2 rollback_conflict index ${index}`);
+      const receiptId=receiptIdFor(diffId,index,'rollback'); let result; let klass=receiptClass(op);
+      if(['write','replace','delete'].includes(op.kind)){
+        const current=await codingRuntime.fileState({rootId:identity.root_id,relativePath:op.path});
+        if(snap.existed) result=await codingRuntime.fileWrite({rootId:identity.root_id,relativePath:op.path,content:snap.content_base64,encoding:'base64',expectedSha256:current.exists?current.sha256:'absent',receiptId});
+        else result=await codingRuntime.fileDelete({rootId:identity.root_id,relativePath:op.path,expectedSha256:current.sha256,receiptId});
+      }else if(op.kind==='mkdir'){
+        result=await machineFsRuntime.removeEmptyDir({rootId:identity.root_id,relativePath:op.path,expectedSourceIdentity:op.after_identity_sha256,receiptId});
+      }else if(op.kind==='move'){
+        result=await machineFsRuntime.move({rootId:identity.root_id,sourcePath:op.destination_path,destinationPath:op.source_path,expectedSourceIdentity:op.after_destination_identity_sha256,receiptId});
+      }else{
+        result=await machineFsRuntime.mkdir({rootId:identity.root_id,relativePath:op.path,receiptId});
+        const restored=await machineFsRuntime.state({rootId:identity.root_id,relativePath:op.path});
+        if(!restored.exists||restored.identity_sha256!==snap.identity_sha256) throw new Error(`native diff V2 rmdir rollback identity mismatch '${op.path}'`);
+      }
+      receipts.push({index,receipt_class:klass,receipt_id:receiptId,receipt_sha256:result.receipt_sha256});
+    }
+    return receipts;
+  }
+
+  async function createApplyReceipt(ctx,diffId,identity,preimage,events){
+    const committed=events.filter(e=>e.type==='operation_committed'); if(committed.length!==identity.operations.length)throw new Error('native diff V2 cannot receipt incomplete transaction');
+    const finalStates=[];
+    for(const op of identity.operations){
+      if(!(await terminalStateMatches(identity.root_id,op))) throw new Error(`native diff V2 final state mismatch '${op.path??op.source_path}'`);
+      if(op.kind==='move') finalStates.push({kind:'move',source_path:op.source_path,destination_path:op.destination_path,source_exists:false,destination_identity_sha256:op.after_destination_identity_sha256});
+      else if(op.kind==='mkdir') finalStates.push({kind:'mkdir',path:op.path,exists:true,terminal_children:op.terminal_children??[]});
+      else finalStates.push({kind:op.kind,path:op.path,exists:op.kind!=='delete'&&op.kind!=='rmdir',sha256:op.after_sha256??null,identity_sha256:op.after_identity_sha256??null});
+    }
+    const body={schema:NATIVE_DIFF_V2_RECEIPT_SCHEMA,diff_id:diffId,policy_sha256:policy.policy_sha256,coding_policy_sha256:policy.coding_policy_sha256,preimage_sha256:preimage.preimage_sha256,event_head_sha256:events.at(-1)?.event_sha256??ZERO_HASH,completed_at_utc:new Date().toISOString(),operation_receipts:committed.map(e=>({index:e.payload.index,kind:e.payload.kind,receipt_class:e.payload.receipt_class,receipt_id:e.payload.receipt_id,receipt_sha256:e.payload.receipt_sha256,request_sha256:e.payload.request_sha256})),final_states:finalStates};
+    const receiptSha=sha256Object(body); const signing=await loadPrivateSigningKey(signingKeyPath); const receipt=signEnvelope(signing,RECEIPT_DOMAIN,{...body,receipt_sha256:receiptSha}); await writeExclusive(ctx.receiptPath,receipt); await appendEvent(ctx,events,diffId,'transaction_completed',{receipt_sha256:receiptSha}); return receipt;
+  }
+
+  async function apply({diffId,expectedOperationCount=null}){
+    const {ctx,identity}=await loadDiff(diffId);
+    if(expectedOperationCount!==null&&(!Number.isInteger(expectedOperationCount)||expectedOperationCount<1||expectedOperationCount>policy.limits.max_files_per_diff||identity.operations.length!==expectedOperationCount))throw new Error(`native diff V2 operation count mismatch: expected ${String(expectedOperationCount)}, signed ${identity.operations.length}`);
+    await assertAutonomousArmed(policy,identity.root_id); const codingStatus=await codingRuntime.sessionStatus(); if(!codingStatus.armed)throw new Error(`coding plane is disarmed: ${codingStatus.reason}`);
+    if(await exists(ctx.receiptPath)){const checked=await verify({diffId});if(!checked.ok)throw new Error(`existing native diff V2 receipt invalid: ${checked.reason}`);return {status:'existing',diff_id:diffId,receipt_sha256:checked.receipt_sha256,operation_count:identity.operations.length,current_state_matches:checked.current_state_matches};}
+    const preimage=await ensurePreimage(ctx,diffId,identity); const events=await readEvents(ctx); if(!events.some(e=>e.type==='transaction_started'))await appendEvent(ctx,events,diffId,'transaction_started',{operation_count:identity.operations.length,preimage_sha256:preimage.preimage_sha256});
+    try{
+      for(let index=0;index<identity.operations.length;index+=1){const op=identity.operations[index];const prior=events.find(e=>e.type==='operation_committed'&&e.payload?.index===index);if(prior){if(!(await stateMatches(identity.root_id,op,'after')))throw new Error(`native diff V2 committed state changed index ${index}`);continue;}let executed;if(await stateMatches(identity.root_id,op,'after')){const receiptId=receiptIdFor(diffId,index,'apply');const checked=await verifyOperationReceipt(op,receiptId);if(!checked.ok)throw new Error(`native diff V2 unreceipted mutation index ${index}`);executed={recovered:true,receipt_id:receiptId,receipt_sha256:checked.receipt_sha256,request_sha256:checked.request_sha256,operation:checked.operation,receipt_class:receiptClass(op)};}else if(await stateMatches(identity.root_id,op,'before')) executed=await executeOperation(diffId,identity.root_id,op,index);else throw new Error(`native diff V2 concurrent state conflict index ${index}`);if(!(await stateMatches(identity.root_id,op,'after')))throw new Error(`native diff V2 post-operation mismatch index ${index}`);await appendEvent(ctx,events,diffId,'operation_committed',{index,kind:op.kind,path:op.path??null,source_path:op.source_path??null,destination_path:op.destination_path??null,receipt_class:executed.receipt_class,receipt_id:executed.receipt_id,receipt_sha256:executed.receipt_sha256,request_sha256:executed.request_sha256,recovered:executed.recovered});}
+    }catch(error){try{const rollbackReceipts=await rollbackToPreimage(diffId,identity,preimage);await appendEvent(ctx,events,diffId,'transaction_rolled_back',{reason:String(error).slice(0,2048),rollback_receipts:rollbackReceipts});}catch(rollbackError){await appendEvent(ctx,events,diffId,'transaction_paused',{reason:String(error).slice(0,1024),rollback_error:String(rollbackError).slice(0,1024)}).catch(()=>{});throw new Error(`native diff V2 apply failed and rollback incomplete: ${String(error)}; ${String(rollbackError)}`);}throw new Error(`native diff V2 apply rolled back: ${String(error)}`);}
+    const receipt=await createApplyReceipt(ctx,diffId,identity,preimage,events);return {status:'committed',diff_id:diffId,receipt_sha256:receipt.receipt_sha256,operation_count:identity.operations.length,operation_receipts:receipt.operation_receipts.map(x=>({index:x.index,kind:x.kind,receipt_class:x.receipt_class,receipt_id:x.receipt_id,receipt_sha256:x.receipt_sha256}))};
+  }
+
+  async function verify({diffId}){
+    try{
+      const {ctx,identity}=await loadDiff(diffId);const verifyKey=await loadPublicVerifyKey(verifyKeyPath);const preimage=await readEnvelope(ctx.preimagePath,verifyKey,PREIMAGE_DOMAIN,'native diff V2 preimage');const events=await readEvents(ctx);const receipt=await readEnvelope(ctx.receiptPath,verifyKey,RECEIPT_DOMAIN,'native diff V2 receipt');const {attestation:_a,receipt_sha256:claimed,...body}=receipt;
+      if(body.schema!==NATIVE_DIFF_V2_RECEIPT_SCHEMA||body.diff_id!==diffId||body.policy_sha256!==policy.policy_sha256||body.coding_policy_sha256!==policy.coding_policy_sha256||!SHA256_RE.test(claimed??'')||sha256Object(body)!==claimed)return {ok:false,reason:'native diff V2 receipt identity/hash mismatch'};
+      const completion=events.at(-1);if(completion?.type!=='transaction_completed'||completion.prev_sha256!==receipt.event_head_sha256||completion.payload?.receipt_sha256!==claimed||receipt.preimage_sha256!==preimage.preimage_sha256)return {ok:false,reason:'native diff V2 receipt/event/preimage binding mismatch'};
+      if(!Array.isArray(receipt.operation_receipts)||receipt.operation_receipts.length!==identity.operations.length)return {ok:false,reason:'native diff V2 operation receipt count mismatch'};
+      let verified=0,codingVerified=0;for(let index=0;index<identity.operations.length;index+=1){const op=identity.operations[index];const bound=receipt.operation_receipts.find(x=>x.index===index);if(!bound||bound.kind!==op.kind||bound.receipt_class!==receiptClass(op))return {ok:false,reason:`native diff V2 receipt binding mismatch index ${index}`};const checked=await verifyOperationReceipt(op,bound.receipt_id);if(!checked.ok||checked.receipt_sha256!==bound.receipt_sha256||checked.request_sha256!==bound.request_sha256)return {ok:false,reason:`native diff V2 operation receipt invalid index ${index}`};verified+=1;if(bound.receipt_class==='coding')codingVerified+=1;}
+      let currentMatches=true;for(const op of identity.operations)if(!(await terminalStateMatches(identity.root_id,op)))currentMatches=false;
+      return {ok:true,diff_id:diffId,receipt_sha256:claimed,signature_valid:true,root_id:identity.root_id,operation_count:identity.operations.length,coding_receipts_verified:codingVerified,operation_receipts_verified:verified,final_states:receipt.final_states,current_state_matches:currentMatches,journal_head_sha256:completion.event_sha256};
+    }catch(error){return {ok:false,reason:String(error).slice(0,2048)};}
+  }
+
+  return Object.freeze({preview,apply,verify,policy});
+}

package/src/native-diff.mjs

@@ -5,6 +5,7 @@ import { canonicalJson } from './canonical-json.mjs';
 import { validatePortableRelativePath } from './path-policy.mjs';
 import { loadPrivateSigningKey, loadPublicVerifyKey } from './trust.mjs';
 import { assertAutonomousArmed } from './autonomous-policy.mjs';
+import { createNativeDiffV2Runtime, NATIVE_DIFF_V2_SCHEMA } from './native-diff-v2.mjs';
 
 export const NATIVE_DIFF_SCHEMA = 'deadbyte.native-diff.v1';
 export const NATIVE_DIFF_PREIMAGE_SCHEMA = 'deadbyte.native-diff-preimage.v1';
@@ -97,7 +98,7 @@ async function readEnvelope(file, key, domain, label) {
 async function writeExclusive(file, value) {
   await writeFile(file, `${canonicalJson(value)}\n`, { flag:'wx' });
 }
-export function createNativeDiffRuntime({ policy, codingRuntime, signingKeyPath, verifyKeyPath }) {
+function createNativeDiffRuntimeV1({ policy, codingRuntime, signingKeyPath, verifyKeyPath }) {
   if (!policy || !codingRuntime?.policy) throw new Error('native diff runtime requires autonomous and coding policy');
   if (!signingKeyPath || !verifyKeyPath) throw new Error('native diff runtime requires trust keys');
 
@@ -288,8 +289,11 @@ export function createNativeDiffRuntime({ policy, codingRuntime, signingKeyPath,
     return receipt;
   }
 
-  async function apply({ diffId }) {
+  async function apply({ diffId, expectedOperationCount = null }) {
     const { ctx, identity } = await loadDiff(diffId);
+    if (expectedOperationCount !== null && (!Number.isInteger(expectedOperationCount) || expectedOperationCount < 1 || expectedOperationCount > policy.limits.max_files_per_diff || identity.operations.length !== expectedOperationCount)) {
+      throw new Error(`native diff operation count mismatch: expected ${String(expectedOperationCount)}, signed ${identity.operations.length}`);
+    }
     await assertAutonomousArmed(policy, identity.root_id);
     const codingStatus = await codingRuntime.sessionStatus();
     if (!codingStatus.armed) throw new Error(`coding plane is disarmed: ${codingStatus.reason}`);
@@ -401,3 +405,47 @@ export function createNativeDiffRuntime({ policy, codingRuntime, signingKeyPath,
 
   return Object.freeze({ preview, apply, verify, policy });
 }
+
+export { NATIVE_DIFF_V2_SCHEMA };
+
+export function createNativeDiffRuntime(options) {
+  const v1=createNativeDiffRuntimeV1(options);
+  const v2=options.machineFsRuntime ? createNativeDiffV2Runtime(options) : null;
+  const isTopology=operations=>Array.isArray(operations)&&operations.some(op=>['mkdir','move','rmdir'].includes(op?.kind));
+  const diffPath=diffId=>{
+    if(!/^[0-9a-f]{64}$/.test(diffId??'')) throw new Error('invalid native diff_id');
+    return path.join(options.policy.evidence_dir,'native-diffs',diffId,'diff.json');
+  };
+  async function schemaFor(diffId){
+    const parsed=JSON.parse(await readFile(diffPath(diffId),'utf8'));
+    return parsed?.schema;
+  }
+  async function preview(args){
+    if(!isTopology(args?.operations)) return v1.preview(args);
+    if(!v2) throw new Error('native diff V2 topology requires machine fs runtime');
+    return v2.preview(args);
+  }
+  async function apply(args){
+    const schema=await schemaFor(args?.diffId);
+    if(schema===NATIVE_DIFF_SCHEMA) return v1.apply(args);
+    if(schema===NATIVE_DIFF_V2_SCHEMA){
+      if(!v2) throw new Error('native diff V2 topology requires machine fs runtime');
+      return v2.apply(args);
+    }
+    throw new Error(`unsupported native diff schema: ${String(schema)}`);
+  }
+  async function verify(args){
+    try {
+      const schema=await schemaFor(args?.diffId);
+      if(schema===NATIVE_DIFF_SCHEMA) return v1.verify(args);
+      if(schema===NATIVE_DIFF_V2_SCHEMA){
+        if(!v2) return {ok:false,reason:'native diff V2 topology requires machine fs runtime'};
+        return v2.verify(args);
+      }
+      return {ok:false,reason:`unsupported native diff schema: ${String(schema)}`};
+    } catch(error) {
+      return {ok:false,reason:String(error).slice(0,2048)};
+    }
+  }
+  return Object.freeze({preview,apply,verify,policy:options.policy});
+}

package/src/observation-smoke-client.mjs

@@ -53,8 +53,9 @@ const transport=new StdioClientTransport({command:process.execPath,args:[serverP
 const stderr=[]; transport.stderr?.on('data',chunk=>stderr.push(Buffer.from(chunk)));
 const base=['contained_transform','evidence_verify','file_read','proof_execute','workspace_open'];
 const machine=['machine_list','machine_ping','machine_revoke','machine_status'];
-const coding=['coding_benchmark_run','coding_command_run','coding_file_read','coding_file_write','coding_receipt_verify','coding_search',
-  'coding_session_status','coding_stat','coding_task_approve','coding_task_cancel','coding_task_events','coding_task_run','coding_task_status',
+const coding=['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'];
 const observation=['machine_process_list','machine_search_cancel','machine_search_page','machine_search_start','machine_search_status','machine_system_status'];
 const expected=[...base,...machine,...coding,...observation].sort();

package/src/operator-surface.mjs

@@ -0,0 +1,43 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import * as z from 'zod/v4';
+
+function userMessage(text){return {messages:[{role:'user',content:{type:'text',text}}]};}
+function workflow(goal,verb){
+  return [
+    `${verb}: ${goal}`,
+    'Read deadbyte://context only if domain vocabulary or invariants are needed.',
+    'Inspect the smallest relevant source/evidence slice; prefer semantic navigation or bounded search over whole-repo reads.',
+    'State the acceptance condition, reproduce the current behavior, then make one surgical change.',
+    'Verify with the narrow test first, then relevant regression gates. If a tool fails, change the hypothesis instead of retrying blindly.',
+    'Report observed outcome and remaining blockers; never call a claim verified without evidence.'
+  ].join('\n');
+}
+
+export function registerOperatorSurface(server,{packageRoot,surfaceProfile='full',compactToolLimit=42}){
+  if(!server||!packageRoot) throw new Error('operator surface requires server and packageRoot');
+  if(!['full','compact'].includes(surfaceProfile)) throw new Error('operator surface profile must be full or compact');
+  const contextPath=path.join(packageRoot,'CONTEXT.md');
+  const architecturePath=path.join(packageRoot,'docs','ADR-0001-PRODUCTION-BASELINE-SEAMS.md');
+  const argSchema=z.strictObject({goal:z.string().min(1).max(2000)});
+  for(const [name,title,verb] of [
+    ['deadbyte.review','Review','Review the requested code or change'],
+    ['deadbyte.patch','Patch','Patch the requested behavior'],
+    ['deadbyte.diagnose','Diagnose','Diagnose the reported failure'],
+    ['deadbyte.run-tests','Run tests','Verify the requested behavior with tests']
+  ]){
+    server.registerPrompt(name,{title,description:`Compact DEADBYTE ${title.toLowerCase()} workflow with evidence-first verification.`,argsSchema:argSchema},
+      async ({goal})=>userMessage(workflow(goal,verb)));
+  }
+  server.registerResource('deadbyte-context','deadbyte://context',{
+    title:'DEADBYTE MCP Context',description:'Canonical production vocabulary, context discipline, and Final-baseline invariants.',mimeType:'text/markdown'
+  },async uri=>({contents:[{uri:uri.href,mimeType:'text/markdown',text:await readFile(contextPath,'utf8')}]}));
+  server.registerResource('deadbyte-architecture','deadbyte://architecture',{
+    title:'DEADBYTE MCP Architecture',description:'Production module seams, tracer bullet, policy, telemetry, semantic and remote decisions.',mimeType:'text/markdown'
+  },async uri=>({contents:[{uri:uri.href,mimeType:'text/markdown',text:await readFile(architecturePath,'utf8')}]}));
+  server.registerResource('deadbyte-surface-profile','deadbyte://surface-profile',{
+    title:'DEADBYTE MCP Surface Profile',description:'Active R36 MCP surface profile and compact tool ceiling.',mimeType:'application/json'
+  },async uri=>({contents:[{uri:uri.href,mimeType:'application/json',text:JSON.stringify({
+    schema:'deadbyte.surface-profile.v1',profile:surfaceProfile,compact_tool_limit:compactToolLimit
+  })}]}));
+}