@neuroverseos/governance 0.3.0 → 0.3.1

package/dist/chunk-PDOZHZWL.js

@@ -1,225 +0,0 @@
-import {
-  readAuditLog
-} from "./chunk-QPASI2BR.js";
-
-// src/engine/impact-report.ts
-function generateImpactReport(events) {
-  if (events.length === 0) {
-    return emptyReport();
-  }
-  const blocked = events.filter((e) => e.decision === "BLOCK");
-  const paused = events.filter((e) => e.decision === "PAUSE");
-  const prevented = [...blocked, ...paused];
-  const categoryMap = /* @__PURE__ */ new Map();
-  for (const e of prevented) {
-    const cat = classifyPreventionCategory(e);
-    if (!categoryMap.has(cat)) categoryMap.set(cat, /* @__PURE__ */ new Set());
-    categoryMap.get(cat).add(e.intent);
-  }
-  const preventedByCategory = [...categoryMap.entries()].map(([category, intents]) => ({
-    category,
-    count: prevented.filter((e) => classifyPreventionCategory(e) === category).length,
-    examples: [...intents].slice(0, 5)
-  })).sort((a, b) => b.count - a.count);
-  const intentMap = /* @__PURE__ */ new Map();
-  for (const e of prevented) {
-    const entry = intentMap.get(e.intent) ?? { count: 0, rules: /* @__PURE__ */ new Map() };
-    entry.count++;
-    if (e.ruleId) {
-      entry.rules.set(e.ruleId, (entry.rules.get(e.ruleId) ?? 0) + 1);
-    }
-    for (const g of e.guardsMatched) {
-      entry.rules.set(g, (entry.rules.get(g) ?? 0) + 1);
-    }
-    intentMap.set(e.intent, entry);
-  }
-  const topPreventedIntents = [...intentMap.entries()].map(([intent, data]) => {
-    let topRule = "";
-    let topCount = 0;
-    for (const [rule, count] of data.rules) {
-      if (count > topCount) {
-        topRule = rule;
-        topCount = count;
-      }
-    }
-    return { intent, count: data.count, topRule };
-  }).sort((a, b) => b.count - a.count).slice(0, 15);
-  const actorMap = /* @__PURE__ */ new Map();
-  for (const e of events) {
-    const actor = e.actor ?? "unknown";
-    const entry = actorMap.get(actor) ?? { blocked: 0, paused: 0, total: 0 };
-    entry.total++;
-    if (e.decision === "BLOCK") entry.blocked++;
-    if (e.decision === "PAUSE") entry.paused++;
-    actorMap.set(actor, entry);
-  }
-  const hotActors = [...actorMap.entries()].filter(([, data]) => data.blocked > 0 || data.paused > 0).map(([actor, data]) => ({ actor, ...data })).sort((a, b) => b.blocked + b.paused - (a.blocked + a.paused)).slice(0, 10);
-  const ruleMap = /* @__PURE__ */ new Map();
-  for (const e of prevented) {
-    const ruleIds = [e.ruleId, ...e.guardsMatched, ...e.rulesMatched].filter(Boolean);
-    for (const rId of new Set(ruleIds)) {
-      const entry = ruleMap.get(rId) ?? { blockCount: 0, pauseCount: 0 };
-      if (e.decision === "BLOCK") entry.blockCount++;
-      if (e.decision === "PAUSE") entry.pauseCount++;
-      ruleMap.set(rId, entry);
-    }
-  }
-  const mostActiveRules = [...ruleMap.entries()].map(([ruleId, data]) => ({ ruleId, ...data })).sort((a, b) => b.blockCount + b.pauseCount - (a.blockCount + a.pauseCount)).slice(0, 10);
-  const hourMap = /* @__PURE__ */ new Map();
-  for (const e of events) {
-    const hour = new Date(e.timestamp).getHours();
-    const entry = hourMap.get(hour) ?? { total: 0, blocked: 0 };
-    entry.total++;
-    if (e.decision === "BLOCK") entry.blocked++;
-    hourMap.set(hour, entry);
-  }
-  const hourlyDistribution = Array.from({ length: 24 }, (_, hour) => ({
-    hour,
-    total: hourMap.get(hour)?.total ?? 0,
-    blocked: hourMap.get(hour)?.blocked ?? 0
-  }));
-  const violationKey = (e) => `${e.actor ?? "unknown"}::${e.intent}`;
-  const violationMap = /* @__PURE__ */ new Map();
-  for (const e of blocked) {
-    const key = violationKey(e);
-    const entry = violationMap.get(key) ?? {
-      intent: e.intent,
-      actor: e.actor ?? "unknown",
-      attempts: 0,
-      firstSeen: e.timestamp,
-      lastSeen: e.timestamp
-    };
-    entry.attempts++;
-    entry.lastSeen = e.timestamp;
-    violationMap.set(key, entry);
-  }
-  const repeatViolations = [...violationMap.values()].filter((v) => v.attempts > 1).sort((a, b) => b.attempts - a.attempts).slice(0, 10);
-  return {
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    periodStart: events[0].timestamp,
-    periodEnd: events[events.length - 1].timestamp,
-    worldName: events[0].worldName ?? "unknown",
-    totalEvaluations: events.length,
-    totalBlocked: blocked.length,
-    totalPaused: paused.length,
-    totalAllowed: events.length - blocked.length - paused.length,
-    preventionRate: prevented.length / events.length,
-    preventedByCategory,
-    topPreventedIntents,
-    hotActors,
-    mostActiveRules,
-    hourlyDistribution,
-    repeatViolations
-  };
-}
-function classifyPreventionCategory(event) {
-  const intent = event.intent.toLowerCase();
-  const rule = (event.ruleId ?? "").toLowerCase();
-  const combined = `${intent} ${rule}`;
-  if (combined.match(/inject|prompt|jailbreak|bypass/)) return "Prompt Injection Prevention";
-  if (combined.match(/scope|escape|traversal|path/)) return "Scope Escape Prevention";
-  if (combined.match(/delete|drop|destroy|remove|purge/)) return "Destructive Action Prevention";
-  if (combined.match(/trade|margin|position|leverage/)) return "Financial Risk Prevention";
-  if (combined.match(/withdraw|transfer|payment|fund/)) return "Unauthorized Transfer Prevention";
-  if (combined.match(/credential|secret|key|password|token/)) return "Credential Access Prevention";
-  if (combined.match(/shell|exec|command|script/)) return "Command Execution Prevention";
-  if (combined.match(/network|http|api|external/)) return "Network Access Prevention";
-  if (combined.match(/write|modify|update|alter/)) return "Unauthorized Modification Prevention";
-  if (combined.match(/approval|review|confirm/)) return "Approval Gate";
-  return "Policy Violation Prevention";
-}
-function renderImpactReport(report) {
-  const lines = [];
-  lines.push("GOVERNANCE IMPACT REPORT");
-  lines.push("\u2550".repeat(50));
-  lines.push("");
-  lines.push(`  World: ${report.worldName}`);
-  lines.push(`  Period: ${report.periodStart.split("T")[0]} \u2192 ${report.periodEnd.split("T")[0]}`);
-  lines.push(`  Generated: ${report.generatedAt}`);
-  lines.push("");
-  lines.push("SUMMARY");
-  lines.push("\u2500".repeat(50));
-  lines.push(`  Total evaluations:   ${report.totalEvaluations}`);
-  lines.push(`  Allowed:             ${report.totalAllowed}`);
-  lines.push(`  Blocked:             ${report.totalBlocked}`);
-  lines.push(`  Paused:              ${report.totalPaused}`);
-  lines.push(`  Prevention rate:     ${(report.preventionRate * 100).toFixed(1)}%`);
-  lines.push("");
-  if (report.totalBlocked > 0 || report.totalPaused > 0) {
-    lines.push("WITHOUT GOVERNANCE");
-    lines.push("\u2500".repeat(50));
-    lines.push(`  ${report.totalBlocked + report.totalPaused} actions would have executed unchecked:`);
-    for (const cat of report.preventedByCategory) {
-      lines.push(`    ${cat.category.padEnd(38)} ${String(cat.count).padStart(5)}`);
-      if (cat.examples.length > 0) {
-        lines.push(`      e.g. ${cat.examples.slice(0, 3).join(", ")}`);
-      }
-    }
-    lines.push("");
-  }
-  if (report.topPreventedIntents.length > 0) {
-    lines.push("TOP PREVENTED ACTIONS");
-    lines.push("\u2500".repeat(50));
-    for (const entry of report.topPreventedIntents.slice(0, 10)) {
-      lines.push(`  ${entry.intent.padEnd(30)} ${String(entry.count).padStart(5)}  (rule: ${entry.topRule || "\u2014"})`);
-    }
-    lines.push("");
-  }
-  if (report.hotActors.length > 0) {
-    lines.push("ACTORS WITH MOST VIOLATIONS");
-    lines.push("\u2500".repeat(50));
-    for (const actor of report.hotActors) {
-      const violations = actor.blocked + actor.paused;
-      const rate = (violations / actor.total * 100).toFixed(0);
-      lines.push(`  ${actor.actor.padEnd(25)} ${String(violations).padStart(5)} violations / ${actor.total} total (${rate}%)`);
-    }
-    lines.push("");
-  }
-  if (report.mostActiveRules.length > 0) {
-    lines.push("MOST ACTIVE RULES");
-    lines.push("\u2500".repeat(50));
-    for (const rule of report.mostActiveRules) {
-      lines.push(`  ${rule.ruleId.padEnd(30)} ${String(rule.blockCount).padStart(5)} blocked  ${String(rule.pauseCount).padStart(5)} paused`);
-    }
-    lines.push("");
-  }
-  if (report.repeatViolations.length > 0) {
-    lines.push("REPEAT VIOLATIONS");
-    lines.push("\u2500".repeat(50));
-    lines.push("  Actions attempted multiple times after being blocked:");
-    for (const v of report.repeatViolations) {
-      lines.push(`  ${v.actor.padEnd(20)} ${v.intent.padEnd(25)} ${v.attempts}x  (${v.firstSeen.split("T")[0]} \u2192 ${v.lastSeen.split("T")[0]})`);
-    }
-    lines.push("");
-  }
-  return lines.join("\n");
-}
-async function generateImpactReportFromFile(logPath) {
-  const events = await readAuditLog(logPath);
-  return generateImpactReport(events);
-}
-function emptyReport() {
-  return {
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    periodStart: "",
-    periodEnd: "",
-    worldName: "unknown",
-    totalEvaluations: 0,
-    totalBlocked: 0,
-    totalPaused: 0,
-    totalAllowed: 0,
-    preventionRate: 0,
-    preventedByCategory: [],
-    topPreventedIntents: [],
-    hotActors: [],
-    mostActiveRules: [],
-    hourlyDistribution: [],
-    repeatViolations: []
-  };
-}
-
-export {
-  generateImpactReport,
-  renderImpactReport,
-  generateImpactReportFromFile
-};

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-QPASI2BR.js

@@ -1,187 +0,0 @@
-import {
-  evaluateGuard
-} from "./chunk-4JRYGIO7.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 icon = event.decision === "ALLOW" ? "\u2713" : event.decision === "BLOCK" ? "\u2717" : "\u23F8";
-    const ts = event.timestamp.split("T")[1]?.replace("Z", "") ?? event.timestamp;
-    process.stderr.write(
-      `[${ts}] ${icon} ${event.decision.padEnd(5)} ${event.actor ?? "\u2014"} \u2192 ${event.intent}${event.reason ? ` (${event.reason})` : ""}
-`
-    );
-  }
-};
-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) {
-  return {
-    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
-  };
-}
-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 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 };
-    entry.count++;
-    if (e.decision === "BLOCK") entry.blocked++;
-    if (e.decision === "PAUSE") entry.paused++;
-    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);
-  return {
-    totalActions: events.length,
-    allowed,
-    blocked,
-    paused,
-    actors: [...actorSet],
-    topIntents,
-    topRules,
-    firstEvent: events[0]?.timestamp ?? "",
-    lastEvent: events[events.length - 1]?.timestamp ?? ""
-  };
-}
-
-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
-};