deadbyte-mcp 0.8.9 → 0.9.0

package/scripts/tool-surface-snapshot.mjs

@@ -0,0 +1,73 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
+import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
+import { snapshotToolsListResult } from '../src/tool-surface-ledger.mjs';
+
+function parseArgs(argv){
+  const out={input:'',endpointFile:'',output:''};
+  for(let i=0;i<argv.length;i+=1){
+    const arg=argv[i];
+    if(arg==='--input') out.input=argv[++i]??'';
+    else if(arg==='--endpoint-file') out.endpointFile=argv[++i]??'';
+    else if(arg==='--output') out.output=argv[++i]??'';
+    else throw new Error(`unknown argument: ${arg}`);
+  }
+  if(Boolean(out.input)===Boolean(out.endpointFile)) throw new Error('use exactly one of --input or --endpoint-file');
+  if(!out.input&&!out.endpointFile) throw new Error('missing snapshot source');
+  return out;
+}
+
+async function listFromEndpointFile(endpointFile){
+  const endpointText=(await readFile(path.resolve(endpointFile),'utf8')).trim();
+  const endpoint=new URL(endpointText);
+  if(endpoint.protocol!=='https:') throw new Error('tool surface endpoint must use HTTPS');
+  const client=new Client({name:'deadbyte-r35-tool-surface',version:'0.9.0'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  const transport=new StreamableHTTPClientTransport(endpoint);
+  try{
+    await client.connect(transport);
+    return await client.listTools();
+  } finally {
+    await client.close().catch(()=>{});
+  }
+}
+
+export async function snapshotStdioServer({command,args=[],cwd=process.cwd(),env={}}){
+  if(typeof command!=='string'||command.length<1) throw new Error('stdio snapshot command required');
+  if(!Array.isArray(args)||args.some(arg=>typeof arg!=='string')) throw new Error('stdio snapshot args must be strings');
+  const client=new Client({name:'deadbyte-r35-tool-surface-stdio',version:'0.9.0'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  const transport=new StdioClientTransport({
+    command,
+    args,
+    cwd,
+    env:{...getDefaultEnvironment(),...env},
+    stderr:'pipe'
+  });
+  try{
+    await client.connect(transport);
+    return snapshotToolsListResult(await client.listTools());
+  } finally {
+    await client.close().catch(()=>{});
+  }
+}
+
+export async function snapshotSource({input='',endpointFile=''}){
+  const listed=input
+    ? JSON.parse(await readFile(path.resolve(input),'utf8'))
+    : await listFromEndpointFile(endpointFile);
+  return snapshotToolsListResult(listed);
+}
+
+export async function main(argv=process.argv.slice(2)){
+  const args=parseArgs(argv);
+  const snapshot=await snapshotSource(args);
+  const text=`${JSON.stringify(snapshot,null,2)}\n`;
+  if(args.output) await writeFile(path.resolve(args.output),text,{encoding:'utf8',flag:'w'});
+  else process.stdout.write(text);
+  return snapshot;
+}
+
+if(process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url)){
+  main().catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});
+}

package/scripts/windows-gate-evidence.mjs

@@ -7,7 +7,7 @@ import { fileURLToPath } from 'node:url';
 const here=path.dirname(fileURLToPath(import.meta.url));
 const root=path.resolve(here,'..');
 const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
-const marker='DEADBYTE V0.8.9 / R33 WINDOWS BATCH GATE: PASS';
+const marker='DEADBYTE V0.9.0 / R35 WINDOWS BATCH GATE: PASS';
 function insist(ok,message){if(!ok) throw new Error(message);}
 
 export async function writeWindowsGateEvidence({
@@ -19,17 +19,17 @@ export async function writeWindowsGateEvidence({
   const manifestBytes=await readFile(path.join(candidate,'MANIFEST.SHA256'));
   const manifestSha256=sha256(manifestBytes);
   const pkg=JSON.parse(await readFile(path.join(candidate,'package.json'),'utf8'));
-  insist(pkg.version==='0.8.9',`Windows gate evidence requires V0.8.9, found ${pkg.version}`);
+  insist(pkg.version==='0.9.0',`Windows gate evidence requires V0.9.0, found ${pkg.version}`);
   const completed=clock();
   insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'Windows gate evidence clock invalid');
   const evidence={
-    schema:'deadbyte.r33-windows-gate.v1',status:'passed',exit_code:0,version:'0.8.9',
+    schema:'deadbyte.r35-windows-gate.v1',status:'passed',exit_code:0,version:'0.9.0',
     marker,completed_at_utc:completed.toISOString(),manifest_sha256:manifestSha256
   };
   const bytes=Buffer.from(`${JSON.stringify(evidence,null,2)}\n`,'utf8');
   const dir=path.join(path.resolve(stateRoot),'evidence','release');
   await mkdir(dir,{recursive:true});
-  const file=path.join(dir,`r33-windows-gate-${manifestSha256.slice(0,16)}.json`);
+  const file=path.join(dir,`r35-windows-gate-${manifestSha256.slice(0,16)}.json`);
   try{
     const handle=await open(file,'wx',0o600);
     try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}
@@ -39,7 +39,7 @@ export async function writeWindowsGateEvidence({
     const existingBytes=await readFile(file);
     const existing=JSON.parse(existingBytes.toString('utf8'));
     insist(existing.schema===evidence.schema&&existing.status==='passed'&&existing.exit_code===0,'existing Windows gate evidence invalid');
-    insist(existing.version==='0.8.9'&&existing.marker===marker&&existing.manifest_sha256===manifestSha256,'existing Windows gate evidence binding mismatch');
+    insist(existing.version==='0.9.0'&&existing.marker===marker&&existing.manifest_sha256===manifestSha256,'existing Windows gate evidence binding mismatch');
     return {status:'existing',path:file,sha256:sha256(existingBytes),manifest_sha256:manifestSha256};
   }
 }

package/src/audit-verify.mjs

@@ -43,6 +43,8 @@ export async function verifyAuditChain({stateRoot,verifyKeyPath,requireComplete=
 
     let seq=0,head=ZERO,previousCheckpoint=ZERO,requestCount=0,resultCount=0,checkpointCount=0;
     const open=new Map();
+    const usage=new Map();
+    const usageFor=tool=>{ if(!usage.has(tool)) usage.set(tool,{tool,requests:0,results:0,errors:0}); return usage.get(tool); };
     for(let pos=0;pos<segmentIndexes.length;pos++){
       const index=segmentIndexes[pos],fileName=segmentName(index),file=path.join(auditDir,fileName),bytes=await readFile(file),rows=parseSegment(bytes,fileName);
       const firstSeq=seq+1,firstPrev=head;
@@ -59,11 +61,12 @@ export async function verifyAuditChain({stateRoot,verifyKeyPath,requireComplete=
         if(event.event_type==='tool.request'){
           if(open.has(event.request_id)) throw new Error(`audit duplicate request id at seq ${event.seq}`);
           if(event.args===undefined) throw new Error(`audit request args missing at seq ${event.seq}`);
-          open.set(event.request_id,{tool:event.tool,seq:event.seq,segment:index});requestCount++;
+          open.set(event.request_id,{tool:event.tool,seq:event.seq,segment:index});requestCount++;usageFor(event.tool).requests++;
         }else if(event.event_type==='tool.result'){
           const pending=open.get(event.request_id);if(!pending) throw new Error(`audit orphan result at seq ${event.seq}`);
           if(pending.tool!==event.tool) throw new Error(`audit result tool mismatch at seq ${event.seq}`);
           requireObject(event.outcome,`audit outcome at seq ${event.seq}`);
+          const stats=usageFor(event.tool);stats.results++;if(event.outcome.is_error===true)stats.errors++;
           open.delete(event.request_id);resultCount++;
         }else throw new Error(`audit event type invalid at seq ${event.seq}`);
         seq=event.seq;head=event.event_sha256;
@@ -88,6 +91,7 @@ export async function verifyAuditChain({stateRoot,verifyKeyPath,requireComplete=
       }
     }
     if(requireComplete&&open.size>0) throw new Error(`audit has ${open.size} request(s) without result`);
-    return {ok:true,event_count:seq,request_count:requestCount,result_count:resultCount,open_request_count:open.size,segment_count:segmentIndexes.length,checkpoint_count:checkpointCount,last_seq:seq,head_sha256:head,last_checkpoint_sha256:previousCheckpoint,key_id:key.keyId,complete:open.size===0};
+    const toolUsage=[...usage.values()].sort((a,b)=>a.tool.localeCompare(b.tool,'en'));
+    return {ok:true,event_count:seq,request_count:requestCount,result_count:resultCount,open_request_count:open.size,segment_count:segmentIndexes.length,checkpoint_count:checkpointCount,last_seq:seq,head_sha256:head,last_checkpoint_sha256:previousCheckpoint,key_id:key.keyId,complete:open.size===0,tool_usage:toolUsage};
   }catch(error){return {ok:false,reason:String(error?.message||error)};}
 }

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,255 @@
+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 }) {
+  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,
+    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;
+}