deadbyte-mcp 0.8.7

package/src/autonomous-runtime.mjs

@@ -0,0 +1,993 @@
+import { createHash, randomBytes, sign as cryptoSign, verify as cryptoVerify } from 'node:crypto';
+import { access, mkdir, open, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { canonicalJson } from './canonical-json.mjs';
+import { loadPrivateSigningKey, loadPublicVerifyKey } from './trust.mjs';
+import { assertAutonomousArmed, autonomousSessionStatus } from './autonomous-policy.mjs';
+import { buildPlannerPrompt, parsePlannerDecision, requestProviderDecision } from './autonomous-planner.mjs';
+import { verifyObservationReceiptFile } from './observation-runtime.mjs';
+
+export const AUTONOMOUS_GOAL_SCHEMA = 'deadbyte.autonomous-goal.v1';
+export const AUTONOMOUS_EVENT_SCHEMA = 'deadbyte.autonomous-event.v1';
+export const AUTONOMOUS_RECEIPT_SCHEMA = 'deadbyte.autonomous-release-receipt.v1';
+const CANCEL_SCHEMA = 'deadbyte.autonomous-cancel.v1';
+const GOAL_ID_RE = /^[0-9a-f]{64}$/;
+const ID_RE = /^[A-Za-z0-9._-]{1,64}$/;
+const SHA256_RE = /^[0-9a-f]{64}$/;
+const ZERO_HASH = '0'.repeat(64);
+const EVENT_FILE_RE = /^(\d{6})\.json$/;
+const GOAL_DOMAIN = Buffer.from('DEADBYTE-AUTONOMOUS-GOAL-V1\0');
+const EVENT_DOMAIN = Buffer.from('DEADBYTE-AUTONOMOUS-EVENT-V1\0');
+const CANCEL_DOMAIN = Buffer.from('DEADBYTE-AUTONOMOUS-CANCEL-V1\0');
+const RECEIPT_DOMAIN = Buffer.from('DEADBYTE-AUTONOMOUS-RELEASE-RECEIPT-V1\0');
+const sha256Bytes = bytes => createHash('sha256').update(bytes).digest('hex');
+const sha256Object = value => sha256Bytes(Buffer.from(canonicalJson(value), 'utf8'));
+const exists = file => access(file).then(() => true, () => false);
+function truncated(error, max = 2048) { const s = error instanceof Error ? error.message : String(error); return s.length <= max ? s : `${s.slice(0,max)}…`; }
+function signEnvelope(signingKey, domain, body) {
+  const bytes = Buffer.from(canonicalJson(body), 'utf8');
+  const signature = cryptoSign(null, Buffer.concat([domain, bytes]), signingKey.privateKey);
+  return { ...body, attestation:{ algorithm:'ed25519', key_id:signingKey.keyId, signature_base64:signature.toString('base64') } };
+}
+function verifyEnvelope(verifyKey, domain, envelope, label) {
+  const { attestation, ...body } = envelope ?? {};
+  if (attestation?.algorithm !== 'ed25519' || attestation?.key_id !== verifyKey.keyId || typeof attestation?.signature_base64 !== 'string') {
+    throw new Error(`${label} signature metadata mismatch`);
+  }
+  const signature = Buffer.from(attestation.signature_base64, 'base64');
+  if (signature.length !== 64 || signature.toString('base64') !== attestation.signature_base64) throw new Error(`${label} signature encoding mismatch`);
+  const bytes = Buffer.from(canonicalJson(body), 'utf8');
+  if (!cryptoVerify(null, Buffer.concat([domain, bytes]), verifyKey.publicKey, signature)) throw new Error(`${label} signature verification failed`);
+  return body;
+}
+function goalIdFor(policySha, submissionId) {
+  return sha256Object({ schema:'deadbyte.autonomous-submission.v1', policy_sha256:policySha, submission_id:submissionId });
+}
+function goalContext(policy, goalId) {
+  if (!GOAL_ID_RE.test(goalId ?? '')) throw new Error('invalid autonomous goal_id');
+  const dir = path.join(policy.evidence_dir, 'goals', goalId);
+  return { dir, goalPath:path.join(dir,'goal.json'), eventsDir:path.join(dir,'events'),
+    lockPath:path.join(dir,'run.lock.json'), cancelPath:path.join(dir,'cancel.request.json'),
+    receiptPath:path.join(dir,'release-receipt.json') };
+}
+function eventName(seq) { return `${String(seq).padStart(6,'0')}.json`; }
+async function loadGoal(ctx, policy, verifyKeyPath) {
+  let parsed;
+  try { parsed = JSON.parse(await readFile(ctx.goalPath,'utf8')); }
+  catch (error) { throw new Error(`autonomous goal unavailable: ${error?.code ?? truncated(error)}`); }
+  const verifyKey = await loadPublicVerifyKey(verifyKeyPath);
+  const body = verifyEnvelope(verifyKey, GOAL_DOMAIN, parsed, 'autonomous goal');
+  const { goal_id:goalId, goal_sha256:claimed, ...identity } = body;
+  if (body.schema !== AUTONOMOUS_GOAL_SCHEMA || goalId !== path.basename(ctx.dir) ||
+      body.policy_sha256 !== policy.policy_sha256 || !SHA256_RE.test(claimed ?? '') || sha256Object(identity) !== claimed) {
+    throw new Error('autonomous goal identity/hash mismatch');
+  }
+  return parsed;
+}
+async function readEvents(ctx, verifyKeyPath) {
+  let names;
+  try { names = (await readdir(ctx.eventsDir)).filter(name => EVENT_FILE_RE.test(name)).sort(); }
+  catch (error) { throw new Error(`autonomous event directory unavailable: ${error?.code ?? truncated(error)}`); }
+  const verifyKey = await loadPublicVerifyKey(verifyKeyPath);
+  const events = []; let previous = ZERO_HASH;
+  for (let i = 0; i < names.length; i += 1) {
+    const expected = eventName(i + 1);
+    if (names[i] !== expected) throw new Error(`autonomous event gap at ${expected}`);
+    const event = JSON.parse(await readFile(path.join(ctx.eventsDir,names[i]),'utf8'));
+    const signed = verifyEnvelope(verifyKey, EVENT_DOMAIN, event, 'autonomous event');
+    const { event_sha256:claimed, ...body } = signed;
+    if (body.schema !== AUTONOMOUS_EVENT_SCHEMA || body.seq !== i + 1 || body.goal_id !== path.basename(ctx.dir) ||
+        body.prev_sha256 !== previous || !SHA256_RE.test(claimed ?? '') || sha256Object(body) !== claimed) {
+      throw new Error(`autonomous event ${expected} hash-chain mismatch`);
+    }
+    events.push(event); previous = claimed;
+  }
+  return events;
+}
+async function appendEvent(ctx, events, signingKeyPath, type, payload = {}) {
+  const body = { schema:AUTONOMOUS_EVENT_SCHEMA, seq:events.length + 1, goal_id:path.basename(ctx.dir),
+    created_at_utc:new Date().toISOString(), prev_sha256:events.at(-1)?.event_sha256 ?? ZERO_HASH, type, payload };
+  const signingKey = await loadPrivateSigningKey(signingKeyPath);
+  const event = signEnvelope(signingKey, EVENT_DOMAIN, { ...body, event_sha256:sha256Object(body) });
+  await writeFile(path.join(ctx.eventsDir,eventName(event.seq)), `${canonicalJson(event)}\n`, { flag:'wx' });
+  events.push(event); return event;
+}
+function deriveState(goal, events) {
+  let state = 'pending'; let reason = null; let mutationEpoch = 0; let plannerRound = 0; let mutationCount = 0;
+  const contexts = new Map(); const observations = []; const diffs = []; const decisions = [];
+  const plannerRejections = []; let activePlan = null;
+  const completedDecisions = new Set(); const plannerResponses = new Set(); let pendingRequest = null;
+  for (const event of events) {
+    const p = event.payload ?? {};
+    if (event.type === 'goal_run_started' && !['succeeded','cancelled'].includes(state)) state = 'running';
+    if (event.type === 'planner_requested') pendingRequest = { ...p, event_sha256:event.event_sha256 };
+    if (event.type === 'planner_decision') {
+      plannerRound = Math.max(plannerRound, Number(p.planner_round ?? plannerRound + 1));
+      decisions.push({ ...p, event_sha256:event.event_sha256 });
+      if (p.decision?.plan) activePlan = p.decision.plan;
+      if (p.request_id) plannerResponses.add(p.request_id);
+      if (pendingRequest?.request_id === p.request_id) pendingRequest = null;
+    }
+    if (event.type === 'planner_rejected') {
+      plannerRejections.push({ ...p, event_sha256:event.event_sha256 });
+      if (pendingRequest?.request_id === p.request_id) pendingRequest = null;
+    }
+    if (event.type === 'decision_completed' && p.decision_event_sha256) completedDecisions.add(p.decision_event_sha256);
+    if (event.type === 'inspect_completed') for (const item of p.contexts ?? []) contexts.set(item.path, item);
+    if (event.type === 'profile_completed') observations.push({ ...p, event_sha256:event.event_sha256 });
+    if (event.type === 'delegated_action_completed') {
+      const binding = { ...p, event_sha256:event.event_sha256 };
+      observations.push(binding);
+    }
+    if (event.type === 'native_diff_committed') {
+      mutationEpoch = Number(p.mutation_epoch ?? mutationEpoch + 1); mutationCount += Number(p.mutation_count ?? 1);
+      diffs.push({ ...p, event_sha256:event.event_sha256 });
+    }
+    if (event.type === 'goal_paused') { state = 'paused'; reason = p.reason ?? 'paused'; }
+    if (event.type === 'goal_resumed') { state = 'running'; reason = null; }
+    if (event.type === 'goal_cancelled') { state = 'cancelled'; reason = p.reason ?? 'cancelled'; }
+    if (event.type === 'release_completed') { state = 'succeeded'; reason = null; }
+  }
+  const pendingDecision = [...decisions].reverse().find(item => !completedDecisions.has(item.event_sha256)) ?? null;
+  if (pendingRequest?.request_id && plannerResponses.has(pendingRequest.request_id)) pendingRequest = null;
+  return {
+    state, reason, planner_round:plannerRound, mutation_epoch:mutationEpoch, mutation_count:mutationCount,
+    contexts:[...contexts.values()], observations, diffs, decisions, planner_rejections:plannerRejections,
+    active_plan:activePlan, pending_request:pendingRequest, pending_decision:pendingDecision,
+    journal_head_sha256:events.at(-1)?.event_sha256 ?? ZERO_HASH,
+    created_at_utc:events[0]?.created_at_utc ?? null,
+    elapsed_ms:events[0]?.created_at_utc ? Math.max(0, Date.now() - Date.parse(events[0].created_at_utc)) : 0
+  };
+}
+async function processExists(pid) { if (!Number.isInteger(pid) || pid <= 0) return false; try { process.kill(pid,0); return true; } catch { return false; } }
+async function acquireLock(ctx) {
+  for (let pass = 0; pass < 2; pass += 1) {
+    let handle;
+    try {
+      handle = await open(ctx.lockPath,'wx',0o600);
+      await handle.writeFile(`${canonicalJson({ schema:'deadbyte.autonomous-lock.v1', goal_id:path.basename(ctx.dir), pid:process.pid, created_at_utc:new Date().toISOString() })}\n`);
+      await handle.close(); return;
+    } catch (error) {
+      if (handle) await handle.close().catch(() => {});
+      if (error?.code !== 'EEXIST') throw error;
+      let existing; try { existing = JSON.parse(await readFile(ctx.lockPath,'utf8')); } catch { throw new Error('autonomous lock malformed'); }
+      if (await processExists(existing?.pid)) throw new Error(`autonomous goal busy under pid ${existing.pid}`);
+      await rm(ctx.lockPath,{force:true});
+    }
+  }
+  throw new Error('autonomous lock acquisition failed');
+}
+async function releaseLock(ctx) { await rm(ctx.lockPath,{force:true}); }
+async function readCancel(ctx, verifyKeyPath) {
+  if (!await exists(ctx.cancelPath)) return null;
+  const parsed = JSON.parse(await readFile(ctx.cancelPath,'utf8'));
+  const verifyKey = await loadPublicVerifyKey(verifyKeyPath);
+  const body = verifyEnvelope(verifyKey, CANCEL_DOMAIN, parsed, 'autonomous cancel');
+  if (body.schema !== CANCEL_SCHEMA || body.goal_id !== path.basename(ctx.dir) || typeof body.reason !== 'string') throw new Error('autonomous cancel identity invalid');
+  return body;
+}
+async function consumeCancel(ctx, events, signingKeyPath, verifyKeyPath) {
+  const request = await readCancel(ctx,verifyKeyPath); if (!request) return false;
+  await appendEvent(ctx,events,signingKeyPath,'goal_cancelled',{ reason:request.reason, requested_at_utc:request.requested_at_utc });
+  await rm(ctx.cancelPath,{force:true}).catch(() => {}); return true;
+}
+function profileReceiptId(goalId, actionKey, profileId) {
+  return sha256Object({ schema:'deadbyte.autonomous-profile-receipt-id.v1', goal_id:goalId, action_key:actionKey, profile_id:profileId }).slice(0,24);
+}
+function profileRequestSha(codingRuntime, profile) {
+  const base = { root_id:profile.root_id, command_id:profile.command_id, script_path:profile.script_path,
+    script_sha256:profile.script_sha256, args:profile.args, cwd:profile.cwd, timeout_ms:profile.timeout_ms };
+  return profile.kind === 'command'
+    ? codingRuntime.requestSha('coding_command_run', base)
+    : codingRuntime.requestSha('coding_benchmark_run', { ...base, warmups:profile.warmups, iterations:profile.iterations,
+      baseline_median_ms:profile.baseline_median_ms, max_regression_pct:profile.max_regression_pct });
+}
+function profileOutcome(profile, checked) {
+  if (!checked?.ok) return { valid:false, reason:checked?.reason ?? 'profile receipt invalid' };
+  const receipt = checked.receipt;
+  const expectedOp = profile.kind === 'command' ? 'coding_command_run' : 'coding_benchmark_run';
+  if (receipt.operation !== expectedOp || receipt.root_id !== profile.root_id || receipt.command_id !== profile.command_id ||
+      receipt.script_sha256 !== profile.script_sha256) return { valid:false, reason:'profile receipt identity mismatch' };
+  const passed = profile.kind === 'command'
+    ? !receipt.timed_out && receipt.exit_code === profile.expect_exit_code
+    : receipt.verdict === 'pass';
+  return { valid:true, passed, payload:{ profile_kind:profile.kind, receipt_id:receipt.receipt_id,
+    receipt_sha256:receipt.receipt_sha256, request_sha256:receipt.request_sha256,
+    ...(profile.kind === 'command' ? { exit_code:receipt.exit_code, timed_out:receipt.timed_out, elapsed_ms:receipt.elapsed_ms } :
+      { median_ms:receipt.median_ms, p95_ms:receipt.p95_ms, regression_pct:receipt.regression_pct, verdict:receipt.verdict }) } };
+}
+async function executeProfile({ ctx, events, goalId, actionKey, profileId, epoch, policy, codingRuntime, signingKeyPath }) {
+  const profile = policy.profiles[profileId];
+  if (!profile) throw new Error(`autonomous profile '${profileId}' not found`);
+  const prior = [...events].reverse().find(event => event.type === 'profile_completed' && event.payload?.action_key === actionKey && event.payload?.profile_id === profileId);
+  if (prior) return { status:prior.payload.passed ? 'passed' : 'failed', observation:prior.payload, existing:true };
+  const receiptId = profileReceiptId(goalId, actionKey, profileId);
+  const requestSha256 = profileRequestSha(codingRuntime, profile);
+  const started = [...events].reverse().find(event => event.type === 'profile_started' && event.payload?.action_key === actionKey && event.payload?.profile_id === profileId);
+  if (started) {
+    const checked = await codingRuntime.verifyReceiptDetailed(receiptId);
+    if (!checked.ok) {
+      await appendEvent(ctx,events,signingKeyPath,'goal_paused',{ reason:'interrupted_profile_without_receipt', profile_id:profileId, action_key:actionKey });
+      return { status:'paused', observation:null, existing:false };
+    }
+    if (checked.request_sha256 !== requestSha256) throw new Error(`profile '${profileId}' recovered receipt request mismatch`);
+    const outcome = profileOutcome(profile,checked); if (!outcome.valid) throw new Error(outcome.reason);
+    const payload = { action_key:actionKey, profile_id:profileId, mutation_epoch:epoch, passed:outcome.passed,
+      recovered:true, required_for_release:profile.required_for_release, run_after_mutation:profile.run_after_mutation, ...outcome.payload };
+    await appendEvent(ctx,events,signingKeyPath,'profile_completed',payload);
+    return { status:outcome.passed ? 'passed' : 'failed', observation:payload, existing:false };
+  }
+  await appendEvent(ctx,events,signingKeyPath,'profile_started',{ action_key:actionKey, profile_id:profileId,
+    mutation_epoch:epoch, receipt_id:receiptId, request_sha256:requestSha256 });
+  let result;
+  try {
+    result = profile.kind === 'command'
+      ? await codingRuntime.commandRun({ rootId:profile.root_id, commandId:profile.command_id, scriptPath:profile.script_path,
+          scriptSha256:profile.script_sha256, args:profile.args, cwd:profile.cwd, timeoutMs:profile.timeout_ms,
+          receiptId, requestSha256 })
+      : await codingRuntime.benchmarkRun({ rootId:profile.root_id, commandId:profile.command_id, scriptPath:profile.script_path,
+          scriptSha256:profile.script_sha256, args:profile.args, cwd:profile.cwd, timeoutMs:profile.timeout_ms,
+          warmups:profile.warmups, iterations:profile.iterations, baselineMedianMs:profile.baseline_median_ms,
+          maxRegressionPct:profile.max_regression_pct, receiptId, requestSha256 });
+  } catch (error) {
+    const checked = await codingRuntime.verifyReceiptDetailed(receiptId);
+    if (!checked.ok) {
+      await appendEvent(ctx,events,signingKeyPath,'goal_paused',{ reason:'profile_execution_without_receipt', profile_id:profileId,
+        action_key:actionKey, detail:truncated(error) });
+      return { status:'paused', observation:null, existing:false };
+    }
+    result = null;
+  }
+  const checked = await codingRuntime.verifyReceiptDetailed(receiptId);
+  if (!checked.ok || checked.request_sha256 !== requestSha256 || (result && result.receipt_sha256 !== checked.receipt_sha256)) {
+    throw new Error(`profile '${profileId}' post-execution receipt verification failed`);
+  }
+  const outcome = profileOutcome(profile,checked); if (!outcome.valid) throw new Error(outcome.reason);
+  const payload = { action_key:actionKey, profile_id:profileId, mutation_epoch:epoch, passed:outcome.passed,
+    recovered:result === null, required_for_release:profile.required_for_release,
+    run_after_mutation:profile.run_after_mutation,
+    stdout_excerpt:typeof result?.stdout === 'string' ? result.stdout.slice(-65536) : '',
+    stderr_excerpt:typeof result?.stderr === 'string' ? result.stderr.slice(-65536) : '', ...outcome.payload };
+  await appendEvent(ctx,events,signingKeyPath,'profile_completed',payload);
+  return { status:outcome.passed ? 'passed' : 'failed', observation:payload, existing:false };
+}
+
+function latestProfileObservation(state, profileId, epoch) {
+  return [...state.observations].reverse().find(item => item.profile_id === profileId && item.mutation_epoch === epoch) ?? null;
+}
+function releaseReadiness(policy, state) {
+  const required = Object.entries(policy.profiles).filter(([,profile]) => profile.required_for_release);
+  const results = required.map(([profileId]) => {
+    const observation = latestProfileObservation(state,profileId,state.mutation_epoch);
+    return { profile_id:profileId, passed:observation?.passed === true,
+      receipt_id:observation?.receipt_id ?? null, receipt_sha256:observation?.receipt_sha256 ?? null,
+      request_sha256:observation?.request_sha256 ?? null };
+  });
+  return { ready:results.every(item => item.passed), mutation_epoch:state.mutation_epoch, required_profiles:results };
+}
+function normalizeGoal(policy, { submissionId, rootId, title = '', goal, acceptance = '', maxIterations = null }) {
+  if (!ID_RE.test(submissionId ?? '')) throw new Error('autonomous submission_id invalid');
+  if (!policy.root_ids.includes(rootId)) throw new Error(`autonomous root '${rootId}' is not allowed`);
+  if (typeof title !== 'string' || title.length > 160) throw new Error('autonomous title must be <=160 characters');
+  if (typeof goal !== 'string' || goal.length < 1 || goal.length > 8192) throw new Error('autonomous goal must be 1-8192 characters');
+  if (typeof acceptance !== 'string' || acceptance.length > 4096) throw new Error('autonomous acceptance must be <=4096 characters');
+  const iterations = maxIterations ?? policy.limits.max_iterations;
+  if (!Number.isInteger(iterations) || iterations < 1 || iterations > policy.limits.max_iterations) throw new Error('autonomous max_iterations exceeds policy');
+  const body = { schema:AUTONOMOUS_GOAL_SCHEMA, policy_sha256:policy.policy_sha256,
+    coding_policy_sha256:policy.coding_policy_sha256, submission_id:submissionId, root_id:rootId,
+    title, goal, acceptance, max_iterations:iterations };
+  return Object.freeze({ ...body, goal_sha256:sha256Object(body) });
+}
+
+async function plannerView(goal, state, codingRuntime) {
+  const tree = await codingRuntime.tree({ rootId:goal.root_id, path:'.', maxDepth:4, maxEntries:600 });
+  return { mutation_epoch:state.mutation_epoch, planner_round:state.planner_round, tree:tree.entries,
+    contexts:state.contexts.slice(-16), observations:state.observations.slice(-24), active_plan:state.active_plan,
+    recent_decisions:state.decisions.slice(-8).map(item => ({ planner_round:item.planner_round,
+      action:item.decision?.action, summary:item.decision?.summary })) };
+}
+function requestIdFor(goalId, plannerRound, journalHead) {
+  return sha256Object({ schema:'deadbyte.autonomous-planner-request.v1', goal_id:goalId, planner_round:plannerRound, journal_head_sha256:journalHead });
+}
+async function requestPlanner(ctx, goal, events, state, policy, codingRuntime, signingKeyPath) {
+  if (state.pending_request) return state.pending_request;
+  const round = state.planner_round + 1;
+  if (round > goal.max_iterations) {
+    await appendEvent(ctx,events,signingKeyPath,'goal_paused',{ reason:'iteration_limit', max_iterations:goal.max_iterations });
+    return null;
+  }
+  if (policy.limits.max_wall_ms !== null && state.elapsed_ms > policy.limits.max_wall_ms) {
+    await appendEvent(ctx,events,signingKeyPath,'goal_paused',{ reason:'wall_time_limit', max_wall_ms:policy.limits.max_wall_ms });
+    return null;
+  }
+  const view = await plannerView(goal,state,codingRuntime);
+  let prompt = buildPlannerPrompt({ goal:{ title:goal.title, goal:goal.goal, acceptance:goal.acceptance }, policy, view });
+  const repair = [...(state.planner_rejections ?? [])].reverse().find(item => item.planner_round === round) ?? null;
+  if (repair) {
+    const repairState = canonicalJson({ request_id:repair.request_id, response_sha256:repair.response_sha256,
+      reason:repair.reason, attempt:repair.attempt });
+    prompt += `
+PREVIOUS_RESPONSE_REJECTED=${repairState}
+Repair only the decision contract. Return one corrected strict JSON decision; do not repeat Markdown or prose.`;
+  }
+  const requestId = requestIdFor(goal.goal_id,round,state.journal_head_sha256);
+  const payload = { request_id:requestId, planner_round:round, mutation_epoch:state.mutation_epoch,
+    prompt, prompt_sha256:sha256Bytes(Buffer.from(prompt,'utf8')), backend:policy.planner.backend,
+    ...(repair ? { repair_of_request_id:repair.request_id, rejection_event_sha256:repair.event_sha256 } : {}) };
+  await appendEvent(ctx,events,signingKeyPath,'planner_requested',payload);
+  return payload;
+}
+function completedPlanPrefix(plan) {
+  if (!plan?.steps) return 0;
+  let count = 0;
+  for (const step of plan.steps) { if (step.status !== 'completed') break; count += 1; }
+  return count;
+}
+function validatePlanTransition(previous, next) {
+  if (!next || !previous) return;
+  if (next.title !== previous.title) throw new Error('planner plan title is immutable after creation');
+  const locked = completedPlanPrefix(previous);
+  if (next.steps.length < locked) throw new Error('planner plan cannot remove completed prefix');
+  for (let i = 0; i < locked; i += 1) {
+    if (canonicalJson(next.steps[i]) !== canonicalJson(previous.steps[i])) {
+      throw new Error(`planner plan completed step '${previous.steps[i].step_id}' is immutable`);
+    }
+  }
+}
+function planIsComplete(plan) {
+  return Boolean(plan?.steps?.length) && plan.steps.every(step => step.status === 'completed');
+}
+async function acceptPlannerDecision({ ctx, events, goal, state, policy, codingRuntime, signingKeyPath, plannerResponse }) {
+  let currentState = state;
+  let pending = currentState.pending_request ?? await requestPlanner(ctx,goal,events,currentState,policy,codingRuntime,signingKeyPath);
+  if (!pending) return null;
+  let suppliedResponse = plannerResponse;
+  while (pending) {
+    let response;
+    if (policy.planner.backend === 'openai_compatible') {
+      response = await requestProviderDecision(policy,pending.prompt);
+    } else {
+      if (!suppliedResponse) return { needs_planner:true, request:pending };
+      if (suppliedResponse.request_id !== pending.request_id) throw new Error('planner response request_id mismatch');
+      if (typeof suppliedResponse.raw_text !== 'string') throw new Error('planner response raw_text missing');
+      response = { backend:'client_sampling',
+        model:typeof suppliedResponse.model === 'string' ? suppliedResponse.model.slice(0,128) : 'client-model',
+        raw_text:suppliedResponse.raw_text };
+      suppliedResponse = null;
+    }
+    let decision;
+    try {
+      decision = parsePlannerDecision(response.raw_text,policy);
+      validatePlanTransition(currentState.active_plan,decision.plan);
+    } catch (error) {
+      const reason = truncated(error,512);
+      const attempt = 1 + events.filter(event => event.type === 'planner_rejected' &&
+        event.payload?.planner_round === pending.planner_round).length;
+      const rejected = await appendEvent(ctx,events,signingKeyPath,'planner_rejected',{
+        request_id:pending.request_id, planner_round:pending.planner_round, mutation_epoch:pending.mutation_epoch,
+        backend:response.backend, model:response.model ?? 'unknown',
+        response_sha256:sha256Bytes(Buffer.from(response.raw_text,'utf8')), reason, attempt
+      });
+      if (attempt >= 3) {
+        await appendEvent(ctx,events,signingKeyPath,'goal_paused',{
+          reason:'planner_contract_repeated_failure', planner_round:pending.planner_round,
+          last_rejection_event_sha256:rejected.event_sha256
+        });
+        return { needs_planner:false, rejected:true, paused:true };
+      }
+      currentState = deriveState(goal,events);
+      pending = await requestPlanner(ctx,goal,events,currentState,policy,codingRuntime,signingKeyPath);
+      if (!pending) return null;
+      if (policy.planner.backend === 'client_sampling') return { needs_planner:true, request:pending };
+      continue;
+    }
+    const event = await appendEvent(ctx,events,signingKeyPath,'planner_decision',{
+      request_id:pending.request_id, planner_round:pending.planner_round, mutation_epoch:pending.mutation_epoch,
+      backend:response.backend, model:response.model ?? 'unknown', response_sha256:sha256Bytes(Buffer.from(response.raw_text,'utf8')),
+      decision
+    });
+    return { needs_planner:false, event, decision };
+  }
+  return null;
+}
+function repeatedDecisionCount(state, decision) {
+  const key = canonicalJson(decision);
+  let count = 0;
+  for (const item of [...state.decisions].reverse()) {
+    if (canonicalJson(item.decision) !== key) break;
+    count += 1;
+  }
+  return count;
+}
+async function executeInspect({ ctx, events, goal, decisionEvent, decision, codingRuntime, signingKeyPath }) {
+  const contexts = [];
+  for (const item of decision.reads) {
+    const read = await codingRuntime.fileRead({ rootId:goal.root_id, relativePath:item.path, encoding:'utf8' });
+    const bytes = Buffer.byteLength(read.content,'utf8');
+    if (bytes > item.max_bytes) throw new Error(`planner inspect '${item.path}' exceeds requested max_bytes`);
+    contexts.push({ path:item.path, sha256:read.sha256, bytes:read.bytes, content:read.content });
+  }
+  await appendEvent(ctx,events,signingKeyPath,'inspect_completed',{
+    decision_event_sha256:decisionEvent.event_sha256, contexts
+  });
+  return { status:'completed', contexts };
+}
+
+const DELEGATED_MUTATIONS = new Set(['process_start','process_action','process_terminate','observation_search_cancel']);
+function assertDelegatedIdentity(events, operation) {
+  if (['observation_search_status','observation_search_page','observation_search_cancel'].includes(operation.kind)) {
+    const owned = events.some(event => event.type === 'delegated_action_completed' &&
+      event.payload?.operation?.kind === 'observation_search_start' && event.payload?.result?.search_id === operation.search_id);
+    if (!owned) throw new Error(`delegated search identity '${operation.search_id}' is stale or belongs to another goal`);
+  }
+  if (['process_read','process_status','process_action','process_terminate'].includes(operation.kind)) {
+    const owned = events.some(event => event.type === 'delegated_action_completed' &&
+      event.payload?.operation?.kind === 'process_start' && event.payload?.result?.session_id === operation.session_id);
+    if (!owned) throw new Error(`delegated process session '${operation.session_id}' is stale or belongs to another goal`);
+  }
+}
+async function invokeDelegatedOperation(goal, operation, runtimes) {
+  const { machineFsRuntime, observationRuntime, processRuntime } = runtimes;
+  switch (operation.kind) {
+    case 'machine_stat':
+      if (!machineFsRuntime) throw new Error('machine filesystem runtime unavailable');
+      return machineFsRuntime.stat({ rootId:goal.root_id, relativePath:operation.path, hash:operation.hash });
+    case 'machine_list':
+      if (!machineFsRuntime) throw new Error('machine filesystem runtime unavailable');
+      return machineFsRuntime.list({ rootId:goal.root_id, relativePath:operation.path, cursor:operation.cursor,
+        limit:operation.limit, hashFiles:operation.hash_files });
+    case 'machine_read':
+      if (!machineFsRuntime) throw new Error('machine filesystem runtime unavailable');
+      return machineFsRuntime.read({ rootId:goal.root_id, relativePath:operation.path, offset:operation.offset,
+        maxBytes:operation.max_bytes, hashFile:operation.hash });
+    case 'observation_search_start':
+      if (!observationRuntime) throw new Error('observation runtime unavailable');
+      return observationRuntime.searchStart({ rootId:goal.root_id, relativePath:operation.path, pattern:operation.pattern,
+        caseSensitive:operation.case_sensitive, maxResults:operation.max_results, maxFiles:operation.max_files,
+        maxBytes:operation.max_bytes, maxFileBytes:operation.max_file_bytes });
+    case 'observation_search_status':
+      if (!observationRuntime) throw new Error('observation runtime unavailable');
+      return observationRuntime.searchStatus({ searchId:operation.search_id });
+    case 'observation_search_page':
+      if (!observationRuntime) throw new Error('observation runtime unavailable');
+      return observationRuntime.searchPage({ searchId:operation.search_id, cursor:operation.cursor, limit:operation.limit });
+    case 'observation_search_cancel':
+      if (!observationRuntime) throw new Error('observation runtime unavailable');
+      return observationRuntime.searchCancel({ searchId:operation.search_id });
+    case 'observation_process_list':
+      if (!observationRuntime) throw new Error('observation runtime unavailable');
+      return observationRuntime.processList({ includeExternal:operation.include_external, cursor:operation.cursor, limit:operation.limit });
+    case 'observation_system_status':
+      if (!observationRuntime) throw new Error('observation runtime unavailable');
+      return observationRuntime.systemStatus();
+    case 'process_start':
+      if (!processRuntime) throw new Error('process runtime unavailable');
+      return processRuntime.start({ profileId:operation.profile_id, rootId:goal.root_id, cwd:operation.cwd, args:[] });
+    case 'process_read':
+      if (!processRuntime) throw new Error('process runtime unavailable');
+      return processRuntime.read({ sessionId:operation.session_id, offset:operation.offset, maxBytes:operation.max_bytes });
+    case 'process_status':
+      if (!processRuntime) throw new Error('process runtime unavailable');
+      return processRuntime.status({ sessionId:operation.session_id });
+    case 'process_list':
+      if (!processRuntime) throw new Error('process runtime unavailable');
+      return processRuntime.list();
+    case 'process_action':
+      if (!processRuntime) throw new Error('process runtime unavailable');
+      return processRuntime.action({ sessionId:operation.session_id, actionId:operation.action_id });
+    case 'process_terminate':
+      if (!processRuntime) throw new Error('process runtime unavailable');
+      return processRuntime.terminate({ sessionId:operation.session_id });
+    default: throw new Error(`unsupported delegated operation '${String(operation.kind)}'`);
+  }
+}
+async function verifyDelegatedEvidence(operation, result, runtimes, verifyKeyPath) {
+  if (operation.kind.startsWith('observation_') && result?.receipt_id) {
+    const checked = await verifyObservationReceiptFile({ policy:runtimes.observationRuntime.policy, verifyKeyPath,
+      receiptId:result.receipt_id });
+    if (!checked.ok || checked.receipt_sha256 !== result.receipt_sha256 || checked.request_sha256 !== result.request_sha256) {
+      throw new Error('delegated observation receipt mismatch');
+    }
+    return { kind:'observation_receipt', receipt_id:result.receipt_id, receipt_sha256:checked.receipt_sha256,
+      request_sha256:checked.request_sha256, result_head_sha256:checked.result_head_sha256 };
+  }
+  if (operation.kind.startsWith('process_') && operation.kind !== 'process_list') {
+    const sessionId = operation.session_id ?? result?.session_id ?? result?.session?.session_id;
+    if (sessionId && ['process_start','process_action','process_terminate'].includes(operation.kind)) {
+      const checked = await runtimes.processRuntime.verifyEventJournal({ sessionId });
+      if (!checked.ok) throw new Error('delegated process journal verification failed');
+      return { kind:'process_journal', session_id:sessionId, event_count:checked.event_count,
+        journal_head_sha256:checked.head_sha256 };
+    }
+  }
+  return { kind:'runtime_result', result_sha256:sha256Object(result) };
+}
+async function executeDelegate({ ctx, events, goal, decisionEvent, decision, policy, runtimes, assertRunAuthority,
+  signingKeyPath, verifyKeyPath }) {
+  const actionKey = `delegate-${decisionEvent.event_sha256}`;
+  const prior = [...events].reverse().find(event => event.type === 'delegated_action_completed' && event.payload?.action_key === actionKey);
+  if (prior) return { status:'completed', result:prior.payload.result, existing:true };
+  const started = [...events].reverse().find(event => event.type === 'delegated_action_started' && event.payload?.action_key === actionKey);
+  if (started) {
+    await appendEvent(ctx,events,signingKeyPath,'goal_paused',{ reason:'interrupted_delegated_action', action_key:actionKey,
+      operation_kind:decision.operation.kind });
+    return { status:'paused' };
+  }
+  await appendEvent(ctx,events,signingKeyPath,'delegated_action_started',{ action_key:actionKey,
+    decision_event_sha256:decisionEvent.event_sha256, operation:decision.operation });
+  try {
+    assertDelegatedIdentity(events,decision.operation);
+    if (DELEGATED_MUTATIONS.has(decision.operation.kind)) await assertRunAuthority(goal.root_id);
+    const result = await invokeDelegatedOperation(goal,decision.operation,runtimes);
+    if (Buffer.byteLength(canonicalJson(result),'utf8') > policy.limits.max_context_bytes) {
+      throw new Error('delegated result exceeds autonomous context bound');
+    }
+    const evidence = await verifyDelegatedEvidence(decision.operation,result,runtimes,verifyKeyPath);
+    await appendEvent(ctx,events,signingKeyPath,'delegated_action_completed',{ action_key:actionKey,
+      decision_event_sha256:decisionEvent.event_sha256, operation:decision.operation, result, evidence });
+    return { status:'completed', result, evidence };
+  } catch (error) {
+    await appendEvent(ctx,events,signingKeyPath,'goal_paused',{ reason:'delegated_action_failed', action_key:actionKey,
+      operation_kind:decision.operation.kind, detail:truncated(error) });
+    return { status:'paused', reason:'delegated_action_failed' };
+  }
+}
+
+async function runMutationProfiles({ ctx, events, goal, epoch, actionKey, policy, codingRuntime, signingKeyPath }) {
+  const profileIds = Object.entries(policy.profiles)
+    .filter(([,profile]) => profile.run_after_mutation)
+    .map(([id]) => id);
+  const results = [];
+  for (const profileId of profileIds) {
+    const result = await executeProfile({ ctx,events,goalId:goal.goal_id,actionKey:`${actionKey}:${profileId}`,
+      profileId,epoch,policy,codingRuntime,signingKeyPath });
+    results.push({ profile_id:profileId, status:result.status, observation:result.observation });
+    if (result.status === 'paused') break;
+  }
+  return results;
+}
+async function executePatch({ ctx, events, goal, state, decisionEvent, decision, nativeDiffRuntime,
+  policy, codingRuntime, signingKeyPath }) {
+  if (state.mutation_count + decision.operations.length > policy.limits.max_mutations) {
+    await appendEvent(ctx,events,signingKeyPath,'goal_paused',{
+      reason:'mutation_limit', max_mutations:policy.limits.max_mutations
+    });
+    return { status:'paused' };
+  }
+  const applicationScope = sha256Object({ schema:'deadbyte.autonomous-native-diff-scope.v1',
+    goal_id:goal.goal_id, decision_event_sha256:decisionEvent.event_sha256 });
+  const preview = await nativeDiffRuntime.preview({ rootId:goal.root_id,
+    operations:decision.operations, title:decision.summary, applicationScope });
+  const applied = await nativeDiffRuntime.apply({ diffId:preview.diff_id });
+  const verified = await nativeDiffRuntime.verify({ diffId:preview.diff_id });
+  if (!verified.ok || verified.current_state_matches !== true) {
+    throw new Error(`autonomous native diff verification failed: ${verified.reason ?? 'state mismatch'}`);
+  }
+  const epoch = state.mutation_epoch + 1;
+  await appendEvent(ctx,events,signingKeyPath,'native_diff_committed',{
+    decision_event_sha256:decisionEvent.event_sha256, diff_id:preview.diff_id,
+    diff_receipt_sha256:verified.receipt_sha256, mutation_epoch:epoch,
+    mutation_count:decision.operations.length, operation_count:preview.operation_count,
+    paths:preview.paths, coding_receipts_verified:verified.coding_receipts_verified
+  });
+  const profiles = await runMutationProfiles({ ctx,events,goal,epoch,
+    actionKey:`mutation-${epoch}`,policy,codingRuntime,signingKeyPath });
+  return { status:profiles.some(item => item.status === 'paused') ? 'paused' : 'completed',
+    diff_id:preview.diff_id, mutation_epoch:epoch, profiles };
+}
+async function runRequiredReleaseProfiles({ ctx, events, goal, state, policy, codingRuntime, signingKeyPath }) {
+  const requiredIds = Object.entries(policy.profiles)
+    .filter(([,profile]) => profile.required_for_release)
+    .map(([id]) => id);
+  const results = [];
+  for (const profileId of requiredIds) {
+    const existing = latestProfileObservation(deriveState(goal,events),profileId,state.mutation_epoch);
+    if (existing?.passed === true) {
+      results.push({ profile_id:profileId, status:'passed', observation:existing, existing:true });
+      continue;
+    }
+    const result = await executeProfile({ ctx,events,goalId:goal.goal_id,
+      actionKey:`release-${state.mutation_epoch}:${profileId}`, profileId,
+      epoch:state.mutation_epoch,policy,codingRuntime,signingKeyPath });
+    results.push({ profile_id:profileId, ...result });
+    if (result.status === 'paused') break;
+  }
+  return results;
+}
+
+async function collectNativeHead(state, nativeDiffRuntime, codingRuntime) {
+  const diffBindings = []; const head = new Map();
+  for (const item of state.diffs) {
+    const checked = await nativeDiffRuntime.verify({ diffId:item.diff_id });
+    if (!checked.ok || !Array.isArray(checked.final_states)) throw new Error(`release diff '${item.diff_id}' verification failed`);
+    diffBindings.push({ diff_id:item.diff_id, receipt_sha256:checked.receipt_sha256,
+      coding_receipts_verified:checked.coding_receipts_verified });
+    for (const finalState of checked.final_states) {
+      head.set(`${checked.root_id}\0${finalState.path}`, { root_id:checked.root_id,
+        path:finalState.path, exists:finalState.exists, sha256:finalState.sha256 });
+    }
+  }
+  const finalSourceStates = [...head.values()].sort((a,b) => `${a.root_id}/${a.path}`.localeCompare(`${b.root_id}/${b.path}`));
+  for (const expected of finalSourceStates) {
+    const current = await codingRuntime.fileState({ rootId:expected.root_id, relativePath:expected.path });
+    if (current.exists !== expected.exists || current.sha256 !== expected.sha256) {
+      throw new Error(`release native HEAD mismatch '${expected.path}'`);
+    }
+  }
+  return { diffBindings, finalSourceStates };
+}
+
+async function createReleaseReceipt({ ctx, events, goal, state, policy, nativeDiffRuntime,
+  codingRuntime, signingKeyPath }) {
+  const readiness = releaseReadiness(policy,state);
+  if (!readiness.ready) throw new Error('release receipt requires all required profiles passing at current mutation epoch');
+  const { diffBindings, finalSourceStates } = await collectNativeHead(state,nativeDiffRuntime,codingRuntime);
+  const body = {
+    schema:AUTONOMOUS_RECEIPT_SCHEMA, goal_id:goal.goal_id, goal_sha256:goal.goal_sha256,
+    policy_sha256:policy.policy_sha256, coding_policy_sha256:policy.coding_policy_sha256,
+    mutation_epoch:state.mutation_epoch, mutation_count:state.mutation_count,
+    planner_round:state.planner_round, event_head_sha256:state.journal_head_sha256,
+    required_profiles:readiness.required_profiles, native_diffs:diffBindings,
+    delegated_evidence:state.observations.filter(item => item.operation && item.evidence).map(item => ({ action_key:item.action_key,
+      decision_event_sha256:item.decision_event_sha256, operation:item.operation, evidence:item.evidence,
+      event_sha256:item.event_sha256 })),
+    final_source_states:finalSourceStates, completed_at_utc:new Date().toISOString()
+  };
+  const receiptSha = sha256Object(body);
+  const signingKey = await loadPrivateSigningKey(signingKeyPath);
+  const receipt = signEnvelope(signingKey, RECEIPT_DOMAIN, { ...body, receipt_sha256:receiptSha });
+  await writeFile(ctx.receiptPath, `${canonicalJson(receipt)}\n`, { flag:'wx' });
+  await appendEvent(ctx,events,signingKeyPath,'release_completed',{
+    receipt_sha256:receiptSha, mutation_epoch:state.mutation_epoch,
+    event_head_sha256:state.journal_head_sha256
+  });
+  return receipt;
+}
+
+async function verifyReleaseReceipt({ ctx, goal, events, policy, verifyKeyPath, nativeDiffRuntime, codingRuntime }) {
+  if (!await exists(ctx.receiptPath)) return { ok:false, reason:'release receipt missing' };
+  let receipt;
+  try { receipt = JSON.parse(await readFile(ctx.receiptPath,'utf8')); }
+  catch { return { ok:false, reason:'release receipt unreadable' }; }
+  const verifyKey = await loadPublicVerifyKey(verifyKeyPath);
+  let signed;
+  try { signed = verifyEnvelope(verifyKey,RECEIPT_DOMAIN,receipt,'autonomous release receipt'); }
+  catch (error) { return { ok:false, reason:truncated(error) }; }
+  const { receipt_sha256:claimed, ...body } = signed;
+  if (body.schema !== AUTONOMOUS_RECEIPT_SCHEMA || body.goal_id !== goal.goal_id ||
+      body.goal_sha256 !== goal.goal_sha256 || body.policy_sha256 !== policy.policy_sha256 ||
+      body.coding_policy_sha256 !== policy.coding_policy_sha256 || !SHA256_RE.test(claimed ?? '') ||
+      sha256Object(body) !== claimed) return { ok:false, reason:'release receipt identity/hash mismatch' };
+  const completion = events.at(-1);
+  if (completion?.type !== 'release_completed' || completion.prev_sha256 !== body.event_head_sha256 ||
+      completion.payload?.receipt_sha256 !== claimed || completion.payload?.event_head_sha256 !== body.event_head_sha256) {
+    return { ok:false, reason:'release receipt/event binding mismatch' };
+  }
+  const preCompletionState = deriveState(goal,events.slice(0,-1));
+  if (preCompletionState.mutation_epoch !== body.mutation_epoch ||
+      preCompletionState.mutation_count !== body.mutation_count ||
+      preCompletionState.planner_round !== body.planner_round) {
+    return { ok:false, reason:'release receipt state binding mismatch' };
+  }
+  const readiness = releaseReadiness(policy,preCompletionState);
+  if (!readiness.ready || canonicalJson(readiness.required_profiles) !== canonicalJson(body.required_profiles)) {
+    return { ok:false, reason:'release profile evidence mismatch' };
+  }
+  let nativeHead;
+  try { nativeHead = await collectNativeHead(preCompletionState,nativeDiffRuntime,codingRuntime); }
+  catch (error) { return { ok:false, reason:truncated(error) }; }
+  if (canonicalJson(nativeHead.diffBindings) !== canonicalJson(body.native_diffs ?? [])) {
+    return { ok:false, reason:'release native diff binding mismatch' };
+  }
+  if (canonicalJson(nativeHead.finalSourceStates) !== canonicalJson(body.final_source_states ?? [])) {
+    return { ok:false, reason:'release native HEAD binding mismatch' };
+  }
+  const delegatedEvidence = preCompletionState.observations.filter(item => item.operation && item.evidence).map(item => ({ action_key:item.action_key,
+    decision_event_sha256:item.decision_event_sha256, operation:item.operation, evidence:item.evidence,
+    event_sha256:item.event_sha256 }));
+  if (canonicalJson(delegatedEvidence) !== canonicalJson(body.delegated_evidence ?? [])) {
+    return { ok:false, reason:'release delegated evidence binding mismatch' };
+  }
+  const diffsVerified = nativeHead.diffBindings.length;
+  return { ok:true, goal_id:goal.goal_id, receipt_sha256:claimed, signature_valid:true,
+    mutation_epoch:body.mutation_epoch, mutation_count:body.mutation_count,
+    planner_round:body.planner_round, required_profiles_verified:body.required_profiles.length,
+    native_diffs_verified:diffsVerified, delegated_actions_verified:delegatedEvidence.length,
+    journal_head_sha256:completion.event_sha256 };
+}
+
+async function executeDecision({ ctx, events, goal, state, decisionEvent, policy, codingRuntime,
+  nativeDiffRuntime, machineFsRuntime, observationRuntime, processRuntime, assertRunAuthority,
+  signingKeyPath, verifyKeyPath }) {
+  const decision = decisionEvent.decision;
+  if (repeatedDecisionCount(state,decision) >= 3) {
+    await appendEvent(ctx,events,signingKeyPath,'goal_paused',{ reason:'no_progress_repeated_decision' });
+    return { status:'paused' };
+  }
+  let outcome;
+  const activePlan = state.active_plan;
+  if (decision.action === 'finish' && activePlan && !planIsComplete(activePlan)) {
+    await appendEvent(ctx,events,signingKeyPath,'plan_guard_blocked',{
+      decision_event_sha256:decisionEvent.event_sha256, action:decision.action,
+      reason:'plan_incomplete_blocks_finish', plan_title:activePlan.title
+    });
+    outcome = { status:'blocked', reason:'plan_incomplete_blocks_finish' };
+  } else if (['inspect','patch','delegate','run_profile'].includes(decision.action) && planIsComplete(activePlan)) {
+    await appendEvent(ctx,events,signingKeyPath,'plan_guard_blocked',{
+      decision_event_sha256:decisionEvent.event_sha256, action:decision.action,
+      reason:'plan_complete_requires_finish', plan_title:activePlan.title
+    });
+    outcome = { status:'blocked', reason:'plan_complete_requires_finish' };
+  } else if (decision.action === 'inspect') {
+    outcome = await executeInspect({ ctx,events,goal,decisionEvent,decision,codingRuntime,signingKeyPath });
+  } else if (decision.action === 'patch') {
+    await assertRunAuthority(goal.root_id);
+    outcome = await executePatch({ ctx,events,goal,state,decisionEvent,decision,nativeDiffRuntime,
+      policy,codingRuntime,signingKeyPath });
+  } else if (decision.action === 'delegate') {
+    outcome = await executeDelegate({ ctx,events,goal,decisionEvent,decision,policy,
+      runtimes:{ machineFsRuntime,observationRuntime,processRuntime },assertRunAuthority,signingKeyPath,verifyKeyPath });
+  } else if (decision.action === 'run_profile') {
+    await assertRunAuthority(goal.root_id);
+    outcome = await executeProfile({ ctx,events,goalId:goal.goal_id,
+      actionKey:`planner-${decisionEvent.event_sha256}`, profileId:decision.profile_id,
+      epoch:state.mutation_epoch,policy,codingRuntime,signingKeyPath });
+  } else if (decision.action === 'pause') {
+    await appendEvent(ctx,events,signingKeyPath,'goal_paused',{
+      reason:decision.reason, planner_summary:decision.summary
+    });
+    outcome = { status:'paused', reason:decision.reason };
+  } else if (decision.action === 'finish') {
+    await appendEvent(ctx,events,signingKeyPath,'finish_requested',{
+      decision_event_sha256:decisionEvent.event_sha256, mutation_epoch:state.mutation_epoch,
+      planner_summary:decision.summary
+    });
+    outcome = { status:'finish_requested' };
+  } else {
+    throw new Error(`unsupported autonomous decision '${String(decision.action)}'`);
+  }
+  await appendEvent(ctx,events,signingKeyPath,'decision_completed',{
+    decision_event_sha256:decisionEvent.event_sha256, action:decision.action,
+    outcome_status:outcome.status ?? 'completed'
+  });
+  return outcome;
+}
+
+function terminalState(state) {
+  return ['succeeded','cancelled'].includes(state.state);
+}
+function pauseState(state) { return state.state === 'paused'; }
+
+export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRuntime, machineFsRuntime = null,
+  observationRuntime = null, processRuntime = null, signingKeyPath, verifyKeyPath }) {
+  if (!policy || !codingRuntime || !nativeDiffRuntime) throw new Error('autonomous runtime requires policy/coding/native-diff runtimes');
+  if (!signingKeyPath || !verifyKeyPath) throw new Error('autonomous runtime requires trust keys');
+  async function sessionStatus() {
+    const autonomous = await autonomousSessionStatus(policy);
+    const coding = await codingRuntime.sessionStatus();
+    return { status:'ok', configured:true, armed:autonomous.armed && coding.armed,
+      autonomous_armed:autonomous.armed, autonomous_reason:autonomous.reason,
+      autonomous_expires_at_utc:autonomous.expires_at_utc,
+      coding_armed:coding.armed, coding_reason:coding.reason,
+      root_ids:policy.root_ids, planner_backend:policy.planner.backend,
+      profile_ids:Object.keys(policy.profiles), policy_sha256:policy.policy_sha256,
+      coding_policy_sha256:policy.coding_policy_sha256 };
+  }
+
+  async function assertRunAuthority(rootId) {
+    const autonomous = await assertAutonomousArmed(policy,rootId);
+    const coding = await codingRuntime.sessionStatus();
+    if (!coding.armed) throw new Error(`coding plane is disarmed: ${coding.reason}`);
+    if (!coding.root_ids.includes(rootId)) throw new Error(`coding root '${rootId}' is outside active lease`);
+    return { autonomous, coding };
+  }
+
+  async function submit({ submissionId, rootId, title = '', goal, acceptance = '', maxIterations = null }) {
+    await assertRunAuthority(rootId);
+    const normalized = normalizeGoal(policy,{ submissionId,rootId,title,goal,acceptance,maxIterations });
+    const goalId = goalIdFor(policy.policy_sha256,submissionId);
+    const ctx = goalContext(policy,goalId);
+    if (await exists(ctx.dir)) {
+      const existing = await loadGoal(ctx,policy,verifyKeyPath);
+      if (existing.goal_sha256 !== normalized.goal_sha256) throw new Error('autonomous submission_id already exists with different goal');
+      const journal = await readEvents(ctx,verifyKeyPath);
+      return { status:'existing', goal_id:goalId, goal_sha256:existing.goal_sha256,
+        state:deriveState(existing,journal).state };
+    }
+    await mkdir(path.dirname(ctx.dir),{recursive:true});
+    await mkdir(ctx.dir,{recursive:false}); await mkdir(ctx.eventsDir);
+    const signingKey = await loadPrivateSigningKey(signingKeyPath);
+    const envelope = signEnvelope(signingKey,GOAL_DOMAIN,{ ...normalized, goal_id:goalId });
+    await writeFile(ctx.goalPath,`${canonicalJson(envelope)}\n`,{flag:'wx'});
+    const journal = [];
+    await appendEvent(ctx,journal,signingKeyPath,'goal_created',{
+      submission_id:submissionId, root_id:rootId, title, goal_sha256:normalized.goal_sha256,
+      max_iterations:normalized.max_iterations
+    });
+    return { status:'accepted', goal_id:goalId, goal_sha256:normalized.goal_sha256, state:'pending' };
+  }
+
+  async function status({ goalId }) {
+    const ctx = goalContext(policy,goalId);
+    const goal = await loadGoal(ctx,policy,verifyKeyPath);
+    const journal = await readEvents(ctx,verifyKeyPath);
+    const derived = deriveState(goal,journal);
+    return { status:'ok', goal_id:goalId, goal_sha256:goal.goal_sha256,
+      title:goal.title, root_id:goal.root_id, journal_verified:true, ...derived };
+  }
+
+  async function events({ goalId, fromSeq = 1, limit = 100 }) {
+    if (!Number.isInteger(fromSeq) || fromSeq < 1) throw new Error('autonomous from_seq must be >=1');
+    if (!Number.isInteger(limit) || limit < 1 || limit > 200) throw new Error('autonomous event limit must be in [1,200]');
+    const ctx = goalContext(policy,goalId); await loadGoal(ctx,policy,verifyKeyPath);
+    const journal = await readEvents(ctx,verifyKeyPath);
+    return { status:'ok', goal_id:goalId, journal_verified:true,
+      journal_head_sha256:journal.at(-1)?.event_sha256 ?? ZERO_HASH,
+      events:journal.slice(fromSeq-1,fromSeq-1+limit) };
+  }
+  async function cancel({ goalId, reason = 'operator_request' }) {
+    if (typeof reason !== 'string' || reason.length < 1 || reason.length > 256) throw new Error('autonomous cancel reason invalid');
+    const ctx = goalContext(policy,goalId);
+    const goal = await loadGoal(ctx,policy,verifyKeyPath);
+    const current = deriveState(goal,await readEvents(ctx,verifyKeyPath));
+    if (terminalState(current)) return { status:'terminal', goal_id:goalId, state:current.state };
+    const signingKey = await loadPrivateSigningKey(signingKeyPath);
+    const envelope = signEnvelope(signingKey,CANCEL_DOMAIN,{
+      schema:CANCEL_SCHEMA, goal_id:goalId, requested_at_utc:new Date().toISOString(), reason
+    });
+    try {
+      await writeFile(ctx.cancelPath,`${canonicalJson(envelope)}\n`,{flag:'wx'});
+      return { status:'requested', goal_id:goalId, state:current.state };
+    } catch (error) {
+      if (error?.code !== 'EEXIST') throw error;
+      return { status:'existing', goal_id:goalId, state:current.state };
+    }
+  }
+  async function approve({ goalId, decision = 'approve' }) {
+    if (!['approve','reject'].includes(decision)) throw new Error('autonomous approval decision invalid');
+    const ctx = goalContext(policy,goalId);
+    await acquireLock(ctx);
+    try {
+      const goal = await loadGoal(ctx,policy,verifyKeyPath);
+      const journal = await readEvents(ctx,verifyKeyPath);
+      const current = deriveState(goal,journal);
+      if (terminalState(current)) return { status:'terminal', goal_id:goalId, state:current.state };
+      if (!pauseState(current)) throw new Error('autonomous goal is not paused');
+      if (decision === 'reject') {
+        await appendEvent(ctx,journal,signingKeyPath,'goal_cancelled',{ reason:'resume_rejected' });
+        return { status:'rejected', goal_id:goalId, state:'cancelled' };
+      }
+      await appendEvent(ctx,journal,signingKeyPath,'goal_resumed',{
+        previous_reason:current.reason, approved_at_utc:new Date().toISOString()
+      });
+      return { status:'approved', goal_id:goalId, state:'running' };
+    } finally {
+      await releaseLock(ctx);
+    }
+  }
+  async function releaseGateLocked(ctx, goal, journal) {
+    let state = deriveState(goal,journal);
+    const finish = [...journal].reverse().find(event =>
+      event.type === 'finish_requested' && event.payload?.mutation_epoch === state.mutation_epoch);
+    if (!finish) return { status:'blocked', goal_id:goal.goal_id, ready:false,
+      reason:'finish_not_requested', mutation_epoch:state.mutation_epoch };
+    const actionKey = `release-gate-${state.mutation_epoch}-${finish.event_sha256}`;
+    if (!journal.some(event => event.type === 'release_gate_started' && event.payload?.action_key === actionKey)) {
+      await appendEvent(ctx,journal,signingKeyPath,'release_gate_started',{
+        action_key:actionKey, mutation_epoch:state.mutation_epoch
+      });
+    }
+    state = deriveState(goal,journal);
+    const profiles = await runRequiredReleaseProfiles({ ctx,events:journal,goal,state,
+      policy,codingRuntime,signingKeyPath });
+    if (profiles.some(item => item.status === 'paused')) {
+      return { status:'paused', goal_id:goal.goal_id, ready:false,
+        reason:'release_profile_interrupted', mutation_epoch:state.mutation_epoch };
+    }
+    state = deriveState(goal,journal);
+    const readiness = releaseReadiness(policy,state);
+    if (!readiness.ready) {
+      await appendEvent(ctx,journal,signingKeyPath,'release_gate_failed',{
+        action_key:actionKey, mutation_epoch:state.mutation_epoch,
+        required_profiles:readiness.required_profiles
+      });
+      return { status:'failed', goal_id:goal.goal_id, ready:false,
+        mutation_epoch:state.mutation_epoch, required_profiles:readiness.required_profiles };
+    }
+    if (!await exists(ctx.receiptPath)) {
+      await createReleaseReceipt({ ctx,events:journal,goal,state,policy,nativeDiffRuntime,codingRuntime,signingKeyPath });
+    }
+    const checked = await verifyReleaseReceipt({ ctx,goal,events:journal,policy,
+      verifyKeyPath,nativeDiffRuntime,codingRuntime });
+    if (!checked.ok) throw new Error(`autonomous release receipt verification failed: ${checked.reason}`);
+    return { status:'passed', goal_id:goal.goal_id, ready:true,
+      mutation_epoch:checked.mutation_epoch, receipt_sha256:checked.receipt_sha256,
+      required_profiles_verified:checked.required_profiles_verified,
+      native_diffs_verified:checked.native_diffs_verified };
+  }
+
+  async function releaseGate({ goalId }) {
+    const ctx = goalContext(policy,goalId);
+    const goal = await loadGoal(ctx,policy,verifyKeyPath);
+    await assertRunAuthority(goal.root_id);
+    await acquireLock(ctx);
+    try {
+      const journal = await readEvents(ctx,verifyKeyPath);
+      const state = deriveState(goal,journal);
+      if (state.state === 'succeeded') {
+        const checked = await verifyReleaseReceipt({ctx,goal,events:journal,policy,verifyKeyPath,nativeDiffRuntime,codingRuntime});
+        return checked.ok ? { status:'existing', goal_id:goalId, ready:true, receipt_sha256:checked.receipt_sha256 } :
+          { status:'failed', goal_id:goalId, ready:false, reason:checked.reason };
+      }
+      if (state.state === 'cancelled') return { status:'blocked', goal_id:goalId, ready:false, reason:'goal_cancelled' };
+      return await releaseGateLocked(ctx,goal,journal);
+    } finally { await releaseLock(ctx); }
+  }
+  async function run({ goalId, maxCycles = 8, plannerResponse = null }) {
+    if (!Number.isInteger(maxCycles) || maxCycles < 1 || maxCycles > 32) throw new Error('autonomous max_cycles must be in [1,32]');
+    const ctx = goalContext(policy,goalId);
+    const goal = await loadGoal(ctx,policy,verifyKeyPath);
+    await assertRunAuthority(goal.root_id);
+    await acquireLock(ctx);
+    try {
+      const journal = await readEvents(ctx,verifyKeyPath);
+      let state = deriveState(goal,journal);
+      if (terminalState(state)) return { status:'terminal', goal_id:goalId, ...state };
+      if (pauseState(state)) return { status:'paused', goal_id:goalId, ...state };
+      if (await consumeCancel(ctx,journal,signingKeyPath,verifyKeyPath)) {
+        state = deriveState(goal,journal); return { status:'cancelled', goal_id:goalId, ...state };
+      }
+      await appendEvent(ctx,journal,signingKeyPath,'goal_run_started',{ max_cycles:maxCycles });
+      let cycles = 0; let suppliedResponse = plannerResponse;
+      while (cycles < maxCycles) {
+        state = deriveState(goal,journal);
+        if (terminalState(state) || pauseState(state)) return { status:state.state, goal_id:goalId, ...state };
+        if (await consumeCancel(ctx,journal,signingKeyPath,verifyKeyPath)) {
+          state = deriveState(goal,journal); return { status:'cancelled', goal_id:goalId, ...state };
+        }
+        if (state.pending_decision) {
+          const outcome = await executeDecision({ ctx,events:journal,goal,state,
+            decisionEvent:state.pending_decision,policy,codingRuntime,nativeDiffRuntime,machineFsRuntime,
+            observationRuntime,processRuntime,assertRunAuthority,signingKeyPath,verifyKeyPath });
+          cycles += 1; state = deriveState(goal,journal);
+          if (outcome.status === 'paused' || pauseState(state)) return { status:'paused', goal_id:goalId, ...state };
+          if (outcome.status === 'finish_requested') {
+            const gate = await releaseGateLocked(ctx,goal,journal);
+            state = deriveState(goal,journal);
+            if (gate.status === 'passed') return { status:'completed', goal_id:goalId, release:gate, ...state };
+            if (gate.status === 'paused') return { status:'paused', goal_id:goalId, release:gate, ...state };
+          }
+          continue;
+        }
+        const accepted = await acceptPlannerDecision({ ctx,events:journal,goal,state,policy,codingRuntime,
+          signingKeyPath,plannerResponse:suppliedResponse });
+        suppliedResponse = null;
+        if (accepted?.needs_planner) {
+          state = deriveState(goal,journal);
+          return { status:'input_required', goal_id:goalId,
+            planner_request:{ request_id:accepted.request.request_id,
+              planner_round:accepted.request.planner_round,
+              mutation_epoch:accepted.request.mutation_epoch,
+              prompt:accepted.request.prompt,
+              prompt_sha256:accepted.request.prompt_sha256 }, ...state };
+        }
+        state = deriveState(goal,journal);
+        if (pauseState(state)) return { status:'paused', goal_id:goalId, ...state };
+      }
+      state = deriveState(goal,journal);
+      return { status:'yielded', goal_id:goalId, cycles, ...state };
+    } finally { await releaseLock(ctx); }
+  }
+
+  async function verify({ goalId }) {
+    const ctx = goalContext(policy,goalId);
+    const goal = await loadGoal(ctx,policy,verifyKeyPath);
+    const journal = await readEvents(ctx,verifyKeyPath);
+    const state = deriveState(goal,journal);
+    if (state.state !== 'succeeded') return { ok:false, reason:`autonomous goal state is ${state.state}` };
+    return verifyReleaseReceipt({ ctx,goal,events:journal,policy,verifyKeyPath,nativeDiffRuntime,codingRuntime });
+  }
+
+  return Object.freeze({ policy, sessionStatus, submit, run, status, events, cancel, approve,
+    releaseGate, verify });
+}