deadbyte-mcp 0.15.18 → 0.15.20

package/scripts/deploy-r48.mjs

@@ -0,0 +1,86 @@
+import { createHash } from 'node:crypto';
+import { readFile, access } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { loadPowerShellDataFile, runSlotUpdateCli } from '../src/runtime-update.mjs';
+import { parseActivePointer } from '../src/release-slot.mjs';
+
+const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+const state=path.join(os.homedir(),'.deadbyte-mcp');
+const sha=async f=>createHash('sha256').update(await readFile(f)).digest('hex');
+const sleep=ms=>new Promise(resolve=>setTimeout(resolve,ms));
+
+async function waitForActivation({handoffPath,expectedVersion,expectedManifest,timeoutMs=900000,pollMs=1000}){
+  const evidenceDir=path.dirname(path.resolve(handoffPath));
+  const statePath=path.join(evidenceDir,'state.json');
+  const receiptPath=path.join(evidenceDir,'receipt.json');
+  const failurePath=path.join(evidenceDir,'failure-receipt.json');
+  const deadline=Date.now()+timeoutMs;
+  let lastPhase='unknown';
+
+  while(Date.now()<deadline){
+    // Do not poll state.json during activation: the detached supervisor atomically replaces it,
+    // and Windows can reject that rename while a read handle is still open. Final receipt/failure
+    // files are the synchronization boundary and avoid a cross-process read/write race.
+    try{
+      const receipt=JSON.parse(await readFile(receiptPath,'utf8'));
+      const body=receipt?.body;
+      const pointer=body?.active_pointer;
+      if(body?.schema!=='deadbyte.r27-slot-update-receipt.v1') throw new Error('activation receipt schema mismatch');
+      if(body?.rollback_performed!==false) throw new Error('activation receipt reports rollback');
+      if(pointer?.version!==expectedVersion||pointer?.manifest_sha256!==expectedManifest) {
+        throw new Error('activation receipt target mismatch');
+      }
+      parseActivePointer(JSON.stringify(pointer));
+
+      const activePath=path.join(state,'active-release.json');
+      const active=parseActivePointer(await readFile(activePath,'utf8'));
+      if(active.version!==expectedVersion||active.manifest_sha256!==expectedManifest) {
+        throw new Error('active pointer does not match expected release');
+      }
+      return {receiptPath,statePath,phase:lastPhase,release_id:active.release_id};
+    }catch(error){
+      if(error?.code!=='ENOENT') throw error;
+    }
+
+    try{
+      await access(failurePath);
+      throw new Error('slot activation failure receipt detected');
+    }catch(error){
+      if(error?.code!=='ENOENT') throw error;
+    }
+    await sleep(pollMs);
+  }
+  throw new Error(`slot activation timed out after ${timeoutMs}ms; last_phase=${lastPhase}`);
+}
+
+const manifest=await sha(path.join(root,'MANIFEST.SHA256'));
+const pointer=JSON.parse(await readFile(path.join(state,'active-release.json'),'utf8'));
+const cfg=await loadPowerShellDataFile(pointer.config_path);
+const bridgeRoot=path.resolve(cfg.Bridge.WorkingDirectory);
+const bridgeScript=path.join(bridgeRoot,'src','bridge.mjs');
+const pkg=JSON.parse(await readFile(path.join(root,'package.json'),'utf8'));
+const expectedVersion=pkg.version;
+const args=[
+  '--stage',root,'--development-root',root,'--expected-version',expectedVersion,'--expected-manifest',manifest,
+  '--process-policy',path.join(root,'controller','deadbyte-process-policy.json'),'--process-policy-sha256',await sha(path.join(root,'controller','deadbyte-process-policy.json')),
+  '--desktop-policy',path.join(root,'controller','deadbyte-desktop-policy.json'),'--desktop-policy-sha256',await sha(path.join(root,'controller','deadbyte-desktop-policy.json')),
+  '--semantic-lsp-config',path.join(root,'controller','deadbyte-semantic-lsp-config.json'),'--semantic-lsp-config-sha256',await sha(path.join(root,'controller','deadbyte-semantic-lsp-config.json')),
+  '--bridge-root',bridgeRoot,'--bridge-script-sha256',await sha(bridgeScript),
+  '--enable-machine-fs','--enable-observation','--enable-desktop','--enable-autonomous-supervisor','--recover-offline-predecessor'
+];
+const result=await runSlotUpdateCli(args,{stateRoot:state});
+if(!result.handed_off) throw new Error('release activation unexpectedly completed inline; refusing to skip post-activation verification');
+const verification=await waitForActivation({handoffPath:result.handoff_path,expectedVersion,expectedManifest:manifest});
+console.log(JSON.stringify({
+  status:'activated',
+  manifest_sha256:manifest,
+  previous_release:pointer.release_id,
+  update_id:result.update_id,
+  supervisor_pid:result.supervisor_pid,
+  release_id:verification.release_id,
+  receipt_path:verification.receiptPath,
+  state_path:verification.statePath
+},null,2));

package/scripts/full-regression-r48.mjs

@@ -0,0 +1,28 @@
+import { readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const root=path.resolve(here,'..');
+const testDir=path.join(root,'test');
+const excluded=new Set(['full-max-catalog-r44.test.mjs','full-max-catalog-r45.test.mjs','full-max-catalog-r46.test.mjs']);
+const files=(await readdir(testDir,{withFileTypes:true}))
+  .filter(entry=>entry.isFile()&&entry.name.endsWith('.test.mjs')&&!excluded.has(entry.name));
+const weighted=[];
+for(const entry of files) weighted.push({path:path.join('test',entry.name),size:(await stat(path.join(testDir,entry.name))).size});
+weighted.sort((a,b)=>b.size-a.size||a.path.localeCompare(b.path,'en'));
+const batchCount=8;
+const batches=Array.from({length:batchCount},()=>[]);
+weighted.forEach((entry,index)=>batches[index%batchCount].push(entry.path));
+let total=0;
+for(let index=0;index<batchCount;index++){
+  const batch=batches[index].sort((a,b)=>a.localeCompare(b,'en'));
+  console.log(`R48-BOUNDED-REGRESSION batch=${index+1}/${batchCount} files=${batch.length}`);
+  const result=spawnSync(process.execPath,['--test','--test-concurrency=1',...batch],{cwd:root,stdio:'inherit',windowsHide:true,shell:false});
+  if(result.error) throw result.error;
+  if(result.signal) throw new Error(`regression batch ${index} terminated by ${result.signal}`);
+  if(result.status!==0) throw new Error(`regression batch ${index} failed with exit code ${result.status}`);
+  total+=batch.length;
+}
+console.log(`R48-BOUNDED-REGRESSION PASS files=${total} batches=${batchCount}`);

package/src/coding-search.mjs

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import pathModule from 'node:path';
 import { canonicalJson } from './canonical-json.mjs';
 import { decodeUtf8Strict } from './text-policy.mjs';
 import { createSequenceStream } from './workload-substrate.mjs';
@@ -55,11 +56,13 @@ function preview(text,index,length){
   const start=Math.max(0,index-48); const end=Math.min(text.length,index+Math.max(length,1)+112);
   return text.slice(start,end);
 }
-function normalizeQuery({rootId,path,target,mode,pattern,caseSensitive,maxResults,maxFileBytes,maxScanBytes,pageSize,fuzzyTimeoutMs}){
+function normalizeQuery({rootId,path,target,mode,pattern,caseSensitive,maxResults,maxFileBytes,maxScanBytes,pageSize,fuzzyTimeoutMs,includeHidden,filePattern,pathGlob,contextLines,earlyTermination}){
   return {
     schema:'deadbyte.coding-search-query.v3',root_id:rootId,path,target,mode,pattern,
     case_sensitive:caseSensitive,max_results:maxResults,max_file_bytes:maxFileBytes,
-    max_scan_bytes:maxScanBytes,page_size:pageSize,fuzzy_timeout_ms:fuzzyTimeoutMs
+    max_scan_bytes:maxScanBytes,page_size:pageSize,fuzzy_timeout_ms:fuzzyTimeoutMs,
+    include_hidden:includeHidden,file_pattern:filePattern,path_glob:pathGlob,context_lines:contextLines,
+    early_termination:earlyTermination
   };
 }
 
@@ -70,17 +73,37 @@ export function createCodingSearch({tree,fileRead,cursorCodec}){
   return async function search({
     rootId,path='.',pattern,target='content',mode='literal',caseSensitive=false,
     maxResults=200,maxFileBytes=262144,maxScanBytes=4*1024*1024,pageSize=100,cursor=null,
-    fuzzyTimeoutMs=FUZZY_SEARCH_TIMEOUT_MS
+    fuzzyTimeoutMs=FUZZY_SEARCH_TIMEOUT_MS,includeHidden=true,filePattern=null,signal=null,pathGlob=false,contextLines=null,
+    earlyTermination=false
   }){
+    const checkCancellation=()=>{if(signal?.aborted) throw new Error('coding search cancelled');};
+    checkCancellation();
     if(!['content','path'].includes(target)) throw new Error('coding search target must be content or path');
     if(!['literal','regex','fuzzy'].includes(mode)) throw new Error('coding search mode must be literal, regex, or fuzzy');
     validateInt(maxResults,'max_results',1,1000);
     validateInt(maxFileBytes,'max_file_bytes',1,4*1024*1024);
     validateInt(maxScanBytes,'max_scan_bytes',1,64*1024*1024);
     validateInt(pageSize,'page_size',1,500);
+    if(contextLines!==null) validateInt(contextLines,'contextLines',0,100);
+    if(typeof earlyTermination!=='boolean') throw new Error('earlyTermination must be boolean');
+    if(typeof includeHidden!=='boolean') throw new Error('includeHidden must be boolean');
+    if(typeof pathGlob!=='boolean'||(pathGlob&&target!=='path')) throw new Error('pathGlob requires path search');
+    if(filePattern!==null&&filePattern!==undefined&&(typeof filePattern!=='string'||filePattern.length>4096)) throw new Error('filePattern must be a bounded string');
+    const globs=(filePattern??'').split('|').map(x=>x.trim()).filter(Boolean);
+    if(globs.length>64) throw new Error('too many file patterns');
+    if(globs.length&&typeof pathModule.posix.matchesGlob!=='function') throw new Error('filePattern requires Node glob support');
     if(!Number.isInteger(fuzzyTimeoutMs)||fuzzyTimeoutMs<100||fuzzyTimeoutMs>FUZZY_SEARCH_TIMEOUT_MS) throw new Error('fuzzy_timeout_ms must be in [100, 30000]');
-    const matcher=mode==='fuzzy'?null:compileMatcher({pattern,mode,caseSensitive});
-    const query=normalizeQuery({rootId,path,target,mode,pattern,caseSensitive,maxResults,maxFileBytes,maxScanBytes,pageSize,fuzzyTimeoutMs});
+    let matcher=mode==='fuzzy'?null:compileMatcher({pattern,mode,caseSensitive});
+    if(pathGlob){
+      if(typeof pathModule.posix.matchesGlob!=='function') throw new Error('path glob requires Node glob support');
+      const glob=/[*?\[\]{}]/.test(pattern)||/\.[a-zA-Z0-9]+$/.test(pattern)?pattern:`*${pattern}*`;
+      matcher={path(value){
+        const subject=glob.includes('/')?value.replaceAll('\\','/'):pathModule.posix.basename(value.replaceAll('\\','/'));
+        const dotAware=s=>s.replace(/(^|\/)\./g,'$1\u0001');
+        return pathModule.posix.matchesGlob(dotAware(caseSensitive?subject:subject.toLowerCase()),dotAware(caseSensitive?glob:glob.toLowerCase()));
+      }};
+    }
+    const query=normalizeQuery({rootId,path,target,mode,pattern,caseSensitive,maxResults,maxFileBytes,maxScanBytes,pageSize,fuzzyTimeoutMs,includeHidden,filePattern:filePattern??null,pathGlob,contextLines,earlyTermination});
     const querySha=sha256Object(query);
     let decodedCursor=null;
     if(cursor!==null){
@@ -89,14 +112,30 @@ export function createCodingSearch({tree,fileRead,cursorCodec}){
     }
 
     const listed=await tree({rootId,path,maxDepth:12,maxEntries:2000});
-    const entries=listed.entries.filter(entry=>entry.type==='file').sort((a,b)=>a.path.localeCompare(b.path,'en'));
+    checkCancellation();
+    const entries=listed.entries.filter(entry=>{
+      if(entry.type!=='file') return false;
+      const normalized=entry.path.replaceAll('\\','/');
+      if(!includeHidden&&normalized.split('/').some(part=>part.startsWith('.')&&part!=='.')) return false;
+      if(!globs.length) return true;
+      return globs.some(glob=>{
+        const insensitive=target==='path'&&!caseSensitive;
+        const subject=glob.includes('/')?normalized:pathModule.posix.basename(normalized);
+        // Hidden-file admission is enforced above, not by the glob engine's
+        // implicit dotfile exclusion. Preserve literal dot prefixes on both sides.
+        const dotAware=value=>value.replace(/(^|\/)\./g,'$1\u0001');
+        return pathModule.posix.matchesGlob(dotAware(insensitive?subject.toLowerCase():subject),dotAware(insensitive?glob.toLowerCase():glob));
+      });
+    }).sort((a,b)=>a.path.localeCompare(b.path,'en'));
     const matches=[]; const snapshotEntries=[];
     let filesScanned=0,bytesScanned=0,binaryFilesSkipped=0;
     let truncated=listed.truncated===true;
     let truncationReason=listed.truncated===true?'tree_limit':null;
 
     if(target==='path'){
-      for(const entry of entries){
+      const exactFilename=pathGlob&&/\.[a-zA-Z0-9]+$/.test(pattern)&&!/[\*\?\[\]\{\}]/.test(pattern);
+      pathEntries: for(const entry of entries){
+        checkCancellation();
         snapshotEntries.push({path:entry.path,bytes:entry.bytes,type:'file'});
         const found=mode==='fuzzy'
           ? [fuzzyIndexOf(caseSensitive?entry.path:entry.path.toLowerCase(),caseSensitive?pattern:pattern.toLowerCase())]
@@ -107,16 +146,19 @@ export function createCodingSearch({tree,fileRead,cursorCodec}){
             path:entry.path,line:null,column:null,preview:entry.path,file_sha256:null,
             ...(mode==='fuzzy'?{distance:hit.distance,similarity:hit.similarity,match_length:Math.max(1,hit.value.length)}:{})
           });
+          if(earlyTermination&&exactFilename) break pathEntries;
           if(matches.length>=maxResults){truncated=true;truncationReason='max_results';break;}
         }
         if(matches.length>=maxResults) break;
       }
     } else {
       for(const entry of entries){
+        checkCancellation();
         if(entry.bytes>maxFileBytes) continue;
         if(bytesScanned+entry.bytes>maxScanBytes){truncated=true;truncationReason='scan_byte_limit';break;}
         let item;
         try{item=await fileRead({rootId,relativePath:entry.path,encoding:'base64'});}catch{continue;}
+        checkCancellation();
         const raw=Buffer.from(item.content,'base64');
         filesScanned+=1; bytesScanned+=item.bytes;
         const fileSha=item.sha256??sha256Bytes(raw);
@@ -138,11 +180,27 @@ export function createCodingSearch({tree,fileRead,cursorCodec}){
           }
         } else {
           const found=matcher.all(text);
+          if(contextLines!==null){
+            const lines=text.split(/\r?\n/);if(lines.at(-1)==='') lines.pop();
+            const matchingLines=new Map(),included=new Set();
+            for(const hit of found){
+              const lc=lineColumn(text,hit.index);
+              if(!matchingLines.has(lc.line)) matchingLines.set(lc.line,{hit,lc});
+              for(let n=Math.max(1,lc.line-contextLines);n<=Math.min(lines.length,lc.line+contextLines);n++) included.add(n);
+            }
+            for(const n of [...included].sort((a,b)=>a-b)){
+              const matched=matchingLines.get(n);
+              const value=matched?text.slice(matched.hit.index,matched.hit.index+matched.hit.length):lines[n-1].trim();
+              matches.push({path:entry.path,line:n,column:matched?.lc.column??null,preview:value.slice(0,4096),file_sha256:fileSha});
+              if(matches.length>=maxResults){truncated=true;truncationReason='max_results';break;}
+            }
+          }else{
           for(const hit of found){
             const lc=lineColumn(text,hit.index);
             matches.push({path:entry.path,line:lc.line,column:lc.column,preview:preview(text,hit.index,hit.length),file_sha256:fileSha});
             if(matches.length>=maxResults){truncated=true;truncationReason='max_results';break;}
           }
+          }
         }
         if(matches.length>=maxResults) break;
       }

package/src/coding-task-runtime.mjs

@@ -553,7 +553,7 @@ export function createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyK
       journal_head_sha256: all.at(-1)?.event_sha256 ?? ZERO_HASH,
       stream_id: snapshot.stream_id, stream_generation: snapshot.generation, stream_next_seq: snapshot.next_seq,
       stream_coverage: stream.coverage(),
-      events: page.items.map(item=>item.value)
+      events: page.items.map(item => all[item.seq - 1])
     };
   }
 

package/src/commander-compat-contracts.mjs

@@ -2,6 +2,16 @@ import { createHash } from 'node:crypto';
 
 export const COMMANDER_COMPAT_SCHEMA = 'deadbyte.commander-compat.v2';
 
+export const COMMANDER_REFERENCE_PUBLIC_TOOLS = Object.freeze([
+  'get_config','set_config_value','read_file','read_multiple_files','write_file','write_pdf',
+  'create_directory','list_directory','move_file','start_search','get_more_search_results',
+  'stop_search','list_searches','get_file_info','edit_block','start_process',
+  'read_process_output','interact_with_process','force_terminate','list_sessions',
+  'list_processes','kill_process','get_usage_stats','get_recent_tool_calls',
+  'give_feedback_to_desktop_commander','get_prompts'
+]);
+export const COMMANDER_REFERENCE_HIDDEN_DISPATCH = Object.freeze(['track_ui_event']);
+
 const sha256 = value => createHash('sha256').update(JSON.stringify(value), 'utf8').digest('hex');
 
 // Behavioral/interface surface observed from the local reference package.

package/src/commander-core-bridge.mjs

@@ -2,9 +2,9 @@ import { createCommanderWireAdapter } from './commander-wire-adapter-r47.mjs';
 
 export function registerCommanderCoreBridge(
   server,
-  { machineFsRuntime=null, processRuntime=null, searchRuntime=null, extendedRuntime=null, includeMarkdownEditor=false }={}
+  { machineFsRuntime=null, processRuntime=null, searchRuntime=null, extendedRuntime=null, externalProcessRuntime=null, includeMarkdownEditor=false }={}
 ){
-  const adapter=createCommanderWireAdapter({machineFsRuntime,processRuntime,searchRuntime,extendedRuntime});
+  const adapter=createCommanderWireAdapter({machineFsRuntime,processRuntime,searchRuntime,extendedRuntime,externalProcessRuntime});
   const names=Object.keys(adapter.handlers);
   for(const name of names){
     server.registerTool(name,{

package/src/commander-extended-bridge-r47.mjs

@@ -1,17 +1,121 @@
 import * as z from 'zod/v4';
 
+const origin=z.enum(['ui','llm']).optional();
+const configValue=z.union([z.string(),z.number(),z.boolean(),z.array(z.string()),z.null()]);
+
+function ok(text,structuredContent){
+  return {content:[{type:'text',text:String(text)}],structuredContent};
+}
+function jsonText(prefix,value){
+  return `${prefix}\n${JSON.stringify(value,null,2)}`;
+}
+
 export function registerCommanderExtendedBridge(server,{extendedRuntime,observability=null,skillPlane=null}={}){
-  if(!extendedRuntime) throw new Error('Commander extended runtime is required');
-  const reg=(name,schema,handler)=>server.registerTool(name,{description:'RDC-compatible DEADBYTE native extended surface.',inputSchema:schema},async args=>{
+  void skillPlane;
+  if(!extendedRuntime)throw new Error('Commander extended runtime is required');
+  const reg=(name,schema,handler)=>server.registerTool(name,{
+    description:'Desktop Commander wire-compatible adapter backed by DEADBYTE native state/evidence planes.',
+    inputSchema:schema
+  },async args=>{
     try{return await handler(args??{});}
-    catch(error){const message=error instanceof Error?error.message:String(error);return {content:[{type:'text',text:`Error: ${name}: ${message}`}],isError:true,structuredContent:{status:'error',tool:name,error:message}};}
-  });
-  reg('get_config',z.strictObject({key:z.string().optional()}),a=>extendedRuntime.getConfig(a));
-  reg('set_config_value',z.strictObject({key:z.string(),value:z.union([z.string(),z.number(),z.boolean(),z.array(z.string()),z.null()]),expected_sha256:z.string().regex(/^[0-9a-f]{64}$/)}),a=>extendedRuntime.setConfigValue(a));
-  reg('give_feedback_to_desktop_commander',z.strictObject({message:z.string(),category:z.string().optional()}),a=>extendedRuntime.feedback(a));
-  reg('get_prompts',z.strictObject({}),()=>extendedRuntime.getPrompts());
-  reg('resources',z.strictObject({}),()=>extendedRuntime.getResources());
-  reg('file_preview',z.strictObject({root_id:z.string(),path:z.string(),offset:z.number().int().min(0).optional(),max_bytes:z.number().int().min(1).max(65536).optional(),mime_type:z.string().optional()}),a=>extendedRuntime.filePreview({rootId:a.root_id,path:a.path,offset:a.offset,maxBytes:a.max_bytes,mimeType:a.mime_type}));
-  reg('get_recent_tool_calls',z.strictObject({after_sequence:z.number().int().min(0).optional(),limit:z.number().int().min(1).max(1000).optional()}),a=>observability?observability.recentToolCalls({afterSequence:a.after_sequence??0,limit:a.limit??100}):({status:'unavailable',error:'observability disabled'}));
-  reg('get_usage_stats',z.strictObject({}),()=>observability?observability.usageStats():({status:'unavailable',error:'observability disabled'}));
+    catch(error){
+      const message=error instanceof Error?error.message:String(error);
+      return {
+        content:[{type:'text',text:`Error: ${name}: ${message}`}],
+        isError:true,
+        structuredContent:{status:'error',tool:name,error:message}
+      };
+    }
+  });
+
+  reg('get_config',z.object({origin}),async()=>{
+    const current=await extendedRuntime.getConfig();
+    return ok(jsonText('Current configuration:',current.config),current);
+  });
+
+  reg('set_config_value',z.object({key:z.string(),value:configValue,origin}),async args=>{
+    const before=await extendedRuntime.getConfig();
+    const committed=await extendedRuntime.setConfigValue({
+      key:args.key,
+      value:args.value,
+      expected_sha256:before.config_sha256
+    });
+    const after=await extendedRuntime.getConfig();
+    return ok(
+      `Successfully set ${args.key} to ${JSON.stringify(args.value)}\n\nUpdated configuration:\n${JSON.stringify(after.config,null,2)}`,
+      {...committed,config:after.config,config_sha256:after.config_sha256}
+    );
+  });
+
+  reg('give_feedback_to_desktop_commander',z.object({}),async()=>ok(
+    'Feedback compatibility endpoint is available locally. DEADBYTE does not open a vendor browser or transmit telemetry.',
+    {status:'ready',mode:'local',external_browser_opened:false,telemetry_sent:false}
+  ));
+
+  reg('get_prompts',z.object({
+    action:z.literal('get_prompt'),
+    promptId:z.string()
+  }),async args=>{
+    const result=extendedRuntime.getPrompt(args.promptId);
+    const prompt=result.prompt;
+    return ok(`# ${prompt.title}\n\n${prompt.prompt}`,result);
+  });
+
+  reg('resources',z.object({}),async()=>{
+    const result=extendedRuntime.getResources();
+    return ok(jsonText('Resources:',result.resources),result);
+  });
+
+  reg('file_preview',z.strictObject({
+    root_id:z.string(),path:z.string(),
+    offset:z.number().int().min(0).optional(),
+    max_bytes:z.number().int().min(1).max(65536).optional(),
+    mime_type:z.string().optional()
+  }),async args=>{
+    const result=await extendedRuntime.filePreview({
+      rootId:args.root_id,path:args.path,offset:args.offset,maxBytes:args.max_bytes,mimeType:args.mime_type
+    });
+    return ok(result.text??`Preview ${result.bytes} bytes`,result);
+  });
+
+  reg('get_recent_tool_calls',z.object({
+    maxResults:z.number().min(1).max(1000).optional().default(50),
+    toolName:z.string().optional(),
+    since:z.iso.datetime().optional()
+  }),async args=>{
+    if(!observability)throw new Error('observability disabled');
+    const result=observability.recentToolCalls({
+      maxResults:args.maxResults,
+      toolName:args.toolName??null,
+      since:args.since??null
+    });
+    return ok(jsonText(`Tool Call History (${result.events.length} events)`,result.events),result);
+  });
+
+  reg('get_usage_stats',z.object({}),async()=>{
+    if(!observability)throw new Error('observability disabled');
+    const result=observability.usageStats();
+    return ok(jsonText('Usage statistics:',result),result);
+  });
+}
+
+export function registerCommanderHiddenUiDispatch(server){
+  const registry=server?._registeredTools;
+  if(!registry||typeof registry!=='object'||Array.isArray(registry)) throw new Error('MCP SDK hidden-tool registry unavailable');
+  if(Object.hasOwn(registry,'track_ui_event')) throw new Error('duplicate hidden tool registration: track_ui_event');
+  const registered=server.registerTool('track_ui_event',{
+    description:'Hidden local UI compatibility dispatch; never advertised and never transmits vendor telemetry.',
+    inputSchema:z.object({
+      event:z.string().min(1).max(80),
+      component:z.string().optional().default('file_preview'),
+      params:z.record(z.string(),z.union([z.string(),z.number(),z.boolean(),z.null()])).optional().default({})
+    })
+  },async args=>({
+    content:[{type:'text',text:`Tracked UI event: ${args.event}`}],
+    structuredContent:{accepted:true,local_only:true,event:args.event,component:args.component}
+  }));
+  const descriptor=Object.getOwnPropertyDescriptor(registry,'track_ui_event');
+  if(!descriptor||descriptor.value!==registered) throw new Error('MCP SDK hidden-tool registration identity mismatch');
+  Object.defineProperty(registry,'track_ui_event',{...descriptor,enumerable:false});
+  return registered;
 }

package/src/commander-extended-runtime.mjs

@@ -2,9 +2,30 @@ import { createHash, randomUUID } from 'node:crypto';
 import { mkdir, readFile, writeFile, rename } from 'node:fs/promises';
 import path from 'node:path';
 import { canonicalJson } from './canonical-json.mjs';
+import { createDeadbytePdf } from './commander-pdf-r48.mjs';
+import { DEADBYTE_VERSION } from './version.mjs';
 
 export const COMMANDER_EXTENDED_SCHEMA='deadbyte.commander-extended.v1';
 const MAX_VALUE=16384,MAX_FEEDBACK=4096,MAX_PREVIEW=65536;
+const COMPAT_CONFIG_DEFAULTS=Object.freeze({
+  blockedCommands:[],
+  defaultShell:process.platform==='win32'?'powershell.exe':(process.env.SHELL||'/bin/sh'),
+  allowedDirectories:[],
+  fileReadLineLimit:1000,
+  fileWriteLineLimit:50,
+  telemetryEnabled:false,
+  currentClient:{name:'deadbyte-mcp',version:DEADBYTE_VERSION},
+  clientHistory:[],
+  version:DEADBYTE_VERSION,
+  systemInfo:{platform:process.platform,architecture:process.arch,node:process.version,authority:'native-policy-roots'}
+});
+const DEFAULT_PROMPTS=Object.freeze([
+  {id:'onb2_01',title:'Explore codebase',prompt:'Inspect the workspace, map the smallest relevant surface, and report evidence before changing bytes.'},
+  {id:'onb2_02',title:'Diagnose failure',prompt:'Reproduce the failure, isolate the defect surface, and show the check that catches it.'},
+  {id:'onb2_03',title:'Surgical change',prompt:'Make the smallest state-bound change that fixes the verified defect, then rerun the focused check.'},
+  {id:'onb2_04',title:'Verify release',prompt:'Run focused and bounded regression gates, verify receipts and manifests, and separate source truth from active runtime truth.'},
+  {id:'onb2_05',title:'Operate machine',prompt:'Use typed DEADBYTE machine, process, filesystem, desktop, and remote capabilities with explicit authority and observable evidence.'}
+]);
 const sha256=v=>createHash('sha256').update(Buffer.isBuffer(v)?v:Buffer.from(typeof v==='string'?v:canonicalJson(v),'utf8')).digest('hex');
 const keyOk=k=>typeof k==='string'&&/^[A-Za-z0-9._-]{1,128}$/.test(k);
 
@@ -20,14 +41,14 @@ function makePdf(text){
   return Buffer.from(out,'utf8');
 }
 
-export function createCommanderExtendedRuntime({stateRoot,history=null,prompts=[],resources=[]}={}){
+export function createCommanderExtendedRuntime({stateRoot,history=null,prompts=DEFAULT_PROMPTS,resources=[]}={}){
   if(typeof stateRoot!=='string'||!stateRoot)throw new Error('extended runtime stateRoot required');
   const configPath=path.join(stateRoot,'commander-config.json'),feedbackDir=path.join(stateRoot,'feedback');
   let configCache=null;
   async function loadConfig(){
     if(configCache)return configCache;
-    try{configCache=JSON.parse(await readFile(configPath,'utf8'));}
-    catch(e){if(e?.code!=='ENOENT')throw e;configCache={};}
+    try{configCache={...structuredClone(COMPAT_CONFIG_DEFAULTS),...JSON.parse(await readFile(configPath,'utf8'))};}
+    catch(e){if(e?.code!=='ENOENT')throw e;configCache=structuredClone(COMPAT_CONFIG_DEFAULTS);}
     return configCache;
   }
   async function getConfig({key=null}={}){
@@ -58,6 +79,12 @@ export function createCommanderExtendedRuntime({stateRoot,history=null,prompts=[
     return {status:'committed',feedback_id:id,feedback_sha256:sha256(record)};
   }
   function getPrompts(){return {schema:COMMANDER_EXTENDED_SCHEMA,status:'ok',prompts:prompts.map(x=>({...x})).slice(0,128)};}
+  function getPrompt(promptId){
+    if(typeof promptId!=='string'||promptId.length<1||Buffer.byteLength(promptId,'utf8')>MAX_VALUE)throw new Error('promptId invalid');
+    const prompt=prompts.find(x=>x?.id===promptId);
+    if(!prompt)throw new Error(`prompt '${promptId}' not found`);
+    return {schema:COMMANDER_EXTENDED_SCHEMA,status:'ok',prompt:{...prompt}};
+  }
   function getResources(){return {schema:COMMANDER_EXTENDED_SCHEMA,status:'ok',resources:resources.map(x=>({...x})).slice(0,128)};}
   async function filePreview({rootId,path:relativePath,offset=0,maxBytes=MAX_PREVIEW,mimeType='text/plain'}){
     if(!Number.isInteger(offset)||offset<0||offset>64*1024*1024)throw new Error('preview offset invalid');
@@ -68,8 +95,8 @@ export function createCommanderExtendedRuntime({stateRoot,history=null,prompts=[
   }
   function writePdf({text,metadata={}}){
     if(typeof text!=='string'||Buffer.byteLength(text)>MAX_PREVIEW)throw new Error('PDF text exceeds byte limit');
-    const bytes=makePdf(text);
-    return {schema:COMMANDER_EXTENDED_SCHEMA,status:'ok',mime_type:'application/pdf',bytes_base64:bytes.toString('base64'),bytes_sha256:sha256(bytes),bytes:bytes.length,metadata};
+    const pdf=createDeadbytePdf([text],{metadata});
+    return {schema:COMMANDER_EXTENDED_SCHEMA,status:'ok',mime_type:'application/pdf',bytes_base64:pdf.bytes_base64,bytes_sha256:pdf.bytes_sha256,bytes:pdf.bytes.length,page_count:pdf.page_count,profile:pdf.profile,metadata};
   }
-  return Object.freeze({getConfig,setConfigValue,feedback,getPrompts,getResources,filePreview,writePdf,history});
+  return Object.freeze({getConfig,setConfigValue,feedback,getPrompts,getPrompt,getResources,filePreview,writePdf,history});
 }

package/src/commander-external-process-r48.mjs

@@ -0,0 +1,125 @@
+const MAX_PROCESSES=8192;
+const PAGE_SIZE=256;
+const ISO_UTC=/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/;
+
+function bounded(value,max=2048){
+  const s=String(value??'').replace(/[\r\n\t]+/g,' ').replace(/\s{2,}/g,' ').trim();
+  return s.length<=max?s:s.slice(0,max)+'...';
+}
+function normalizeIdentity(item){
+  if(!item||!Number.isInteger(item.pid)||item.pid<=0) throw new Error('external process observation PID invalid');
+  const creation=typeof item.creation_time_utc==='string'&&ISO_UTC.test(item.creation_time_utc)&&Number.isFinite(Date.parse(item.creation_time_utc))
+    ? new Date(item.creation_time_utc).toISOString()
+    : null;
+  return {
+    pid:item.pid,
+    parent_pid:Number.isInteger(item.parent_pid)&&item.parent_pid>=0?item.parent_pid:0,
+    name:String(item.name??'').slice(0,260),
+    ownership:String(item.ownership??'external'),
+    creation_time_utc:creation,
+    executable_path:item.executable_path??null,
+    command_line:item.command_line??null
+  };
+}
+function selectHostBinding(hostPolicy){
+  const spec=hostPolicy?.commands?.powershell_inline;
+  if(!spec||spec.kind!=='inline') throw new Error('external process termination requires host powershell_inline policy');
+  const requested=process.env.DEADBYTE_COMMANDER_HOST_ROOT;
+  if(requested){
+    if(!spec.root_ids?.includes(requested)) throw new Error('DEADBYTE_COMMANDER_HOST_ROOT is not allowed for powershell_inline');
+    return {commandId:'powershell_inline',rootId:requested};
+  }
+  if(spec.root_ids?.includes('core')) return {commandId:'powershell_inline',rootId:'core'};
+  if(Array.isArray(spec.root_ids)&&spec.root_ids.length===1) return {commandId:'powershell_inline',rootId:spec.root_ids[0]};
+  throw new Error('external process termination requires DEADBYTE_COMMANDER_HOST_ROOT when powershell_inline has multiple non-core roots');
+}
+function terminateCommand(identity){
+  if(!identity.creation_time_utc) throw new Error('external process creation time identity unavailable');
+  const nameB64=Buffer.from(identity.name,'utf8').toString('base64');
+  const creation=identity.creation_time_utc;
+  if(!ISO_UTC.test(creation)) throw new Error('external process creation time identity invalid');
+  return [
+    "$ErrorActionPreference='Stop';",
+    `$pidExpected=${identity.pid};`,
+    `$createdExpected='${creation}';`,
+    `$nameExpected=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${nameB64}'));`,
+    '$cim=Get-CimInstance Win32_Process -Filter ("ProcessId={0}" -f $pidExpected) -ErrorAction Stop;',
+    "if($null -eq $cim){throw 'process missing before termination'};",
+    '$live=Get-Process -Id $pidExpected -ErrorAction Stop;',
+    "$created=$live.StartTime.ToUniversalTime().ToString('o');",
+    "if($created -ne $createdExpected){throw 'process identity mismatch: creation_time'};",
+    "if([string]$cim.Name -cne $nameExpected){throw 'process identity mismatch: name'};",
+    'Stop-Process -Id $pidExpected -Force -ErrorAction Stop;',
+    "Write-Output 'TERMINATED';"
+  ].join(' ');
+}
+
+export function createCommanderExternalProcessRuntime({observationRuntime,hostPolicy=null,hostExecInlineFn=null}={}){
+  if(!observationRuntime||typeof observationRuntime.processList!=='function') throw new Error('external process runtime requires observationRuntime');
+
+  async function list(){
+    let cursor=null,first=null;
+    const processes=[];
+    const receiptIds=[];
+    do{
+      const page=await observationRuntime.processList({limit:PAGE_SIZE,includeExternal:true,cursor});
+      if(page?.status!=='ok'||!Array.isArray(page.processes)) throw new Error('external process observation failed');
+      if(!first) first=page;
+      else if(page.snapshot_id!==first.snapshot_id) throw new Error('external process observation snapshot changed during pagination');
+      for(const item of page.processes){
+        if(processes.length>=MAX_PROCESSES) throw new Error('external process observation exceeds bounded process cap');
+        processes.push(normalizeIdentity(item));
+      }
+      if(typeof page.receipt_id==='string') receiptIds.push(page.receipt_id);
+      cursor=page.next_cursor??null;
+    }while(cursor!==null);
+    return {
+      status:'ok',
+      snapshot_id:first?.snapshot_id??null,
+      observed_at_utc:first?.observed_at_utc??null,
+      processes,
+      receipt_ids:[...new Set(receiptIds)]
+    };
+  }
+
+  async function findFresh(pid){
+    if(!Number.isInteger(pid)||pid<=0) throw new Error('external process PID invalid');
+    const snapshot=await list();
+    const process=snapshot.processes.find(item=>item.pid===pid)??null;
+    return {snapshot,process};
+  }
+
+  async function terminate({pid}){
+    if(!hostPolicy||typeof hostExecInlineFn!=='function') throw new Error('external process termination requires configured Host plane');
+    const before=await findFresh(pid);
+    if(!before.process) throw new Error(`external process PID ${pid} not found`);
+    const identity=before.process;
+    if(!identity.creation_time_utc) throw new Error('external process creation time identity unavailable');
+    const binding=selectHostBinding(hostPolicy);
+    const result=await hostExecInlineFn(hostPolicy,{
+      commandId:binding.commandId,
+      rootId:binding.rootId,
+      command:terminateCommand(identity),
+      cwd:'.',
+      timeoutMs:30000
+    });
+    if(result?.timed_out===true||result?.exit_code!==0){
+      throw new Error(`external process termination failed: ${bounded(result?.stderr||result?.stdout||`exit=${result?.exit_code}`)}`);
+    }
+    const after=await findFresh(pid);
+    const same=after.process&&after.process.creation_time_utc===identity.creation_time_utc&&after.process.name===identity.name;
+    if(same) throw new Error('external process termination returned but the same process identity is still alive');
+    return {
+      status:'terminated',
+      pid:identity.pid,
+      name:identity.name,
+      creation_time_utc:identity.creation_time_utc,
+      before_snapshot_id:before.snapshot.snapshot_id,
+      after_snapshot_id:after.snapshot.snapshot_id,
+      before_receipt_ids:before.snapshot.receipt_ids,
+      after_receipt_ids:after.snapshot.receipt_ids
+    };
+  }
+
+  return Object.freeze({list,terminate});
+}