deadbyte-mcp 0.8.7

package/src/audit-context.mjs

@@ -0,0 +1,73 @@
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { assertHostArmed } from './host-plane.mjs';
+import { processSessionStatus } from './process-policy.mjs';
+import { parseActivePointer } from './release-slot.mjs';
+
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const authority=(configured,armed,reason)=>({configured:Boolean(configured),armed:Boolean(armed),reason:String(reason||'unknown').slice(0,128)});
+const unconfigured=()=>authority(false,false,'unconfigured');
+
+async function readPointer(stateRoot){
+  return parseActivePointer(await readFile(path.join(path.resolve(stateRoot),'active-release.json'),'utf8'));
+}
+async function hostAuthority(hostPolicy){
+  if(!hostPolicy) return unconfigured();
+  try{
+    const state=await assertHostArmed(hostPolicy);
+    return authority(true,true,state.standing?'standing-grant':'armed');
+  }catch(error){
+    const message=String(error?.message||error);const prefix='privileged host plane is disarmed: ';
+    return authority(true,false,message.startsWith(prefix)?message.slice(prefix.length):'disarmed');
+  }
+}
+async function processAuthority(processPolicy){
+  if(!processPolicy) return unconfigured();
+  const status=await processSessionStatus(processPolicy);return authority(status.configured,status.armed,status.reason);
+}
+async function codingAuthority(codingRuntime){
+  if(!codingRuntime) return unconfigured();
+  const status=await codingRuntime.sessionStatus();return authority(status.configured!==false,status.armed,status.reason);
+}
+async function autonomousAuthority(autonomousRuntime){
+  if(!autonomousRuntime) return unconfigured();
+  const status=await autonomousRuntime.sessionStatus();
+  return authority(status.configured!==false,status.autonomous_armed??status.armed,status.autonomous_reason??status.reason);
+}
+
+export function createAuditContextProvider({stateRoot,packageRoot,machineRuntime=null,processPolicy=null,codingRuntime=null,autonomousRuntime=null,hostPolicy=null}={}){
+  if(!stateRoot) throw new Error('audit context requires stateRoot');
+  if(!packageRoot) throw new Error('audit context requires packageRoot');
+  const state=path.resolve(stateRoot),pkg=path.resolve(packageRoot);
+  return async()=>{
+    const manifestBytes=await readFile(path.join(pkg,'MANIFEST.SHA256'));
+    const packageManifestSha=sha256(manifestBytes);
+    let pointer=null;
+    try{pointer=await readPointer(state);}catch(error){if(machineRuntime||error?.code!=='ENOENT') throw error;}
+    let machine=null;
+    if(machineRuntime){
+      machine=await machineRuntime.status();
+      if(machine.release_manifest_sha256!==packageManifestSha) throw new Error(`audit release manifest binding mismatch: package=${packageManifestSha} active=${machine.release_manifest_sha256}`);
+      if(!pointer) throw new Error('audit active release pointer missing');
+      if(pointer.manifest_sha256!==machine.release_manifest_sha256||pointer.release_id!==machine.release_id) throw new Error('audit active release pointer does not match machine runtime');
+      if(pointer.generation_manifest_sha256!==machine.generation_manifest_sha256) throw new Error('audit generation manifest binding mismatch');
+      if(path.resolve(pointer.release_root)!==pkg) throw new Error('audit executing package root does not match active release root');
+    }else if(pointer&&pointer.manifest_sha256!==packageManifestSha){
+      throw new Error('audit package manifest does not match active pointer');
+    }
+    const [processState,codingState,autonomousState,hostState]=await Promise.all([
+      processAuthority(processPolicy),codingAuthority(codingRuntime),autonomousAuthority(autonomousRuntime),hostAuthority(hostPolicy)
+    ]);
+    return {
+      release_id:machine?.release_id??pointer?.release_id??`package-${packageManifestSha.slice(0,16)}`,
+      release_manifest_sha256:packageManifestSha,
+      generation_id:pointer?path.basename(path.resolve(pointer.generation_root)):null,
+      generation_manifest_sha256:machine?.generation_manifest_sha256??pointer?.generation_manifest_sha256??null,
+      machine_id:machine?.machine_id??null,
+      identity_generation:machine?.identity_generation??null,
+      online_epoch:machine?.online_epoch??null,
+      authority:{process:processState,coding:codingState,autonomous:autonomousState,host:hostState}
+    };
+  };
+}

package/src/audit-verify.mjs

@@ -0,0 +1,93 @@
+import { createHash, verify as cryptoVerify } from 'node:crypto';
+import { readFile, readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { canonicalJson } from './canonical-json.mjs';
+import { loadPublicVerifyKey } from './trust.mjs';
+
+const EVENT_SCHEMA='deadbyte.tool-audit-event.v1';
+const CHECKPOINT_SCHEMA='deadbyte.tool-audit-checkpoint.v1';
+const CHECKPOINT_DOMAIN=Buffer.from('DEADBYTE-AUDIT-CHECKPOINT-V1\0','utf8');
+const ZERO='0'.repeat(64);
+const HEX64=/^[0-9a-f]{64}$/;
+const TOOL=/^[A-Za-z0-9._-]{1,128}$/;
+const UUID=/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const eventHash=body=>sha256(Buffer.from(canonicalJson(body),'utf8'));
+const checkpointHash=body=>sha256(Buffer.from(canonicalJson(body),'utf8'));
+const segmentName=index=>`segment-${String(index).padStart(8,'0')}.jsonl`;
+const checkpointName=index=>`checkpoint-${String(index).padStart(8,'0')}.json`;
+
+function parseSegment(bytes,name){
+  const text=bytes.toString('utf8');
+  if(!text.endsWith('\n')) throw new Error(`${name} missing final newline`);
+  const lines=text.split('\n');lines.pop();
+  if(lines.length<1) throw new Error(`${name} empty`);
+  if(lines.some(line=>line.length===0)) throw new Error(`${name} contains blank JSONL line`);
+  return lines.map((line,index)=>{try{return JSON.parse(line);}catch(error){throw new Error(`${name} line ${index+1} JSON invalid: ${error.message}`);}});
+}
+function cpBody(cp){const {checkpoint_sha256:_hash,attestation:_attestation,...body}=cp;return body;}
+function requireObject(value,label){if(!value||typeof value!=='object'||Array.isArray(value)) throw new Error(`${label} must be object`);}
+
+export async function verifyAuditChain({stateRoot,verifyKeyPath,requireComplete=true}={}){
+  try{
+    if(!stateRoot) throw new Error('audit verifier requires stateRoot');
+    if(!verifyKeyPath) throw new Error('audit verifier requires verifyKeyPath');
+    const auditDir=path.join(path.resolve(stateRoot),'audit');
+    const key=await loadPublicVerifyKey(verifyKeyPath);
+    const names=await readdir(auditDir);
+    const segmentIndexes=names.map(name=>{const m=/^segment-(\d{8})\.jsonl$/.exec(name);return m?Number(m[1]):null;}).filter(x=>x!==null).sort((a,b)=>a-b);
+    const checkpointIndexes=names.map(name=>{const m=/^checkpoint-(\d{8})\.json$/.exec(name);return m?Number(m[1]):null;}).filter(x=>x!==null).sort((a,b)=>a-b);
+    if(segmentIndexes.length<1) throw new Error('audit has no segments');
+    for(let i=0;i<segmentIndexes.length;i++) if(segmentIndexes[i]!==i+1) throw new Error(`audit segment index gap before ${segmentIndexes[i]}`);
+    for(const index of checkpointIndexes) if(!segmentIndexes.includes(index)) throw new Error(`audit checkpoint ${index} has no segment`);
+
+    let seq=0,head=ZERO,previousCheckpoint=ZERO,requestCount=0,resultCount=0,checkpointCount=0;
+    const open=new Map();
+    for(let pos=0;pos<segmentIndexes.length;pos++){
+      const index=segmentIndexes[pos],fileName=segmentName(index),file=path.join(auditDir,fileName),bytes=await readFile(file),rows=parseSegment(bytes,fileName);
+      const firstSeq=seq+1,firstPrev=head;
+      for(const event of rows){
+        requireObject(event,`audit event seq ${seq+1}`);
+        if(event.schema!==EVENT_SCHEMA) throw new Error(`audit event schema mismatch at seq ${seq+1}`);
+        if(event.seq!==seq+1) throw new Error(`audit seq mismatch: expected ${seq+1}, found ${event.seq}`);
+        if(event.prev_sha256!==head) throw new Error(`audit prev hash mismatch at seq ${event.seq}`);
+        if(!HEX64.test(event.event_sha256??'')) throw new Error(`audit event hash invalid at seq ${event.seq}`);
+        const {event_sha256,...body}=event;if(eventHash(body)!==event_sha256) throw new Error(`audit event hash mismatch at seq ${event.seq}`);
+        if(!UUID.test(event.request_id??'')) throw new Error(`audit request id invalid at seq ${event.seq}`);
+        if(!TOOL.test(event.tool??'')) throw new Error(`audit tool invalid at seq ${event.seq}`);
+        requireObject(event.context,`audit context at seq ${event.seq}`);
+        if(event.event_type==='tool.request'){
+          if(open.has(event.request_id)) throw new Error(`audit duplicate request id at seq ${event.seq}`);
+          if(event.args===undefined) throw new Error(`audit request args missing at seq ${event.seq}`);
+          open.set(event.request_id,{tool:event.tool,seq:event.seq,segment:index});requestCount++;
+        }else if(event.event_type==='tool.result'){
+          const pending=open.get(event.request_id);if(!pending) throw new Error(`audit orphan result at seq ${event.seq}`);
+          if(pending.tool!==event.tool) throw new Error(`audit result tool mismatch at seq ${event.seq}`);
+          requireObject(event.outcome,`audit outcome at seq ${event.seq}`);
+          open.delete(event.request_id);resultCount++;
+        }else throw new Error(`audit event type invalid at seq ${event.seq}`);
+        seq=event.seq;head=event.event_sha256;
+      }
+
+      const cpFile=path.join(auditDir,checkpointName(index));const hasCheckpoint=checkpointIndexes.includes(index);
+      if(pos<segmentIndexes.length-1&&!hasCheckpoint) throw new Error(`audit segment ${index} is unsealed before later segment`);
+      if(hasCheckpoint){
+        const cp=JSON.parse(await readFile(cpFile,'utf8'));requireObject(cp,`audit checkpoint ${index}`);
+        if(cp.schema!==CHECKPOINT_SCHEMA) throw new Error(`audit checkpoint ${index} schema mismatch`);
+        const body=cpBody(cp),computed=checkpointHash(body);if(cp.checkpoint_sha256!==computed) throw new Error(`audit checkpoint ${index} self hash mismatch`);
+        if(cp.segment_index!==index||cp.segment_file!==fileName) throw new Error(`audit checkpoint ${index} segment identity mismatch`);
+        if(cp.first_seq!==firstSeq||cp.last_seq!==seq||cp.first_prev_sha256!==firstPrev||cp.head_sha256!==head) throw new Error(`audit checkpoint ${index} event range mismatch`);
+        requireObject(cp.manifest,`audit checkpoint ${index} manifest`);
+        if(cp.manifest.segment_file!==fileName||cp.manifest.segment_bytes!==bytes.length||cp.manifest.segment_sha256!==sha256(bytes)) throw new Error(`audit checkpoint ${index} manifest mismatch`);
+        if(cp.previous_checkpoint_sha256!==previousCheckpoint) throw new Error(`audit checkpoint ${index} previous checkpoint mismatch`);
+        if(cp.attestation?.algorithm!=='ed25519'||cp.attestation?.key_id!==key.keyId||typeof cp.attestation?.signature_base64!=='string') throw new Error(`audit checkpoint ${index} attestation invalid`);
+        const sig=Buffer.from(cp.attestation.signature_base64,'base64');if(sig.length!==64||sig.toString('base64')!==cp.attestation.signature_base64) throw new Error(`audit checkpoint ${index} signature encoding invalid`);
+        const signed={...body,checkpoint_sha256:cp.checkpoint_sha256};
+        if(!cryptoVerify(null,Buffer.concat([CHECKPOINT_DOMAIN,Buffer.from(canonicalJson(signed),'utf8')]),key.publicKey,sig)) throw new Error(`audit checkpoint ${index} signature invalid`);
+        previousCheckpoint=cp.checkpoint_sha256;checkpointCount++;
+      }
+    }
+    if(requireComplete&&open.size>0) throw new Error(`audit has ${open.size} request(s) without result`);
+    return {ok:true,event_count:seq,request_count:requestCount,result_count:resultCount,open_request_count:open.size,segment_count:segmentIndexes.length,checkpoint_count:checkpointCount,last_seq:seq,head_sha256:head,last_checkpoint_sha256:previousCheckpoint,key_id:key.keyId,complete:open.size===0};
+  }catch(error){return {ok:false,reason:String(error?.message||error)};}
+}

package/src/authority-smoke.mjs

@@ -0,0 +1,117 @@
+import { spawn } from 'node:child_process';
+import { mkdtemp, rm, stat } from 'node:fs/promises';
+import { randomBytes } from 'node:crypto';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Client } from '@modelcontextprotocol/client';
+import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
+import { generateTrustKeypair } from './trust.mjs';
+
+if (process.platform !== 'win32') throw new Error('authority smoke requires Windows');
+
+const repoRoot = path.resolve(fileURLToPath(new URL('..', import.meta.url)));
+const launcherPath = path.join(repoRoot, 'bin', 'deadbyte-exec.exe');
+const serverPath = path.join(repoRoot, 'src', 'mcp-server.mjs');
+const workspaceRoot = path.join(repoRoot, 'workspaces');
+
+async function runNativeExtraArgumentProbe() {
+  return await new Promise((resolve, reject) => {
+    const child = spawn(launcherPath, [
+      '--operation', 'uppercase_ascii',
+      '--challenge', '11'.repeat(32),
+      '--request-digest', '22'.repeat(32),
+      '--worker', 'C:\\Windows\\System32\\cmd.exe'
+    ], { cwd: repoRoot, shell: false, windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] });
+    const stdout = [];
+    const stderr = [];
+    child.stdout.on('data', chunk => stdout.push(Buffer.from(chunk)));
+    child.stderr.on('data', chunk => stderr.push(Buffer.from(chunk)));
+    child.once('error', reject);
+    child.once('close', code => resolve({
+      exitCode: Number.isInteger(code) ? code : 128,
+      stdout: Buffer.concat(stdout).toString('utf8'),
+      stderr: Buffer.concat(stderr).toString('utf8')
+    }));
+  });
+}
+
+async function fileExists(file) {
+  try { await stat(file); return true; } catch { return false; }
+}
+
+const native = await runNativeExtraArgumentProbe();
+if (native.exitCode !== 64 || !native.stderr.includes('invalid fixed argument contract')) {
+  throw new Error(`native authority probe failed: ${JSON.stringify(native)}`);
+}
+
+const trust = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-v060-authority-trust-'));
+const keys = await generateTrustKeypair({
+  privateKeyPath: path.join(trust, 'private.pem'),
+  publicKeyPath: path.join(trust, 'public.pem')
+});
+const client = new Client(
+  { name: 'deadbyte-mcp-authority-smoke', version: '0.8.0' },
+  { versionNegotiation: { mode: { pin: '2026-07-28' } } }
+);
+const transport = new StdioClientTransport({
+  command: process.execPath,
+  args: [serverPath],
+  cwd: repoRoot,
+  env: {
+    ...getDefaultEnvironment(),
+    DEADBYTE_WORKSPACE_ROOT: workspaceRoot,
+    DEADBYTE_SIGNING_KEY: keys.privateKeyPath,
+    DEADBYTE_VERIFY_KEY: keys.publicKeyPath
+  },
+  stderr: 'pipe'
+});
+
+async function expectToolInputRejected(argumentsObject, label, outputPath) {
+  let rejected = false;
+  let detail = '';
+  try {
+    const result = await client.callTool({ name: 'contained_transform', arguments: argumentsObject });
+    rejected = result.isError === true;
+    detail = JSON.stringify(result.structuredContent ?? result.content);
+  } catch (error) {
+    rejected = true;
+    detail = error instanceof Error ? error.message : String(error);
+  }
+  if (!rejected) throw new Error(`${label} unexpectedly accepted: ${detail}`);
+  if (outputPath && await fileExists(path.join(workspaceRoot, 'demo', outputPath))) {
+    throw new Error(`${label} created output despite rejected authority request`);
+  }
+  return { label, rejected: true };
+}
+
+try {
+  await client.connect(transport);
+  const suffix = randomBytes(6).toString('hex');
+  const extraExecutableOutput = `authority-extra-executable.${suffix}.txt`;
+  const extraArgvOutput = `authority-extra-argv.${suffix}.txt`;
+  const pathOperationOutput = `authority-path-operation.${suffix}.txt`;
+  const probes = [];
+  probes.push(await expectToolInputRejected({
+    workspace_id: 'demo', input: 'input.txt', output: extraExecutableOutput,
+    operation: 'uppercase_ascii', executable: 'C:\\Windows\\System32\\cmd.exe'
+  }, 'extra executable field', extraExecutableOutput));
+  probes.push(await expectToolInputRejected({
+    workspace_id: 'demo', input: 'input.txt', output: extraArgvOutput,
+    operation: 'uppercase_ascii', argv: ['/c', 'whoami']
+  }, 'extra argv field', extraArgvOutput));
+  probes.push(await expectToolInputRejected({
+    workspace_id: 'demo', input: 'input.txt', output: pathOperationOutput,
+    operation: '..\\..\\Windows\\System32\\cmd.exe'
+  }, 'path-shaped operation', pathOperationOutput));
+
+  console.log(JSON.stringify({
+    status: 'passed',
+    policy: 'operation-only-no-user-executable-argv-worker-or-environment',
+    native_extra_argument_rejected: true,
+    mcp_strict_schema_rejections: probes
+  }, null, 2));
+} finally {
+  await client.close().catch(() => {});
+  await rm(trust, { recursive: true, force: true }).catch(() => {});
+}

package/src/autonomous-mcp-tools.mjs

@@ -0,0 +1,118 @@
+import * as z from 'zod/v4';
+import {
+  autonomousGoalApproveOutputSchema, autonomousGoalCancelOutputSchema,
+  autonomousGoalEventsOutputSchema, autonomousGoalRunOutputSchema,
+  autonomousGoalStatusOutputSchema, autonomousGoalSubmitOutputSchema,
+  autonomousGoalVerifyOutputSchema, autonomousReleaseGateOutputSchema,
+  autonomousSessionStatusOutputSchema, autonomousStructuredResult,
+  nativeDiffApplyOutputSchema, nativeDiffPreviewOutputSchema, nativeDiffVerifyOutputSchema
+} from './autonomous-output-contracts.mjs';
+
+const hex64 = z.string().regex(/^[0-9a-f]{64}$/);
+const id = z.string().regex(/^[A-Za-z0-9._-]{1,64}$/);
+const relPath = z.string().min(1).max(512);
+const writeOperation = z.strictObject({ kind:z.literal('write'), path:relPath,
+  content:z.string().max(524288), encoding:z.enum(['utf8','base64']).default('utf8'),
+  expected_sha256:z.string().regex(/^(?:absent|[0-9a-f]{64})$/) });
+const replaceOperation = z.strictObject({ kind:z.literal('replace'), path:relPath,
+  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) });
+const deleteOperation = z.strictObject({ kind:z.literal('delete'), path:relPath, expected_sha256:hex64 });
+const nativeOperation = z.union([writeOperation,replaceOperation,deleteOperation]);
+const plannerResponse = z.strictObject({ request_id:hex64, raw_text:z.string().min(2).max(8*1024*1024),
+  model:z.string().min(1).max(128).default('client-model') });
+function result(schema,value,isError=false) { return autonomousStructuredResult(schema,value,isError); }
+function fail(schema,error,status='failed') { return result(schema,{ status, error:String(error) },true); }
+
+export function registerAutonomousTools(server,{ autonomousRuntime, nativeDiffRuntime }) {
+  if (!autonomousRuntime || !nativeDiffRuntime) throw new Error('autonomous tool registration requires runtimes');
+  server.registerTool('autonomous_session_status',{
+    description:'Read R24 autonomous and coding lease status. This never arms or renews authority.',
+    inputSchema:z.strictObject({}), outputSchema:autonomousSessionStatusOutputSchema
+  },async()=>{ try { return result(autonomousSessionStatusOutputSchema,await autonomousRuntime.sessionStatus()); }
+    catch(error){ return fail(autonomousSessionStatusOutputSchema,error); } });
+
+  server.registerTool('native_diff_preview',{
+    description:'Create a signed content-addressed DEADBYTE Native Diff v1 after validating exact file SHA-256 preconditions. No Git metadata is used.',
+    inputSchema:z.strictObject({ root_id:id, title:z.string().max(160).default(''), operations:z.array(nativeOperation).min(1).max(32) }),
+    outputSchema:nativeDiffPreviewOutputSchema
+  },async({root_id,title,operations})=>{ try { return result(nativeDiffPreviewOutputSchema,
+      await nativeDiffRuntime.preview({rootId:root_id,title,operations})); }
+    catch(error){ return fail(nativeDiffPreviewOutputSchema,error); } });
+  server.registerTool('native_diff_apply',{
+    description:'Transactionally apply one signed DEADBYTE Native Diff with signed preimage, per-operation receipts, rollback, and conflict detection.',
+    inputSchema:z.strictObject({ diff_id:hex64 }), outputSchema:nativeDiffApplyOutputSchema
+  },async({diff_id})=>{ try { return result(nativeDiffApplyOutputSchema,await nativeDiffRuntime.apply({diffId:diff_id})); }
+    catch(error){ return fail(nativeDiffApplyOutputSchema,error); } });
+
+  server.registerTool('native_diff_verify',{
+    description:'Independently verify one DEADBYTE Native Diff transaction, its Ed25519 receipt chain, coding receipts, and current-state relation.',
+    inputSchema:z.strictObject({ diff_id:hex64 }), outputSchema:nativeDiffVerifyOutputSchema
+  },async({diff_id})=>{ try { const value=await nativeDiffRuntime.verify({diffId:diff_id});
+      return result(nativeDiffVerifyOutputSchema,value,value.ok!==true); }
+    catch(error){ return fail(nativeDiffVerifyOutputSchema,error); } });
+
+  server.registerTool('autonomous_goal_submit',{
+    description:'Submit one bounded R24 production goal. Execution requires separate live coding and autonomous leases.',
+    inputSchema:z.strictObject({ submission_id:id, root_id:id, title:z.string().max(160).default(''),
+      goal:z.string().min(1).max(8192), acceptance:z.string().max(4096).default(''),
+      max_iterations:z.number().int().min(1).max(64).nullable().default(null) }),
+    outputSchema:autonomousGoalSubmitOutputSchema
+  },async({submission_id,root_id,title,goal,acceptance,max_iterations})=>{ try {
+      return result(autonomousGoalSubmitOutputSchema,await autonomousRuntime.submit({ submissionId:submission_id,
+        rootId:root_id,title,goal,acceptance,maxIterations:max_iterations })); }
+    catch(error){ return fail(autonomousGoalSubmitOutputSchema,error); } });
+  server.registerTool('autonomous_goal_run',{
+    description:'Advance one autonomous production goal through inspect/native-diff/build/test/benchmark/replan cycles. Client-planner mode returns a typed input_required sentinel for the Bridge MRTR adapter.',
+    inputSchema:z.strictObject({ goal_id:hex64, max_cycles:z.number().int().min(1).max(32).default(8),
+      planner_response:plannerResponse.nullable().default(null) }),
+    outputSchema:autonomousGoalRunOutputSchema
+  },async({goal_id,max_cycles,planner_response})=>{ try {
+      return result(autonomousGoalRunOutputSchema,await autonomousRuntime.run({ goalId:goal_id,
+        maxCycles:max_cycles, plannerResponse:planner_response ? { request_id:planner_response.request_id,
+          raw_text:planner_response.raw_text, model:planner_response.model } : null }));
+    } catch(error){ return fail(autonomousGoalRunOutputSchema,error); } });
+
+  server.registerTool('autonomous_goal_status',{
+    description:'Read derived R24 goal state from its authenticated event journal.',
+    inputSchema:z.strictObject({ goal_id:hex64 }), outputSchema:autonomousGoalStatusOutputSchema
+  },async({goal_id})=>{ try { return result(autonomousGoalStatusOutputSchema,
+      await autonomousRuntime.status({goalId:goal_id})); }
+    catch(error){ return fail(autonomousGoalStatusOutputSchema,error); } });
+
+  server.registerTool('autonomous_goal_events',{
+    description:'Read a bounded authenticated R24 goal-event slice.',
+    inputSchema:z.strictObject({ goal_id:hex64, from_seq:z.number().int().min(1).default(1),
+      limit:z.number().int().min(1).max(200).default(100) }), outputSchema:autonomousGoalEventsOutputSchema
+  },async({goal_id,from_seq,limit})=>{ try { return result(autonomousGoalEventsOutputSchema,
+      await autonomousRuntime.events({goalId:goal_id,fromSeq:from_seq,limit})); }
+    catch(error){ return fail(autonomousGoalEventsOutputSchema,error); } });
+  server.registerTool('autonomous_goal_cancel',{
+    description:'Request signed cooperative cancellation of one R24 goal between bounded actions.',
+    inputSchema:z.strictObject({ goal_id:hex64, reason:z.string().min(1).max(256).default('operator_request') }),
+    outputSchema:autonomousGoalCancelOutputSchema
+  },async({goal_id,reason})=>{ try { return result(autonomousGoalCancelOutputSchema,
+      await autonomousRuntime.cancel({goalId:goal_id,reason})); }
+    catch(error){ return fail(autonomousGoalCancelOutputSchema,error); } });
+
+  server.registerTool('autonomous_goal_approve',{
+    description:'Approve or reject resuming a paused autonomous goal. This never arms or renews any lease and cannot bypass release evidence.',
+    inputSchema:z.strictObject({ goal_id:hex64, decision:z.enum(['approve','reject']).default('approve') }),
+    outputSchema:autonomousGoalApproveOutputSchema
+  },async({goal_id,decision})=>{ try { return result(autonomousGoalApproveOutputSchema,
+      await autonomousRuntime.approve({goalId:goal_id,decision})); }
+    catch(error){ return fail(autonomousGoalApproveOutputSchema,error); } });
+
+  server.registerTool('autonomous_goal_verify',{
+    description:'Verify the signed R24 release receipt, journal binding, native diff chain, final native HEAD, and required release profile receipts.',
+    inputSchema:z.strictObject({ goal_id:hex64 }), outputSchema:autonomousGoalVerifyOutputSchema
+  },async({goal_id})=>{ try { const value=await autonomousRuntime.verify({goalId:goal_id});
+      return result(autonomousGoalVerifyOutputSchema,value,value.ok!==true); }
+    catch(error){ return fail(autonomousGoalVerifyOutputSchema,error); } });
+  server.registerTool('autonomous_release_gate',{
+    description:'Run the objective R24 release gate for the latest mutation epoch. A planner finish request is necessary but never sufficient.',
+    inputSchema:z.strictObject({ goal_id:hex64 }), outputSchema:autonomousReleaseGateOutputSchema
+  },async({goal_id})=>{ try { return result(autonomousReleaseGateOutputSchema,
+      await autonomousRuntime.releaseGate({goalId:goal_id})); }
+    catch(error){ return fail(autonomousReleaseGateOutputSchema,error,'error'); } });
+}

package/src/autonomous-output-contracts.mjs

@@ -0,0 +1,125 @@
+import * as z from 'zod/v4';
+
+const hex64 = z.string().regex(/^[0-9a-f]{64}$/);
+const goalId = hex64;
+const jsonObject = z.record(z.string(),z.json());
+const goalState = z.enum(['pending','running','paused','cancelled','succeeded']);
+function requireFields(value,ctx,fields) {
+  for (const field of fields) if (value[field] === undefined) ctx.addIssue({ code:'custom', path:[field], message:`${field} is required` });
+}
+function statusContract({ statuses, shape = {}, success, required = [], errorStatuses = ['failed'] }) {
+  return z.strictObject({ status:z.enum(statuses), error:z.string().optional(), ...shape }).superRefine((value,ctx) => {
+    if (value.error !== undefined) {
+      if (!errorStatuses.includes(value.status)) ctx.addIssue({ code:'custom', path:['error'], message:'error not valid for status' });
+      return;
+    }
+    if (errorStatuses.includes(value.status) && !success.includes(value.status)) {
+      ctx.addIssue({ code:'custom', path:['error'], message:'error required for failed status' }); return;
+    }
+    if (success.includes(value.status)) requireFields(value,ctx,required);
+  });
+}
+const derivedShape = {
+  state:goalState, reason:z.string().nullable(), planner_round:z.number().int().min(0),
+  mutation_epoch:z.number().int().min(0), mutation_count:z.number().int().min(0),
+  contexts:z.array(jsonObject), observations:z.array(jsonObject), diffs:z.array(jsonObject),
+  decisions:z.array(jsonObject), planner_rejections:z.array(jsonObject), active_plan:jsonObject.nullable(),
+  pending_request:jsonObject.nullable(), pending_decision:jsonObject.nullable(),
+  journal_head_sha256:hex64, created_at_utc:z.string().nullable(), elapsed_ms:z.number().min(0)
+};
+export const autonomousSessionStatusOutputSchema = statusContract({
+  statuses:['ok','failed'], success:['ok'], required:['configured','armed','autonomous_armed','autonomous_reason',
+    'autonomous_expires_at_utc','coding_armed','coding_reason','root_ids','planner_backend','profile_ids',
+    'policy_sha256','coding_policy_sha256'],
+  shape:{ configured:z.literal(true).optional(), armed:z.boolean().optional(), autonomous_armed:z.boolean().optional(),
+    autonomous_reason:z.string().optional(), autonomous_expires_at_utc:z.string().nullable().optional(),
+    coding_armed:z.boolean().optional(), coding_reason:z.string().optional(), root_ids:z.array(z.string()).max(64).optional(),
+    planner_backend:z.enum(['client_sampling','openai_compatible']).optional(), profile_ids:z.array(z.string()).max(128).optional(),
+    policy_sha256:hex64.optional(), coding_policy_sha256:hex64.optional() }
+});
+
+export const nativeDiffPreviewOutputSchema = statusContract({
+  statuses:['ready','failed'], success:['ready'], required:['diff_id','root_id','operation_count','payload_bytes','paths','operations'],
+  shape:{ diff_id:hex64.optional(), root_id:z.string().min(1).max(64).optional(), operation_count:z.number().int().min(1).max(32).optional(),
+    payload_bytes:z.number().int().min(0).optional(), paths:z.array(z.string()).max(32).optional(),
+    operations:z.array(jsonObject).max(32).optional() }
+});
+export const nativeDiffApplyOutputSchema = statusContract({
+  statuses:['committed','existing','failed'], success:['committed','existing'],
+  required:['diff_id','receipt_sha256','operation_count'],
+  shape:{ diff_id:hex64.optional(), receipt_sha256:hex64.optional(), operation_count:z.number().int().min(1).max(32).optional(),
+    current_state_matches:z.boolean().optional(), coding_receipts:z.array(jsonObject).max(32).optional() }
+});
+export const nativeDiffVerifyOutputSchema = z.strictObject({
+  status:z.literal('failed').optional(), error:z.string().optional(), ok:z.boolean().optional(), reason:z.string().optional(),
+  diff_id:hex64.optional(), receipt_sha256:hex64.optional(), signature_valid:z.literal(true).optional(),
+  root_id:z.string().min(1).max(64).optional(), operation_count:z.number().int().min(1).max(32).optional(),
+  coding_receipts_verified:z.number().int().min(0).max(32).optional(), final_states:z.array(jsonObject).max(32).optional(),
+  current_state_matches:z.boolean().optional(), journal_head_sha256:hex64.optional()
+}).superRefine((value,ctx) => {
+  if (value.status === 'failed') { requireFields(value,ctx,['error']); return; }
+  if (value.ok === undefined) { ctx.addIssue({code:'custom',path:['ok'],message:'ok required'}); return; }
+  if (!value.ok) { requireFields(value,ctx,['reason']); return; }
+  requireFields(value,ctx,['diff_id','receipt_sha256','signature_valid','root_id','operation_count',
+    'coding_receipts_verified','final_states','current_state_matches','journal_head_sha256']);
+});
+
+export const autonomousGoalSubmitOutputSchema = statusContract({
+  statuses:['accepted','existing','failed'], success:['accepted','existing'],
+  required:['goal_id','goal_sha256','state'],
+  shape:{ goal_id:goalId.optional(), goal_sha256:hex64.optional(), state:goalState.optional() }
+});
+const runShape = Object.fromEntries(Object.entries(derivedShape).map(([key,schema]) => [key,schema.optional()]));
+export const autonomousGoalRunOutputSchema = z.strictObject({
+  status:z.enum(['terminal','paused','cancelled','completed','yielded','running','input_required','failed']), error:z.string().optional(),
+  goal_id:goalId.optional(), release:jsonObject.optional(), planner_request:jsonObject.optional(), ...runShape
+}).superRefine((value,ctx) => {
+  if (value.error !== undefined) { if (value.status !== 'failed') ctx.addIssue({code:'custom',path:['error'],message:'error wrapper requires failed'}); return; }
+  requireFields(value,ctx,['goal_id',...Object.keys(derivedShape)]);
+  if (value.status === 'input_required') requireFields(value,ctx,['planner_request']);
+});
+export const autonomousGoalStatusOutputSchema = statusContract({
+  statuses:['ok','failed'], success:['ok'], required:['goal_id','goal_sha256','title','root_id','journal_verified',...Object.keys(derivedShape)],
+  shape:{ goal_id:goalId.optional(), goal_sha256:hex64.optional(), title:z.string().optional(), root_id:z.string().optional(),
+    journal_verified:z.literal(true).optional(), ...runShape }
+});
+export const autonomousGoalEventsOutputSchema = statusContract({
+  statuses:['ok','failed'], success:['ok'], required:['goal_id','journal_verified','journal_head_sha256','events'],
+  shape:{ goal_id:goalId.optional(), journal_verified:z.literal(true).optional(), journal_head_sha256:hex64.optional(),
+    events:z.array(jsonObject).max(200).optional() }
+});
+export const autonomousGoalCancelOutputSchema = statusContract({
+  statuses:['terminal','requested','existing','failed'], success:['terminal','requested','existing'], required:['goal_id','state'],
+  shape:{ goal_id:goalId.optional(), state:goalState.optional() }
+});
+export const autonomousGoalApproveOutputSchema = statusContract({
+  statuses:['terminal','approved','rejected','failed'], success:['terminal','approved','rejected'], required:['goal_id','state'],
+  shape:{ goal_id:goalId.optional(), state:goalState.optional() }
+});
+export const autonomousReleaseGateOutputSchema = statusContract({
+  statuses:['blocked','paused','failed','passed','existing','error'], success:['blocked','paused','failed','passed','existing'],
+  errorStatuses:['error'], required:['goal_id','ready'],
+  shape:{ goal_id:goalId.optional(), ready:z.boolean().optional(), reason:z.string().optional(), mutation_epoch:z.number().int().min(0).optional(),
+    receipt_sha256:hex64.optional(), required_profiles:z.array(jsonObject).optional(), required_profiles_verified:z.number().int().min(0).optional(),
+    native_diffs_verified:z.number().int().min(0).optional() }
+});
+export const autonomousGoalVerifyOutputSchema = z.strictObject({
+  status:z.literal('failed').optional(), error:z.string().optional(), ok:z.boolean().optional(), reason:z.string().optional(),
+  goal_id:goalId.optional(), receipt_sha256:hex64.optional(), signature_valid:z.literal(true).optional(),
+  mutation_epoch:z.number().int().min(0).optional(), mutation_count:z.number().int().min(0).optional(),
+  planner_round:z.number().int().min(0).optional(), required_profiles_verified:z.number().int().min(0).optional(),
+  native_diffs_verified:z.number().int().min(0).optional(), delegated_actions_verified:z.number().int().min(0).optional(),
+  journal_head_sha256:hex64.optional()
+}).superRefine((value,ctx) => {
+  if (value.status === 'failed') { requireFields(value,ctx,['error']); return; }
+  if (value.ok === undefined) { ctx.addIssue({code:'custom',path:['ok'],message:'ok required'}); return; }
+  if (!value.ok) { requireFields(value,ctx,['reason']); return; }
+  requireFields(value,ctx,['goal_id','receipt_sha256','signature_valid','mutation_epoch','mutation_count','planner_round',
+    'required_profiles_verified','native_diffs_verified','delegated_actions_verified','journal_head_sha256']);
+});
+
+export function autonomousStructuredResult(schema, object, isError = false) {
+  const parsed = schema.safeParse(object);
+  if (!parsed.success) throw new Error(`DEADBYTE autonomous output contract violation: ${z.prettifyError(parsed.error)}`);
+  return { isError, structuredContent:parsed.data, content:[{type:'text',text:JSON.stringify(parsed.data)}] };
+}

package/src/autonomous-planner-contracts.mjs

@@ -0,0 +1,73 @@
+import * as z from 'zod/v4';
+
+const HEX64 = /^[0-9a-f]{64}$/;
+const ID = /^[A-Za-z0-9._-]{1,64}$/;
+const relPath = z.string().min(1).max(512);
+const commandShape = {
+  command_id: z.string().regex(ID),
+  script_path: relPath,
+  script_sha256: z.string().regex(HEX64),
+  args: z.array(z.string().max(2048)).max(64).default([]),
+  cwd: relPath.default('.'),
+  timeout_ms: z.number().int().min(100).max(900000).nullable().default(null)
+};
+
+export const autonomousActionSchema = z.discriminatedUnion('kind', [
+  z.strictObject({ kind: z.literal('tree'), path: relPath.default('.'),
+    max_depth: z.number().int().min(0).max(12).default(4),
+    max_entries: z.number().int().min(1).max(1000).default(300) }),
+  z.strictObject({ kind: z.literal('read'), path: relPath,
+    encoding: z.enum(['utf8','base64']).default('utf8') }),
+  z.strictObject({ kind: z.literal('write'), path: relPath,
+    content: z.string().max(524288), encoding: z.enum(['utf8','base64']).default('utf8'),
+    expected_sha256: z.string().regex(/^(?:absent|[0-9a-f]{64})$/) }),  z.strictObject({ kind: z.literal('replace'), path: relPath,
+    old_string: z.string().min(1).max(262144), new_string: z.string().max(524288),
+    expected_sha256: z.string().regex(HEX64),
+    expected_replacements: z.number().int().min(1).max(64).default(1) }),
+  z.strictObject({ kind: z.literal('command'), ...commandShape,
+    expect_exit_code: z.number().int().default(0) }),
+  z.strictObject({ kind: z.literal('benchmark'), ...commandShape,
+    warmups: z.number().int().min(0).max(3).default(1),
+    iterations: z.number().int().min(1).max(20).default(5),
+    baseline_median_ms: z.number().positive().nullable().default(null),
+    max_regression_pct: z.number().min(0).max(1000).default(5) }),
+  z.strictObject({ kind: z.literal('checkpoint'), message: z.string().min(1).max(512) }),
+  z.strictObject({ kind: z.literal('finish'), summary: z.string().min(1).max(2000) }),
+  z.strictObject({ kind: z.literal('pause'), reason: z.string().min(1).max(1000) })
+]);
+
+export const plannerDecisionSchema = z.strictObject({
+  rationale: z.string().min(1).max(2000),
+  action: autonomousActionSchema
+});
+
+export const mutationReviewSchema = z.strictObject({
+  decision: z.enum(['approve','reject']),
+  reason: z.string().min(1).max(1200)
+});
+export const diagnosisSchema = z.strictObject({
+  summary: z.string().min(1).max(1600),
+  likely_causes: z.array(z.string().min(1).max(500)).min(1).max(6),
+  recommended_focus: z.array(z.string().min(1).max(500)).min(1).max(6)
+});
+
+export const releaseReviewSchema = z.strictObject({
+  decision: z.enum(['ready','continue','pause']),
+  reason: z.string().min(1).max(1600)
+});
+
+export function parseStrictJsonText(schema, text, label) {
+  if (typeof text !== 'string' || text.length < 2 || text.length > 128 * 1024) {
+    throw new Error(`${label} response must be bounded JSON text`);
+  }
+  const trimmed = text.trim();
+  if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) {
+    throw new Error(`${label} response must be one raw JSON object without markdown`);
+  }
+  let parsed;
+  try { parsed = JSON.parse(trimmed); }
+  catch (error) { throw new Error(`${label} response JSON invalid: ${error.message}`); }
+  const checked = schema.safeParse(parsed);
+  if (!checked.success) throw new Error(`${label} response contract mismatch`);
+  return checked.data;
+}