deadbyte-mcp 0.15.51 → 0.15.53

package/docs/R138-COMMANDER-WORKFLOW.md

@@ -0,0 +1,21 @@
+# R138 — Commander process, output, session workflow
+
+Status: DEVELOPMENT successor, not published, not deployed, no authority changes.
+
+The native DEADBYTE MCP runtime remains the sole executor; reference Desktop Commander 0.2.52/0.3.0/0.3.1-alpha.2 tool schemas, not vendor servers. This train focuses on making its existing Commander bridge practical without adding Autonomous privilege layers.
+
+## Process list integrity
+`src/commander-external-process-r48.mjs` now validates every observation page, including the SHA-256 snapshot identity, timestamp, max page size and cursor. It detects repeated cursors before re-querying, denies duplicate PIDs within a snapshot, denies changing timestamps or snapshot IDs, and bounds page count. A corrupt observation is rejected before the returned PID can be used for an external kill. The existing identity-bound external termination path is unchanged.
+
+## Output pagination and sessions
+`src/commander-wire-adapter-r47.mjs` now attaches byte-level resume and truncation metadata to the Commander-compatible `read_process_output` structured response. Incremental offset=0 reads return `next_byte_offset` and `more_unread`; historical offset reads return `next_byte_offset:null` because they do not consume the incremental cursor. `earliest_offset` and `truncated` report retention loss explicitly. The public tool input schemas remain exactly as before.
+
+`list_sessions` now displays child PID, profile, root, execution state and known exit outcome on one line; empty inventories are readable. Structured session data is untouched. No PID kill authority, raw command execution permissions or standing grants are expanded.
+
+## Tests and provenance
+TDD initial RED reproduced repeated cursor, duplicate PID, inconsistent snapshot timestamps, invalid cursor/identity, missing resume metadata and unreadable session list. The modified tests subsequently passed alongside the R48 Commander wire/managed/external-process regressions. The reference schema parity test for three pinned Desktop Commander versions remains present from R137.
+
+The predecessor R137 source manifest SHA-256 is `7fd24ceda2f9369293c79f8da2a12616af822fa4c1224833336e7271a662a643`. Active production pointer SHA-256 is `df926f14fca1c14478342dce5ed41aa1c4b67fb12ae733114f03c8c720ea61e9` (runtime `0.15.45`) and must remain unchanged. R138 still uses package version `0.15.51` for development and must not republish it. Any release requires a distinct version and independent full protected Windows gate.
+
+## Limits
+The Commander bridge has existing file editing/reading/search and process operations, not every Desktop Commander UX feature. R138 proves the named improvements, not full remote parity, production activation, all historical 49 skipped tests, or OS privilege isolation.

package/docs/R139-COMMANDER-ERGONOMICS.md

@@ -0,0 +1,17 @@
+# R139 — Practical Commander: large text, partial search, startup preview
+
+Status: DEVELOPMENT ONLY / not a new npm release / not production activation.
+
+Predecessor is R138 (2390 file manifest SHA-256 `8a60c3408dfc18f7593ff6a029a194ee2b503bcc2eed16c2b9ac020d490e863a`). Isolated source `D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-r139-commander-ergonomics-dev`. Runtime remains `0.15.45`; published npm latest remains `0.15.51`.
+
+## Four improvements
+- **Large text reading:** `read_file` for text exceeding the former native 4 MiB compatibility-read cap now uses `src/commander-large-text-r139.mjs` to scan at most 64 MiB with 256 KiB native pages (or the stricter policy cap). It verifies an identical native full-file SHA-256 across pages and rejects malformed cursors, file changes, oversized lines, invalid UTF-8, and oversized files. Only requested line ranges are retained in memory; the full-file scan is O(file size) and may require several native reads. Regular small files and document-specific readers remain unchanged.
+- **Large text edit:** plain-text `edit_block` can modify a uniquely matched string in a UTF-8 file up to 16 MiB (or tighter native policy limit) using the *existing* native hash-preconditioned atomic write. Count of replacements must match the caller. Binary/NUL and invalid UTF-8 targets are rejected; a UTF-8 BOM is preserved. Not an unbounded text writer; DOCX/XLSX native authoring paths are unchanged.
+- **Search results sooner:** `get_more_search_results` now returns discovered matches during an unfinished multi-page search, with `isComplete:false` and `hasMoreResults:true`; it does not disguise discovered matches as zero until all pages finish. Search runtime's existing signed cursor, abort policy and limits are unchanged.
+- **Initial output preview:** `start_process` performs one nonwaiting (`waitMs:0`) 16 KiB maximum read after the process has started and returns any *already available* UTF-8 data in `structuredContent.initial_output` and text. It does not advance the independent process output cursor, so `read_process_output` will still show those bytes again; consumers should deduplicate if mixing both outputs. A failed/binary output probe does **not** disguise a successfully started process as a failed start.
+
+## Security / compatibility
+No command policies, grants, project roots, owner authority, token permissions, npm dependencies, or public tool input schemas are broadened. Existing Desktop Commander 0.2.52, 0.3.0 and 0.3.1-alpha.2 public-schema tests stay in the suite. Most large-file failures remain fail-closed rather than attempting partial destructive edits. A changed file is not rewritten, and no unrestricted subprocess or external vendor server is introduced.
+
+## Evidence
+Observed TDD RED -> GREEN for each feature using `test/r139-*.test.mjs` and existing R47/R48 tests. The new tests include large 5 MiB read/edit, SHA change during paging, binary edit refusal, exact replacement, UTF-8 BOM preservation, oversized edit refusal, partial search and immediate process-output preview. This candidate retains package version `0.15.51` and must not republish that immutable version. Production activation requires a separate decision and live/rollback gates.

package/docs/THIRD-PARTY-DESKTOP-COMMANDER-MIT.md

@@ -0,0 +1,27 @@
+# Desktop Commander reference — MIT notice
+
+The reference design and compatibility tests draw on the Desktop Commander MCP project, by Eduard Ruzga and Desktop Commander Contributors. Source: https://github.com/wonderwhy-er/DesktopCommanderMCP. Exact reference snapshots are described in R137-DESKTOP-COMMANDER-FOUNDATION.md.
+
+The following text is the license notice found in the local 0.3.1-alpha.2 distribution. Include it if copying or redistributing covered Desktop Commander software.
+
+MIT License
+
+Copyright (c) 2024-2025 Eduard Ruzga and Desktop Commander Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deadbyte-mcp",
-  "version": "0.15.51",
+  "version": "0.15.53",
   "private": false,
   "type": "module",
   "description": "Authenticated MCP agentic runtime with signed skills, persistent model backends, identity-bound remote devices, durable job supervision, immutable release slots, and separately revocable machine authority.",

package/src/autonomous-scope-r135.mjs

@@ -0,0 +1,91 @@
+import {createHash} from 'node:crypto';
+import {existsSync,lstatSync,realpathSync} from 'node:fs';
+import path from 'node:path';
+
+// R135 is an offline POLICY PROJECTION only. It cannot mint a lease or grant,
+// modify an active generation, or make a broad manual Coding grant safe to
+// inherit in the same process. Execution requires a separate proven boundary.
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const clone=value=>structuredClone(value);
+function realProjectRoot(input){
+ if(typeof input!=='string'||!path.isAbsolute(input))throw new Error('real project directory required');
+ const candidate=path.resolve(input),disk=path.parse(candidate).root;
+ const eq=(a,b)=>process.platform==='win32'?a.toLowerCase()===b.toLowerCase():a===b;
+ if(eq(candidate,disk))throw new Error('project-scoped root required');
+ try{
+  const info=lstatSync(candidate);
+  if(!info.isDirectory()||info.isSymbolicLink()||!eq(realpathSync(candidate),candidate)){
+   throw new Error('path redirected');
+  }
+  let cursor=candidate;
+  for(;;){
+   if(lstatSync(cursor).isSymbolicLink())throw new Error('linked ancestor');
+   const parent=path.dirname(cursor);
+   if(parent===cursor)break;
+   cursor=parent;
+  }
+ }catch{throw new Error('real project directory required')}
+ return candidate;
+}
+export function deriveIsolatedAutonomousScope({manualCodingPolicy,autonomousPolicy,scopeRootId,isolatedStateRoot}={}){
+ if(manualCodingPolicy?.schema!=='deadbyte.coding-policy.v1'||manualCodingPolicy.enabled!==true)
+  throw new Error('manual Coding policy schema invalid');
+ if(autonomousPolicy?.schema!=='deadbyte.autonomous-policy.v1'||autonomousPolicy.enabled!==true)
+  throw new Error('Autonomous policy schema invalid');
+ if(!/^[A-Za-z0-9._-]{1,64}$/.test(scopeRootId??''))throw new Error('invalid project scope');
+ if(!path.isAbsolute(isolatedStateRoot??''))throw new Error('isolated state root must be absolute');
+ const scopedRoot=manualCodingPolicy.roots?.[scopeRootId];
+ if(!scopedRoot)throw new Error('approved project root missing from Coding policy');
+ if(!Array.isArray(autonomousPolicy.root_ids)||autonomousPolicy.root_ids.length!==1||
+   autonomousPolicy.root_ids[0]!==scopeRootId)throw new Error('Autonomous root outside approved scope');
+ const safeRoot=realProjectRoot(scopedRoot.path);
+ const isolated=realProjectRoot(isolatedStateRoot);
+ const eq=(a,b)=>process.platform==='win32'?a.toLowerCase()===b.toLowerCase():a===b;
+ const manualLease=manualCodingPolicy.lease_file,autonLease=autonomousPolicy.lease_file;
+ for(const lease of [manualLease,autonLease]){
+  if(typeof lease!=='string'||!path.isAbsolute(lease))throw new Error('manual policy lease invalid');
+  const rel=path.relative(isolated,path.resolve(lease));
+  if(rel===''||(!path.isAbsolute(rel)&&rel!=='..'&&!rel.startsWith('..'+path.sep))){
+   throw new Error('isolated state root overlaps manual Coding lease');
+  }
+ }
+ // Fail closed for any profiles referencing another root or missing command.
+ const selectedCommands={};
+ for(const [id,profile] of Object.entries(autonomousPolicy.profiles??{})){
+  if(profile?.root_id!==scopeRootId)throw new Error('Autonomous profile '+id+' root outside approved scope');
+  const command=profile.command_id;
+  if(typeof command!=='string'||!Object.hasOwn(manualCodingPolicy.commands??{},command)){
+   throw new Error('Autonomous command missing from Coding policy');
+  }
+  const selected=clone(manualCodingPolicy.commands[command]);
+  if(!Array.isArray(selected.root_ids)||!selected.root_ids.includes(scopeRootId)){
+   throw new Error('Autonomous command '+command+' outside approved scope');
+  }
+  selected.root_ids=[scopeRootId];
+  selectedCommands[command]=selected;
+ }
+ if(autonomousPolicy.planner?.backend==='codex_app_server'&&
+     autonomousPolicy.planner.root_id!==scopeRootId)throw new Error('planner root outside approved scope');
+ const codingPolicy=clone(manualCodingPolicy);
+ codingPolicy.roots={[scopeRootId]:{...clone(scopedRoot),path:safeRoot}};
+ codingPolicy.commands=selectedCommands;
+ codingPolicy.lease_file=path.join(isolated,'runtime','coding-grant.json');
+ codingPolicy.evidence_dir=path.join(isolated,'evidence','coding');
+ if(existsSync(codingPolicy.lease_file)||existsSync(path.join(isolated,'runtime','autonomous-grant.json'))){
+  throw new Error('isolated grant file already present');
+ }
+ const codingBytes=Buffer.from(JSON.stringify(codingPolicy,null,2)+'\n','utf8');
+ const nextAutonomous=clone(autonomousPolicy);
+ nextAutonomous.root_ids=[scopeRootId];
+ nextAutonomous.coding_policy_sha256=sha(codingBytes);
+ nextAutonomous.lease_file=path.join(isolated,'runtime','autonomous-grant.json');
+ nextAutonomous.evidence_dir=path.join(isolated,'evidence','autonomous');
+ const autonomousBytes=Buffer.from(JSON.stringify(nextAutonomous,null,2)+'\n','utf8');
+ return Object.freeze({
+  scope_root_id:scopeRootId,isolated_state_root:isolated,
+  codingBytes,autonomousBytes,
+  codingPolicy,autonomousPolicy:nextAutonomous,
+  coding_sha256:sha(codingBytes),autonomous_sha256:sha(autonomousBytes),
+  status:'OFFLINE_UNAUTHORIZED_PROJECTION'
+ });
+}

package/src/commander-config-recovery-r137.mjs

@@ -0,0 +1,67 @@
+import {createHash,randomUUID} from 'node:crypto';
+import {readFile,writeFile,rename} from 'node:fs/promises';
+import path from 'node:path';
+
+// Reference design: Desktop Commander 0.3.0 MIT config-recovery.
+// DEADBYTE independently restricts salvage to NON-AUTHORITY display limits;
+// privileged configuration never flows into this recovery path.
+const MAX_BYTES=1024*1024;
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const isObject=v=>v!==null&&typeof v==='object'&&!Array.isArray(v);
+
+export function salvageSafeCommanderLimits(raw){
+ if(typeof raw!=='string'||Buffer.byteLength(raw,'utf8')>MAX_BYTES)return {};
+ let str=raw.charCodeAt(0)===0xfeff?raw.slice(1):raw;
+ if(!str.trimStart().startsWith('{'))return {};
+ const base=str.indexOf('{'),ends=[];
+ let depth=0,quoted=false,escaped=false;
+ for(let i=base;i<str.length;i++){
+  const c=str[i];
+  if(quoted){if(escaped)escaped=false;else if(c==='\\')escaped=true;else if(c==='"')quoted=false;continue;}
+  if(c==='"'){quoted=true;continue;}
+  if(c==='{'||c==='['){depth++;continue;}
+  if(c==='}'||c===']'){depth--;if(depth===0){ends.push({index:i+1,complete:true});break;}if(depth<0)break;continue;}
+  if(c===','&&depth===1)ends.push({index:i,complete:false});
+ }
+ let obj={};
+ for(const item of ends.reverse()){
+  try{
+   const v=JSON.parse(str.slice(base,item.index)+(item.complete?'':'}'));
+   if(isObject(v)){obj=v;break;}
+  }catch{}
+ }
+ const safe={};
+ for(const [key,max] of [['fileReadLineLimit',1000],['fileWriteLineLimit',50]]){
+  const value=obj[key];
+  if(Number.isSafeInteger(value)&&value>=1&&value<=max)safe[key]=value;
+ }
+ return safe;
+}
+
+export async function recoverCorruptCommanderConfig(file,bytes,defaults){
+ if(!Buffer.isBuffer(bytes)||bytes.length>MAX_BYTES)throw new Error('Commander config corrupt or oversized; manual inspection required');
+ if(!isObject(defaults))throw new Error('recovery defaults invalid');
+ const safe=salvageSafeCommanderLimits(bytes.toString('utf8'));
+ const next={...structuredClone(defaults),...safe};
+ // The only trusted recovered settings are bounded display limits.
+ next.telemetryEnabled=false;
+ next.allowedDirectories=[];
+ next.blockedCommands=structuredClone(defaults.blockedCommands);
+ const current=await readFile(file);
+ if(sha(current)!==sha(bytes))throw new Error('Commander config changed during recovery; stop');
+ const backup=path.basename(file)+'.corrupt.'+Date.now()+'.'+randomUUID();
+ const backupPath=path.join(path.dirname(file),backup);
+ await writeFile(backupPath,bytes,{flag:'wx',mode:0o600});
+ const tmp=file+'.recover-'+randomUUID();
+ try{
+  await writeFile(tmp,JSON.stringify(next)+'\n',{flag:'wx',mode:0o600});
+  const verify=await readFile(file);
+  if(sha(verify)!==sha(bytes))throw new Error('Commander config changed during recovery; stop');
+  await rename(tmp,file);
+ }catch(error){
+  const {rm}=await import('node:fs/promises');
+  await rm(tmp,{force:true}).catch(()=>{});
+  throw error;
+ }
+ return {config:next,recovery:{status:'recovered',backup_filename:backup,corrupt_sha256:sha(bytes),salvaged_keys:Object.keys(safe)}};
+}

package/src/commander-extended-runtime.mjs

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { canonicalJson } from './canonical-json.mjs';
 import { createDeadbytePdf } from './commander-pdf-r48.mjs';
 import { DEADBYTE_VERSION } from './version.mjs';
+import {recoverCorruptCommanderConfig} from './commander-config-recovery-r137.mjs';
 
 export const COMMANDER_EXTENDED_SCHEMA='deadbyte.commander-extended.v1';
 const MAX_VALUE=16384,MAX_FEEDBACK=4096,MAX_PREVIEW=65536;
@@ -44,17 +45,33 @@ function makePdf(text){
 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;
+  let configCache=null,recovery=null,loadPromise=null;
   async function loadConfig(){
     if(configCache)return 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;
+    if(!loadPromise)loadPromise=(async()=>{
+      let bytes;
+      try{bytes=await readFile(configPath);}
+      catch(e){
+        if(e?.code!=='ENOENT')throw e;
+        configCache=structuredClone(COMPAT_CONFIG_DEFAULTS);return configCache;
+      }
+      try{
+        const parsed=JSON.parse(bytes.toString('utf8'));
+        if(!parsed||typeof parsed!=='object'||Array.isArray(parsed))throw new SyntaxError('config must be an object');
+        configCache={...structuredClone(COMPAT_CONFIG_DEFAULTS),...parsed};
+      }catch(e){
+        if(!(e instanceof SyntaxError))throw e;
+        const result=await recoverCorruptCommanderConfig(configPath,bytes,COMPAT_CONFIG_DEFAULTS);
+        configCache=result.config;recovery=result.recovery;
+      }
+      return configCache;
+    })();
+    try{return await loadPromise;}finally{loadPromise=null;}
   }
   async function getConfig({key=null}={}){
     const cfg=await loadConfig();
     if(key!==null&&!keyOk(key))throw new Error('config key invalid');
-    return {schema:COMMANDER_EXTENDED_SCHEMA,status:'ok',config:key===null?structuredClone(cfg):{[key]:cfg[key]},config_sha256:sha256(cfg)};
+    return {schema:COMMANDER_EXTENDED_SCHEMA,status:'ok',config:key===null?structuredClone(cfg):{[key]:cfg[key]},config_sha256:sha256(cfg),...(recovery?{recovery:structuredClone(recovery)}:{})};
   }
   async function setConfigValue({key,value,expected_sha256}){
     if(!keyOk(key))throw new Error('config key invalid');

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

@@ -61,17 +61,39 @@ export function createCommanderExternalProcessRuntime({observationRuntime,hostPo
     let cursor=null,first=null;
     const processes=[];
     const receiptIds=[];
+    const cursorSet=new Set(),pidSet=new Set();
     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(typeof page.snapshot_id!=='string'||!/^[0-9a-f]{64}$/.test(page.snapshot_id))
+        throw new Error('external process observation snapshot identity invalid');
+      if(typeof page.observed_at_utc!=='string'||!ISO_UTC.test(page.observed_at_utc)||
+         !Number.isFinite(Date.parse(page.observed_at_utc)))
+        throw new Error('external process observation timestamp invalid');
       if(!first) first=page;
-      else if(page.snapshot_id!==first.snapshot_id) throw new Error('external process observation snapshot changed during pagination');
+      else{
+        if(page.snapshot_id!==first.snapshot_id) throw new Error('external process observation snapshot changed during pagination');
+        if(page.observed_at_utc!==first.observed_at_utc)
+          throw new Error('external process observation time changed during pagination');
+      }
+      if(page.processes.length>PAGE_SIZE)throw new Error('external process observation page exceeds bounded limit');
       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));
+        const identity=normalizeIdentity(item);
+        if(pidSet.has(identity.pid))throw new Error('external process observation duplicate PID');
+        pidSet.add(identity.pid);
+        processes.push(identity);
       }
       if(typeof page.receipt_id==='string') receiptIds.push(page.receipt_id);
-      cursor=page.next_cursor??null;
+      const next=page.next_cursor??null;
+      if(next!==null){
+        if(typeof next!=='string'||next.length<1||next.length>8192)throw new Error('external process observation cursor invalid');
+        if(cursorSet.has(next))throw new Error('external process pagination cursor repeated');
+        cursorSet.add(next);
+        if(cursorSet.size>Math.ceil(MAX_PROCESSES/PAGE_SIZE)+1)
+          throw new Error('external process pagination exceeded page limit');
+      }
+      cursor=next;
     }while(cursor!==null);
     return {
       status:'ok',

package/src/commander-large-text-r139.mjs

@@ -0,0 +1,66 @@
+// Bounded-memory Commander text paging, using only the policy-authorized native filesystem.
+// Never rewrites the file. Pages accumulate a SHA-256 checked against one final native hash.
+import {createHash} from 'node:crypto';
+const SHA=/^[a-f0-9]{64}$/;
+const MAX_SCAN=64*1024*1024;
+const MAX_LINE=4*1024*1024;
+
+export async function readCommanderLargeText({runtime,rootId,relativePath,offset=0,length=1000}={}){
+ if(!runtime||typeof runtime.read!=='function')throw new Error('native filesystem read unavailable');
+ if(!Number.isInteger(offset)||offset<0||!Number.isInteger(length)||length<0||length>10000)
+  throw new Error('large text offset or length invalid');
+ const policyChunk=runtime.policy?.max_read_bytes??256*1024;
+ const chunkSize=Math.min(256*1024,policyChunk);
+ if(!Number.isSafeInteger(chunkSize)||chunkSize<1)throw new Error('large text read policy limit invalid');
+ const decoder=new TextDecoder('utf-8',{fatal:true,ignoreBOM:true});
+ let pending='',position=0,fileSha=null,fileSize=null,totalLines=0,scanned=0,done=false;
+ const streamedHash=createHash('sha256');
+ const selected=[];
+ const emit=line=>{
+  if(totalLines>=offset&&selected.length<length)selected.push(line);
+  totalLines++;
+ };
+ const feed=(part,final=false)=>{
+  const value=pending+part;
+  const re=/\r\n|\r|\n/g;
+  let match,from=0;
+  while((match=re.exec(value))){
+   if(!final&&match[0]==='\r'&&match.index+1===value.length)break;
+   emit(value.slice(from,match.index));
+   from=match.index+match[0].length;
+  }
+  pending=value.slice(from);
+  if(Buffer.byteLength(pending,'utf8')>MAX_LINE)throw new Error('large text line exceeds bounded read limit');
+  if(final)emit(pending);
+ };
+ while(!done){
+  const page=await runtime.read({rootId,relativePath,offset:position,maxBytes:chunkSize,hashFile:false});
+  if(Number.isSafeInteger(page.file_size)){
+   if(fileSize===null)fileSize=page.file_size;
+   else if(fileSize!==page.file_size)throw new Error('large text file changed during paged read: size mismatch');
+   if(fileSize>MAX_SCAN)throw new Error('large text file exceeds bounded 64MiB scan limit');
+  }
+  if(!Number.isSafeInteger(page.offset)||page.offset!==position)throw new Error('large text native page offset drift');
+  if(typeof page.data_base64!=='string')throw new Error('large text native payload missing');
+  const bytes=Buffer.from(page.data_base64,'base64');
+  if(bytes.length>chunkSize||page.next_offset!==position+bytes.length)throw new Error('large text native page cursor invalid');
+  if(bytes.length===0&&page.eof!==true)throw new Error('large text read stalled before EOF');
+  streamedHash.update(bytes);
+  position+=bytes.length;scanned+=bytes.length;
+  if(scanned>MAX_SCAN)throw new Error('large text file exceeds bounded 64MiB scan limit');
+  feed(decoder.decode(bytes,{stream:true}));
+  if(page.eof===true){feed(decoder.decode(),true);done=true;}
+ }
+ if(fileSize!==null&&fileSize!==position)throw new Error('large text file changed during paged read: size mismatch');
+ // One native full-file hash after all delivered bytes binds them to final file contents.
+ const closing=await runtime.read({rootId,relativePath,offset:position,maxBytes:1,hashFile:true});
+ if(!SHA.test(closing?.file_sha256??''))throw new Error('large text native file identity missing');
+ if(closing.offset!==position||closing.next_offset!==position||closing.eof!==true||
+    closing.data_base64!==''||!Number.isSafeInteger(closing.file_size)||closing.file_size!==position)
+  throw new Error('large text file changed during paged read: closing cursor or size mismatch');
+ fileSha=closing.file_sha256;
+ if(streamedHash.digest('hex')!==fileSha)throw new Error('large text file changed during paged read: identity mismatch');
+ const start=Math.min(offset,totalLines);
+ return {content:selected.join('\n')+(start+selected.length<totalLines?'\n':''),
+  lineOffset:start,lineCount:selected.length,totalLines,fileSha256:fileSha,bytesScanned:scanned,paged:true};
+}

package/src/commander-wire-adapter-r47.mjs

@@ -5,6 +5,7 @@ import { readCommanderUrl } from './commander-url-reader-r48.mjs';
 import { readDocxBytes, searchDocxTextBytes, createDocxBytes, editDocxBytes, readXlsxBytes, editXlsxBytes, createXlsxBytes, appendXlsxBytes } from './commander-office-reader-r48.mjs';
 import { editDeadbytePdf, parseDeadbytePdf, readPdfText } from './commander-pdf-r48.mjs';
 import { decodeUtf8Strict } from './text-policy.mjs';
+import { readCommanderLargeText } from './commander-large-text-r139.mjs';
 
 const sha256Bytes = bytes => createHash('sha256').update(bytes).digest('hex');
 const RDC_PROCESS_READ_CHUNK=256*1024;
@@ -207,12 +208,26 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
       const tail=await machineFsRuntime.read({
         rootId:target.rootId,relativePath:target.relativePath,offset:-policyMax,maxBytes:policyMax,hashFile:false
       });
-      let decoded=Buffer.from(tail.data_base64,'base64').toString('utf8').replaceAll('\r\n','\n').replaceAll('\r','\n');
+      let tailBytes=Buffer.from(tail.data_base64,'base64');
       if((tail.offset??0)>0){
-        const firstBreak=decoded.indexOf('\n');
-        if(firstBreak<0) throw new Error('text tail window contains no complete line');
-        decoded=decoded.slice(firstBreak+1);
+        const previous=await machineFsRuntime.read({
+          rootId:target.rootId,relativePath:target.relativePath,
+          offset:tail.offset-1,maxBytes:1,hashFile:false
+        });
+        const before=Buffer.from(previous.data_base64,'base64');
+        if(previous.offset!==tail.offset-1||previous.next_offset!==tail.offset||
+           previous.file_size!==tail.file_size||before.length!==1)
+          throw new Error('text tail window changed before boundary check');
+        const aligned=before[0]===0x0a||(before[0]===0x0d&&tailBytes[0]!==0x0a);
+        if(!aligned){
+          const firstBreak=tailBytes.findIndex(byte=>byte===0x0a||byte===0x0d);
+          if(firstBreak<0) throw new Error('text tail window contains no complete line');
+          const crlf=tailBytes[firstBreak]===0x0d&&tailBytes[firstBreak+1]===0x0a;
+          tailBytes=tailBytes.subarray(firstBreak+(crlf?2:1));
+        }
       }
+      if(tailBytes.includes(0)) throw new Error('text tail window contains NUL byte');
+      let decoded=decodeUtf8Strict(tailBytes).replaceAll('\r\n','\n').replaceAll('\r','\n');
       let all=decoded.split('\n');
       if(all.length&&all.at(-1)==='') all.pop();
       const wanted=Math.abs(requestedOffset);
@@ -232,6 +247,13 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
       hashFile:richDocument
     });
     if(richDocument&&raw.eof===false) throw new Error('document exceeds bounded native read limit');
+    if(!richDocument&&raw.eof===false&&!imageMime&&ext!=='.xls'){
+      const large=await readCommanderLargeText({runtime:machineFsRuntime,
+        rootId:target.rootId,relativePath:target.relativePath,
+        offset:requestedOffset,length:requestedLength});
+      return text(large.content,false,{path:args.path,content:large.content,
+        mimeType:'text/plain',isImage:false,isPdf:false,...large,...optionMeta});
+    }
     if(!richDocument&&raw.eof===false) throw new Error('text file exceeds bounded compatibility read limit');
     const bytes=Buffer.from(raw.data_base64,'base64');
     const fileSha256=raw.file_sha256??sha256Bytes(bytes);
@@ -477,11 +499,17 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
       });
     }
     if(args.old_string===undefined||args.new_string===undefined) throw new Error('Must provide either old_string + new_string');
-    const raw=await machineFsRuntime.read({rootId:target.rootId,relativePath:target.relativePath,offset:0,maxBytes:Math.min(4*1024*1024,machineFsRuntime.policy.max_read_bytes??4*1024*1024),hashFile:false});
+    const editBound=16*1024*1024;
+    const raw=await machineFsRuntime.read({rootId:target.rootId,relativePath:target.relativePath,offset:0,
+      maxBytes:Math.min(editBound,machineFsRuntime.policy.max_read_bytes??editBound),hashFile:true});
     if(raw.eof===false) throw new Error('text edit target exceeds bounded compatibility edit limit');
     const before=Buffer.from(raw.data_base64,'base64');
+    if(before.includes(0))throw new Error('binary text edit target rejected');
+    let current;
+    try{current=decodeUtf8Strict(before);}catch{throw new Error('invalid UTF-8 in text edit target');}
+    if(before.length>=3&&before[0]===0xef&&before[1]===0xbb&&before[2]===0xbf)
+      current='\uFEFF'+current;
     const fileSha256=raw.file_sha256??sha256Bytes(before);
-    const current=before.toString('utf8');
     let count=0,index=0;
     while((index=current.indexOf(args.old_string,index))>=0){count++;index+=Math.max(1,args.old_string.length);}
     if(count!==args.expected_replacements) throw new Error(`expected ${args.expected_replacements} replacements, found ${count}`);
@@ -652,7 +680,20 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
     }
     pidMap.set(compatPid,native.session_id);
     processCompatState.set(compatPid,{last_read_byte:0});
-    return text(`Process started with PID ${compatPid} (DEADBYTE session ${native.session_id})\\n`,false,{pid:compatPid,session_id:native.session_id});
+    let initialOutput='',previewUnavailable=false,previewTruncated=false;
+    try{
+      // Optional, non-waiting preview: does not advance the independent output cursor.
+      const first=await processRuntime.read({sessionId:native.session_id,offset:0,maxBytes:16384,waitMs:0});
+      const data=Buffer.from(first.data_base64??'','base64');
+      if(data.includes(0))throw new Error('binary process output preview');
+      initialOutput=decodeUtf8Strict(data);
+      previewTruncated=(first.stream_head??data.length)>(first.next_offset??data.length);
+    }catch{previewUnavailable=true;}
+    const summary=`Process started with PID ${compatPid} (DEADBYTE session ${native.session_id})`;
+    return text(initialOutput?summary+'\n'+initialOutput:summary+'\n',false,{
+      pid:compatPid,session_id:native.session_id,initial_output:initialOutput,
+      initial_output_truncated:previewTruncated,output_preview_unavailable:previewUnavailable
+    });
   }
   function sessionForPid(pid){
     const sessionId=pidMap.get(pid);
@@ -693,7 +734,9 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
         state:snapshot.state,exitCode:snapshot.exit_code,truncated:wasTruncated
       }),false,{
         pid:args.pid,session_id:sessionId,read_from:readFrom,read_count:readCount,total_lines:retainedRanges.length,
-        remaining,next_line:readFrom+readCount,stream_head:snapshot.stream_head,state:snapshot.state,exit_code:snapshot.exit_code
+        remaining,next_line:readFrom+readCount,stream_head:snapshot.stream_head,state:snapshot.state,exit_code:snapshot.exit_code,
+        earliest_offset:snapshot.earliest_offset,truncated:wasTruncated,
+        next_byte_offset:state.last_read_byte,more_unread:state.last_read_byte<snapshot.stream_head
       });
     }
     const totalLines=retainedRanges.length;
@@ -705,7 +748,9 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
       readFrom,readCount,totalLines,remaining,lines,state:snapshot.state,exitCode:snapshot.exit_code,truncated:snapshot.earliest_offset>0
     }),false,{
       pid:args.pid,session_id:sessionId,read_from:readFrom,read_count:readCount,total_lines:totalLines,
-      remaining,next_line:readFrom+readCount,stream_head:snapshot.stream_head,state:snapshot.state,exit_code:snapshot.exit_code
+      remaining,next_line:readFrom+readCount,stream_head:snapshot.stream_head,state:snapshot.state,exit_code:snapshot.exit_code,
+      earliest_offset:snapshot.earliest_offset,truncated:snapshot.earliest_offset>0,
+      next_byte_offset:null,more_unread:remaining>0
     });
   }
   async function interactProcess(args){
@@ -745,8 +790,15 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
     return text(`Successfully terminated process ${args.pid}`,false,{pid:args.pid,session_id:sessionId,...native});
   }
   async function listSessions(){
+    if(!processRuntime)throw new Error('process runtime is disabled');
     const native=await processRuntime.list();
-    return text(native.sessions.map(s=>`Session ${s.session_id}: state=${s.state}, profile=${s.profile_id}, root=${s.root_id}`).join('\\n'),false,{sessions:native.sessions});
+    if(!Array.isArray(native?.sessions))throw new Error('native session inventory unavailable');
+    const rows=native.sessions.map(s=>{
+      const pid=Number.isInteger(s.child_pid)&&s.child_pid>0?String(s.child_pid):'unknown';
+      const exit=s.state==='running'?'':`, exit=${Number.isInteger(s.exit_code)?s.exit_code:'unknown'}`;
+      return `Session ${s.session_id}: PID=${pid}, state=${s.state}, profile=${s.profile_id}, root=${s.root_id}${exit}`;
+    });
+    return text(rows.length?rows.join('\n'):'No managed sessions.',false,{sessions:native.sessions});
   }
   async function listProcesses(){
     if(!externalProcessRuntime) return listSessions();
@@ -882,11 +934,10 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
   async function getMoreSearchResults(args){
     const s=searchSessions.get(args.sessionId);
     if(!s) throw new Error('search session not found');
-    if(!s.isComplete) return {results:[],returnedCount:0,totalResults:0,isComplete:false,isError:false,hasMoreResults:true};
     const start=args.offset<0?Math.max(0,s.results.length+args.offset):args.offset;
     const end=args.offset<0?s.results.length:Math.min(s.results.length,start+args.length);
     const results=s.results.slice(start,end);
-    return {results,returnedCount:results.length,totalResults:s.results.length,isComplete:true,isError:s.isError,error:s.error,hasMoreResults:end<s.results.length,runtime:Date.now()-s.created};
+    return {results,returnedCount:results.length,totalResults:s.results.length,isComplete:s.isComplete,isError:s.isError,error:s.error,hasMoreResults:!s.isComplete||end<s.results.length,runtime:Date.now()-s.created};
   }
   async function stopSearch(args){
     const s=searchSessions.get(args.sessionId);

package/src/deadbyte-cli.mjs

@@ -400,7 +400,11 @@ async function cleanupRemoteSession(ctx,{displayMode='unicode'}={}){
   for(const command of SESSION_CLEANUP){
     try{
       const result=invokeController(ctx,command,{allowFailure:true,capture:true,echoCaptured:false,timeoutMs:REMOTE_STATUS_TIMEOUT_MS});
-      if(result.status!==0){failed.push(command);writeRemote(process.stderr,`${remoteTag('warn',displayMode)} cleanup ${command} exit=${result.status}\n`,displayMode);}
+      if(result.status!==0){
+        failed.push(command);
+        const detail=boundedSingleLine(result.stderr||result.stdout||'controller returned no diagnostic',512);
+        writeRemote(process.stderr,`${remoteTag('warn',displayMode)} cleanup ${command} exit=${result.status}: ${detail}\n`,displayMode);
+      }
     }
     catch(error){failed.push(command);writeRemote(process.stderr,`${remoteTag('warn',displayMode)} cleanup ${command}: ${String(error?.message||error)}\n`,displayMode);}
   }

package/src/scoped-observer-launcher-r136.mjs

@@ -0,0 +1,77 @@
+import {fork} from 'node:child_process';
+import {fileURLToPath} from 'node:url';
+import path from 'node:path';
+
+const worker=fileURLToPath(new URL('./scoped-observer-worker-r136.mjs',import.meta.url));
+const hex=/^[0-9a-f]{64}$/;
+export async function startScopedObserver({stateRoot,codingPolicyFile,autonomousPolicyFile,codingSha256,autonomousSha256,ambientEnv={}}={}){
+ if(![stateRoot,codingPolicyFile,autonomousPolicyFile].every(p=>typeof p==='string'&&path.isAbsolute(p)))
+  throw new Error('observer absolute isolated paths required');
+ if(!hex.test(codingSha256??'')||!hex.test(autonomousSha256??''))
+  throw new Error('observer pinned policy SHA256 required');
+ // Deliberately no DEADBYTE_ authority config, inherited token, NODE_OPTIONS,
+ // or shell PATH. Child is a disarmed status-only IPC process, not an OS sandbox.
+ const env={};
+ for(const key of ['SystemRoot','SYSTEMROOT','windir','WINDIR','TEMP','TMP']){
+  if(typeof process.env[key]==='string')env[key]=process.env[key];
+ }
+ // ambientEnv is an adversarial test vector and is NEVER merged.
+ void ambientEnv;
+ const child=fork(worker,[stateRoot,codingPolicyFile,codingSha256,autonomousPolicyFile,autonomousSha256],{
+  execPath:process.execPath,execArgv:[],cwd:stateRoot,env,stdio:['ignore','ignore','ignore','ipc'],windowsHide:true
+ });
+ let pending=new Map(),serial=0,closed=false;
+ const rejectAll=reason=>{for(const {reject,timer} of pending.values()){clearTimeout(timer);reject(reason);}pending.clear();};
+ let bootResolve,bootReject;
+ const boot=new Promise((resolve,reject)=>{bootResolve=resolve;bootReject=reject});
+ let bootFinished=false;
+ const bootTimer=setTimeout(()=>{if(!bootFinished){bootFinished=true;bootReject(new Error('observer boot failed: timeout'));child.kill();}},6000);
+ child.on('message',msg=>{
+  if(msg?.kind==='ready'&&!bootFinished){bootFinished=true;clearTimeout(bootTimer);bootResolve(msg.result);return;}
+  if(msg?.kind==='boot-error'&&!bootFinished){bootFinished=true;clearTimeout(bootTimer);bootReject(new Error('observer boot failed: '+msg.reason));child.kill();return;}
+  if(msg?.kind==='reply'){
+   const p=pending.get(msg.id);if(!p)return;pending.delete(msg.id);clearTimeout(p.timer);p.resolve(msg.result);
+  }
+ });
+ child.on('error',error=>{if(!bootFinished){bootFinished=true;clearTimeout(bootTimer);bootReject(error);}rejectAll(error);});
+ child.on('exit',(code)=>{
+  closed=true;
+  if(!bootFinished){bootFinished=true;clearTimeout(bootTimer);bootReject(new Error('observer boot failed: exit '+code));}
+  rejectAll(new Error('observer exited'));
+ });
+ let ready;
+ try{ready=await boot;}catch(error){
+  if(!closed){
+   const exited=new Promise(resolve=>{
+    const timer=setTimeout(()=>{child.kill();},1500);
+    child.once('exit',()=>{clearTimeout(timer);resolve();});
+   });
+   child.kill();await exited;
+  }
+  throw error;
+ }
+ const request=payload=>{
+  if(closed) return Promise.reject(new Error('observer already exited'));
+  return new Promise((resolve,reject)=>{
+   const id=++serial;
+   const timer=setTimeout(()=>{pending.delete(id);reject(new Error('observer request timeout'));child.kill();},3000);
+   pending.set(id,{resolve,reject,timer});
+   try{child.send({kind:'request',id,op:payload?.op},err=>{if(err){clearTimeout(timer);pending.delete(id);reject(err);}});}
+   catch(error){clearTimeout(timer);pending.delete(id);reject(error);}
+  });
+ };
+ return Object.freeze({
+  ready,
+  request,
+  async close(){
+   if(closed)return;
+   const exited=new Promise(resolve=>{
+    if(closed)return resolve();
+    const timer=setTimeout(()=>{child.kill();},1500);
+    child.once('exit',()=>{clearTimeout(timer);resolve();});
+   });
+   try{await request({op:'shutdown'});}catch{child.kill();}
+   await exited;
+  }
+ });
+}