@neuroverseos/governance 0.2.3 → 0.3.1

package/dist/chunk-Q6O7ZLO2.js

@@ -1,62 +0,0 @@
-// src/providers/ai-provider.ts
-var ChatCompletionsProvider = class {
-  model;
-  apiKey;
-  endpoint;
-  constructor(config) {
-    this.model = config.model;
-    this.apiKey = config.apiKey;
-    this.endpoint = config.endpoint ?? "https://api.openai.com/v1/chat/completions";
-  }
-  async complete(systemPrompt, userPrompt) {
-    const body = {
-      model: this.model,
-      messages: [
-        { role: "system", content: systemPrompt },
-        { role: "user", content: userPrompt }
-      ],
-      temperature: 0.2,
-      max_tokens: 16384
-    };
-    const response = await fetch(this.endpoint, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      const text = await response.text().catch(() => "");
-      throw new Error(`Provider returned ${response.status}: ${text.slice(0, 200)}`);
-    }
-    const data = await response.json();
-    const content = data?.choices?.[0]?.message?.content;
-    if (!content) {
-      throw new Error("Provider returned empty response \u2014 no content in choices[0].message.content");
-    }
-    return content;
-  }
-};
-function createProvider(config) {
-  return new ChatCompletionsProvider(config);
-}
-
-// src/contracts/derive-contract.ts
-var DERIVE_EXIT_CODES = {
-  SUCCESS: 0,
-  VALIDATION_FAIL: 1,
-  INPUT_ERROR: 2,
-  PROVIDER_ERROR: 3
-};
-var CONFIGURE_AI_EXIT_CODES = {
-  SUCCESS: 0,
-  VALIDATION_FAIL: 1,
-  ERROR: 3
-};
-
-export {
-  createProvider,
-  DERIVE_EXIT_CODES,
-  CONFIGURE_AI_EXIT_CODES
-};

package/dist/chunk-QLPTHTVB.js

@@ -1,253 +0,0 @@
-// src/engine/text-utils.ts
-function normalizeEventText(event) {
-  return [
-    event.intent,
-    event.tool ?? "",
-    event.scope ?? ""
-  ].join(" ").toLowerCase();
-}
-function extractKeywords(text, minLength = 3) {
-  return text.toLowerCase().split(/\s+/).filter((w) => w.length > minLength);
-}
-function matchesAllKeywords(eventText, ruleText) {
-  const keywords = extractKeywords(ruleText);
-  if (keywords.length === 0) return false;
-  return keywords.every((kw) => eventText.includes(kw));
-}
-function matchesKeywordThreshold(eventText, ruleText, threshold = 0.5) {
-  const keywords = extractKeywords(ruleText);
-  if (keywords.length === 0) return false;
-  const matched = keywords.filter((kw) => eventText.includes(kw));
-  return matched.length >= Math.ceil(keywords.length * threshold);
-}
-function tokenSimilarity(a, b) {
-  const tokensA = new Set(a.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
-  const tokensB = new Set(b.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
-  if (tokensA.size === 0 || tokensB.size === 0) return 0;
-  let intersection = 0;
-  for (const t of tokensA) {
-    if (tokensB.has(t)) intersection++;
-  }
-  const union = (/* @__PURE__ */ new Set([...tokensA, ...tokensB])).size;
-  return union > 0 ? intersection / union : 0;
-}
-
-// src/engine/plan-engine.ts
-function keywordMatch(eventText, step) {
-  const stepText = [
-    step.label,
-    step.description ?? "",
-    ...step.tags ?? []
-  ].join(" ");
-  return matchesKeywordThreshold(eventText, stepText, 0.5);
-}
-function tokenSimilarity2(a, b) {
-  return tokenSimilarity(a, b);
-}
-function findMatchingStep(eventText, event, steps) {
-  const pendingOrActive = steps.filter((s) => s.status === "pending" || s.status === "active");
-  if (pendingOrActive.length === 0) {
-    return { matched: null, closest: null, closestScore: 0 };
-  }
-  for (const step of pendingOrActive) {
-    if (keywordMatch(eventText, step)) {
-      if (step.tools && event.tool && !step.tools.includes(event.tool)) {
-        continue;
-      }
-      return { matched: step, closest: step, closestScore: 1 };
-    }
-  }
-  const intentText = [event.intent, event.tool ?? "", event.scope ?? ""].join(" ");
-  let bestStep = null;
-  let bestScore = 0;
-  for (const step of pendingOrActive) {
-    const stepText = [step.label, step.description ?? "", ...step.tags ?? []].join(" ");
-    const score = tokenSimilarity2(intentText, stepText);
-    if (score > bestScore) {
-      bestScore = score;
-      bestStep = step;
-    }
-  }
-  const SIMILARITY_THRESHOLD = 0.35;
-  if (bestScore >= SIMILARITY_THRESHOLD && bestStep) {
-    if (bestStep.tools && event.tool && !bestStep.tools.includes(event.tool)) {
-      return { matched: null, closest: bestStep, closestScore: bestScore };
-    }
-    return { matched: bestStep, closest: bestStep, closestScore: bestScore };
-  }
-  return { matched: null, closest: bestStep, closestScore: bestScore };
-}
-function isSequenceValid(step, plan) {
-  if (!plan.sequential) return true;
-  if (!step.requires || step.requires.length === 0) return true;
-  return step.requires.every((reqId) => {
-    const reqStep = plan.steps.find((s) => s.id === reqId);
-    return reqStep?.status === "completed";
-  });
-}
-function checkConstraints(event, eventText, constraints) {
-  const checks = [];
-  for (const constraint of constraints) {
-    if (constraint.type === "approval") {
-      if (constraint.trigger && eventText.includes(constraint.trigger.substring(0, 10).toLowerCase())) {
-        checks.push({ constraintId: constraint.id, passed: false, reason: constraint.description });
-        return { violated: constraint, checks };
-      }
-      const keywords = constraint.description.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
-      const relevant = keywords.some((kw) => eventText.includes(kw));
-      if (relevant) {
-        checks.push({ constraintId: constraint.id, passed: false, reason: constraint.description });
-        return { violated: constraint, checks };
-      }
-      checks.push({ constraintId: constraint.id, passed: true });
-      continue;
-    }
-    if (constraint.type === "scope" && constraint.trigger) {
-      const keywords = extractKeywords(constraint.trigger);
-      const violated = keywords.length > 0 && keywords.every((kw) => eventText.includes(kw));
-      checks.push({
-        constraintId: constraint.id,
-        passed: !violated,
-        reason: violated ? constraint.description : void 0
-      });
-      if (violated) {
-        return { violated: constraint, checks };
-      }
-      continue;
-    }
-    checks.push({ constraintId: constraint.id, passed: true });
-  }
-  return { violated: null, checks };
-}
-function getPlanProgress(plan) {
-  const completed = plan.steps.filter((s) => s.status === "completed").length;
-  const total = plan.steps.length;
-  return {
-    completed,
-    total,
-    percentage: total > 0 ? Math.round(completed / total * 100) : 0
-  };
-}
-function advancePlan(plan, stepId, evidence) {
-  const step = plan.steps.find((s) => s.id === stepId);
-  if (!step) {
-    return { success: false, reason: `Step "${stepId}" not found in plan.` };
-  }
-  if (step.status === "completed") {
-    return { success: false, reason: `Step "${stepId}" is already completed.` };
-  }
-  const mode = plan.completion ?? "trust";
-  if (mode === "verified" && step.verify) {
-    if (!evidence) {
-      return {
-        success: false,
-        reason: `Step "${step.label}" requires evidence (verify: ${step.verify}). Provide evidence to advance.`
-      };
-    }
-    if (evidence.type !== step.verify) {
-      return {
-        success: false,
-        reason: `Evidence type "${evidence.type}" does not match required verification "${step.verify}".`
-      };
-    }
-  }
-  const updatedPlan = {
-    ...plan,
-    steps: plan.steps.map(
-      (s) => s.id === stepId ? { ...s, status: "completed" } : s
-    )
-  };
-  return {
-    success: true,
-    plan: updatedPlan,
-    evidence: evidence ?? void 0
-  };
-}
-function evaluatePlan(event, plan) {
-  const progress = getPlanProgress(plan);
-  if (plan.expires_at) {
-    const expiresAt = new Date(plan.expires_at).getTime();
-    if (Date.now() > expiresAt) {
-      return {
-        allowed: true,
-        status: "PLAN_COMPLETE",
-        reason: "Plan has expired.",
-        progress
-      };
-    }
-  }
-  if (progress.completed === progress.total) {
-    return {
-      allowed: true,
-      status: "PLAN_COMPLETE",
-      reason: "All plan steps are completed.",
-      progress
-    };
-  }
-  const eventText = normalizeEventText(event);
-  const { matched, closest, closestScore } = findMatchingStep(eventText, event, plan.steps);
-  if (!matched) {
-    return {
-      allowed: false,
-      status: "OFF_PLAN",
-      reason: "Action does not match any plan step.",
-      closestStep: closest?.label,
-      similarityScore: closestScore,
-      progress
-    };
-  }
-  if (!isSequenceValid(matched, plan)) {
-    const pendingDeps = (matched.requires ?? []).filter((reqId) => plan.steps.find((s) => s.id === reqId)?.status !== "completed").join(", ");
-    return {
-      allowed: false,
-      status: "OFF_PLAN",
-      reason: `Step "${matched.label}" requires completion of: ${pendingDeps}`,
-      matchedStep: matched.id,
-      progress
-    };
-  }
-  const { violated } = checkConstraints(event, eventText, plan.constraints);
-  if (violated) {
-    return {
-      allowed: false,
-      status: "CONSTRAINT_VIOLATED",
-      reason: violated.description,
-      matchedStep: matched.id,
-      progress
-    };
-  }
-  return {
-    allowed: true,
-    status: "ON_PLAN",
-    reason: `Matches step: ${matched.label}`,
-    matchedStep: matched.id,
-    progress
-  };
-}
-function buildPlanCheck(event, plan, verdict) {
-  const eventText = normalizeEventText(event);
-  const { matched, closest, closestScore } = findMatchingStep(eventText, event, plan.steps);
-  const { checks: constraintChecks } = checkConstraints(event, eventText, plan.constraints);
-  const progress = getPlanProgress(plan);
-  return {
-    planId: plan.plan_id,
-    matched: !!matched,
-    matchedStepId: matched?.id,
-    matchedStepLabel: matched?.label,
-    closestStepId: !matched ? closest?.id : void 0,
-    closestStepLabel: !matched ? closest?.label : void 0,
-    similarityScore: !matched ? closestScore : void 0,
-    sequenceValid: matched ? isSequenceValid(matched, plan) : void 0,
-    constraintsChecked: constraintChecks,
-    progress: { completed: progress.completed, total: progress.total }
-  };
-}
-
-export {
-  normalizeEventText,
-  matchesAllKeywords,
-  getPlanProgress,
-  advancePlan,
-  evaluatePlan,
-  buildPlanCheck
-};

package/dist/chunk-REXY4LUL.js

@@ -1,226 +0,0 @@
-import {
-  evaluateGuard
-} from "./chunk-IZSO75NZ.js";
-
-// src/engine/audit-logger.ts
-var FileAuditLogger = class {
-  logPath;
-  buffer = [];
-  flushTimer = null;
-  flushIntervalMs;
-  constructor(logPath, options) {
-    this.logPath = logPath;
-    this.flushIntervalMs = options?.flushIntervalMs ?? 1e3;
-  }
-  log(event) {
-    this.buffer.push(JSON.stringify(event));
-    if (!this.flushTimer) {
-      this.flushTimer = setTimeout(() => {
-        void this.flush();
-      }, this.flushIntervalMs);
-    }
-  }
-  async flush() {
-    if (this.buffer.length === 0) return;
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
-    }
-    const lines = this.buffer.splice(0).join("\n") + "\n";
-    try {
-      const { appendFile, mkdir } = await import("fs/promises");
-      const { dirname } = await import("path");
-      await mkdir(dirname(this.logPath), { recursive: true });
-      await appendFile(this.logPath, lines, "utf-8");
-    } catch {
-    }
-  }
-};
-var ConsoleAuditLogger = class {
-  log(event) {
-    const iconMap = {
-      "ALLOW": "\u25CF",
-      "BLOCK": "\u25CB",
-      "PAUSE": "\u25D1",
-      "MODIFY": "\u25D0",
-      "PENALIZE": "\u25CC",
-      "REWARD": "\u25C9",
-      "NEUTRAL": "\u25EF"
-    };
-    const icon = iconMap[event.decision] ?? "\xB7";
-    const ts = event.timestamp.split("T")[1]?.replace("Z", "") ?? event.timestamp;
-    let line = `[${ts}] ${icon} ${event.decision.padEnd(10)} ${event.actor ?? "\u2014"} \u2192 ${event.intent}`;
-    if (event.reason) line += ` (${event.reason})`;
-    if (event.consequence) line += ` [consequence: ${event.consequence.description}]`;
-    if (event.reward) line += ` [reward: ${event.reward.description}]`;
-    process.stderr.write(line + "\n");
-  }
-};
-var CompositeAuditLogger = class {
-  loggers;
-  constructor(...loggers) {
-    this.loggers = loggers;
-  }
-  log(event) {
-    for (const logger of this.loggers) {
-      try {
-        logger.log(event);
-      } catch {
-      }
-    }
-  }
-  async flush() {
-    await Promise.all(
-      this.loggers.map((l) => l.flush?.()).filter(Boolean)
-    );
-  }
-};
-function verdictToAuditEvent(event, verdict) {
-  const auditEvent = {
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    worldId: verdict.evidence.worldId,
-    worldName: verdict.evidence.worldName,
-    worldVersion: verdict.evidence.worldVersion,
-    intent: event.intent,
-    tool: event.tool,
-    scope: event.scope,
-    actor: event.roleId,
-    direction: event.direction,
-    decision: verdict.status,
-    reason: verdict.reason,
-    ruleId: verdict.ruleId,
-    warning: verdict.warning,
-    guardsMatched: verdict.evidence.guardsMatched,
-    rulesMatched: verdict.evidence.rulesMatched,
-    invariantsSatisfied: verdict.evidence.invariantsSatisfied,
-    invariantsTotal: verdict.evidence.invariantsTotal,
-    enforcementLevel: verdict.evidence.enforcementLevel,
-    durationMs: verdict.trace?.durationMs,
-    args: event.args
-  };
-  if (verdict.consequence) {
-    auditEvent.consequence = verdict.consequence;
-  }
-  if (verdict.reward) {
-    auditEvent.reward = verdict.reward;
-  }
-  if (verdict.intentRecord) {
-    auditEvent.originalIntent = verdict.intentRecord.originalIntent;
-    auditEvent.finalAction = verdict.intentRecord.finalAction;
-  }
-  return auditEvent;
-}
-function createGovernanceEngine(world, options = {}) {
-  const { auditLogger, auditArgs, ...engineOptions } = options;
-  return {
-    /**
-     * Evaluate a governance event and log the result.
-     */
-    evaluate(event) {
-      const verdict = evaluateGuard(event, world, engineOptions);
-      if (auditLogger) {
-        const auditEvent = verdictToAuditEvent(event, verdict);
-        if (!auditArgs) {
-          delete auditEvent.args;
-        }
-        auditLogger.log(auditEvent);
-      }
-      return verdict;
-    },
-    /** Flush the audit logger. */
-    async flush() {
-      await auditLogger?.flush?.();
-    },
-    /** The underlying world definition. */
-    world
-  };
-}
-async function readAuditLog(logPath, filter) {
-  const { readFile } = await import("fs/promises");
-  let content;
-  try {
-    content = await readFile(logPath, "utf-8");
-  } catch {
-    return [];
-  }
-  const events = [];
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      const event = JSON.parse(trimmed);
-      if (!filter || filter(event)) {
-        events.push(event);
-      }
-    } catch {
-    }
-  }
-  return events;
-}
-function summarizeAuditEvents(events) {
-  const allowed = events.filter((e) => e.decision === "ALLOW").length;
-  const blocked = events.filter((e) => e.decision === "BLOCK").length;
-  const paused = events.filter((e) => e.decision === "PAUSE").length;
-  const modified = events.filter((e) => e.decision === "MODIFY").length;
-  const penalized = events.filter((e) => e.decision === "PENALIZE").length;
-  const rewarded = events.filter((e) => e.decision === "REWARD").length;
-  const neutral = events.filter((e) => e.decision === "NEUTRAL").length;
-  const actorSet = /* @__PURE__ */ new Set();
-  for (const e of events) {
-    if (e.actor) actorSet.add(e.actor);
-  }
-  const intentMap = /* @__PURE__ */ new Map();
-  for (const e of events) {
-    const entry = intentMap.get(e.intent) ?? { count: 0, blocked: 0, paused: 0, penalized: 0, rewarded: 0 };
-    entry.count++;
-    if (e.decision === "BLOCK") entry.blocked++;
-    if (e.decision === "PAUSE") entry.paused++;
-    if (e.decision === "PENALIZE") entry.penalized++;
-    if (e.decision === "REWARD") entry.rewarded++;
-    intentMap.set(e.intent, entry);
-  }
-  const topIntents = [...intentMap.entries()].map(([intent, data]) => ({ intent, ...data })).sort((a, b) => b.count - a.count);
-  const ruleMap = /* @__PURE__ */ new Map();
-  for (const e of events) {
-    if (e.ruleId) {
-      ruleMap.set(e.ruleId, (ruleMap.get(e.ruleId) ?? 0) + 1);
-    }
-    for (const g of e.guardsMatched) {
-      ruleMap.set(g, (ruleMap.get(g) ?? 0) + 1);
-    }
-  }
-  const topRules = [...ruleMap.entries()].map(([ruleId, count]) => ({ ruleId, count })).sort((a, b) => b.count - a.count);
-  const redirected = blocked + paused + modified + penalized;
-  const total = events.length;
-  return {
-    totalActions: total,
-    allowed,
-    blocked,
-    paused,
-    modified,
-    penalized,
-    rewarded,
-    neutral,
-    actors: [...actorSet],
-    topIntents,
-    topRules,
-    firstEvent: events[0]?.timestamp ?? "",
-    lastEvent: events[events.length - 1]?.timestamp ?? "",
-    behavioralEconomy: {
-      totalPenalties: penalized,
-      totalRewards: rewarded,
-      netPressure: rewarded - penalized,
-      redirectionRate: total > 0 ? redirected / total : 0
-    }
-  };
-}
-
-export {
-  FileAuditLogger,
-  ConsoleAuditLogger,
-  CompositeAuditLogger,
-  verdictToAuditEvent,
-  createGovernanceEngine,
-  readAuditLog,
-  summarizeAuditEvents
-};

package/dist/chunk-T5EUJQE5.js

@@ -1,172 +0,0 @@
-// src/adapters/autoresearch.ts
-var AutoresearchGovernor = class {
-  config;
-  state;
-  constructor(config) {
-    this.config = config;
-    this.state = {
-      experiments_run: 0,
-      best_result: null,
-      architectures_tested: [],
-      experiment_log: [],
-      total_compute_minutes: 0,
-      keep_count: 0
-    };
-  }
-  /**
-   * Convert an experiment proposal into a GuardEvent for governance evaluation.
-   */
-  proposalToGuardEvent(proposal) {
-    return {
-      intent: `run experiment: ${proposal.description}`,
-      tool: "experiment_runner",
-      scope: "experiment",
-      roleId: "experiment_runner",
-      direction: "output",
-      actionCategory: "shell",
-      args: {
-        experiment_id: String(proposal.experiment_id),
-        architecture: proposal.architecture,
-        estimated_minutes: String(proposal.estimated_minutes || 5)
-      }
-    };
-  }
-  /**
-   * Evaluate an experiment proposal against governance rules.
-   * Returns a simplified verdict without requiring the full guard engine.
-   */
-  evaluateProposal(proposal) {
-    const warnings = [];
-    const estimatedMinutes = proposal.estimated_minutes || 5;
-    if (this.state.total_compute_minutes + estimatedMinutes > this.config.computeBudgetMinutes) {
-      return {
-        allowed: false,
-        reason: `Compute budget exhausted: ${this.state.total_compute_minutes}/${this.config.computeBudgetMinutes} minutes used`,
-        warnings
-      };
-    }
-    if (this.config.constraints) {
-      for (const constraint of this.config.constraints) {
-        const lower = constraint.toLowerCase();
-        const archLower = proposal.architecture.toLowerCase();
-        const descLower = proposal.description.toLowerCase();
-        if (lower.startsWith("no ")) {
-          const forbidden = lower.slice(3).trim();
-          if (archLower.includes(forbidden) || descLower.includes(forbidden)) {
-            return {
-              allowed: false,
-              reason: `Architecture constraint violated: ${constraint}`,
-              warnings
-            };
-          }
-        }
-      }
-    }
-    const failureCount = this.state.experiment_log.filter((e) => !e.success).length;
-    if (failureCount > 5) {
-      warnings.push(`High failure rate: ${failureCount} failed experiments. Consider investigating root cause.`);
-    }
-    const recentArchitectures = this.state.experiment_log.slice(-5).map((e) => e.architecture);
-    const uniqueRecent = new Set(recentArchitectures).size;
-    if (recentArchitectures.length >= 5 && uniqueRecent === 1) {
-      warnings.push("Research may be stuck: last 5 experiments used the same architecture.");
-    }
-    return { allowed: true, reason: "Experiment approved", warnings };
-  }
-  /**
-   * Record an experiment result and update research state.
-   */
-  recordResult(result) {
-    this.state.experiments_run++;
-    this.state.total_compute_minutes += result.wall_clock_minutes;
-    this.state.experiment_log.push(result);
-    if (!this.state.architectures_tested.includes(result.architecture)) {
-      this.state.architectures_tested.push(result.architecture);
-    }
-    if (!result.success) {
-      return { kept: false, improvement: null, state: { ...this.state } };
-    }
-    let kept = false;
-    let improvement = null;
-    if (this.state.best_result === null) {
-      kept = true;
-      this.state.best_result = result;
-      this.state.keep_count++;
-    } else {
-      const prev = this.state.best_result.metric_value;
-      const curr = result.metric_value;
-      if (this.config.optimize === "minimize") {
-        kept = curr < prev;
-        improvement = kept ? prev - curr : null;
-      } else {
-        kept = curr > prev;
-        improvement = kept ? curr - prev : null;
-      }
-      if (kept) {
-        this.state.best_result = result;
-        this.state.keep_count++;
-      }
-    }
-    return { kept, improvement, state: { ...this.state } };
-  }
-  /**
-   * Export current state as a state snapshot compatible with the world file.
-   */
-  toWorldState() {
-    const successfulExperiments = this.state.experiment_log.filter((e) => e.success);
-    const failedCount = this.state.experiment_log.filter((e) => !e.success).length;
-    const keepRate = this.state.experiments_run > 0 ? Math.round(this.state.keep_count / this.state.experiments_run * 100) : 0;
-    let improvementRate = 0;
-    if (successfulExperiments.length >= 2) {
-      const recent = successfulExperiments.slice(-10);
-      let improvements = 0;
-      for (let i = 1; i < recent.length; i++) {
-        const prev = recent[i - 1].metric_value;
-        const curr = recent[i].metric_value;
-        if (this.config.optimize === "minimize" ? curr < prev : curr > prev) {
-          improvements++;
-        }
-      }
-      improvementRate = Math.round(improvements / (recent.length - 1) * 100);
-    }
-    return {
-      experiments_run: this.state.experiments_run,
-      best_metric_value: this.state.best_result?.metric_value ?? (this.config.optimize === "minimize" ? 100 : -1e3),
-      keep_rate: keepRate,
-      compute_used_minutes: Math.round(this.state.total_compute_minutes),
-      compute_budget_minutes: this.config.computeBudgetMinutes,
-      failed_experiments: failedCount,
-      metric_improvement_rate: improvementRate,
-      research_context_drift: 0
-      // would need NLP to compute properly
-    };
-  }
-  /**
-   * Get a summary of the current research state.
-   */
-  getSummary() {
-    return {
-      experiments_run: this.state.experiments_run,
-      best_result: this.state.best_result,
-      keep_rate: this.state.experiments_run > 0 ? Math.round(this.state.keep_count / this.state.experiments_run * 100) : 0,
-      compute_remaining_minutes: this.config.computeBudgetMinutes - this.state.total_compute_minutes,
-      architectures_tested: [...this.state.architectures_tested]
-    };
-  }
-  /**
-   * Load state from a persisted research context file.
-   */
-  loadState(state) {
-    this.state = { ...state };
-  }
-  /**
-   * Export state for persistence.
-   */
-  exportState() {
-    return { ...this.state };
-  }
-};
-
-export {
-  AutoresearchGovernor
-};