deadbyte-mcp 0.8.10 → 0.10.0

package/src/autonomous-planner.mjs

@@ -1,7 +1,11 @@
+import { createHash } from 'node:crypto';
 import { canonicalJson } from './canonical-json.mjs';
+import { buildLoopContext } from './autonomous-context-engine.mjs';
+import { r34PlannerDecisionSchema } from './autonomous-planner-contracts.mjs';
 import { validatePortableRelativePath } from './path-policy.mjs';
 
 export const AUTONOMOUS_DECISION_SCHEMA = 'deadbyte.autonomous-decision.v1';
+export const AUTONOMOUS_R34_DECISION_SCHEMA = 'deadbyte.autonomous-decision.v2';
 const ID_RE = /^[A-Za-z0-9._-]{1,64}$/;
 const SHA256_RE = /^[0-9a-f]{64}$/;
 function strictKeys(value, allowed, label) {
@@ -115,6 +119,27 @@ function normalizeDelegatedOperation(raw) {
   }
   throw new Error('planner delegated operation kind invalid');
 }
+
+function legacyDelegatedToTyped(operation) {
+  if (operation.kind === 'machine_stat') return { kind:'machine_fs_stat', path:operation.path, hash:operation.hash };
+  if (operation.kind === 'machine_list') return { kind:'machine_fs_list', path:operation.path, cursor:operation.cursor, limit:operation.limit, hash_files:operation.hash_files };
+  if (operation.kind === 'machine_read') return { kind:'machine_fs_read', path:operation.path, offset:operation.offset, max_bytes:operation.max_bytes, hash_file:operation.hash };
+  return operation;
+}
+function validateR36TypedAction(action) {
+  const pathFields=[];
+  if (typeof action.path === 'string' && action.path !== '.') pathFields.push(action.path);
+  if (typeof action.cwd === 'string' && action.cwd !== '.') pathFields.push(action.cwd);
+  if (typeof action.source_path === 'string') pathFields.push(action.source_path);
+  if (typeof action.destination_path === 'string') pathFields.push(action.destination_path);
+  for (const item of action.files ?? []) if (typeof item?.path === 'string') pathFields.push(item.path);
+  for (const candidate of pathFields) validatePortableRelativePath(candidate);
+  return action;
+}
+function normalizeR36TypedAction(action) {
+  if (action.kind === 'delegate') return validateR36TypedAction(legacyDelegatedToTyped(normalizeDelegatedOperation(action.operation)));
+  return validateR36TypedAction(action);
+}
 function normalizePlan(raw) {
   strictKeys(raw, ['title','reason','steps'], 'planner plan');
   const title = text(raw.title, 'planner plan title', 160, 1);
@@ -178,6 +203,73 @@ export function parsePlannerDecision(rawText, policy) {
   if (raw.action === 'pause') return withPlan({ schema:AUTONOMOUS_DECISION_SCHEMA, action:'pause', summary, reason:text(raw.reason ?? 'planner_pause','planner pause reason',512,1) });
   throw new Error('planner action invalid');
 }
+function assertR34UniqueSteps(steps,label) {
+  const seen = new Set();
+  for (const step of steps) {
+    if (seen.has(step.step_id)) throw new Error(`${label} duplicate step_id '${step.step_id}'`);
+    seen.add(step.step_id);
+  }
+}
+
+export function parseR34PlannerDecision(rawText, policy) {
+  if (typeof rawText !== 'string' || rawText.length < 2 || rawText.length > policy.limits.max_context_bytes) {
+    throw new Error('R34 planner structured response size invalid');
+  }
+  const trimmed = rawText.trim();
+  if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) {
+    throw new Error('R34 planner structured response must be one raw JSON object');
+  }
+  let raw;
+  try { raw = JSON.parse(trimmed); }
+  catch (error) { throw new Error(`R34 planner JSON invalid: ${error.message}`); }
+  const checked = r34PlannerDecisionSchema.safeParse(raw);
+  if (!checked.success) throw new Error('R34 planner decision contract mismatch');
+  const decision = checked.data;
+  if (decision.schema !== AUTONOMOUS_R34_DECISION_SCHEMA) throw new Error('R34 planner decision schema mismatch');
+
+  if (decision.kind === 'plan_create') {
+    assertR34UniqueSteps(decision.steps,'R34 plan_create');
+    return decision;
+  }
+  if (decision.kind === 'inspect') {
+    return { ...decision, reads:decision.reads.map(item => {
+      validatePortableRelativePath(item.path);
+      return { path:item.path, max_bytes:item.max_bytes };
+    }) };
+  }
+  if (decision.kind === 'act') {
+    if (decision.action.kind === 'patch') {
+      if (decision.action.operations.length > policy.limits.max_files_per_diff) throw new Error('R34 patch operation count exceeds policy');
+      return { ...decision, action:{ kind:'patch', operations:decision.action.operations.map(normalizeOperation) } };
+    }
+    if (decision.action.kind === 'run_profile') {
+      if (!policy.profiles?.[decision.action.profile_id]) throw new Error('R34 planner profile_id invalid');
+      return decision;
+    }
+    if (decision.action.kind === 'delegate') {
+      return { ...decision, action:normalizeR36TypedAction(decision.action) };
+    }
+    return { ...decision, action:normalizeR36TypedAction(decision.action) };
+  }
+  if (decision.kind === 'step_complete') return decision;
+  if (decision.kind === 'replan') {
+    assertR34UniqueSteps(decision.steps,'R34 replan');
+    return decision;
+  }
+  if (decision.kind === 'pause' || decision.kind === 'finish') return decision;
+  throw new Error('R34 planner decision kind unsupported');
+}
+
+export async function requestR34ProviderDecision(policy,prompt,fetchImpl = fetch) {
+  const response = await requestProviderDecision(policy,prompt,fetchImpl);
+  return {
+    backend:response.backend,
+    model:response.model,
+    raw_response_sha256:createHash('sha256').update(Buffer.from(response.raw_text,'utf8')).digest('hex'),
+    decision:parseR34PlannerDecision(response.raw_text,policy)
+  };
+}
+
 function plannerStateBytes(state) {
   return Buffer.byteLength(canonicalJson(state),'utf8');
 }
@@ -223,12 +315,27 @@ function compactPlannerState(state, limit) {
   return candidate;
 }
 export function buildPlannerPrompt({ goal, policy, view }) {
-  const profiles = Object.entries(policy.profiles).map(([id,p]) => ({ id, kind:p.kind,
-    required_for_release:p.required_for_release, description:p.description }));
-  let state = { goal, mutation_epoch:view.mutation_epoch, planner_round:view.planner_round,
-    tree:view.tree ?? [], contexts:view.contexts ?? [], observations:view.observations ?? [],
-    active_plan:view.active_plan ?? null, recent_decisions:view.recent_decisions ?? [], profiles };
-  state = compactPlannerState(state,policy.limits.max_context_bytes);
+  const state = buildLoopContext({
+    goal,
+    policy,
+    loopState:{
+      phase:view.loop?.phase ?? null,
+      mutation_epoch:Number.isInteger(view.mutation_epoch) ? view.mutation_epoch : (view.loop?.mutation_epoch ?? 0),
+      planner_round:Number.isInteger(view.planner_round) ? view.planner_round : (view.loop?.planner_round ?? 0),
+      plan:view.loop?.plan ?? view.active_plan ?? null,
+      active_plan:view.active_plan ?? view.loop?.plan ?? null,
+      current_step:view.loop?.current_step ?? null,
+      plan_id:view.loop?.plan_id ?? null,
+      plan_version:view.loop?.plan_version ?? null,
+      replan_count:view.loop?.replan_count ?? 0
+    },
+    tree:view.tree ?? [],
+    contexts:view.contexts ?? [],
+    observations:view.observations ?? [],
+    decisions:view.recent_decisions ?? [],
+    projectMemory:view.project_memory ?? null,
+    capabilities:view.capabilities ?? null
+  });
   const stateJson = canonicalJson(state);
   return [
     'You are the DEADBYTE R24 autonomous coding planner.',

package/src/autonomous-policy.mjs

@@ -21,6 +21,15 @@ function finite(value, name, min, max, fallback) {
   if (!Number.isFinite(n) || n < min || n > max) throw new Error(`${name} must be in [${min}, ${max}]`);
   return n;
 }
+function normalizeProviderCircuit(raw) {
+  const value=raw ?? {};
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('planner.circuit invalid');
+  return Object.freeze({
+    failure_threshold:integer(value.failure_threshold,'planner.circuit.failure_threshold',1,32,3),
+    open_ms:integer(value.open_ms,'planner.circuit.open_ms',100,3_600_000,30_000),
+    half_open_probe_limit:integer(value.half_open_probe_limit,'planner.circuit.half_open_probe_limit',1,8,1)
+  });
+}
 function normalizePlanner(raw) {
   if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw new Error('autonomous planner missing');
   const backend = raw.backend;
@@ -40,7 +49,8 @@ function normalizePlanner(raw) {
   return {
     ...common, endpoint: endpoint.toString(), model: raw.model, api_key_env: apiKeyEnv,
     timeout_ms: integer(raw.timeout_ms, 'planner.timeout_ms', 1000, 300000, 60000),
-    max_response_bytes: integer(raw.max_response_bytes, 'planner.max_response_bytes', 4096, 2 * 1024 * 1024, 512 * 1024)
+    max_response_bytes: integer(raw.max_response_bytes, 'planner.max_response_bytes', 4096, 2 * 1024 * 1024, 512 * 1024),
+    circuit:normalizeProviderCircuit(raw.circuit)
   };
 }
 function normalizeProfile(id, raw, codingPolicy) {
@@ -106,7 +116,10 @@ export async function loadAutonomousPolicy(policyPath, codingPolicy) {
       max_wall_ms: limits.max_wall_ms === null ? null : integer(limits.max_wall_ms, 'limits.max_wall_ms', 60000, 14_400_000, 1_800_000),
       max_context_bytes: integer(limits.max_context_bytes, 'limits.max_context_bytes', 65536, 8 * 1024 * 1024, 1024 * 1024),
       max_diff_bytes: integer(limits.max_diff_bytes, 'limits.max_diff_bytes', 65536, 8 * 1024 * 1024, 1024 * 1024),
-      max_files_per_diff: integer(limits.max_files_per_diff, 'limits.max_files_per_diff', 1, 32, 8)
+      max_files_per_diff: integer(limits.max_files_per_diff, 'limits.max_files_per_diff', 1, 32, 8),
+      max_stalled_cycles: integer(limits.max_stalled_cycles, 'limits.max_stalled_cycles', 1, 32, 2),
+      max_post_replan_stalls: integer(limits.max_post_replan_stalls, 'limits.max_post_replan_stalls', 1, 32, 2),
+      max_replans: integer(limits.max_replans, 'limits.max_replans', 1, 32, 8)
     }
   };
   policy.policy_sha256 = sha256Bytes(bytes);

package/src/autonomous-progress.mjs

@@ -0,0 +1,127 @@
+import { createHash } from 'node:crypto';
+import { canonicalJson } from './canonical-json.mjs';
+
+const POSITIVE_REASONS = Object.freeze([
+  'new_source_identity',
+  'new_profile_evidence',
+  'verified_mutation_epoch_advanced',
+  'acceptance_failure_resolved',
+  'plan_step_completed',
+  'diagnostic_narrowed',
+  'interrupted_action_recovered',
+  'release_readiness_improved'
+]);
+
+const STALL_REASONS = Object.freeze([
+  'equivalent_decision_no_new_evidence',
+  'identical_read_repeated',
+  'identical_profile_failure_repeated',
+  'equivalent_replan',
+  'plan_oscillation'
+]);
+
+function sha256Object(value) {
+  return createHash('sha256').update(Buffer.from(canonicalJson(value),'utf8')).digest('hex');
+}
+
+function stripPlannerText(value) {
+  if (Array.isArray(value)) return value.map(stripPlannerText);
+  if (!value || typeof value !== 'object') return value;
+  const out = {};
+  for (const [key,item] of Object.entries(value)) {
+    if (['rationale','summary','explanation','planner_reason'].includes(key)) continue;
+    out[key] = stripPlannerText(item);
+  }
+  return out;
+}
+
+function finiteNumber(value,fallback = 0) {
+  return Number.isFinite(value) ? value : fallback;
+}
+
+function add(reasons,reason,condition) {
+  if (condition && !reasons.includes(reason)) reasons.push(reason);
+}
+
+export function judgeProgress({ before = {}, after = {}, decision = {}, evidence = {} } = {}) {
+  const positive = [];
+  const stalled = [];
+  const regressed = [];
+
+  add(positive,'new_source_identity',evidence.new_source_identity === true ||
+    (typeof before.source_sha256 === 'string' && typeof after.source_sha256 === 'string' && before.source_sha256 !== after.source_sha256));
+  add(positive,'new_profile_evidence',evidence.new_profile_evidence === true);
+  add(positive,'verified_mutation_epoch_advanced',evidence.native_diff_verified === true &&
+    Number.isInteger(before.mutation_epoch) && Number.isInteger(after.mutation_epoch) && after.mutation_epoch > before.mutation_epoch);
+  add(positive,'acceptance_failure_resolved',finiteNumber(before.acceptance_failures) > finiteNumber(after.acceptance_failures));
+  add(positive,'plan_step_completed',evidence.step_evidence_verified === true &&
+    finiteNumber(after.completed_steps) > finiteNumber(before.completed_steps));
+  add(positive,'diagnostic_narrowed',evidence.diagnostic_narrowed === true);
+  add(positive,'interrupted_action_recovered',evidence.interrupted_action_recovered === true);
+  add(positive,'release_readiness_improved',evidence.release_readiness_improved === true ||
+    (before.release_ready === false && after.release_ready === true));
+
+  add(stalled,'equivalent_decision_no_new_evidence',evidence.equivalent_decision === true);
+  add(stalled,'identical_read_repeated',evidence.same_source_sha === true);
+  add(stalled,'identical_profile_failure_repeated',evidence.identical_profile_failure === true);
+  add(stalled,'equivalent_replan',evidence.equivalent_replan === true);
+  add(stalled,'plan_oscillation',evidence.plan_oscillation === true);
+
+  add(regressed,'acceptance_failures_increased',finiteNumber(after.acceptance_failures) > finiteNumber(before.acceptance_failures));
+  add(regressed,'release_readiness_regressed',before.release_ready === true && after.release_ready === false);
+
+  let verdict = 'stalled';
+  let score = 0;
+  let reasonCodes;
+  if (positive.length > 0) {
+    verdict = 'progress';
+    score = positive.length;
+    reasonCodes = positive;
+  } else if (regressed.length > 0) {
+    verdict = 'regressed';
+    score = -regressed.length;
+    reasonCodes = regressed;
+  } else {
+    reasonCodes = stalled.length > 0 ? stalled : ['no_machine_progress_signal'];
+  }
+
+  const fingerprint = sha256Object({
+    before:stripPlannerText(before),
+    after:stripPlannerText(after),
+    decision:stripPlannerText(decision),
+    evidence:stripPlannerText(evidence),
+    verdict,
+    reason_codes:reasonCodes
+  });
+
+  return Object.freeze({ verdict, score, reason_codes:Object.freeze([...reasonCodes]), fingerprint });
+}
+
+function integerLimit(limits,name) {
+  const value = limits?.[name];
+  if (!Number.isInteger(value) || value < 1 || value > 32) throw new Error(`progress ${name} invalid`);
+  return value;
+}
+
+export function stallDisposition({ history = [], limits } = {}) {
+  if (!Array.isArray(history)) throw new Error('progress history must be an array');
+  const maxStalled = integerLimit(limits,'max_stalled_cycles');
+  const maxPostReplan = integerLimit(limits,'max_post_replan_stalls');
+  const maxReplans = integerLimit(limits,'max_replans');
+  const replanCount = history.filter(item => item === 'replan').length;
+  if (replanCount >= maxReplans) return { action:'wait', reason:'replan_limit_reached' };
+
+  let trailingStalls = 0;
+  for (let index = history.length - 1; index >= 0 && history[index] === 'stalled'; index -= 1) trailingStalls += 1;
+  const lastReplan = history.lastIndexOf('replan');
+  if (lastReplan >= 0 && trailingStalls >= maxPostReplan) {
+    return { action:'wait', reason:'post_replan_stall_threshold_reached' };
+  }
+  if (lastReplan < 0 && trailingStalls >= maxStalled) {
+    return { action:'replan', reason:'stall_threshold_reached' };
+  }
+  return { action:'continue', reason:'within_progress_budget' };
+}
+
+export const AUTONOMOUS_PROGRESS_POSITIVE_REASONS = POSITIVE_REASONS;
+export const AUTONOMOUS_PROGRESS_STALL_REASONS = STALL_REASONS;