deadbyte-mcp 0.15.2 → 0.15.4

package/src/coding-mcp-tools.mjs

@@ -70,14 +70,14 @@ export function registerCodingTools(server, { codingRuntime, taskRuntime, semant
   server.registerTool('coding_search', {
     description: 'Deterministic bounded content/path search with literal or regex mode, signed cursor paging, and observed file identities.',
     inputSchema: z.strictObject({ root_id: rootId, path: relPath.default('.'), pattern: z.string().min(1).max(256),
-      target: z.enum(['content','path']).default('content'), mode: z.enum(['literal','regex']).default('literal'), case_sensitive: z.boolean().default(false),
+      target: z.enum(['content','path']).default('content'), mode: z.enum(['literal','regex','fuzzy']).default('literal'), case_sensitive: z.boolean().default(false),
       max_results: z.number().int().min(1).max(1000).default(200), max_file_bytes: z.number().int().min(1).max(4194304).default(262144),
       max_scan_bytes: z.number().int().min(1).max(67108864).default(4194304), page_size: z.number().int().min(1).max(500).default(100),
-      cursor: z.string().max(8192).nullable().default(null) }),
+      cursor: z.string().max(8192).nullable().default(null), fuzzy_timeout_ms: z.number().int().min(100).max(30000).default(30000) }),
     outputSchema: codingSearchOutputSchema
-  }, async ({ root_id, path, pattern, target, mode, case_sensitive, max_results, max_file_bytes, max_scan_bytes, page_size, cursor }) => {
+  }, async ({ root_id, path, pattern, target, mode, case_sensitive, max_results, max_file_bytes, max_scan_bytes, page_size, cursor, fuzzy_timeout_ms }) => {
     try { return result(codingSearchOutputSchema, await codingRuntime.search({ rootId: root_id, path, pattern, target, mode, caseSensitive: case_sensitive,
-      maxResults: max_results, maxFileBytes: max_file_bytes, maxScanBytes: max_scan_bytes, pageSize: page_size, cursor })); }
+      maxResults: max_results, maxFileBytes: max_file_bytes, maxScanBytes: max_scan_bytes, pageSize: page_size, cursor, fuzzyTimeoutMs: fuzzy_timeout_ms })); }
     catch (error) { return fail(codingSearchOutputSchema, error); }
   });
 
@@ -171,8 +171,8 @@ export function registerCodingTools(server, { codingRuntime, taskRuntime, semant
   }, async ({ submission_id, title, steps }) => { try { return result(codingTaskSubmitOutputSchema, await taskRuntime.submit({ submissionId: submission_id, title, steps })); } catch (error) { return fail(codingTaskSubmitOutputSchema, error); } });
   server.registerTool('coding_task_run', {
     description: 'Advance one durable coding task by bounded steps with retry/checkpoint/crash reconciliation.',
-    inputSchema: z.strictObject({ task_id: taskId, max_steps: z.number().int().min(1).max(32).default(8) }), outputSchema: codingTaskRunOutputSchema
-  }, async ({ task_id, max_steps }) => { try { return result(codingTaskRunOutputSchema, await taskRuntime.run({ taskId: task_id, maxSteps: max_steps })); } catch (error) { return fail(codingTaskRunOutputSchema, error); } });
+    inputSchema: z.strictObject({ task_id: taskId, max_steps: z.number().int().min(1).max(32).default(8), timeout_ms: z.number().int().min(100).max(900000).nullable().default(null) }), outputSchema: codingTaskRunOutputSchema
+  }, async ({ task_id, max_steps, timeout_ms }) => { try { return result(codingTaskRunOutputSchema, await taskRuntime.run({ taskId: task_id, maxSteps: max_steps, timeoutMs: timeout_ms })); } catch (error) { return fail(codingTaskRunOutputSchema, error); } });
 
   server.registerTool('coding_task_status', {
     description: 'Read derived coding-task state from the authenticated event journal.',

package/src/coding-output-contracts.mjs

@@ -8,9 +8,19 @@ const hex64 = z.string().regex(HEX64_RE);
 const receiptId = z.string().regex(HEX24_RE);
 const taskId = z.string().regex(TASK_ID_RE);
 const stepId = z.string().regex(STEP_ID_RE);
+const streamCoverage = z.strictObject({
+  logical_first_seq:z.number().int().min(1), logical_last_seq:z.number().int().min(0),
+  retained_first_seq:z.number().int().min(1), retained_last_seq:z.number().int().min(0),
+  complete:z.boolean(), truncated:z.boolean(),
+  missing_ranges:z.array(z.strictObject({from:z.number().int().min(1),to:z.number().int().min(0)})).max(100000),
+  logical_item_count:z.number().int().min(0), retained_item_count:z.number().int().min(0),
+  logical_bytes:z.number().int().min(0), retained_bytes:z.number().int().min(0),
+  dropped_items:z.number().int().min(0), dropped_bytes:z.number().int().min(0), status:z.enum(['open','closed'])
+});
 const jsonObject = z.record(z.string(), z.json());
 const taskState = z.enum(['pending', 'running', 'paused', 'failed', 'cancelled', 'succeeded']);
 const codingKind = z.enum(['checkpoint', 'write', 'replace', 'command', 'benchmark']);
+const deadline = z.strictObject({ schema:z.literal('deadbyte.deadline.v1'), id:z.string().nullable(), created_at_ms:z.number(), timeout_ms:z.number().int().min(1).nullable(), deadline_ms:z.number().nullable() });
 
 function requireFields(value, ctx, fields) {
   for (const field of fields) if (value[field] === undefined) ctx.addIssue({ code: 'custom', path: [field], message: `${field} is required` });
@@ -82,12 +92,15 @@ export const codingSearchOutputSchema = statusContract({
     pattern: z.string().min(1).max(256).optional(), target: z.enum(['content','path']).optional(),
     mode: z.enum(['literal','regex']).optional(), case_sensitive: z.boolean().optional(),
     matches: z.array(z.strictObject({ path: z.string().min(1).max(512), line: z.number().int().min(1).nullable(),
-      column: z.number().int().min(1).nullable(), preview: z.string().max(512), file_sha256: hex64.nullable() })).max(500).optional(),
+      column: z.number().int().min(1).nullable(), preview: z.string().max(512), file_sha256: hex64.nullable(),
+      distance: z.number().int().nonnegative().optional(), similarity: z.number().min(0).max(1).optional(), match_length: z.number().int().positive().optional() })).max(500).optional(),
     files_scanned: z.number().int().min(0).optional(), bytes_scanned: z.number().int().min(0).optional(),
     binary_files_skipped: z.number().int().min(0).optional(), truncated: z.boolean().optional(),
     truncation_reason: z.enum(['tree_limit','scan_byte_limit','max_results']).nullable().optional(),
     query_sha256: hex64.optional(), snapshot_sha256: hex64.optional(), page_sha256: hex64.optional(),
-    next_cursor: z.string().max(8192).nullable().optional() },
+    next_cursor: z.string().max(8192).nullable().optional(),
+    stream_id: hex64.optional(), stream_generation: z.number().int().min(1).optional(), stream_next_seq: z.number().int().min(1).optional(),
+    stream_coverage: streamCoverage.optional() },
   successStatuses: ['ok'], successRequired: ['root_id','path','pattern','target','mode','case_sensitive','matches','files_scanned','bytes_scanned','binary_files_skipped','truncated','truncation_reason','query_sha256','snapshot_sha256','page_sha256','next_cursor']
 });
 const semanticLocationSchema = z.strictObject({
@@ -222,7 +235,7 @@ export const codingTaskSubmitOutputSchema = statusContract({
   successStatuses: ['accepted', 'existing'], successRequired: ['task_id', 'plan_sha256', 'state']
 });
 export const codingTaskRunOutputSchema = z.strictObject({
-  status: z.enum(['terminal', 'paused', 'completed', 'cancelled', 'failed', 'yielded', 'succeeded']), error: z.string().optional(), task_id: taskId.optional(),
+  status: z.enum(['terminal', 'paused', 'completed', 'cancelled', 'failed', 'yielded', 'succeeded']), error: z.string().optional(), task_id: taskId.optional(), deadline: deadline.optional(),
   ...Object.fromEntries(Object.entries(derivedShape).map(([key, schema]) => [key, schema.optional()]))
 }).superRefine((value, ctx) => {
   if (value.error !== undefined) { if (value.status !== 'failed') ctx.addIssue({ code: 'custom', path: ['error'], message: 'error wrapper requires status=failed' }); return; }
@@ -231,13 +244,15 @@ export const codingTaskRunOutputSchema = z.strictObject({
 export const codingTaskStatusOutputSchema = statusContract({
   statuses: ['ok', 'failed'],
   shape: { task_id: taskId.optional(), plan_sha256: hex64.optional(),
-    ...Object.fromEntries(Object.entries(derivedShape).map(([key, schema]) => [key, schema.optional()])), journal_verified: z.literal(true).optional() },
+    ...Object.fromEntries(Object.entries(derivedShape).map(([key, schema]) => [key, schema.optional()])), journal_verified: z.literal(true).optional(),
+    stream_id: taskId.optional(), stream_generation: z.number().int().min(1).optional(), stream_next_seq: z.number().int().min(1).optional(), stream_coverage: streamCoverage.optional() },
   successStatuses: ['ok'], successRequired: ['task_id', 'plan_sha256', ...Object.keys(derivedShape), 'journal_verified']
 });
 export const codingTaskEventsOutputSchema = statusContract({
   statuses: ['ok', 'failed'],
   shape: { task_id: taskId.optional(), plan_sha256: hex64.optional(), journal_verified: z.literal(true).optional(),
-    journal_head_sha256: hex64.optional(), events: z.array(eventSchema).max(200).optional() },
+    journal_head_sha256: hex64.optional(), events: z.array(eventSchema).max(200).optional(),
+    stream_id: taskId.optional(), stream_generation: z.number().int().min(1).optional(), stream_next_seq: z.number().int().min(1).optional(), stream_coverage: streamCoverage.optional() },
   successStatuses: ['ok'], successRequired: ['task_id', 'plan_sha256', 'journal_verified', 'journal_head_sha256', 'events']
 });
 export const codingTaskCancelOutputSchema = statusContract({

package/src/coding-plane.mjs

@@ -10,6 +10,7 @@ import { isInside, validatePortableRelativePath } from './path-policy.mjs';
 import { loadPrivateSigningKey, loadPublicVerifyKey } from './trust.mjs';
 import { createCodingSearch } from './coding-search.mjs';
 import { createSearchCursorCodec } from './search-cursor.mjs';
+import { atomicMutation } from './atomic-mutation.mjs';
 
 export const CODING_POLICY_SCHEMA = 'deadbyte.coding-policy.v1';
 export const CODING_LEASE_SCHEMA = 'deadbyte.coding-lease.v1';
@@ -261,30 +262,8 @@ function decodeContent(content, encoding) {
   throw new Error('encoding must be utf8 or base64');
 }
 async function atomicWrite(target, bytes, expectedSha256, authorityCheck = null) {
-  const before = await targetState(target);
-  checkExpected(before, expectedSha256);
-  const temp = path.join(path.dirname(target), `.${path.basename(target)}.deadbyte-coding-${process.pid}-${randomBytes(8).toString('hex')}.tmp`);
-  let handle;
-  try {
-    if (authorityCheck) await authorityCheck();
-    handle = await open(temp, fsConstants.O_CREAT | fsConstants.O_EXCL | fsConstants.O_WRONLY, 0o600);
-    await handle.writeFile(bytes);
-    await handle.sync();
-    await handle.close();
-    handle = null;
-    const race = await targetState(target);
-    checkExpected(race, expectedSha256);
-    if (authorityCheck) await authorityCheck();
-    await rename(temp, target);
-  } catch (error) {
-    if (handle) await handle.close().catch(() => {});
-    await rm(temp, { force: true }).catch(() => {});
-    throw error;
-  }
-  const after = await targetState(target);
-  const expectedAfter = sha256Bytes(bytes);
-  if (!after.exists || after.sha256 !== expectedAfter) throw new Error('coding write post-commit hash mismatch');
-  return { before, after };
+  return atomicMutation({ target, bytes, expected: expectedSha256, readState: targetState,
+    assertExpected: checkExpected, authorityCheck, tempTag: 'deadbyte-coding' });
 }
 function codingEnvironment() {
   const allowed = new Set([

package/src/coding-search.mjs

@@ -1,6 +1,9 @@
 import { createHash } from 'node:crypto';
 import { canonicalJson } from './canonical-json.mjs';
 import { decodeUtf8Strict } from './text-policy.mjs';
+import { createSequenceStream } from './workload-substrate.mjs';
+import { fuzzyIndexOf } from './fuzzy-search-core.mjs';
+import { runFuzzySearchInWorker, FUZZY_SEARCH_TIMEOUT_MS } from './fuzzy-search.mjs';
 
 const sha256Object=value=>createHash('sha256').update(canonicalJson(value),'utf8').digest('hex');
 const sha256Bytes=bytes=>createHash('sha256').update(bytes).digest('hex');
@@ -52,11 +55,11 @@ function preview(text,index,length){
   const start=Math.max(0,index-48); const end=Math.min(text.length,index+Math.max(length,1)+112);
   return text.slice(start,end);
 }
-function normalizeQuery({rootId,path,target,mode,pattern,caseSensitive,maxResults,maxFileBytes,maxScanBytes,pageSize}){
+function normalizeQuery({rootId,path,target,mode,pattern,caseSensitive,maxResults,maxFileBytes,maxScanBytes,pageSize,fuzzyTimeoutMs}){
   return {
-    schema:'deadbyte.coding-search-query.v2',root_id:rootId,path,target,mode,pattern,
+    schema:'deadbyte.coding-search-query.v3',root_id:rootId,path,target,mode,pattern,
     case_sensitive:caseSensitive,max_results:maxResults,max_file_bytes:maxFileBytes,
-    max_scan_bytes:maxScanBytes,page_size:pageSize
+    max_scan_bytes:maxScanBytes,page_size:pageSize,fuzzy_timeout_ms:fuzzyTimeoutMs
   };
 }
 
@@ -66,15 +69,18 @@ export function createCodingSearch({tree,fileRead,cursorCodec}){
   }
   return async function search({
     rootId,path='.',pattern,target='content',mode='literal',caseSensitive=false,
-    maxResults=200,maxFileBytes=262144,maxScanBytes=4*1024*1024,pageSize=100,cursor=null
+    maxResults=200,maxFileBytes=262144,maxScanBytes=4*1024*1024,pageSize=100,cursor=null,
+    fuzzyTimeoutMs=FUZZY_SEARCH_TIMEOUT_MS
   }){
     if(!['content','path'].includes(target)) throw new Error('coding search target must be content or path');
+    if(!['literal','regex','fuzzy'].includes(mode)) throw new Error('coding search mode must be literal, regex, or fuzzy');
     validateInt(maxResults,'max_results',1,1000);
     validateInt(maxFileBytes,'max_file_bytes',1,4*1024*1024);
     validateInt(maxScanBytes,'max_scan_bytes',1,64*1024*1024);
     validateInt(pageSize,'page_size',1,500);
-    const matcher=compileMatcher({pattern,mode,caseSensitive});
-    const query=normalizeQuery({rootId,path,target,mode,pattern,caseSensitive,maxResults,maxFileBytes,maxScanBytes,pageSize});
+    if(!Number.isInteger(fuzzyTimeoutMs)||fuzzyTimeoutMs<100||fuzzyTimeoutMs>FUZZY_SEARCH_TIMEOUT_MS) throw new Error('fuzzy_timeout_ms must be in [100, 30000]');
+    const matcher=mode==='fuzzy'?null:compileMatcher({pattern,mode,caseSensitive});
+    const query=normalizeQuery({rootId,path,target,mode,pattern,caseSensitive,maxResults,maxFileBytes,maxScanBytes,pageSize,fuzzyTimeoutMs});
     const querySha=sha256Object(query);
     let decodedCursor=null;
     if(cursor!==null){
@@ -92,10 +98,18 @@ export function createCodingSearch({tree,fileRead,cursorCodec}){
     if(target==='path'){
       for(const entry of entries){
         snapshotEntries.push({path:entry.path,bytes:entry.bytes,type:'file'});
-        if(matcher.path(entry.path)){
-          matches.push({path:entry.path,line:null,column:null,preview:entry.path,file_sha256:null});
+        const found=mode==='fuzzy'
+          ? [fuzzyIndexOf(caseSensitive?entry.path:entry.path.toLowerCase(),caseSensitive?pattern:pattern.toLowerCase())]
+          : (matcher.path(entry.path)?[{start:0,end:entry.path.length,value:entry.path}]:[]);
+        for(const hit of found){
+          if(mode==='fuzzy' && hit.distance>Math.max(1,Math.floor(pattern.length*0.75))) continue;
+          matches.push({
+            path:entry.path,line:null,column:null,preview:entry.path,file_sha256:null,
+            ...(mode==='fuzzy'?{distance:hit.distance,similarity:hit.similarity,match_length:Math.max(1,hit.value.length)}:{})
+          });
           if(matches.length>=maxResults){truncated=true;truncationReason='max_results';break;}
         }
+        if(matches.length>=maxResults) break;
       }
     } else {
       for(const entry of entries){
@@ -109,11 +123,26 @@ export function createCodingSearch({tree,fileRead,cursorCodec}){
         snapshotEntries.push({path:entry.path,bytes:item.bytes,sha256:fileSha});
         let text;
         try{text=decodeUtf8Strict(raw);}catch{binaryFilesSkipped+=1;continue;}
-        const found=matcher.all(text);
-        for(const hit of found){
-          const lc=lineColumn(text,hit.index);
-          matches.push({path:entry.path,line:lc.line,column:lc.column,preview:preview(text,hit.index,hit.length),file_sha256:fileSha});
-          if(matches.length>=maxResults){truncated=true;truncationReason='max_results';break;}
+        if(mode==='fuzzy'){
+          const haystack=caseSensitive?text:text.toLowerCase();
+          const queryText=caseSensitive?pattern:pattern.toLowerCase();
+          const hit=await runFuzzySearchInWorker(haystack,queryText,fuzzyTimeoutMs);
+          const threshold=Math.max(1,Math.floor(queryText.length*0.75));
+          if(hit.distance<=threshold){
+            const lc=lineColumn(haystack,hit.start);
+            matches.push({
+              path:entry.path,line:lc.line,column:lc.column,
+              preview:preview(text,hit.start,hit.end-hit.start),file_sha256:fileSha,
+              distance:hit.distance,similarity:hit.similarity,match_length:Math.max(1,hit.value.length)
+            });
+          }
+        } else {
+          const found=matcher.all(text);
+          for(const hit of found){
+            const lc=lineColumn(text,hit.index);
+            matches.push({path:entry.path,line:lc.line,column:lc.column,preview:preview(text,hit.index,hit.length),file_sha256:fileSha});
+            if(matches.length>=maxResults){truncated=true;truncationReason='max_results';break;}
+          }
         }
         if(matches.length>=maxResults) break;
       }
@@ -121,18 +150,26 @@ export function createCodingSearch({tree,fileRead,cursorCodec}){
 
     const snapshotSha=sha256Object({schema:'deadbyte.coding-search-snapshot.v2',query_sha256:querySha,entries:snapshotEntries});
     if(decodedCursor&&decodedCursor.snapshot_sha256!==snapshotSha) throw new Error('coding search cursor stale snapshot mismatch');
+    const stream=createSequenceStream({streamId:querySha,maxItems:Math.max(1,maxResults),maxBytes:Math.max(1024, maxResults*4096)});
+    for(const match of matches) stream.append(match,{producer:'coding-search',channel:'match'});
     const offset=decodedCursor?.offset??0;
     if(offset>matches.length) throw new Error('coding search cursor offset exceeds retained results');
-    const pageMatches=matches.slice(offset,offset+pageSize);
+    const page=stream.read(offset+1,pageSize);
+    if(page.missing) throw new Error('coding search cursor offset is outside retained stream coverage');
+    const pageMatches=page.items.map(item=>item.value);
     const nextOffset=offset+pageMatches.length;
     const hasMore=nextOffset<matches.length;
     const nextCursor=hasMore?await cursorCodec.encode({query_sha256:querySha,snapshot_sha256:snapshotSha,offset:nextOffset}):null;
     const pageSha=sha256Object({schema:'deadbyte.coding-search-page.v2',query_sha256:querySha,snapshot_sha256:snapshotSha,offset,matches:pageMatches});
+    const coverage=stream.coverage();
+    const streamSnapshot=stream.snapshot();
     return {
       status:'ok',root_id:rootId,path,pattern,target,mode,case_sensitive:caseSensitive,
       matches:pageMatches,files_scanned:filesScanned,bytes_scanned:bytesScanned,binary_files_skipped:binaryFilesSkipped,
       truncated:truncated||hasMore,truncation_reason:truncationReason,query_sha256:querySha,snapshot_sha256:snapshotSha,
-      page_sha256:pageSha,next_cursor:nextCursor
+      page_sha256:pageSha,next_cursor:nextCursor,
+      stream_id:stream.streamId,stream_generation:stream.generation,stream_next_seq:streamSnapshot.next_seq,
+      stream_coverage:coverage
     };
   };
 }

package/src/coding-task-runtime.mjs

@@ -4,6 +4,8 @@ import path from 'node:path';
 import { canonicalJson } from './canonical-json.mjs';
 import { validatePortableRelativePath } from './path-policy.mjs';
 import { loadPrivateSigningKey, loadPublicVerifyKey } from './trust.mjs';
+import { createJournalStream } from './workload-substrate.mjs';
+import { createDeadline, deadlineState } from './deadline-cancellation.mjs';
 
 export const CODING_TASK_PLAN_SCHEMA = 'deadbyte.coding-task-plan.v1';
 export const CODING_TASK_EVENT_SCHEMA = 'deadbyte.coding-task-event.v1';
@@ -525,7 +527,11 @@ export function createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyK
     const ctx = taskContext(policy, taskId);
     const plan = await loadPlan(ctx, policy, verifyKeyPath);
     const events = await readEvents(ctx, verifyKeyPath);
-    return { status: 'ok', task_id: taskId, plan_sha256: plan.plan_sha256, ...deriveState(plan, events), journal_verified: true };
+    const stream = createJournalStream({streamId:taskId,events,maxItems:MAX_EVENTS,maxBytes:8*1024*1024,producer:'coding-task',channel:'event'});
+    const snapshot = stream.snapshot();
+    return { status: 'ok', task_id: taskId, plan_sha256: plan.plan_sha256, ...deriveState(plan, events), journal_verified: true,
+      stream_id:snapshot.stream_id, stream_generation:snapshot.generation, stream_next_seq:snapshot.next_seq,
+      stream_coverage:stream.coverage() };
   }
 
   async function events({ taskId, fromSeq = 1, limit = 100 }) {
@@ -534,10 +540,15 @@ export function createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyK
     const ctx = taskContext(policy, taskId);
     const plan = await loadPlan(ctx, policy, verifyKeyPath);
     const all = await readEvents(ctx, verifyKeyPath);
+    const stream = createJournalStream({streamId:taskId,events:all,maxItems:MAX_EVENTS,maxBytes:8*1024*1024,producer:'coding-task',channel:'event'});
+    const page = stream.read(fromSeq,limit);
+    const snapshot = stream.snapshot();
     return {
       status: 'ok', task_id: taskId, plan_sha256: plan.plan_sha256, journal_verified: true,
       journal_head_sha256: all.at(-1)?.event_sha256 ?? ZERO_HASH,
-      events: all.slice(fromSeq - 1, fromSeq - 1 + limit)
+      stream_id: snapshot.stream_id, stream_generation: snapshot.generation, stream_next_seq: snapshot.next_seq,
+      stream_coverage: stream.coverage(),
+      events: page.items.map(item=>item.value)
     };
   }
 
@@ -590,8 +601,18 @@ export function createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyK
     const journal = await readEvents(ctx, verifyKeyPath);
     return verifyTaskReceipt(ctx, plan, journal, policy, verifyKeyPath, codingRuntime);
   }
-  async function run({ taskId, maxSteps = 8 }) {
+  async function run({ taskId, maxSteps = 8, timeoutMs = null }) {
     if (!Number.isInteger(maxSteps) || maxSteps < 1 || maxSteps > MAX_STEPS) throw new Error(`max_steps must be in [1, ${MAX_STEPS}]`);
+    if (timeoutMs !== null && (!Number.isInteger(timeoutMs) || timeoutMs < 100 || timeoutMs > 900000)) throw new Error('timeout_ms must be null or in [100,900000]');
+    const deadline = createDeadline({ timeoutMs });
+    const deadlineExpired = () => timeoutMs !== null && deadlineState(deadline).expired;
+    const failDeadline = async (ctx, journal, plan, stepId = null) => {
+      await appendEvent(ctx, journal, signingKeyPath, 'task_failed', {
+        stepId,
+        payload: { reason: 'deadline_exceeded', deadline }
+      });
+      return deriveState(plan, journal);
+    };
     const session = await codingRuntime.sessionStatus();
     if (!session.armed) throw new Error(`coding plane is disarmed: ${session.reason}`);
     const ctx = taskContext(policy, taskId);
@@ -610,10 +631,14 @@ export function createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyK
       if (await consumeCancel(ctx, journal, signingKeyPath, verifyKeyPath)) {
         derived = deriveState(plan, journal); return { status: 'cancelled', task_id: taskId, ...derived };
       }
-      await appendEvent(ctx, journal, signingKeyPath, 'run_started', { payload: { max_steps: maxSteps } });
+      await appendEvent(ctx, journal, signingKeyPath, 'run_started', { payload: { max_steps: maxSteps, deadline } });
       derived = deriveState(plan, journal);
       let consumed = 0;
       while (consumed < maxSteps) {
+        if (deadlineExpired()) {
+          derived = await failDeadline(ctx, journal, plan);
+          return { status: 'failed', task_id: taskId, ...derived, deadline };
+        }
         if (await consumeCancel(ctx, journal, signingKeyPath, verifyKeyPath)) {
           derived = deriveState(plan, journal); return { status: 'cancelled', task_id: taskId, ...derived };
         }
@@ -638,7 +663,9 @@ export function createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyK
         derived = deriveState(plan, journal);
         consumed += 1;
         try {
-          const executed = await executeStep(codingRuntime, plan, next, attempt);
+          const remainingMs = timeoutMs === null ? null : Math.max(100, Math.floor(deadlineState(deadline).remaining_ms));
+          const boundedStep = remainingMs === null ? next : { ...next, timeout_ms: next.timeout_ms === null || next.timeout_ms === undefined ? remainingMs : Math.min(next.timeout_ms, remainingMs) };
+          const executed = await executeStep(codingRuntime, plan, boundedStep, attempt);
           if (!executed.outcome.valid) {
             await appendEvent(ctx, journal, signingKeyPath, 'task_paused', {
               stepId: next.step_id, payload: { reason: 'post_execute_receipt_mismatch', detail: executed.outcome.reason }
@@ -646,6 +673,10 @@ export function createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyK
             derived = deriveState(plan, journal);
             return { status: 'paused', task_id: taskId, ...derived };
           }
+          if (deadlineExpired()) {
+            derived = await failDeadline(ctx, journal, plan, next.step_id);
+            return { status: 'failed', task_id: taskId, ...derived, deadline };
+          }
           if (executed.outcome.success) {
             await appendEvent(ctx, journal, signingKeyPath, 'step_succeeded', {
               stepId: next.step_id, payload: { ...executed.outcome.payload, attempt, recovered: false }
@@ -664,6 +695,10 @@ export function createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyK
           }
           derived = deriveState(plan, journal);
         } catch (error) {
+          if (deadlineExpired()) {
+            derived = await failDeadline(ctx, journal, plan, next.step_id);
+            return { status: 'failed', task_id: taskId, ...derived, deadline };
+          }
           const checked = await codingRuntime.verifyReceiptDetailed(receiptId);
           if (checked.ok) {
             const outcome = receiptOutcome(next, checked, requestSha256);
@@ -717,7 +752,7 @@ export function createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyK
           }
         }
       }
-      return { status: 'yielded', task_id: taskId, ...derived };
+      return { status: 'yielded', task_id: taskId, ...derived, deadline };
     } finally { await releaseLock(ctx); }
   }
 

package/src/compact-gateway-mcp-tools.mjs

@@ -13,7 +13,7 @@ const symbolName=z.string().regex(/^[A-Za-z_$][A-Za-z0-9_$]{0,127}$/);
 
 export const codingInspectInputSchema=z.discriminatedUnion('op',[
   z.strictObject({op:z.literal('stat'),root_id:id,path:rel512.default('.'),hash:z.boolean().default(false)}),
-  z.strictObject({op:z.literal('search'),root_id:id,path:rel512.default('.'),pattern:z.string().min(1).max(256),target:z.enum(['content','path']).default('content'),mode:z.enum(['literal','regex']).default('literal'),case_sensitive:z.boolean().default(false),max_results:z.number().int().min(1).max(1000).default(200),max_file_bytes:z.number().int().min(1).max(4*1024*1024).default(262144),max_scan_bytes:z.number().int().min(1).max(64*1024*1024).default(4*1024*1024),page_size:z.number().int().min(1).max(500).default(100),cursor}),
+  z.strictObject({op:z.literal('search'),root_id:id,path:rel512.default('.'),pattern:z.string().min(1).max(256),target:z.enum(['content','path']).default('content'),mode:z.enum(['literal','regex','fuzzy']).default('literal'),case_sensitive:z.boolean().default(false),max_results:z.number().int().min(1).max(1000).default(200),max_file_bytes:z.number().int().min(1).max(4*1024*1024).default(262144),max_scan_bytes:z.number().int().min(1).max(64*1024*1024).default(4*1024*1024),page_size:z.number().int().min(1).max(500).default(100),cursor,fuzzy_timeout_ms:z.number().int().min(100).max(30000).default(30000)}),
   z.strictObject({op:z.literal('files_read'),root_id:id,files:z.array(z.strictObject({path:rel512,encoding:z.enum(['utf8','base64']).default('utf8')})).min(1).max(32),max_total_bytes:z.number().int().min(1).max(2097152).default(1048576)}),
   z.strictObject({op:z.literal('symbol_outline'),root_id:id,path:rel512,max_symbols:z.number().int().min(1).max(500).default(200)}),
   z.strictObject({op:z.literal('symbol_definition'),root_id:id,path:rel512,line:nonneg,column:nonneg,max_results:z.number().int().min(1).max(200).default(50)}),
@@ -26,7 +26,7 @@ export const codingInspectInputSchema=z.discriminatedUnion('op',[
 export const machineFsGatewayInputSchema=z.discriminatedUnion('op',[
   z.strictObject({op:z.literal('stat'),root_id:id,path:rel.default('.'),hash:z.boolean().default(false)}),
   z.strictObject({op:z.literal('list'),root_id:id,path:rel.default('.'),cursor,limit:z.number().int().min(1).max(1000).default(100),hash_files:z.boolean().default(false)}),
-  z.strictObject({op:z.literal('read'),root_id:id,path:rel,offset:nonneg.default(0),max_bytes:z.number().int().min(1).max(4*1024*1024).default(65536),hash_file:z.boolean().default(false),timeout_ms:z.number().int().min(100).max(180000).default(30000)}),
+  z.strictObject({op:z.literal('read'),root_id:id,path:rel,offset:z.number().int().min(-4*1024*1024).max(4*1024*1024).default(0),max_bytes:z.number().int().min(1).max(4*1024*1024).default(65536),hash_file:z.boolean().default(false),timeout_ms:z.number().int().min(100).max(180000).default(30000)}),
   z.strictObject({op:z.literal('write'),root_id:id,path:rel,content:z.string().max(12*1024*1024),encoding:z.enum(['utf8','base64']).default('utf8'),expected_sha256:z.string().regex(/^(?:absent|[0-9a-f]{64})$/)}),
   z.strictObject({op:z.literal('edit_exact'),root_id:id,path:rel,expected_sha256:hex64,old_string:z.string().min(1).max(262144),new_string:z.string().max(524288),expected_replacements:z.number().int().min(1).max(64).default(1)}),
   z.strictObject({op:z.literal('mkdir'),root_id:id,path:rel}),
@@ -69,7 +69,7 @@ async function invoke(op,runtime,name,call){
 async function codingInspect(args,codingRuntime,semanticRuntime){
   switch(args.op){
     case 'stat': return invoke(args.op,codingRuntime,'coding',r=>r.stat({rootId:args.root_id,relativePath:args.path,hash:args.hash}));
-    case 'search': return invoke(args.op,codingRuntime,'coding',r=>r.search({rootId:args.root_id,path:args.path,pattern:args.pattern,target:args.target,mode:args.mode,caseSensitive:args.case_sensitive,maxResults:args.max_results,maxFileBytes:args.max_file_bytes,maxScanBytes:args.max_scan_bytes,pageSize:args.page_size,cursor:args.cursor}));
+    case 'search': return invoke(args.op,codingRuntime,'coding',r=>r.search({rootId:args.root_id,path:args.path,pattern:args.pattern,target:args.target,mode:args.mode,caseSensitive:args.case_sensitive,maxResults:args.max_results,maxFileBytes:args.max_file_bytes,maxScanBytes:args.max_scan_bytes,pageSize:args.page_size,cursor:args.cursor,fuzzyTimeoutMs:args.fuzzy_timeout_ms}));
     case 'files_read': return invoke(args.op,codingRuntime,'coding',r=>r.filesRead({rootId:args.root_id,files:args.files,maxTotalBytes:args.max_total_bytes}));
     case 'symbol_outline': return invoke(args.op,semanticRuntime,'semantic',r=>r.outline({rootId:args.root_id,relativePath:args.path,maxSymbols:args.max_symbols}));
     case 'symbol_definition': return invoke(args.op,semanticRuntime,'semantic',r=>r.definition({rootId:args.root_id,relativePath:args.path,line:args.line,column:args.column,maxResults:args.max_results}));

package/src/deadline-cancellation.mjs

@@ -0,0 +1,83 @@
+const ID=/^[A-Za-z0-9._:-]{1,128}$/;
+
+export function createDeadline({timeoutMs=null, nowMs=Date.now(), id=null}={}) {
+  if(timeoutMs!==null && (!Number.isInteger(timeoutMs)||timeoutMs<1)) throw new Error('deadline timeout_ms invalid');
+  if(!Number.isFinite(nowMs)) throw new Error('deadline now_ms invalid');
+  const deadlineMs=timeoutMs===null?null:nowMs+timeoutMs;
+  return Object.freeze({
+    schema:'deadbyte.deadline.v1',
+    id:id===null?null:validateId(id),
+    created_at_ms:nowMs,
+    timeout_ms:timeoutMs,
+    deadline_ms:deadlineMs
+  });
+}
+
+export function deadlineState(deadline,{nowMs=Date.now()}={}) {
+  if(!deadline||deadline.schema!=='deadbyte.deadline.v1') throw new Error('deadline invalid');
+  if(!Number.isFinite(nowMs)) throw new Error('deadline now_ms invalid');
+  if(deadline.deadline_ms===null) return Object.freeze({expired:false,remaining_ms:null});
+  const remainingMs=deadline.deadline_ms-nowMs;
+  return Object.freeze({expired:remainingMs<=0,remaining_ms:Math.max(0,remainingMs)});
+}
+
+export function createCancellationToken({id=null}={}) {
+  const controller=new AbortController();
+  let requestedAtMs=null;
+  let reason=null;
+  const request=(value='cancelled')=>{
+    if(controller.signal.aborted)return false;
+    requestedAtMs=Date.now();
+    reason=String(value);
+    controller.abort(reason);
+    return true;
+  };
+  return Object.freeze({
+    schema:'deadbyte.cancellation.v1',
+    id:id===null?null:validateId(id),
+    signal:controller.signal,
+    request,
+    snapshot:()=>Object.freeze({
+      requested:controller.signal.aborted,
+      requested_at_ms:requestedAtMs,
+      reason
+    })
+  });
+}
+
+export function composeAbortSignal({deadline=null,cancellation=null}={}) {
+  const controller=new AbortController();
+  let timeout=null;
+  const abort=(reason)=>{
+    if(!controller.signal.aborted)controller.abort(reason);
+  };
+  if(cancellation?.signal){
+    if(cancellation.signal.aborted)abort(cancellation.signal.reason??'cancelled');
+    else cancellation.signal.addEventListener('abort',()=>abort(cancellation.signal.reason??'cancelled'),{once:true});
+  }
+  if(deadline?.deadline_ms!==null&&deadline?.deadline_ms!==undefined){
+    const remaining=Math.max(0,deadline.deadline_ms-Date.now());
+    if(remaining===0)abort('deadline_exceeded');
+    else timeout=setTimeout(()=>abort('deadline_exceeded'),remaining);
+    timeout?.unref?.();
+  }
+  const close=()=>{if(timeout)clearTimeout(timeout);};
+  return Object.freeze({signal:controller.signal,close});
+}
+
+export function classifyTermination({deadlineExceeded=false,cancellationRequested=false,physicallyTerminated=false,verified=false}={}) {
+  return Object.freeze({
+    deadline_exceeded:deadlineExceeded===true,
+    cancellation_requested:cancellationRequested===true,
+    physical_termination:physicallyTerminated===true,
+    verified:verified===true,
+    terminal_semantics:
+      verified ? (physicallyTerminated ? 'verified_termination' : 'verified_stop')
+      : physicallyTerminated ? 'termination_unverified'
+      : cancellationRequested ? 'cancellation_requested'
+      : deadlineExceeded ? 'deadline_exceeded'
+      : 'running'
+  });
+}
+
+function validateId(id){if(typeof id!=='string'||!ID.test(id))throw new Error('deadline/cancellation id invalid');return id;}

package/src/fuzzy-search-core.mjs

@@ -0,0 +1,117 @@
+const clamp=(value,min,max)=>Math.min(max,Math.max(min,value));
+
+function boundedLevenshtein(a,b,cutoff=Number.POSITIVE_INFINITY){
+  if(a===b)return 0;
+  if(a.length===0)return b.length;
+  if(b.length===0)return a.length;
+  if(a.length>b.length){const t=a;a=b;b=t;}
+  const previous=new Uint16Array(a.length+1);
+  const current=new Uint16Array(a.length+1);
+  for(let i=0;i<=a.length;i+=1)previous[i]=i;
+  const limit=Number.isFinite(cutoff)?Math.floor(cutoff):Number.MAX_SAFE_INTEGER;
+  for(let row=1;row<=b.length;row+=1){
+    current[0]=row;
+    let rowMin=current[0];
+    const ch=b.charCodeAt(row-1);
+    for(let col=1;col<=a.length;col+=1){
+      const cost=a.charCodeAt(col-1)===ch?0:1;
+      const value=Math.min(current[col-1]+1,previous[col]+1,previous[col-1]+cost);
+      current[col]=value;
+      if(value<rowMin)rowMin=value;
+    }
+    if(rowMin>limit)return limit+1;
+    previous.set(current);
+  }
+  return previous[a.length];
+}
+
+function cheapPositionalScore(text,query,start,length){
+  const overlap=Math.min(length,query.length);
+  if(overlap<=0)return -1;
+  let same=0;
+  for(let i=0;i<overlap;i+=1)if(text.charCodeAt(start+i)===query.charCodeAt(i))same+=1;
+  const lengthPenalty=Math.abs(length-query.length)/Math.max(1,query.length);
+  return (same/overlap)-lengthPenalty*0.20;
+}
+
+function candidateLengths(queryLength,textLength){
+  if(textLength<=queryLength)return [textLength];
+  const delta=clamp(Math.floor(queryLength*0.25),2,32);
+  return [...new Set([
+    Math.max(1,queryLength-delta),
+    queryLength,
+    Math.min(textLength,queryLength+delta)
+  ])];
+}
+
+export function fuzzyIndexOf(text,query){
+  if(typeof text!=='string'||typeof query!=='string')throw new Error('fuzzy search requires text and query strings');
+  if(query.length===0)return {start:0,end:0,value:'',distance:0,similarity:1};
+  if(text.length===0)return {start:0,end:0,value:'',distance:query.length,similarity:0};
+
+  const lengths=candidateLengths(query.length,text.length);
+  const stride=query.length<=32?1:Math.max(1,Math.floor(query.length/4));
+  const ranked=[];
+  const seen=new Set();
+  for(let start=0;start<text.length;start+=stride){
+    for(const length of lengths){
+      if(start+length>text.length)continue;
+      const key=`${start}:${length}`;
+      if(seen.has(key))continue;
+      seen.add(key);
+      ranked.push({start,length,score:cheapPositionalScore(text,query,start,length)});
+    }
+  }
+  const tailStart=Math.max(0,text.length-query.length);
+  for(const start of [0,tailStart]){
+    for(const length of lengths){
+      if(start<0||start+length>text.length)continue;
+      const key=`${start}:${length}`;
+      if(seen.has(key))continue;
+      seen.add(key);
+      ranked.push({start,length,score:cheapPositionalScore(text,query,start,length)});
+    }
+  }
+
+  ranked.sort((a,b)=>b.score-a.score||a.start-b.start||a.length-b.length);
+  const shortlist=ranked.slice(0,64);
+  const refined=new Set();
+  for(const item of shortlist){
+    const radius=Math.max(1,Math.floor(stride/2));
+    for(let delta=-radius;delta<=radius;delta+=1){
+      const start=item.start+delta;
+      if(start<0||start>=text.length)continue;
+      for(const length of lengths){
+        if(start+length>text.length)continue;
+        refined.add(`${start}:${length}`);
+      }
+    }
+  }
+  if(refined.size===0)refined.add(`0:${Math.min(text.length,query.length)}`);
+
+  let best=null;
+  for(const key of refined){
+    const [startText,lengthText]=key.split(':');
+    const start=Number(startText);
+    const length=Number(lengthText);
+    const value=text.slice(start,start+length);
+    const cutoff=best?.distance??Number.POSITIVE_INFINITY;
+    const distance=boundedLevenshtein(value,query,cutoff);
+    if(best&&distance>best.distance)continue;
+    const similarity=1-(distance/Math.max(query.length,value.length));
+    const candidate={start,end:start+value.length,value,distance,similarity};
+    if(!best||
+       candidate.distance<best.distance||
+       (candidate.distance===best.distance&&candidate.similarity>best.similarity)||
+       (candidate.distance===best.distance&&candidate.similarity===best.similarity&&candidate.start<best.start)){
+      best=candidate;
+    }
+  }
+  return best??{start:0,end:Math.min(text.length,query.length),value:text.slice(0,query.length),
+    distance:boundedLevenshtein(text.slice(0,query.length),query),similarity:0};
+}
+
+export function getSimilarityRatio(a,b){
+  if(a.length===0&&b.length===0)return 1;
+  return 1-(boundedLevenshtein(a,b)/Math.max(a.length,b.length));
+}

package/src/fuzzy-search-worker.mjs

@@ -0,0 +1,8 @@
+import { parentPort, workerData } from 'node:worker_threads';
+import { fuzzyIndexOf } from './fuzzy-search-core.mjs';
+
+try {
+  parentPort.postMessage({ ok:true, result:fuzzyIndexOf(workerData.text,workerData.query) });
+} catch (error) {
+  parentPort.postMessage({ ok:false, error:String(error?.stack??error) });
+}