deadbyte-mcp 0.8.10 → 0.10.0

package/src/autonomous-action-reconcile.mjs

@@ -0,0 +1,142 @@
+import { createHash } from 'node:crypto';
+import { canonicalJson } from './canonical-json.mjs';
+
+const HEX64 = /^[0-9a-f]{64}$/;
+const ID = /^[A-Za-z0-9._-]{1,64}$/;
+const RECEIPT_ID = /^[0-9a-f]{24}$/;
+
+function sha256Object(value) {
+  return createHash('sha256').update(Buffer.from(canonicalJson(value),'utf8')).digest('hex');
+}
+
+function hash(value,label) {
+  if (typeof value !== 'string' || !HEX64.test(value)) throw new Error(`${label} invalid`);
+  return value;
+}
+
+function id(value,label) {
+  if (typeof value !== 'string' || !ID.test(value)) throw new Error(`${label} invalid`);
+  return value;
+}
+
+function integer(value,label) {
+  if (!Number.isInteger(value) || value < 0) throw new Error(`${label} invalid`);
+  return value;
+}
+
+function classification(classification,evidence = null,reason = null) {
+  return Object.freeze({
+    classification,
+    replay_allowed:classification === 'not_executed',
+    evidence:evidence === null ? null : Object.freeze({...evidence}),
+    reason
+  });
+}
+
+export function actionIdentity({ goalId, planId, planVersion, stepId, mutationEpoch, decisionEventSha, action }) {
+  hash(goalId,'action goalId');
+  hash(planId,'action planId');
+  if (!Number.isInteger(planVersion) || planVersion < 1) throw new Error('action planVersion invalid');
+  id(stepId,'action stepId');
+  integer(mutationEpoch,'action mutationEpoch');
+  hash(decisionEventSha,'action decisionEventSha');
+  if (!action || typeof action !== 'object' || Array.isArray(action)) throw new Error('action payload invalid');
+  const request = {
+    schema:'deadbyte.autonomous-action-request.v1',
+    goal_id:goalId,
+    plan_id:planId,
+    plan_version:planVersion,
+    step_id:stepId,
+    mutation_epoch:mutationEpoch,
+    decision_event_sha256:decisionEventSha,
+    action:structuredClone(action)
+  };
+  const requestSha256 = sha256Object(request);
+  const actionId = sha256Object({schema:'deadbyte.autonomous-action-id.v1',request_sha256:requestSha256});
+  return Object.freeze({ action_id:actionId, request_sha256:requestSha256 });
+}
+
+function missingEvidence(reason) {
+  return typeof reason === 'string' && /(?:missing|not found|unavailable|enoent|absent)/i.test(reason);
+}
+
+function validateStarted(startedEvent) {
+  if (!startedEvent || typeof startedEvent !== 'object' || startedEvent.type !== 'action_started') {
+    throw new Error('reconcile requires action_started event');
+  }
+  const payload = startedEvent.payload;
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) throw new Error('action_started payload invalid');
+  hash(payload.action_id,'started action_id');
+  hash(payload.request_sha256,'started request_sha256');
+  if (!payload.action || typeof payload.action !== 'object' || Array.isArray(payload.action)) throw new Error('started action payload missing');
+  return payload;
+}
+
+async function reconcilePatch(payload,runtimes) {
+  const diffId = hash(payload.action.diff_id,'started patch diff_id');
+  if (!runtimes?.nativeDiffRuntime?.verify) return classification('ambiguous',null,'native diff verifier unavailable');
+  let checked;
+  try { checked = await runtimes.nativeDiffRuntime.verify({diffId}); }
+  catch (error) {
+    const reason = String(error?.message ?? error);
+    return missingEvidence(reason) ? classification('not_executed',null,reason) : classification('ambiguous',null,reason);
+  }
+  if (checked?.ok === true) {
+    if (checked.current_state_matches !== true) return classification('ambiguous',null,'native diff current state mismatch');
+    if (!HEX64.test(checked.receipt_sha256 ?? '')) return classification('ambiguous',null,'native diff verified without receipt hash');
+    return classification('executed_verified',{
+      kind:'native_diff',
+      diff_id:diffId,
+      receipt_sha256:checked.receipt_sha256,
+      ...(HEX64.test(checked.journal_head_sha256 ?? '') ? {journal_head_sha256:checked.journal_head_sha256} : {})
+    });
+  }
+  const reason = String(checked?.reason ?? 'native diff verification failed');
+  return missingEvidence(reason) ? classification('not_executed',null,reason) : classification('ambiguous',null,reason);
+}
+
+async function reconcileProfile(payload,runtimes) {
+  const receiptId = payload.action.receipt_id;
+  if (typeof receiptId !== 'string' || !RECEIPT_ID.test(receiptId)) return classification('ambiguous',null,'profile receipt id invalid');
+  if (!runtimes?.codingRuntime?.verifyReceiptDetailed) return classification('ambiguous',null,'coding receipt verifier unavailable');
+  let checked;
+  try { checked = await runtimes.codingRuntime.verifyReceiptDetailed(receiptId); }
+  catch (error) {
+    const reason = String(error?.message ?? error);
+    return missingEvidence(reason) ? classification('not_executed',null,reason) : classification('ambiguous',null,reason);
+  }
+  if (checked?.ok !== true) {
+    const reason = String(checked?.reason ?? 'coding receipt verification failed');
+    return missingEvidence(reason) ? classification('not_executed',null,reason) : classification('ambiguous',null,reason);
+  }
+  if (checked.request_sha256 !== payload.request_sha256) return classification('ambiguous',null,'coding receipt request identity mismatch');
+  if (!HEX64.test(checked.receipt_sha256 ?? '')) return classification('ambiguous',null,'coding receipt hash invalid');
+  const receipt = checked.receipt;
+  if (!receipt || receipt.receipt_id !== receiptId) return classification('ambiguous',null,'coding receipt substitution detected');
+  const evidence = {kind:'coding_receipt',receipt_id:receiptId,receipt_sha256:checked.receipt_sha256,request_sha256:checked.request_sha256};
+  if (receipt.operation === 'coding_command_run') {
+    const expected = Number.isInteger(payload.action.expect_exit_code) ? payload.action.expect_exit_code : 0;
+    const passed = receipt.timed_out !== true && receipt.exit_code === expected;
+    return classification(passed ? 'executed_verified' : 'executed_failed_verified',evidence,passed ? null : 'verified command outcome failed');
+  }
+  if (receipt.operation === 'coding_benchmark_run') {
+    const passed = receipt.verdict === 'pass';
+    return classification(passed ? 'executed_verified' : 'executed_failed_verified',evidence,passed ? null : 'verified benchmark outcome failed');
+  }
+  return classification('ambiguous',null,'coding receipt operation mismatch');
+}
+
+export async function reconcileStartedAction({ startedEvent, journal = [], runtimes = {} } = {}) {
+  const payload = validateStarted(startedEvent);
+  if (!Array.isArray(journal)) throw new Error('reconcile journal must be an array');
+  const completed = journal.find(event => event?.type === 'action_completed' && event?.payload?.action_id === payload.action_id);
+  if (completed) {
+    return classification('executed_verified',{
+      kind:'journal_completion',
+      event_sha256:HEX64.test(completed.event_sha256 ?? '') ? completed.event_sha256 : null
+    },'matching verified journal completion already exists');
+  }
+  if (payload.action.kind === 'patch') return reconcilePatch(payload,runtimes);
+  if (payload.action.kind === 'profile') return reconcileProfile(payload,runtimes);
+  return classification('ambiguous',null,`unsupported interrupted action kind '${String(payload.action.kind)}'`);
+}

package/src/autonomous-context-engine.mjs

@@ -0,0 +1,256 @@
+import { createHash } from 'node:crypto';
+import { canonicalJson } from './canonical-json.mjs';
+import { provenanceFor, dedupeEvidence } from './context-provenance.mjs';
+
+const SECRET_KEY = /(?:^|[_-])(token|password|secret|authorization|cookie|credential|credentials|api[_-]?key|private[_-]?key|recovery)(?:$|[_-])/i;
+const HEX64 = /^[0-9a-f]{64}$/;
+
+const sha256Text = text => createHash('sha256').update(Buffer.from(text,'utf8')).digest('hex');
+const bytesOf = value => Buffer.byteLength(canonicalJson(value),'utf8');
+
+function utf8Bytes(value) {
+  if (typeof value === 'string') return Buffer.byteLength(value,'utf8');
+  return Buffer.byteLength(canonicalJson(value),'utf8');
+}
+
+function sanitize(value,key = '') {
+  if (SECRET_KEY.test(key)) {
+    return { redacted:true, reason:'secret', byte_count:utf8Bytes(value) };
+  }
+  if (Array.isArray(value)) return value.map(item => sanitize(item,''));
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const name of Object.keys(value).sort()) out[name] = sanitize(value[name],name);
+    return out;
+  }
+  return value;
+}
+
+function elideStringField(object,field,{hash = true}={}) {
+  if (!object || typeof object !== 'object' || typeof object[field] !== 'string') return false;
+  const text = object[field];
+  object[`${field}_elided`] = true;
+  object[`${field}_bytes`] = Buffer.byteLength(text,'utf8');
+  if (hash) object[`${field}_sha256`] = sha256Text(text);
+  delete object[field];
+  return true;
+}
+
+function compactHistorical(state,fits) {
+  const events = state.historical_evidence?.compacted_events ?? [];
+  for (const event of events) {
+    for (const field of ['raw_payload','content','stdout_excerpt','stderr_excerpt','old_string','new_string','data_base64']) {
+      elideStringField(event,field);
+    }
+    if (fits()) return;
+  }
+  const observations = state.historical_evidence?.observations ?? [];
+  for (const observation of observations) {
+    for (const field of ['stdout_excerpt','stderr_excerpt','content','raw_payload']) elideStringField(observation,field);
+    if (fits()) return;
+  }
+}
+
+function compactWorking(state,fits) {
+  const contexts = state.working_context?.recent_contexts ?? [];
+  for (let index = 0; index < Math.max(0,contexts.length - 1) && !fits(); index += 1) {
+    elideStringField(contexts[index],'content');
+  }
+  const observations = state.working_context?.recent_observations ?? [];
+  for (let index = 0; index < Math.max(0,observations.length - 1) && !fits(); index += 1) {
+    elideStringField(observations[index],'stdout_excerpt');
+    elideStringField(observations[index],'stderr_excerpt');
+    elideStringField(observations[index],'content');
+  }
+  if (!fits() && Array.isArray(state.working_context?.tree) && state.working_context.tree.length > 128) {
+    const original = state.working_context.tree.length;
+    state.working_context.tree = state.working_context.tree.slice(0,128);
+    state.working_context.tree_compaction = { original_entries:original, kept_entries:128 };
+  }
+}
+
+export function compactLoopContext(input,maxBytes) {
+  if (!Number.isInteger(maxBytes) || maxBytes < 1024) throw new Error('loop context maxBytes invalid');
+  const state = sanitize(structuredClone(input));
+  const fits = () => bytesOf(state) <= maxBytes;
+  if (fits()) return state;
+  compactHistorical(state,fits);
+  if (fits()) return state;
+  compactWorking(state,fits);
+  if (fits()) return state;
+  throw new Error('autonomous loop context exceeds policy budget after deterministic compaction');
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.filter(value => typeof value === 'string' && value.length > 0))];
+}
+
+export function deriveProjectMemory(events) {
+  if (!Array.isArray(events)) throw new Error('project memory events must be an array');
+  const acceptance = [];
+  const proven = [];
+  const rejected = [];
+  const files = new Map();
+  const blockers = new Map();
+
+  for (const event of events) {
+    if (!event || typeof event !== 'object' || Array.isArray(event)) continue;
+    const payload = event.payload && typeof event.payload === 'object' && !Array.isArray(event.payload) ? event.payload : {};
+    if (event.type === 'goal_created' && typeof payload.acceptance === 'string' && payload.acceptance.length > 0) {
+      acceptance.push(payload.acceptance);
+    }
+    if (event.type === 'profile_completed' && typeof payload.profile_id === 'string') {
+      const key = `profile:${payload.profile_id}`;
+      if (payload.passed === false) blockers.set(key,`${payload.profile_id}_failed`);
+      if (payload.passed === true) {
+        blockers.delete(key);
+        proven.push(`${payload.profile_id}:passed`);
+      }
+    }
+    if (event.type === 'planner_rejected' && typeof payload.reason === 'string') rejected.push(payload.reason);
+    if (event.type === 'native_diff_committed') {
+      for (const file of payload.paths ?? []) {
+        if (typeof file === 'string' && file.length > 0) {
+          files.set(file,{ path:file, ...(HEX64.test(payload.diff_receipt_sha256 ?? '') ? { receipt_sha256:payload.diff_receipt_sha256 } : {}) });
+        }
+      }
+    }
+    if (event.type === 'waiting_entered' && typeof payload.reason === 'string') blockers.set(`wait:${payload.reason}`,payload.reason);
+    if (event.type === 'waiting_resumed' && typeof payload.previous_reason === 'string') blockers.delete(`wait:${payload.previous_reason}`);
+  }
+
+  return {
+    acceptance_constraints:uniqueStrings(acceptance),
+    proven_invariants:uniqueStrings(proven),
+    rejected_approaches:uniqueStrings(rejected),
+    important_files:[...files.values()].sort((a,b) => a.path.localeCompare(b.path,'en')),
+    unresolved_blockers:[...blockers.values()].sort((a,b) => a.localeCompare(b,'en'))
+  };
+}
+
+const LEGACY_OBSERVED_AT_UTC='1970-01-01T00:00:00.000Z';
+
+function provenancePayload(item,kind){
+  if(kind==='context'&&typeof item?.content==='string') return item.content;
+  const payload=structuredClone(item??{});
+  delete payload.provenance;
+  delete payload.observed_at_utc;
+  delete payload.trust_class;
+  delete payload.relevance_epoch;
+  return payload;
+}
+
+function provenanceSourceId(item,kind,index){
+  const candidates=kind==='context'
+    ? [item?.source_id,item?.path,HEX64.test(item?.sha256??'')?`sha256:${item.sha256}`:null]
+    : [item?.source_id,item?.profile_id?`profile:${item.profile_id}`:null,HEX64.test(item?.request_sha256??'')?`request:${item.request_sha256}`:null,item?.session_id?`session:${item.session_id}`:null,item?.search_id?`search:${item.search_id}`:null,item?.diff_id?`diff:${item.diff_id}`:null,HEX64.test(item?.receipt_sha256??'')?`receipt:${item.receipt_sha256}`:null];
+  const selected=candidates.find(value=>typeof value==='string'&&value.length>0);
+  return selected??`${kind}:legacy:${index}`;
+}
+
+function normalizeEvidence(items,{kind,relevanceEpoch}){
+  if(!Array.isArray(items)) throw new Error(`${kind} evidence must be an array`);
+  const mapped=items.map((item,index)=>{
+    if(!item||typeof item!=='object'||Array.isArray(item)) throw new Error(`${kind} evidence ${index+1} invalid`);
+    if(item.provenance) return structuredClone(item);
+    const observed=typeof item.observed_at_utc==='string'&&item.observed_at_utc.length>0?item.observed_at_utc:LEGACY_OBSERVED_AT_UTC;
+    const stamped={...structuredClone(item)};
+    if(!stamped.observed_at_utc) stamped.observed_at_utc=observed;
+    stamped.provenance=provenanceFor({
+      sourceKind:kind,
+      sourceId:provenanceSourceId(item,kind,index),
+      bytes:provenancePayload(item,kind),
+      observedAtUtc:observed,
+      trustClass:typeof item.trust_class==='string'&&item.trust_class.length>0?item.trust_class:(observed===LEGACY_OBSERVED_AT_UTC?'legacy_unstamped':kind==='context'?'workspace_read':HEX64.test(item.receipt_sha256??'')?'signed_receipt':'runtime_observation'),
+      relevanceEpoch:Number.isInteger(item.relevance_epoch)&&item.relevance_epoch>=0?item.relevance_epoch:relevanceEpoch
+    });
+    return stamped;
+  });
+  return dedupeEvidence(mapped);
+}
+
+function activeIdentities(observations) {
+  const out = [];
+  const seen = new Set();
+  for (const observation of observations) {
+    if (!observation || typeof observation !== 'object') continue;
+    for (const field of ['session_id','search_id','diff_id','receipt_id']) {
+      const value = observation[field] ?? observation.result?.[field] ?? observation.evidence?.[field];
+      if (typeof value !== 'string' || value.length < 1) continue;
+      const key = `${field}:${value}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push({ kind:field.replace(/_id$/,''), id:value });
+    }
+  }
+  return out;
+}
+
+function historicalEvidence({ contexts, observations, loopState }) {
+  const oldContexts = contexts.slice(0,Math.max(0,contexts.length - 16)).map(item => ({ kind:'context', ...structuredClone(item) }));
+  const oldObservations = observations.slice(0,Math.max(0,observations.length - 24)).map(item => ({ kind:'observation', ...structuredClone(item) }));
+  const failures = observations.filter(item => item?.passed === false || item?.status === 'failed' || item?.error)
+    .map(item => ({
+      profile_id:item.profile_id ?? null,
+      cause:item.reason ?? item.error ?? (item.profile_id ? `${item.profile_id}_failed` : 'operation_failed'),
+      ...(HEX64.test(item.receipt_sha256 ?? '') ? { receipt_sha256:item.receipt_sha256 } : {})
+    }));
+  const receipts = observations.filter(item => HEX64.test(item?.receipt_sha256 ?? '')).map(item => ({
+    receipt_id:typeof item.receipt_id === 'string' ? item.receipt_id : null,
+    receipt_sha256:item.receipt_sha256,
+    ...(HEX64.test(item.request_sha256 ?? '') ? { request_sha256:item.request_sha256 } : {})
+  }));
+  const mutationEpochs = uniqueStrings(observations.map(item => Number.isInteger(item?.mutation_epoch) ? String(item.mutation_epoch) : ''))
+    .map(Number);
+  if (Number.isInteger(loopState?.mutation_epoch) && !mutationEpochs.includes(loopState.mutation_epoch)) mutationEpochs.push(loopState.mutation_epoch);
+  mutationEpochs.sort((a,b) => a-b);
+  return {
+    compacted_events:[...oldContexts,...oldObservations],
+    failures,
+    receipts,
+    mutation_epochs:mutationEpochs,
+    plan_transitions:[]
+  };
+}
+
+export function buildLoopContext({ goal, policy, loopState = {}, tree = [], contexts = [], observations = [], decisions = [], projectMemory = null, capabilities = null }) {
+  if (!policy?.limits || !Number.isInteger(policy.limits.max_context_bytes)) throw new Error('loop context policy byte limit missing');
+  const relevanceEpoch=Number.isInteger(loopState?.mutation_epoch)&&loopState.mutation_epoch>=0?loopState.mutation_epoch:0;
+  const retainedContexts=normalizeEvidence(contexts,{kind:'context',relevanceEpoch});
+  const retainedObservations=normalizeEvidence(observations,{kind:'observation',relevanceEpoch});
+  const profiles = Object.entries(policy.profiles ?? {}).map(([id,profile]) => ({
+    id,
+    kind:profile.kind,
+    required_for_release:profile.required_for_release === true,
+    description:profile.description ?? ''
+  }));
+  const memory = projectMemory === null ? {
+    acceptance_constraints:typeof goal?.acceptance === 'string' && goal.acceptance.length > 0 ? [goal.acceptance] : [],
+    proven_invariants:[],rejected_approaches:[],important_files:[],unresolved_blockers:[]
+  } : structuredClone(projectMemory);
+  const state = {
+    goal:structuredClone(goal ?? {}),
+    loop:{
+      phase:loopState.phase ?? null,
+      mutation_epoch:Number.isInteger(loopState.mutation_epoch) ? loopState.mutation_epoch : 0,
+      planner_round:Number.isInteger(loopState.planner_round) ? loopState.planner_round : 0,
+      plan_id:loopState.plan_id ?? null,
+      plan_version:loopState.plan_version ?? null,
+      replan_count:Number.isInteger(loopState.replan_count) ? loopState.replan_count : 0
+    },
+    working_context:{
+      active_plan:structuredClone(loopState.plan ?? loopState.active_plan ?? null),
+      current_step:structuredClone(loopState.current_step ?? null),
+      recent_contexts:structuredClone(retainedContexts.slice(-16)),
+      recent_observations:structuredClone(retainedObservations.slice(-24)),
+      active_identities:activeIdentities(retainedObservations.slice(-24)),
+      recent_decisions:structuredClone(decisions.slice(-8)),
+      tree:structuredClone(tree)
+    },
+    historical_evidence:historicalEvidence({contexts:retainedContexts,observations:retainedObservations,loopState}),
+    project_memory:memory,
+    capabilities:capabilities===null?null:structuredClone(capabilities),
+    profiles
+  };
+  return compactLoopContext(state,policy.limits.max_context_bytes);
+}

package/src/autonomous-live-state.mjs

@@ -0,0 +1,17 @@
+export function promptContexts(state) {
+  if (Array.isArray(state?.working_context?.recent_contexts)) return state.working_context.recent_contexts;
+  if (Array.isArray(state?.contexts)) return state.contexts;
+  return [];
+}
+
+export function promptObservations(state) {
+  if (Array.isArray(state?.working_context?.recent_observations)) return state.working_context.recent_observations;
+  if (Array.isArray(state?.observations)) return state.observations;
+  return [];
+}
+
+export function promptMutationEpoch(state) {
+  if (Number.isInteger(state?.loop?.mutation_epoch)) return state.loop.mutation_epoch;
+  if (Number.isInteger(state?.mutation_epoch)) return state.mutation_epoch;
+  return 0;
+}

package/src/autonomous-local-supervisor.mjs

@@ -0,0 +1,249 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { access, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { startAutonomousSupervisor } from './autonomous-supervisor.mjs';
+
+const execFileAsync=promisify(execFile);
+export const AUTONOMOUS_SUPERVISOR_OWNER_SCHEMA='deadbyte.autonomous-supervisor-owner.v1';
+const HEX64=/^[0-9a-f]{64}$/;
+const RECOVERY_OPERATIONS=Object.freeze(['status','resume','park','disarmautonomous','disarmcoding','disarmprocess','disarmhost']);
+const RECOVERY_SET=new Set(RECOVERY_OPERATIONS);
+
+function sha256Bytes(bytes){ return createHash('sha256').update(bytes).digest('hex'); }
+function isIso(value){ return typeof value==='string' && Number.isFinite(Date.parse(value)); }
+function samePath(a,b){
+  if(typeof a!=='string'||typeof b!=='string') return false;
+  return path.resolve(a).toLowerCase()===path.resolve(b).toLowerCase();
+}
+function assertOptions(options){
+  if(!options||typeof options!=='object'||Array.isArray(options)) throw new Error('supervisor options invalid');
+  if(typeof options.markerPath!=='string'||options.markerPath.length<3) throw new Error('supervisor markerPath invalid');
+  return path.resolve(options.markerPath);
+}
+function validateMarker(marker){
+  if(!marker||typeof marker!=='object'||Array.isArray(marker)) return false;
+  const keys=Object.keys(marker).sort();
+  const expected=['creation_time_utc','image_path','image_sha256','instance_nonce','pid','schema','started_at_utc'].sort();
+  if(JSON.stringify(keys)!==JSON.stringify(expected)) return false;
+  return marker.schema===AUTONOMOUS_SUPERVISOR_OWNER_SCHEMA && Number.isInteger(marker.pid) && marker.pid>0 &&
+    isIso(marker.creation_time_utc) && typeof marker.image_path==='string' && marker.image_path.length>3 &&
+    HEX64.test(marker.image_sha256??'') && HEX64.test(marker.instance_nonce??'') && isIso(marker.started_at_utc);
+}
+async function powershellPath(){
+  if(process.platform!=='win32') return null;
+  const systemRoot=process.env.SystemRoot || process.env.WINDIR;
+  if(systemRoot){
+    const candidate=path.join(systemRoot,'System32','WindowsPowerShell','v1.0','powershell.exe');
+    try { await access(candidate); return candidate; } catch {}
+  }
+  return 'powershell.exe';
+}
+
+export async function observeCurrentProcessIdentity(pid=process.pid){
+  if(!Number.isInteger(pid)||pid<=0) throw new Error('process pid invalid');
+  const shell=await powershellPath();
+  if(!shell) return null;
+  const script=`$ErrorActionPreference='Stop'; $p=Get-Process -Id ${pid} -ErrorAction Stop; $image=''; try { $image=[string]$p.Path } catch {}; if([string]::IsNullOrWhiteSpace($image)){ try { $c=Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}' -ErrorAction Stop; $image=[string]$c.ExecutablePath } catch {} }; if([string]::IsNullOrWhiteSpace($image)){ exit 3 }; [pscustomobject]@{pid=[int]$p.Id;creation_time_utc=$p.StartTime.ToUniversalTime().ToString('o');image_path=[System.IO.Path]::GetFullPath($image)} | ConvertTo-Json -Compress`;
+  let stdout;
+  try {
+    ({stdout}=await execFileAsync(shell,['-NoProfile','-NonInteractive','-ExecutionPolicy','Bypass','-Command',script],{
+      windowsHide:true,timeout:10_000,maxBuffer:1024*1024,encoding:'utf8'
+    }));
+  } catch { return null; }
+  let parsed;
+  try { parsed=JSON.parse(String(stdout).trim()); } catch { return null; }
+  if(parsed?.pid!==pid||!isIso(parsed?.creation_time_utc)||typeof parsed?.image_path!=='string') return null;
+  const imagePath=path.resolve(parsed.image_path);
+  let imageBytes;
+  try { imageBytes=await readFile(imagePath); } catch { return null; }
+  return Object.freeze({
+    pid,creation_time_utc:new Date(parsed.creation_time_utc).toISOString(),
+    image_path:imagePath,image_sha256:sha256Bytes(imageBytes)
+  });
+}
+
+async function readMarker(markerPath){
+  let raw;
+  try { raw=await readFile(markerPath); }
+  catch(error){ if(error?.code==='ENOENT') return {exists:false}; throw error; }
+  let marker;
+  try { marker=JSON.parse(raw.toString('utf8')); }
+  catch { return {exists:true,raw,raw_sha256:sha256Bytes(raw),valid:false,marker:null}; }
+  return {exists:true,raw,raw_sha256:sha256Bytes(raw),valid:validateMarker(marker),marker};
+}
+function markerFor(identity){
+  return {
+    schema:AUTONOMOUS_SUPERVISOR_OWNER_SCHEMA,
+    pid:identity.pid,creation_time_utc:identity.creation_time_utc,image_path:identity.image_path,
+    image_sha256:identity.image_sha256,instance_nonce:randomBytes(32).toString('hex'),
+    started_at_utc:new Date().toISOString()
+  };
+}
+async function currentMarker(){
+  const identity=await observeCurrentProcessIdentity();
+  if(!identity) throw new Error('supervisor current Windows process identity unavailable');
+  return markerFor(identity);
+}
+
+export async function observeSupervisor(options={}){
+  const markerPath=assertOptions(options);
+  const stored=await readMarker(markerPath);
+  if(!stored.exists) return {status:'absent',live:false,reason:'no_owner',marker:null,marker_sha256:null};
+  if(!stored.valid) return {status:'unverified',live:false,reason:'marker_invalid',marker:stored.marker,marker_sha256:stored.raw_sha256};
+  const observed=await observeCurrentProcessIdentity(stored.marker.pid);
+  if(!observed) return {status:'stale',live:false,reason:'process_unobservable',marker:stored.marker,marker_sha256:stored.raw_sha256};
+  if(observed.creation_time_utc!==new Date(stored.marker.creation_time_utc).toISOString()) {
+    return {status:'stale',live:false,reason:'pid_reused',marker:stored.marker,observation:observed,marker_sha256:stored.raw_sha256};
+  }
+  if(!samePath(observed.image_path,stored.marker.image_path)||observed.image_sha256!==stored.marker.image_sha256) {
+    return {status:'stale',live:false,reason:'identity_mismatch',marker:stored.marker,observation:observed,marker_sha256:stored.raw_sha256};
+  }
+  return {status:'owned',live:true,reason:'live_verified_owner',marker:stored.marker,observation:observed,marker_sha256:stored.raw_sha256};
+}
+
+export async function claimSupervisor(options={}){
+  const markerPath=assertOptions(options);
+  const marker=await currentMarker();
+  await mkdir(path.dirname(markerPath),{recursive:true});
+  try {
+    await writeFile(markerPath,`${JSON.stringify(marker)}\n`,{flag:'wx',mode:0o600});
+  } catch(error){
+    if(error?.code==='EEXIST') throw new Error('supervisor owner marker already exists; takeover required');
+    throw error;
+  }
+  return {status:'claimed',instance_nonce:marker.instance_nonce,marker};
+}
+
+export async function takeoverSupervisor(options={}){
+  const markerPath=assertOptions(options);
+  const prior=await observeSupervisor({markerPath});
+  if(prior.live&&prior.reason==='live_verified_owner') throw new Error('supervisor takeover refused: live verified owner');
+  if(prior.reason==='no_owner') return claimSupervisor({markerPath});
+  const marker=await currentMarker();
+  const before=await readMarker(markerPath);
+  if(!before.exists||before.raw_sha256!==prior.marker_sha256) throw new Error('supervisor ownership changed during takeover');
+  const temp=path.join(path.dirname(markerPath),`.${path.basename(markerPath)}.${process.pid}.${randomBytes(8).toString('hex')}.tmp`);
+  try {
+    await writeFile(temp,`${JSON.stringify(marker)}\n`,{flag:'wx',mode:0o600});
+    const check=await readMarker(markerPath);
+    if(!check.exists||check.raw_sha256!==prior.marker_sha256) throw new Error('supervisor ownership changed during takeover');
+    await rename(temp,markerPath);
+  } finally { await rm(temp,{force:true}).catch(()=>{}); }
+  return {status:'claimed',instance_nonce:marker.instance_nonce,marker,taken_over_reason:prior.reason};
+}
+
+export async function releaseSupervisor(options={}){
+  const markerPath=assertOptions(options);
+  if(typeof options.instanceNonce!=='string'||!HEX64.test(options.instanceNonce)) throw new Error('supervisor ownership nonce invalid');
+  const observed=await observeSupervisor({markerPath});
+  if(observed.reason==='no_owner') return {status:'absent'};
+  if(!observed.live||observed.reason!=='live_verified_owner') throw new Error(`supervisor ownership is not a live verified owner: ${observed.reason}`);
+  if(observed.marker.instance_nonce!==options.instanceNonce) throw new Error('supervisor ownership nonce mismatch');
+  if(observed.marker.pid!==process.pid) throw new Error('supervisor ownership belongs to another process');
+  const current=await observeCurrentProcessIdentity();
+  if(!current||current.creation_time_utc!==observed.observation.creation_time_utc||
+    !samePath(current.image_path,observed.observation.image_path)||current.image_sha256!==observed.observation.image_sha256) {
+    throw new Error('supervisor ownership current process identity mismatch');
+  }
+  const check=await readMarker(markerPath);
+  if(!check.exists||check.raw_sha256!==observed.marker_sha256) throw new Error('supervisor ownership changed before release');
+  await rm(markerPath,{force:false});
+  return {status:'released'};
+}
+
+export function validateSupervisorRecoveryRequest(request){
+  if(!request||typeof request!=='object'||Array.isArray(request)) throw new Error('supervisor recovery request invalid');
+  const keys=Object.keys(request);
+  if(keys.length!==1||keys[0]!=='operation') throw new Error('supervisor recovery request fields invalid');
+  if(typeof request.operation!=='string'||!RECOVERY_SET.has(request.operation)) throw new Error('supervisor recovery operation is not in allowlist');
+  return {operation:request.operation};
+}
+
+export async function runPinnedControllerOperation(options={}){
+  if(!options||typeof options!=='object'||Array.isArray(options)) throw new Error('supervisor controller options invalid');
+  const keys=Object.keys(options).sort();
+  if(JSON.stringify(keys)!==JSON.stringify(['controllerPath','controllerSha256','operation'])) {
+    throw new Error('supervisor controller options fields invalid');
+  }
+  if(typeof options.controllerPath!=='string'||options.controllerPath.length<3) throw new Error('supervisor controller path invalid');
+  if(typeof options.controllerSha256!=='string'||!HEX64.test(options.controllerSha256)) throw new Error('supervisor controller hash invalid');
+  const {operation}=validateSupervisorRecoveryRequest({operation:options.operation});
+  const controllerPath=path.resolve(options.controllerPath);
+  let bytes;
+  try { bytes=await readFile(controllerPath); }
+  catch(error){ throw new Error(`supervisor controller unavailable: ${error?.code??String(error)}`); }
+  const actual=sha256Bytes(bytes);
+  if(actual!==options.controllerSha256) throw new Error(`supervisor controller hash mismatch: expected ${options.controllerSha256}, found ${actual}`);
+  const shell=await powershellPath();
+  if(!shell) throw new Error('supervisor controller requires Windows PowerShell');
+  try {
+    const {stdout,stderr}=await execFileAsync(shell,['-NoProfile','-NonInteractive','-ExecutionPolicy','Bypass','-File',controllerPath,operation],{
+      windowsHide:true,timeout:120_000,maxBuffer:4*1024*1024,encoding:'utf8'
+    });
+    return {exit_code:0,stdout:String(stdout??''),stderr:String(stderr??'')};
+  } catch(error) {
+    return {exit_code:Number.isInteger(error?.code)?error.code:1,stdout:String(error?.stdout??''),stderr:String(error?.stderr??error?.message??'')};
+  }
+}
+
+function parseRecoveryStatus(stdout){
+  const text=String(stdout??'');
+  const state=text.match(/^DEADBYTE MCP\s*=\s*(ONLINE|PARKED|OFFLINE|DEGRADED)\s*$/mi)?.[1]??null;
+  const authority={
+    process:text.match(/^Process plane\s*:\s*(ARMED|DISARMED|UNCONFIGURED)\b/mi)?.[1]??null,
+    coding:text.match(/^Coding plane\s*:\s*(ARMED|DISARMED|UNCONFIGURED)\b/mi)?.[1]??null,
+    autonomous:text.match(/^Autonomous\s*:\s*(ARMED|DISARMED|UNCONFIGURED)\b/mi)?.[1]??null,
+    host:text.match(/^Host plane\s*:\s*(ARMED|DISARMED|UNCONFIGURED)\b/mi)?.[1]??null
+  };
+  return {runtime_state:state,authority};
+}
+
+export async function recoverManagedRuntime({runControllerOperation}={}){
+  if(typeof runControllerOperation!=='function') throw new Error('supervisor recovery requires controller runner');
+  const operations=['resume','disarmautonomous','disarmcoding','disarmprocess','disarmhost','status'];
+  const results=[];
+  for(const operation of operations){
+    const request=validateSupervisorRecoveryRequest({operation});
+    const result=await runControllerOperation(request);
+    if(!result||result.exit_code!==0) throw new Error(`supervisor recovery operation '${operation}' failed`);
+    results.push({operation,...result});
+  }
+  const observed=parseRecoveryStatus(results.at(-1)?.stdout);
+  if(observed.runtime_state!=='ONLINE') throw new Error(`supervisor recovery expected ONLINE, observed ${observed.runtime_state??'unknown'}`);
+  for(const [plane,value] of Object.entries(observed.authority)) {
+    if(value!=='DISARMED') throw new Error(`supervisor recovery requires ${plane} DISARMED, observed ${value??'unknown'}`);
+  }
+  return {status:'recovered',...observed,operations:results.map(item=>item.operation)};
+}
+
+export async function startLocalSupervisorHost({runtime,policy=runtime?.policy,markerPath,idleDelayMs=750,maxCycles=32,logger=console,continuous=true}={}){
+  if(!runtime||!policy) throw new Error('local supervisor host requires runtime + policy');
+  const observed=await observeSupervisor({markerPath});
+  const claim=observed.reason==='no_owner'
+    ? await claimSupervisor({markerPath})
+    : await takeoverSupervisor({markerPath});
+  let supervisor;
+  try {
+    supervisor=startAutonomousSupervisor({runtime,policy,idleDelayMs,maxCycles,logger,continuous});
+  } catch(error) {
+    await releaseSupervisor({markerPath,instanceNonce:claim.instance_nonce}).catch(()=>{});
+    throw error;
+  }
+  let stopped=false;
+  return Object.freeze({
+    marker_path:path.resolve(markerPath),instance_nonce:claim.instance_nonce,supervisor,
+    get running(){ return !stopped&&supervisor.running; },
+    async scanNow(){ if(stopped) throw new Error('local supervisor host stopped'); return supervisor.scanNow(); },
+    async stop(){
+      if(stopped) return {status:'stopped'};
+      stopped=true;
+      await supervisor.stop();
+      await releaseSupervisor({markerPath,instanceNonce:claim.instance_nonce});
+      return {status:'stopped'};
+    }
+  });
+}
+
+export const AUTONOMOUS_SUPERVISOR_RECOVERY_OPERATIONS=RECOVERY_OPERATIONS;