deadbyte-mcp 0.15.13 → 0.15.15

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.15.13';
+export const DEADBYTE_VERSION = '0.15.15';
 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/observation-runtime.test.mjs

@@ -148,3 +148,31 @@ test('R46 observation search hard cap fails closed while all retained sessions a
   await waitTerminal(f.runtime,a.search_id).catch(()=>{});
   await waitTerminal(f.runtime,b.search_id).catch(()=>{});
 });
+test('R46 search cursor rejects tampering, wrong search, rewind, and expired snapshot', async () => {
+  let now=1000;
+  const f=await fixture({searchSessionTtlMs:50,clockMs:()=>now});
+  await writeFile(path.join(f.project,'a.txt'),'needle a\nneedle aa\n');
+  await writeFile(path.join(f.project,'b.txt'),'needle b\n');
+  const first=await f.runtime.searchStart({rootId:'project',relativePath:'.',pattern:'needle',maxResults:10,maxFiles:10,maxBytes:65536});
+  await waitTerminal(f.runtime,first.search_id);
+  const p1=await f.runtime.searchPage({searchId:first.search_id,limit:1});
+  assert.match(p1.results[0].result_id,/^[0-9a-f]{64}$/);
+  assert.match(p1.results[0].file_sha256,/^[0-9a-f]{64}$/);
+  assert.equal(p1.snapshot_id,first.snapshot_id);
+  const p2=await f.runtime.searchPage({searchId:first.search_id,limit:1,cursor:p1.next_cursor});
+  assert.equal(p2.results.length,1);
+  const p2Retry=await f.runtime.searchPage({searchId:first.search_id,limit:1,cursor:p1.next_cursor});
+  assert.deepEqual(p2Retry.results.map(x=>x.result_id),p2.results.map(x=>x.result_id));
+  const p3=await f.runtime.searchPage({searchId:first.search_id,limit:1,cursor:p2.next_cursor});
+  assert.equal(p3.results.length,1);
+  await assert.rejects(f.runtime.searchPage({searchId:first.search_id,limit:1,cursor:p1.next_cursor}),/rewound search cursor rejected/);
+  const second=await f.runtime.searchStart({rootId:'project',relativePath:'.',pattern:'needle',maxResults:10,maxFiles:10,maxBytes:65536});
+  await waitTerminal(f.runtime,second.search_id);
+  await assert.rejects(f.runtime.searchPage({searchId:second.search_id,limit:1,cursor:p1.next_cursor}),/invalid observation cursor|invalid, tampered, rewound, or mismatched search cursor/);
+  const raw=Buffer.from(p1.next_cursor,'base64url').toString('utf8');
+  const tampered=Buffer.from(raw.slice(0,-1)+(raw.endsWith('a')?'b':'a'),'utf8').toString('base64url');
+  await assert.rejects(f.runtime.searchPage({searchId:first.search_id,limit:1,cursor:tampered}),/invalid observation cursor|invalid, tampered, rewound, or mismatched search cursor/);
+  now+=60;
+  await assert.rejects(f.runtime.searchPage({searchId:first.search_id,limit:1,cursor:p2.next_cursor}),/unknown or expired search|search snapshot expired/);
+});
+

package/test/operation-history.test.mjs

@@ -0,0 +1,61 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createOperationHistory, operationHistoryReceipt } from '../src/operation-history.mjs';
+
+test('hash-chain preserves operation continuity', () => {
+  const h=createOperationHistory({maxEvents:8,maxBytes:65536,operationId:'op-1'});
+  const a=h.append('started',{root_id:'r1'});
+  const b=h.append('progress',{n:1});
+  assert.equal(b.previous_event_hash,a.event_hash);
+  assert.equal(h.verify().ok,true);
+  const page=h.read({afterSequence:0,limit:8});
+  assert.deepEqual(page.events.map(x=>x.sequence),[1,2]);
+  assert.equal(page.next_sequence,2);
+});
+
+test('payload mutation after append cannot alter recorded digest', () => {
+  const h=createOperationHistory({operationId:'op-2'});
+  const payload={value:'before'};
+  const e=h.append('input',payload);
+  payload.value='after';
+  assert.equal(h.verify().ok,true);
+  assert.equal(e.payload_digest.length,64);
+});
+
+test('event cap creates explicit bounded-retention overflow', () => {
+  const h=createOperationHistory({maxEvents:2,maxBytes:65536,operationId:'op-3'});
+  h.append('a'); h.append('b'); h.append('c');
+  const v=h.verify();
+  assert.equal(v.ok,true);
+  assert.equal(v.overflow.occurred,true);
+  assert.equal(v.overflow.reason,'event_cap');
+  assert.equal(v.overflow.dropped,1);
+  assert.throws(()=>h.read({afterSequence:0}),/cursor expired/);
+});
+
+test('byte cap creates explicit overflow boundary', () => {
+  const h=createOperationHistory({maxEvents:100,maxBytes:1200,operationId:'op-4'});
+  for(let i=0;i<20;i++) h.append('payload',{i,text:'x'.repeat(80)});
+  const v=h.verify();
+  assert.equal(v.ok,true);
+  assert.equal(v.overflow.occurred,true);
+  assert.equal(v.overflow.reason,'byte_cap');
+});
+
+test('same operation cursor resumes after acknowledged boundary without duplicates', () => {
+  const h=createOperationHistory({operationId:'op-5'});
+  h.append('a'); h.append('b'); h.append('c');
+  const first=h.read({afterSequence:0,limit:2});
+  const second=h.read({afterSequence:first.next_sequence,limit:2});
+  assert.deepEqual(first.events.map(e=>e.sequence),[1,2]);
+  assert.deepEqual(second.events.map(e=>e.sequence),[3]);
+  assert.equal(new Set([...first.events,...second.events].map(e=>e.sequence)).size,3);
+});
+
+test('receipt exposes evidence head without becoming authority', () => {
+  const h=createOperationHistory({operationId:'op-6'});
+  h.append('started');
+  const receipt=operationHistoryReceipt(h);
+  assert.equal(receipt.operation_id,'op-6');
+  assert.match(receipt.head_event_hash,/^[0-9a-f]{64}$/);
+});

package/test/operation-lifecycle.test.mjs

@@ -0,0 +1,72 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createOperationLifecycle } from '../src/operation-lifecycle.mjs';
+
+test('lifecycle is monotonic and terminal exactly once', () => {
+  const op=createOperationLifecycle({operationId:'a'.repeat(64),clockMs:()=>1234});
+  op.emit('start',{kind:'process'});
+  op.emit('running',{pid:123});
+  op.emit('output',{channel:'stdout',bytes:4,payload_digest:'b'.repeat(64)});
+  const terminal=op.terminal('success',{exit_code:0});
+  assert.equal(terminal.event.sequence,4);
+  assert.equal(op.snapshot().state,'success');
+  assert.equal(op.snapshot().terminal.sequence,4);
+  assert.throws(()=>op.terminal('failure'),/terminal transition already committed/);
+  assert.throws(()=>op.emit('output'),/late operation event rejected/);
+  const receipt=op.receipt();
+  assert.equal(receipt.terminal_sequence,4);
+  assert.equal(receipt.terminal_event_hash,terminal.event.event_hash);
+  assert.equal(receipt.head_event_hash,terminal.event.event_hash);
+});
+
+test('cancel and timeout terminal outcomes are mutually exclusive', () => {
+  const cancelled=createOperationLifecycle({operationId:'c'.repeat(64)});
+  cancelled.emit('start'); cancelled.emit('running'); cancelled.emit('cancel_requested',{reason:'operator'});
+  cancelled.emit('canceling',{reason:'cancel'});
+  const c=cancelled.terminal('cancelled');
+  assert.equal(cancelled.snapshot().terminal.type,'cancelled');
+  assert.equal(cancelled.receipt().terminal_event_hash,c.event.event_hash);
+  const timed=createOperationLifecycle({operationId:'d'.repeat(64)});
+  timed.emit('start'); timed.emit('running'); timed.emit('canceling',{reason:'deadline_exceeded'});
+  const t=timed.terminal('timed_out');
+  assert.equal(timed.snapshot().terminal.type,'timed_out');
+  assert.equal(timed.receipt().terminal_event_hash,t.event.event_hash);
+});
+
+test('invalid transition and duplicate start fail closed', () => {
+  const op=createOperationLifecycle({operationId:'e'.repeat(64)});
+  assert.throws(()=>op.emit('running'),/invalid operation transition/);
+  op.emit('start');
+  assert.throws(()=>op.emit('start'),/duplicate operation start/);
+  assert.throws(()=>op.emit('canceling'),/invalid operation transition/);
+});
+
+test('producer failure terminal is distinct from cancellation', () => {
+  const op=createOperationLifecycle({operationId:'f'.repeat(64)});
+  op.emit('start'); op.emit('running'); op.emit('error',{channel:'stderr',bytes:1});
+  const terminal=op.terminal('failure',{exit_code:7});
+  assert.equal(op.snapshot().terminal.type,'failure');
+  assert.equal(terminal.event.sequence,4);
+});
+test('history eviction remains evidence-only and terminal receipt binds the retained head', () => {
+  const op=createOperationLifecycle({operationId:'9'.repeat(64),maxEvents:4,maxBytes:65536});
+  op.emit('start'); op.emit('running');
+  op.emit('output',{bytes:1});
+  op.emit('output',{bytes:1});
+  op.emit('output',{bytes:1});
+  const terminal=op.terminal('success',{exit_code:0});
+  const snapshot=op.snapshot();
+  assert.equal(snapshot.overflow.occurred,true);
+  assert.equal(snapshot.overflow.reason,'event_cap');
+  assert.equal(op.receipt().terminal_event_hash,terminal.event.event_hash);
+  assert.equal(op.receipt().head_event_hash,terminal.event.event_hash);
+});
+
+test('late producer event after terminal is rejected and cannot mutate terminal proof', () => {
+  const op=createOperationLifecycle({operationId:'a'.repeat(64)});
+  op.emit('start'); op.emit('running');
+  const terminal=op.terminal('success',{exit_code:0});
+  assert.throws(()=>op.emit('output',{bytes:1}),/late operation event rejected/);
+  assert.equal(op.receipt().terminal_event_hash,terminal.event.event_hash);
+});
+

package/test/process-readiness.test.mjs

@@ -0,0 +1,32 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  analyzeReadiness,
+  detectPrompt,
+  lineEndingProfile,
+  normalizeLineEndings,
+  createReadinessTracker
+} from '../src/process-readiness.mjs';
+
+const LF=String.fromCharCode(10);
+const CR=String.fromCharCode(13);
+
+test('detects prompts without treating arbitrary output as ready', () => {
+  assert.deepEqual(detectPrompt('hello'+LF+'>>> '), { profile: 'python', prompt: '>>> ' });
+  assert.equal(detectPrompt('hello'+LF+'still running'), null);
+  assert.equal(analyzeReadiness({stdout:'hello'+LF+'still running'}).state, 'running');
+});
+
+test('distinguishes terminal state from prompt state', () => {
+  assert.equal(analyzeReadiness({stdout:'PS C:'+String.fromCharCode(92)+'work> ', state:'running'}).state, 'ready_for_input');
+  assert.equal(analyzeReadiness({stdout:'Exit code: 7', state:'running', exitCode:7}).state, 'finished');
+  assert.equal(analyzeReadiness({stdout:'anything', state:'exited', exitCode:0}).evidence, 'process_terminal');
+});
+
+test('handles CRLF/LF/CR and normalization', () => {
+  const value='a'+CR+LF+'b'+CR+LF+'c'+LF;
+  assert.deepEqual(lineEndingProfile(value), { style:CR+LF, crlf:2, lf:1, cr:0, total:3, mixed:true });
+  assert.equal(normalizeLineEndings(value, LF), 'a'+LF+'b'+LF+'c'+LF);
+  assert.equal(normalizeLineEndings('a'+LF+'b', CR+LF), 'a'+CR+LF+'b');
+});
+

package/test/process-runtime.test.mjs

@@ -165,6 +165,11 @@ test('R46 process output retention evicts oldest bytes without losing tail ident
   assert.equal(recovered.stream_next_seq, null);
   assert.equal(recovered.stream_coverage, null);
   assert.ok(recovered.stream_head > 2 * 1024 * 1024);
+  assert.ok(recovered.operation_id);
+  assert.ok(recovered.operation_receipt);
+  assert.ok(recovered.operation.terminal.event_hash);
+  const recoveredEvidence = await recoveredRuntime.verifyOperationEvidence({ sessionId: started.session_id });
+  assert.equal(recoveredEvidence.ok, true);
 });
 
 test('R46 process raw input keeps persistent PowerShell state with bounded wait and tail reads', { skip: process.platform !== 'win32' }, async () => {
@@ -309,3 +314,87 @@ test('R32 named actions reject sessions after child exit', { skip: process.platf
 });
 
 
+test('R47 operation history integrates with real process lifecycle and signed terminal receipt', { skip: process.platform !== 'win32' }, async () => {
+  const f = await fixture();
+  const started = await f.runtime.start({ profileId: 'hold', rootId: 'core', cwd: '.', args: [] });
+  assert.match(started.operation_id, /^[0-9a-f]{64}$/);
+  assert.ok(['running','output'].includes(started.operation.state));
+  const stopped = await f.runtime.terminate({ sessionId: started.session_id });
+  assert.equal(stopped.operation.terminal.type, 'cancelled');
+  assert.ok(stopped.operation.terminal.sequence > 0);
+  assert.equal(stopped.operation.history_head_sha256, stopped.operation.terminal.event_hash);
+  assert.ok(stopped.operation_receipt);
+  assert.equal(stopped.operation_receipt.operation_id, started.operation_id);
+  assert.equal(stopped.operation_receipt.terminal.terminal_sequence, stopped.operation.terminal.sequence);
+  assert.equal(stopped.operation_receipt.terminal.terminal_event_hash, stopped.operation.terminal.event_hash);
+  const evidence = await f.runtime.verifyOperationEvidence({ sessionId: started.session_id });
+  assert.equal(evidence.ok, true);
+  assert.equal(evidence.operation_id, started.operation_id);
+  const history = await readFile(path.join(f.stateDir, started.session_id + '.operation.jsonl'), 'utf8');
+  const events = history.trim().split(/\r?\n/).map(line => JSON.parse(line));
+  assert.equal(events[0].event_type, 'start');
+  assert.equal(events.at(-1).event_type, 'cancelled');
+  assert.deepEqual(events.map(event => event.sequence), events.map((_, i) => i + 1));
+  assert.equal(events.at(-1).event_hash, stopped.operation_receipt.terminal.terminal_event_hash);
+});
+
+test('R47 concurrent cancel/terminate has one terminal operation event', { skip: process.platform !== 'win32' }, async () => {
+  const f = await fixture();
+  const started = await f.runtime.start({ profileId: 'hold', rootId: 'core', cwd: '.', args: [] });
+  const results = await Promise.allSettled([
+    f.runtime.cancel({ sessionId: started.session_id, reason: 'race_cancel' }),
+    f.runtime.terminate({ sessionId: started.session_id })
+  ]);
+  assert.ok(results.some(result => result.status === 'fulfilled'));
+  const status = await f.runtime.status({ sessionId: started.session_id });
+  assert.ok(['cancelled','timed_out'].includes(status.operation.terminal.type));
+  const history = await readFile(path.join(f.stateDir, started.session_id + '.operation.jsonl'), 'utf8');
+  const events = history.trim().split(/\r?\n/).map(line => JSON.parse(line));
+  const terminals = events.filter(event => ['success','failure','cancelled','timed_out'].includes(event.event_type));
+  assert.equal(terminals.length, 1);
+  assert.equal(events.at(-1).event_hash, status.operation_receipt.terminal.terminal_event_hash);
+  const evidence = await f.runtime.verifyOperationEvidence({ sessionId: started.session_id });
+  assert.equal(evidence.ok, true);
+});
+
+test('R47 timeout and producer failure map to distinct terminal evidence', { skip: process.platform !== 'win32' }, async () => {
+  const timed = await fixture();
+  const timedSession = await timed.runtime.start({
+    profileId:'powershell', rootId:'core', cwd:'.',
+    timeoutMs:250, args:['Start-Sleep -Seconds 5']
+  });
+  const deadline=Date.now()+5000;
+  let timedStatus=await timed.runtime.status({sessionId:timedSession.session_id});
+  while(timedStatus.state==='running' && Date.now()<deadline){ await sleep(25); timedStatus=await timed.runtime.status({sessionId:timedSession.session_id}); }
+  assert.equal(timedStatus.operation.terminal.type,'timed_out');
+  assert.equal((await timed.runtime.verifyOperationEvidence({sessionId:timedSession.session_id})).ok,true);
+
+  const failed = await fixture();
+  const failedSession = await failed.runtime.start({
+    profileId:'powershell', rootId:'core', cwd:'.',
+    args:['[Console]::Error.WriteLine(\'DB_FAIL_MARK\'); exit 7']
+  });
+  const failedDeadline=Date.now()+5000;
+  let failedStatus=await failed.runtime.status({sessionId:failedSession.session_id});
+  while(failedStatus.state==='running' && Date.now()<failedDeadline){ await sleep(25); failedStatus=await failed.runtime.status({sessionId:failedSession.session_id}); }
+  assert.equal(failedStatus.state,'exited');
+  assert.equal(failedStatus.exit_code,7);
+  assert.equal(failedStatus.operation.terminal.type,'failure');
+  assert.equal((await failed.runtime.verifyOperationEvidence({sessionId:failedSession.session_id})).ok,true);
+});
+
+test('R47 concurrent cancel and page keep terminal authority singular', { skip: process.platform !== 'win32' }, async () => {
+  const f=await fixture();
+  const started=await f.runtime.start({profileId:'hold',rootId:'core',cwd:'.',args:[]});
+  const operations=await Promise.allSettled([
+    f.runtime.cancel({sessionId:started.session_id,reason:'page_race_cancel'}),
+    f.runtime.read({sessionId:started.session_id,offset:0,maxBytes:1024,waitMs:100}),
+    f.runtime.status({sessionId:started.session_id})
+  ]);
+  assert.ok(operations.some(x=>x.status==='fulfilled'));
+  const status=await f.runtime.status({sessionId:started.session_id});
+  assert.ok(['cancelled','timed_out'].includes(status.operation.terminal.type));
+  const evidence=await f.runtime.verifyOperationEvidence({sessionId:started.session_id});
+  assert.equal(evidence.ok,true);
+});
+