deadbyte-mcp 0.15.18 → 0.15.20

package/src/deadbyte-cli.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { closeSync, openSync } from 'node:fs';
 import { lstat, mkdir, open, readFile, readdir, rm, stat, writeFile } from 'node:fs/promises';
 import { spawn, spawnSync } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
@@ -10,6 +11,7 @@ import { defaultPublicKeyPath } from './trust.mjs';
 import { verifyAuditChain } from './audit-verify.mjs';
 import { openRemoteResultJournal, parseRemoteResultCursor } from './remote-result-journal.mjs';
 import { DEADBYTE_VERSION } from './version.mjs';
+import { parseActivePointer } from './release-slot.mjs';
 import { printDoctor } from './doctor-r45.mjs';
 import { createLiveTimelineTracker, formatCompactAuditEvent, formatRemoteLifecycle, formatRemoteToolCall, formatRuntimeDiagnosticLine } from './remote-live-log.mjs';
 import { prepareRemoteConsole, remoteDisplayText } from './remote-console.mjs';
@@ -60,14 +62,62 @@ async function remoteContext(){
   const powershell=await requireRegular(path.join(systemRoot,'System32','WindowsPowerShell','v1.0','powershell.exe'),'Windows PowerShell');
   return {root,launcher,powershell};
 }
-function invokeController(ctx,command,{capture=false,allowFailure=false,echoCaptured=true,timeoutMs=null,discardOutput=false}={}){
+function boundedSingleLine(value,maxChars=2048){
+  const line=String(value??'').replace(/[\r\n\t]+/g,' ').replace(/\s{2,}/g,' ').trim();
+  return line.length<=maxChars?line:`${line.slice(0,maxChars)}...`;
+}
+async function readActiveRuntimeBinding(root){
+  const file=path.join(root,'active-release.json');
+  try{return parseActivePointer(await readFile(file,'utf8'));}
+  catch(error){if(error?.code==='ENOENT') return null;throw new Error(`active runtime pointer invalid: ${boundedSingleLine(error?.message||error,512)}`);}
+}
+async function reportVersionCoherence(root,{displayMode='ascii'}={}){
+  const active=await readActiveRuntimeBinding(root);
+  if(!active||active.version===DEADBYTE_VERSION) return active;
+  writeRemote(process.stderr,`${remoteTag('warn',displayMode)} VERSION SKEW: CLI package ${DEADBYTE_VERSION}; active runtime ${active.version} (${active.release_id})\n`,displayMode);
+  return active;
+}
+async function readControllerStartFailure(root,command,{maxChars=2048}={}){
+  const file=path.join(root,'runtime','controller-start-failure.json');
+  let raw;
+  try{raw=await readFile(file,'utf8');}catch(error){if(error?.code==='ENOENT') return null;throw error;}
+  let value;
+  try{value=JSON.parse(String(raw).replace(/^\uFEFF/,''));}catch{return null;}
+  if(value?.schema!=='deadbyte.controller-start-failure.v1'||String(value?.command||'')!==command||typeof value?.message!=='string') return null;
+  const message=boundedSingleLine(value.message,maxChars);
+  return message?{file,message}:null;
+}
+async function readTailBounded(file,maxBytes=4096){
+  try{
+    const info=await stat(file);
+    const length=Math.min(info.size,maxBytes);
+    if(length===0) return '';
+    const buffer=Buffer.alloc(length);
+    const handle=await open(file,'r');
+    try{await handle.read(buffer,0,length,info.size-length);}finally{await handle.close();}
+    return boundedSingleLine(buffer.toString('utf8'),maxBytes);
+  }catch(error){if(error?.code==='ENOENT') return '';throw error;}
+}
+function invokeController(ctx,command,{capture=false,allowFailure=false,echoCaptured=true,timeoutMs=null,discardOutput=false,redirectOutput=null}={}){
   if(capture&&discardOutput) throw new Error('invokeController cannot capture and discard output together');
-  const options={
-    stdio:discardOutput?['ignore','ignore','ignore']:(capture?['ignore','pipe','pipe']:'inherit'),
-    encoding:capture?'utf8':undefined,windowsHide:false,shell:false
-  };
-  if(Number.isInteger(timeoutMs)&&timeoutMs>0) options.timeout=timeoutMs;
-  const result=spawnSync(ctx.powershell,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',ctx.launcher,command],options);
+  if(capture&&redirectOutput) throw new Error('invokeController cannot capture and redirect output together');
+  if(discardOutput&&redirectOutput) throw new Error('invokeController cannot discard and redirect output together');
+  let stdoutFd=null,stderrFd=null,result;
+  try{
+    let stdio;
+    if(discardOutput) stdio=['ignore','ignore','ignore'];
+    else if(redirectOutput){
+      stdoutFd=openSync(redirectOutput.stdout_path,'w');
+      stderrFd=openSync(redirectOutput.stderr_path,'w');
+      stdio=['ignore',stdoutFd,stderrFd];
+    }else stdio=capture?['ignore','pipe','pipe']:'inherit';
+    const options={stdio,encoding:capture?'utf8':undefined,windowsHide:false,shell:false};
+    if(Number.isInteger(timeoutMs)&&timeoutMs>0) options.timeout=timeoutMs;
+    result=spawnSync(ctx.powershell,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',ctx.launcher,command],options);
+  }finally{
+    if(stdoutFd!==null) closeSync(stdoutFd);
+    if(stderrFd!==null) closeSync(stderrFd);
+  }
   if(result.error){
     if(result.error?.code==='ETIMEDOUT') throw new Error(`remote controller '${command}' timed out after ${timeoutMs}ms`);
     throw result.error;
@@ -295,6 +345,7 @@ async function runRemoteSession({resumeCursor=null,verbose=false}={}){
   const display=prepareRemoteConsole();
   const displayMode=display.mode;
   const ctx=await remoteContext();
+  await reportVersionCoherence(ctx.root,{displayMode});
   if(displayMode==='ascii') writeRemote(process.stdout,`[DISPLAY] ASCII fallback: ${display.reason}\n`,displayMode);
   if(resumeCursor!==null) await replayRemoteResults(ctx.root,resumeCursor,{displayMode});
   await recoverRemoteSession(ctx,{displayMode});
@@ -324,7 +375,20 @@ async function runRemoteSession({resumeCursor=null,verbose=false}={}){
     }else{
       const recovery=preflight.status===0&&controllerRuntimeDegraded(preflight.stdout);
       process.stdout.write(recovery?'[RECOVERY] Runtime DEGRADED; restarting verified owned components...\n':'[BOOT] Starting bridge/runtime...\n');
-      invokeController(ctx,recovery?'restart':'start',{discardOutput:true,timeoutMs:REMOTE_START_TIMEOUT_MS});
+      const startCommand=recovery?'restart':'start';
+      const controllerLogDir=path.join(ctx.root,'runtime','logs');
+      await mkdir(controllerLogDir,{recursive:true});
+      const launchOutput={
+        stdout_path:path.join(controllerLogDir,`controller-${startCommand}.stdout.log`),
+        stderr_path:path.join(controllerLogDir,`controller-${startCommand}.stderr.log`)
+      };
+      const launch=invokeController(ctx,startCommand,{allowFailure:true,redirectOutput:launchOutput,timeoutMs:REMOTE_START_TIMEOUT_MS});
+      if(launch.status!==0){
+        const evidence=await readControllerStartFailure(ctx.root,startCommand);
+        const fallback=evidence?'':await readTailBounded(launchOutput.stderr_path,2048);
+        const detail=evidence?`; controller-start-failure: ${evidence.message}`:(fallback?`; controller-stderr: ${fallback}`:'');
+        throw new Error(`remote controller '${startCommand}' failed exit=${launch.status}${detail}`);
+      }
       const started=invokeController(ctx,'status',{capture:true,echoCaptured:false,timeoutMs:REMOTE_STATUS_TIMEOUT_MS});
       if(started.status!==0||!controllerRuntimeReady(started.stdout)) throw new Error(`remote controller ${recovery?'restart':'start'} returned without a verified ONLINE runtime`);
       startText=started.stdout||'';
@@ -371,6 +435,7 @@ async function runRemote(args){
   if(filtered.length>1) throw new Error('remote accepts one controller command or --resume <cursor>');
   const command=filtered[0];if(!REMOTE_COMMANDS.has(command)) throw new Error(`unsupported remote command '${command}'`);
   const ctx=await remoteContext();
+  await reportVersionCoherence(ctx.root,{displayMode:'ascii'});
   const result=invokeController(ctx,command,{allowFailure:true});
   process.exitCode=result.status;
 }

package/src/mcp-server.mjs

@@ -51,11 +51,13 @@ 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 { registerCommanderUiResources } from './commander-ui-resources.mjs';
 import { createOperationHistory } from './operation-history.mjs';
 import { createCommanderObservability } from './commander-observability.mjs';
-import { registerCommanderExtendedBridge } from './commander-extended-bridge-r47.mjs';
+import { registerCommanderExtendedBridge, registerCommanderHiddenUiDispatch } from './commander-extended-bridge-r47.mjs';
 import { createCommanderExtendedRuntime } from './commander-extended-runtime.mjs';
 import { registerCommanderCoreBridge } from './commander-core-bridge.mjs';
+import { createCommanderExternalProcessRuntime } from './commander-external-process-r48.mjs';
 import { registerCommanderRemoteBridge } from './commander-remote-bridge-r47.mjs';
 import { createCommanderRemoteRelayR47 } from './commander-remote-relay-r47.mjs';
 import { createRemoteDevicePlaneR44 } from './remote-device-r44.mjs';
@@ -246,6 +248,9 @@ const skillRoot=path.join(runtimeStateRoot,'skills');
 await mkdir(skillRoot,{recursive:true});
 const skillRuntime=await createSkillPlane({root:skillRoot,verifyKeyPath});
 const commanderExtendedRuntime=createCommanderExtendedRuntime({stateRoot:runtimeStateRoot});
+const commanderExternalProcessRuntime=observationRuntime?createCommanderExternalProcessRuntime({
+  observationRuntime,hostPolicy,hostExecInlineFn:hostExecInline
+}):null;
 const commanderHistory=createOperationHistory({maxEvents:1024,maxBytes:1024*1024});
 const commanderObservability=createCommanderObservability({history:commanderHistory});
 const remoteRelayEndpoint=process.env.DEADBYTE_REMOTE_RELAY_ENDPOINT||process.env.DEADBYTE_REMOTE_ENDPOINT||'';
@@ -604,9 +609,11 @@ serveStdio(() => {
   }
 
   if (surfaceProfile === 'full') {
-    registerCommanderCoreBridge(toolServer,{machineFsRuntime,processRuntime,searchRuntime:codingRuntime?.search??null,extendedRuntime:commanderExtendedRuntime,includeMarkdownEditor:true});
+    registerCommanderCoreBridge(toolServer,{machineFsRuntime,processRuntime,searchRuntime:codingRuntime?.search??null,extendedRuntime:commanderExtendedRuntime,externalProcessRuntime:commanderExternalProcessRuntime,includeMarkdownEditor:true});
     registerCommanderExtendedBridge(toolServer,{extendedRuntime:commanderExtendedRuntime,observability:commanderObservability,skillPlane:skillRuntime});
     registerCommanderRemoteBridge(toolServer,{remoteDevicePlane});
+    registerCommanderHiddenUiDispatch(server);
+    registerCommanderUiResources(server);
   }
 
   return server;

package/src/observation-output-contracts.mjs

@@ -8,7 +8,8 @@ const evidenceShape={request_sha256:hex64,result_head_sha256:hex64,receipt_id:re
 const overflowSchema=z.strictObject({occurred:z.boolean(),reason:z.enum(['result_cap','byte_cap','time_limit','producer_failure']).nullable(),emitted:z.number().int().nonnegative(),dropped:z.union([z.number().int().nonnegative(),z.literal('unknown')]),resume_supported:z.boolean()});
 const resultSchema=z.strictObject({result_id:hex64,path:z.string().min(1).max(512),file_sha256:hex64,line:z.number().int().min(1),column:z.number().int().min(1),preview:z.string().max(512)});
 const processSchema=z.strictObject({pid:z.number().int().positive(),parent_pid:z.number().int().nonnegative(),name:z.string().max(260),
-  ownership:z.enum(['deadbyte-runtime','deadbyte-session','external']),executable_path:z.string().max(2048).nullable(),command_line:z.string().max(4096).nullable()});
+  ownership:z.enum(['deadbyte-runtime','deadbyte-session','external']),creation_time_utc:z.string().min(1).nullable(),
+  executable_path:z.string().max(2048).nullable(),command_line:z.string().max(4096).nullable()});
 
 function statusContract(shape,successRequired=[]){
   return z.strictObject({status:z.enum(['ok','failed']),error:z.string().optional(),...shape}).superRefine((value,ctx)=>{

package/src/observation-runtime.mjs

@@ -91,12 +91,13 @@ export async function verifyObservationReceiptFile({policy,verifyKeyPath,receipt
 function defaultProcessSnapshotProvider(){
   if(process.platform!=='win32') return [];
   const exe=path.join(process.env.SystemRoot||'C:\\Windows','System32','WindowsPowerShell','v1.0','powershell.exe');
-  const command="Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,Name,ExecutablePath,CommandLine | ConvertTo-Json -Compress";
+  const command="$ErrorActionPreference='Stop'; Get-CimInstance Win32_Process | ForEach-Object { $created=$null; try { if ($_.CreationDate) { $created=([DateTime]$_.CreationDate).ToUniversalTime().ToString('o') } } catch {}; [pscustomobject]@{ ProcessId=$_.ProcessId; ParentProcessId=$_.ParentProcessId; Name=$_.Name; CreationTimeUtc=$created; ExecutablePath=$_.ExecutablePath; CommandLine=$_.CommandLine } } | ConvertTo-Json -Compress";
   const result=spawnSync(exe,['-NoLogo','-NoProfile','-Command',command],{encoding:'utf8',windowsHide:true,timeout:15000,maxBuffer:8*1024*1024});
   if(result.status!==0) throw new Error(`process observation failed: ${result.stderr||result.stdout}`);
   const text=(result.stdout??'').trim(); if(!text) return [];
   const parsed=JSON.parse(text); const rows=Array.isArray(parsed)?parsed:[parsed];
   return rows.map(item=>({pid:Number(item.ProcessId),parent_pid:Number(item.ParentProcessId),name:String(item.Name??''),
+    creation_time_utc:typeof item.CreationTimeUtc==='string'&&Number.isFinite(Date.parse(item.CreationTimeUtc))?new Date(item.CreationTimeUtc).toISOString():null,
     executable_path:typeof item.ExecutablePath==='string'?item.ExecutablePath:null,
     command_line:typeof item.CommandLine==='string'?item.CommandLine:null}));
 }
@@ -287,7 +288,8 @@ export function createObservationRuntime({policy,signingKeyPath,verifyKeyPath,pr
     const processes=rows.filter(item=>Number.isInteger(item.pid)&&item.pid>0).map(item=>{
       const ownership=sessionPids.has(item.pid)?'deadbyte-session':runtimePids.has(item.pid)?'deadbyte-runtime':'external';
       if(ownership==='external'&&!includeExternal) return null;
-      return {pid:item.pid,parent_pid:Number.isInteger(item.parent_pid)?item.parent_pid:0,name:String(item.name??'').slice(0,260),ownership,
+      const creationTime=typeof item.creation_time_utc==='string'&&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,name:String(item.name??'').slice(0,260),ownership,creation_time_utc:creationTime,
         executable_path:ownership==='external'?null:(typeof item.executable_path==='string'?item.executable_path.slice(0,2048):null),
         command_line:ownership==='external'?null:(typeof item.command_line==='string'?item.command_line.slice(0,4096):null)};
     }).filter(Boolean).sort((a,b)=>a.pid-b.pid||a.name.localeCompare(b.name));

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.15.18';
+export const DEADBYTE_VERSION = '0.15.20';
 export const MCP_PROTOCOL_VERSION = '2026-07-28';
 export const RECEIPT_SCHEMA_V1 = 'deadbyte.receipt.v1';
 export const RECEIPT_SCHEMA_V2 = 'deadbyte.receipt.v2';

package/test/coding-runtime.test.mjs

@@ -158,6 +158,13 @@ test('durable coding task chains edit command benchmark and verifies task receip
     assert.equal(page.stream_id, submitted.task_id);
     assert.equal(page.events.length, 3);
     assert.equal(page.events[0].seq, 4);
+    assert.equal(page.events[0].schema, 'deadbyte.coding-task-event.v1');
+    assert.equal(page.events[0].task_id, submitted.task_id);
+    assert.match(page.events[0].created_at_utc, /^\d{4}-\d{2}-\d{2}T/);
+    assert.match(page.events[0].prev_sha256, /^[0-9a-f]{64}$/);
+    assert.equal(page.events[0].attestation.algorithm, 'ed25519');
+    assert.match(page.events[0].attestation.key_id, /^[0-9a-f]{64}$/);
+    assert.equal(typeof page.events[0].attestation.signature_base64, 'string');
     assert.equal(page.events[2].seq, 6);
     const verified = await f.tasks.verify({ taskId: submitted.task_id });
     assert.equal(verified.ok, true);

package/test/coding-search-r36.test.mjs

@@ -29,6 +29,77 @@ async function fixture(){
   return {temp,state,search,get reads(){return reads;},cleanup:()=>rm(temp,{recursive:true,force:true})};
 }
 
+test('Commander hidden and file-pattern flags affect native search and cursor identity',async()=>{
+ const f=await fixture();
+ try{
+  f.state.set('src/.hidden.txt',Buffer.from('foo'));
+  f.state.set('.cache/item.txt',Buffer.from('foo'));
+  const query={rootId:'core',target:'content',mode:'literal',pattern:'foo',maxResults:20,pageSize:20};
+  const visible=await f.search({...query,includeHidden:false,filePattern:'*.txt'});
+  assert.ok(visible.matches.length>0);
+  assert.ok(visible.matches.every(x=>!x.path.split('/').some(p=>p.startsWith('.'))&&x.path.endsWith('.txt')));
+  const hidden=await f.search({...query,includeHidden:true,filePattern:'*.txt'});
+  assert.ok(hidden.matches.some(x=>x.path==='src/.hidden.txt'));
+  const js=await f.search({...query,includeHidden:true,filePattern:'*.js'});
+  assert.equal(js.matches.length,0);
+  assert.notEqual(visible.query_sha256,hidden.query_sha256);
+ }finally{await f.cleanup();}
+});
+
+test('native search abort prevents further reads after an in-flight file returns',async()=>{
+ const controller=new AbortController();let reads=0;
+ const search=createCodingSearch({
+  tree:async()=>({entries:[{path:'a.txt',type:'file',bytes:1},{path:'b.txt',type:'file',bytes:1}]}),
+  fileRead:async()=>{reads++;controller.abort();return {content:Buffer.from('x').toString('base64'),bytes:1};},
+  cursorCodec:{encode:async()=>'',decode:async()=>({})}
+ });
+ await assert.rejects(()=>search({rootId:'core',pattern:'x',signal:controller.signal}),/cancelled/);
+ assert.equal(reads,1);
+ await assert.rejects(()=>search({rootId:'core',pattern:'x',signal:controller.signal}),/cancelled/);
+ assert.equal(reads,1);
+});
+
+test('Commander file search treats glob and exact filename as filenames, not content regex',async()=>{
+ const f=await fixture();
+ try{
+  f.state.set('src/not-a.txt.backup',Buffer.from('x'));
+  const glob=await f.search({rootId:'core',target:'path',mode:'literal',pathGlob:true,pattern:'*.js',maxResults:20});
+  assert.deepEqual(glob.matches.map(x=>x.path),['src/foo-file.js']);
+  const exact=await f.search({rootId:'core',target:'path',mode:'literal',pathGlob:true,pattern:'a.txt',maxResults:20});
+  assert.deepEqual(exact.matches.map(x=>x.path),['src/a.txt']);
+  assert.equal(f.reads,0);
+ }finally{await f.cleanup();}
+});
+
+test('Commander context lines are ordered, deduplicated and query-bound',async()=>{
+ const f=await fixture();
+ try{
+  f.state.clear();f.state.set('a.txt',Buffer.from('before\r\nfoo foo\r\nafter\r\n'));
+  const q={rootId:'core',pattern:'foo',target:'content',mode:'literal',maxResults:20};
+  const context=await f.search({...q,contextLines:1});
+  assert.deepEqual(context.matches.map(x=>[x.line,x.preview]),[[1,'before'],[2,'foo'],[3,'after']]);
+  const zero=await f.search({...q,contextLines:0});
+  assert.deepEqual(zero.matches.map(x=>[x.line,x.preview]),[[2,'foo']]);
+  assert.notEqual(context.query_sha256,zero.query_sha256);
+ }finally{await f.cleanup();}
+});
+
+test('Commander exact filename early termination returns the first deterministic match unless disabled',async()=>{
+ const f=await fixture();
+ try{
+  f.state.clear();
+  f.state.set('a/target.txt',Buffer.from('a'));
+  f.state.set('b/target.txt',Buffer.from('b'));
+  f.state.set('c/other.txt',Buffer.from('c'));
+  const q={rootId:'core',target:'path',mode:'literal',pathGlob:true,pattern:'target.txt',maxResults:20};
+  const early=await f.search({...q,earlyTermination:true});
+  assert.deepEqual(early.matches.map(x=>x.path),['a/target.txt']);
+  const exhaustive=await f.search({...q,earlyTermination:false});
+  assert.deepEqual(exhaustive.matches.map(x=>x.path),['a/target.txt','b/target.txt']);
+  assert.notEqual(early.query_sha256,exhaustive.query_sha256);
+ }finally{await f.cleanup();}
+});
+
 test('R36 regex search returns multiple matches per file with deterministic signed paging',async()=>{
   const f=await fixture();
   try{

package/test/commander-core-bridge-r47.test.mjs

@@ -2,6 +2,19 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { registerCommanderCoreBridge } from '../src/commander-core-bridge.mjs';
 
+test('search adapter drains bounded native pages instead of silently losing later matches',async()=>{
+ const tools=new Map(), cursors=[];
+ const searchRuntime=async query=>{cursors.push(query.cursor);return query.cursor===null
+  ?{matches:[{path:'a.txt'}],next_cursor:'page-2'}
+  :{matches:[{path:'b.txt'}],next_cursor:null};};
+ registerCommanderCoreBridge({registerTool(name,config,handler){tools.set(name,{config,handler});}},{searchRuntime});
+ const started=await tools.get('start_search').handler({path:'.',pattern:'.',searchType:'files',maxResults:10});
+ let page;
+ for(let i=0;i<20;i++){page=await tools.get('get_more_search_results').handler({sessionId:started.sessionId,offset:0,length:10});if(page.isComplete)break;await new Promise(r=>setTimeout(r,1));}
+ assert.deepEqual(cursors,[null,'page-2']);
+ assert.deepEqual(page.results.map(x=>x.file),['a.txt','b.txt']);
+});
+
 test('bridge registers all aliases',()=>{
  const names=[]; registerCommanderCoreBridge({registerTool(name){names.push(name);}},{}); assert.equal(names.length,20);
  assert.ok(names.includes('read_file')); assert.ok(names.includes('start_search'));
@@ -20,12 +33,28 @@ test('search adapter provides Commander progressive session semantics',async()=>
  throw new Error('search session did not complete');
 });
 
-test('search adapter supports tail pagination and cancellation',async()=>{
- const tools=new Map(); let resolveSearch; const searchRuntime=()=>new Promise(r=>{resolveSearch=r;});
+test('search adapter cancellation aborts native work and rejects late results',async()=>{
+ const tools=new Map(); let resolveSearch,signal; const searchRuntime=query=>{signal=query.signal;return new Promise(r=>{resolveSearch=r;});};
  registerCommanderCoreBridge({registerTool(name,config,handler){tools.set(name,{config,handler});}},{searchRuntime});
  const started=await tools.get('start_search').handler({path:'.',pattern:'x',searchType:'files'});
  assert.equal(await tools.get('stop_search').handler({sessionId:started.sessionId}),true);
+ assert.equal(signal.aborted,true);
+ assert.equal(await tools.get('stop_search').handler({sessionId:started.sessionId}),false);
  resolveSearch({matches:[{path:'z.txt'}],truncated:false});
  let page; for(let i=0;i<20;i++){page=await tools.get('get_more_search_results').handler({sessionId:started.sessionId,offset:-1,length:100}); if(page.isComplete) break; await new Promise(r=>setTimeout(r,1));}
- assert.equal(page.isComplete,true); assert.equal(page.results.length,1);
+ assert.equal(page.isComplete,true); assert.equal(page.results.length,0);
+});
+
+test('search adapter timeout aborts native work, completes cleanly, and rejects late results',async()=>{
+ const tools=new Map(); let resolveSearch,signal; const searchRuntime=query=>{signal=query.signal;return new Promise(r=>{resolveSearch=r;});};
+ registerCommanderCoreBridge({registerTool(name,config,handler){tools.set(name,{config,handler});}},{searchRuntime});
+ const started=await tools.get('start_search').handler({path:'.',pattern:'needle',searchType:'content',timeout_ms:5});
+ await new Promise(r=>setTimeout(r,20));
+ assert.equal(signal.aborted,true);
+ let page=await tools.get('get_more_search_results').handler({sessionId:started.sessionId,offset:0,length:100});
+ assert.equal(page.isComplete,true); assert.equal(page.isError,false); assert.equal(page.results.length,0);
+ resolveSearch({matches:[{path:'late.txt',line:1,preview:'needle'}],truncated:false});
+ await new Promise(r=>setTimeout(r,5));
+ page=await tools.get('get_more_search_results').handler({sessionId:started.sessionId,offset:0,length:100});
+ assert.equal(page.results.length,0);
 });

package/test/commander-exhaustive-surface-r47.test.mjs

@@ -14,7 +14,11 @@ test('Commander exhaustive surface is internally consistent and natively impleme
   assert.equal(new Set(catalog.surface.map(x=>x.name)).size,40);
   assert.ok(catalog.surface.every(x=>x.status==='implemented'));
   assert.ok(catalog.surface.every(x=>typeof x.native==='string'&&x.native.length>0));
-  assert.equal(sha(Buffer.from(JSON.stringify(catalog.reference))),sha(Buffer.from(JSON.stringify({package:'@wonderwhy-er/desktop-commander',version:'0.2.51',license:'MIT'}))));
+  assert.equal(catalog.reference.package,'@wonderwhy-er/desktop-commander');
+  assert.equal(catalog.reference.version,'0.2.51');
+  assert.equal(catalog.reference.license,'MIT');
+  assert.equal(catalog.reference.server_sha256,'dfc303bb7dd2e8d01debac50fc43bb8644d00089bffdf2887e149497cff8b305');
+  assert.equal(catalog.reference.schemas_sha256,'f342345e34e48769dabaefe1b932f09d41e2e207b422f7794a15ee50ffa8f140');
 });
 
 test('Commander extended native source has no Commander dependency',async()=>{

package/test/commander-extended-runtime-r47.test.mjs

@@ -9,12 +9,20 @@ test('Commander extended config is hash-preconditioned and bounded',async()=>{
   const root=await mkdtemp(path.join(tmpdir(),'deadbyte-ext-'));
   const rt=createCommanderExtendedRuntime({stateRoot:root});
   const initial=await rt.getConfig();
+  for(const key of ['blockedCommands','defaultShell','allowedDirectories','fileReadLineLimit','fileWriteLineLimit','telemetryEnabled','currentClient','clientHistory','version','systemInfo'])assert.ok(Object.hasOwn(initial.config,key),`missing compatibility config key ${key}`);
+  assert.deepEqual(initial.config.allowedDirectories,[]);
+  assert.equal(initial.config.telemetryEnabled,false);
   const committed=await rt.setConfigValue({key:'theme',value:'classic',expected_sha256:initial.config_sha256});
   assert.equal(committed.status,'committed');
   await assert.rejects(()=>rt.setConfigValue({key:'theme',value:'modern',expected_sha256:initial.config_sha256}),/precondition/);
   assert.equal((await rt.getConfig({key:'theme'})).config.theme,'classic');
 });
 
+test('Commander prompt runtime accepts reference-valid long IDs within bounded native storage',()=>{
+  const id='x'.repeat(256),rt=createCommanderExtendedRuntime({stateRoot:'x',prompts:[{id,title:'Long',prompt:'bounded'}]});
+  assert.equal(rt.getPrompt(id).prompt.id,id);
+});
+
 test('Commander extended feedback is bounded and durably recorded',async()=>{
   const root=await mkdtemp(path.join(tmpdir(),'deadbyte-ext-'));
   const rt=createCommanderExtendedRuntime({stateRoot:root});

package/test/commander-extended-wire-r48.test.mjs

@@ -0,0 +1,98 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { createCommanderExtendedRuntime } from '../src/commander-extended-runtime.mjs';
+import { registerCommanderExtendedBridge } from '../src/commander-extended-bridge-r47.mjs';
+import { createOperationHistory } from '../src/operation-history.mjs';
+import { createCommanderObservability } from '../src/commander-observability.mjs';
+
+function fakeServer(){
+  const tools=new Map();
+  return {
+    registerTool(name,definition,handler){tools.set(name,{definition,handler});},
+    tools
+  };
+}
+function shape(schema){return schema?._def?.shape??schema?.shape??{};}
+
+test('R48 extended bridge exposes Desktop Commander 0.2.51 argument shapes',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r48-extended-schema-'));
+  try{
+    const runtime=createCommanderExtendedRuntime({stateRoot:root,prompts:[{id:'onb2_01',title:'Explore',prompt:'Inspect the workspace'}]});
+    const history=createOperationHistory();
+    const observability=createCommanderObservability({history});
+    const server=fakeServer();
+    registerCommanderExtendedBridge(server,{extendedRuntime:runtime,observability});
+    const getConfig=shape(server.tools.get('get_config').definition.inputSchema);
+    const setConfig=shape(server.tools.get('set_config_value').definition.inputSchema);
+    const getPrompts=shape(server.tools.get('get_prompts').definition.inputSchema);
+    const recent=shape(server.tools.get('get_recent_tool_calls').definition.inputSchema);
+    const feedback=shape(server.tools.get('give_feedback_to_desktop_commander').definition.inputSchema);
+    assert.ok(getConfig.origin); assert.equal(getConfig.key,undefined);
+    assert.ok(setConfig.key); assert.ok(setConfig.value); assert.ok(setConfig.origin); assert.equal(setConfig.expected_sha256,undefined);
+    assert.ok(getPrompts.action); assert.ok(getPrompts.promptId);
+    assert.ok(recent.maxResults); assert.ok(recent.toolName); assert.ok(recent.since);
+    assert.deepEqual(Object.keys(feedback),[]);
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R48 set_config_value performs internal CAS while preserving reference wire',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r48-extended-cas-'));
+  try{
+    const runtime=createCommanderExtendedRuntime({stateRoot:root});
+    const server=fakeServer();
+    registerCommanderExtendedBridge(server,{extendedRuntime:runtime,observability:null});
+    const set=await server.tools.get('set_config_value').handler({key:'defaultShell',value:'powershell.exe'});
+    assert.equal(set.isError,undefined,JSON.stringify(set));
+    assert.match(set.content[0].text,/Successfully set defaultShell/);
+    const get=await server.tools.get('get_config').handler({});
+    assert.equal(get.structuredContent.config.defaultShell,'powershell.exe');
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R48 prompts, history filters, and feedback accept reference calls',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r48-extended-behavior-'));
+  try{
+    const runtime=createCommanderExtendedRuntime({stateRoot:root,prompts:[{id:'onb2_01',title:'Explore',prompt:'Inspect the workspace'}]});
+    const history=createOperationHistory({clockMs:()=>Date.parse('2026-09-27T00:00:00.000Z')});
+    history.append('tool.call',{tool:'read_file'});
+    history.append('tool.result',{tool:'read_file'});
+    history.append('tool.call',{tool:'start_process'});
+    const observability=createCommanderObservability({history});
+    const server=fakeServer();
+    registerCommanderExtendedBridge(server,{extendedRuntime:runtime,observability});
+    const prompt=await server.tools.get('get_prompts').handler({action:'get_prompt',promptId:'onb2_01'});
+    assert.equal(prompt.isError,undefined,JSON.stringify(prompt));
+    assert.match(prompt.content[0].text,/Inspect the workspace/);
+    const recent=await server.tools.get('get_recent_tool_calls').handler({maxResults:10,toolName:'read_file',since:'2026-09-26T00:00:00.000Z'});
+    assert.equal(recent.isError,undefined,JSON.stringify(recent));
+    assert.ok(recent.structuredContent.events.length>=2);
+    assert.ok(recent.structuredContent.events.every(e=>e.payload?.tool==='read_file'));
+    const feedback=await server.tools.get('give_feedback_to_desktop_commander').handler({});
+    assert.equal(feedback.isError,undefined,JSON.stringify(feedback));
+    assert.match(feedback.content[0].text,/feedback/i);
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+
+test('R48 extended schema matches reference promptId and ISO datetime semantics exactly',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r48-extended-schema-exact-'));
+  try{
+    const runtime=createCommanderExtendedRuntime({stateRoot:root,prompts:[{id:'x'.repeat(256),title:'Long',prompt:'Long id is legal on reference wire'}]});
+    const history=createOperationHistory();
+    const observability=createCommanderObservability({history});
+    const server=fakeServer();
+    registerCommanderExtendedBridge(server,{extendedRuntime:runtime,observability});
+    const promptSchema=server.tools.get('get_prompts').definition.inputSchema;
+    const recentSchema=server.tools.get('get_recent_tool_calls').definition.inputSchema;
+    assert.doesNotThrow(()=>promptSchema.parse({action:'get_prompt',promptId:'x'.repeat(256)}));
+    assert.doesNotThrow(()=>recentSchema.parse({since:'2026-09-27T00:00:00.000Z'}));
+    assert.doesNotThrow(()=>recentSchema.parse({maxResults:1.5}));
+    history.append('tool.call',{tool:'read_file'});history.append('tool.result',{tool:'read_file'});
+    const fractional=await server.tools.get('get_recent_tool_calls').handler(recentSchema.parse({maxResults:1.5}));
+    assert.equal(fractional.isError,undefined);assert.equal(fractional.structuredContent.events.length,1);
+    assert.throws(()=>recentSchema.parse({since:'not-a-datetime'}));
+  }finally{await rm(root,{recursive:true,force:true});}
+});

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

@@ -0,0 +1,76 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createCommanderExternalProcessRuntime } from '../src/commander-external-process-r48.mjs';
+
+function observationSequence(pages){
+  let call=0;
+  return {
+    calls:()=>call,
+    async processList(args){
+      const page=pages[Math.min(call,pages.length-1)];
+      call++;
+      return typeof page==='function'?page(args):structuredClone(page);
+    }
+  };
+}
+
+test('R48 external process list exhausts one signed observation snapshot through cursors',async()=>{
+  const obs=observationSequence([
+    {status:'ok',snapshot_id:'a'.repeat(64),observed_at_utc:'2026-09-27T00:00:00.000Z',
+      processes:[{pid:10,parent_pid:1,name:'a.exe',ownership:'external',creation_time_utc:'2026-09-27T00:00:01.000Z',executable_path:null,command_line:null}],
+      next_cursor:'cursor-1',receipt_id:'1'.repeat(24),receipt_sha256:'2'.repeat(64)},
+    {status:'ok',snapshot_id:'a'.repeat(64),observed_at_utc:'2026-09-27T00:00:00.000Z',
+      processes:[{pid:20,parent_pid:1,name:'b.exe',ownership:'external',creation_time_utc:'2026-09-27T00:00:02.000Z',executable_path:null,command_line:null}],
+      next_cursor:null,receipt_id:'1'.repeat(24),receipt_sha256:'2'.repeat(64)}
+  ]);
+  const rt=createCommanderExternalProcessRuntime({observationRuntime:obs,hostPolicy:null,hostExecInlineFn:null});
+  const listed=await rt.list();
+  assert.deepEqual(listed.processes.map(x=>x.pid),[10,20]);
+  assert.equal(listed.snapshot_id,'a'.repeat(64));
+  assert.equal(obs.calls(),2);
+});
+
+test('R48 external kill binds PID creation time and name then proves the same identity disappeared',async()=>{
+  const before={status:'ok',snapshot_id:'a'.repeat(64),observed_at_utc:'2026-09-27T00:00:00.000Z',
+    processes:[{pid:222,parent_pid:1,name:"external.exe",ownership:'external',creation_time_utc:'2026-09-27T00:00:02.000Z',executable_path:null,command_line:null}],
+    next_cursor:null,receipt_id:'1'.repeat(24),receipt_sha256:'2'.repeat(64)};
+  const after={...before,snapshot_id:'b'.repeat(64),processes:[],receipt_id:'3'.repeat(24),receipt_sha256:'4'.repeat(64)};
+  const obs=observationSequence([before,after]);
+  const hostCalls=[];
+  const hostPolicy={commands:{powershell_inline:{kind:'inline',root_ids:['core']}},roots:{core:{}}};
+  const rt=createCommanderExternalProcessRuntime({
+    observationRuntime:obs,hostPolicy,
+    hostExecInlineFn:async(policy,args)=>{hostCalls.push({policy,args});return {exit_code:0,timed_out:false,stdout:'TERMINATED\n',stderr:''};}
+  });
+  const result=await rt.terminate({pid:222});
+  assert.equal(result.status,'terminated');
+  assert.equal(result.pid,222);
+  assert.equal(result.creation_time_utc,'2026-09-27T00:00:02.000Z');
+  assert.equal(hostCalls.length,1);
+  const command=hostCalls[0].args.command;
+  assert.match(command,/\$pidExpected=222;/);
+  assert.match(command,/2026-09-27T00:00:02\.000Z/);
+  assert.match(command,/Stop-Process -Id \$pidExpected -Force/);
+  assert.doesNotMatch(command,/external\.exe/,'process name must not be interpolated raw');
+});
+
+test('R48 external kill fails closed on missing identity and on post-effect same identity',async()=>{
+  const noIdentity={status:'ok',snapshot_id:'a'.repeat(64),observed_at_utc:'2026-09-27T00:00:00.000Z',
+    processes:[{pid:222,parent_pid:1,name:'external.exe',ownership:'external',creation_time_utc:null,executable_path:null,command_line:null}],
+    next_cursor:null,receipt_id:'1'.repeat(24),receipt_sha256:'2'.repeat(64)};
+  const hostPolicy={commands:{powershell_inline:{kind:'inline',root_ids:['core']}},roots:{core:{}}};
+  let hostCount=0;
+  const noIdentityRuntime=createCommanderExternalProcessRuntime({
+    observationRuntime:observationSequence([noIdentity]),hostPolicy,
+    hostExecInlineFn:async()=>{hostCount++;return {exit_code:0,timed_out:false,stdout:'',stderr:''};}
+  });
+  await assert.rejects(noIdentityRuntime.terminate({pid:222}),/creation time identity unavailable/);
+  assert.equal(hostCount,0);
+
+  const stable={...noIdentity,processes:[{...noIdentity.processes[0],creation_time_utc:'2026-09-27T00:00:02.000Z'}]};
+  const stableRuntime=createCommanderExternalProcessRuntime({
+    observationRuntime:observationSequence([stable,stable]),hostPolicy,
+    hostExecInlineFn:async()=>({exit_code:0,timed_out:false,stdout:'TERMINATED',stderr:''})
+  });
+  await assert.rejects(stableRuntime.terminate({pid:222}),/same process identity is still alive/);
+});