@neuroverseos/governance 0.3.1 → 0.3.3

package/dist/chunk-QXBFT7NI.js

@@ -0,0 +1,201 @@
+import {
+  evaluateGuard
+} from "./chunk-W7LLXRGY.js";
+import {
+  loadWorldFromDirectory
+} from "./chunk-CTZHONLA.js";
+
+// src/adapters/autoresearch.ts
+var AutoresearchGovernor = class {
+  config;
+  state;
+  world;
+  engineOptions;
+  constructor(config) {
+    this.config = config;
+    this.world = config.world;
+    this.engineOptions = { trace: true };
+    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.
+   * Routes through the guard engine when a world is loaded,
+   * then layers on research-specific checks (budget, constraints, drift).
+   */
+  evaluateProposal(proposal) {
+    const warnings = [];
+    const event = this.proposalToGuardEvent(proposal);
+    if (this.world) {
+      const verdict = evaluateGuard(event, this.world, this.engineOptions);
+      if (verdict.status === "BLOCK" || verdict.status === "PAUSE") {
+        return {
+          allowed: false,
+          reason: verdict.reason ?? `Governance ${verdict.status}: ${verdict.ruleId ?? "unknown rule"}`,
+          warnings,
+          verdict
+        };
+      }
+    }
+    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 };
+  }
+};
+async function createAutoresearchGovernor(worldPath, config) {
+  const world = await loadWorldFromDirectory(worldPath);
+  return new AutoresearchGovernor({ ...config, world, worldPath });
+}
+
+export {
+  AutoresearchGovernor,
+  createAutoresearchGovernor
+};

package/dist/chunk-TG6SEF24.js

@@ -0,0 +1,246 @@
+import {
+  readAuditLog
+} from "./chunk-A7GKPPU7.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 modified = events.filter((e) => e.decision === "MODIFY");
+  const penalized = events.filter((e) => e.decision === "PENALIZE");
+  const rewarded = events.filter((e) => e.decision === "REWARD");
+  const neutralEvents = events.filter((e) => e.decision === "NEUTRAL");
+  const prevented = [...blocked, ...paused, ...modified, ...penalized];
+  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);
+  const allowedCount = events.filter((e) => e.decision === "ALLOW").length;
+  const redirected = events.length - allowedCount - neutralEvents.length;
+  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: allowedCount,
+    totalModified: modified.length,
+    totalPenalized: penalized.length,
+    totalRewarded: rewarded.length,
+    totalNeutral: neutralEvents.length,
+    preventionRate: events.length > 0 ? prevented.length / events.length : 0,
+    redirectionRate: events.length > 0 ? redirected / events.length : 0,
+    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(`  Modified:            ${report.totalModified}`);
+  lines.push(`  Paused:              ${report.totalPaused}`);
+  lines.push(`  Penalized:           ${report.totalPenalized}`);
+  lines.push(`  Rewarded:            ${report.totalRewarded}`);
+  lines.push(`  Neutral:             ${report.totalNeutral}`);
+  lines.push(`  Prevention rate:     ${(report.preventionRate * 100).toFixed(1)}%`);
+  lines.push(`  Redirection rate:    ${(report.redirectionRate * 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,
+    totalModified: 0,
+    totalPenalized: 0,
+    totalRewarded: 0,
+    totalNeutral: 0,
+    preventionRate: 0,
+    redirectionRate: 0,
+    preventedByCategory: [],
+    topPreventedIntents: [],
+    hotActors: [],
+    mostActiveRules: [],
+    hourlyDistribution: [],
+    repeatViolations: []
+  };
+}
+
+export {
+  generateImpactReport,
+  renderImpactReport,
+  generateImpactReportFromFile
+};

package/dist/chunk-U6U7EJZL.js

@@ -0,0 +1,177 @@
+import {
+  evaluateGuard
+} from "./chunk-W7LLXRGY.js";
+import {
+  loadWorld
+} from "./chunk-CTZHONLA.js";
+
+// src/runtime/govern.ts
+function actionToGuardEvent(action) {
+  return {
+    intent: action.description,
+    tool: action.type,
+    roleId: action.agentId,
+    riskLevel: magnitudeToRisk(action.magnitude),
+    args: action.context
+  };
+}
+function magnitudeToRisk(magnitude) {
+  if (magnitude === void 0) return void 0;
+  if (magnitude < 0.25) return "low";
+  if (magnitude < 0.5) return "medium";
+  if (magnitude < 0.75) return "high";
+  return "critical";
+}
+function govern(action, world, options) {
+  const event = actionToGuardEvent(action);
+  return evaluateGuard(event, world, options);
+}
+async function createGovernor(config) {
+  const worldPath = config.worldPath;
+  if (!worldPath) {
+    throw new Error("Governor requires a worldPath");
+  }
+  const options = {
+    trace: config.trace,
+    level: config.level
+  };
+  let world = await loadWorld(worldPath);
+  return {
+    evaluate(action) {
+      return govern(action, world, options);
+    },
+    async reload() {
+      world = await loadWorld(worldPath);
+    },
+    get world() {
+      return world;
+    }
+  };
+}
+async function writeTempWorld(dir, policyLines) {
+  const { writeFile, mkdir } = await import("fs/promises");
+  const { join } = await import("path");
+  await mkdir(dir, { recursive: true });
+  const worldJson = {
+    world_id: "demo-live",
+    name: "Live Demo World",
+    thesis: "Interactive governance demo",
+    version: "0.1.0",
+    runtime_mode: "COMPLIANCE",
+    default_assumption_profile: "baseline",
+    default_alternative_profile: "baseline",
+    modules: [],
+    players: { thinking_space: false, experience_space: false, action_space: true }
+  };
+  const forbiddenPatterns = policyLines.filter((line) => line.trim().length > 0).map((line, i) => ({
+    id: `demo-rule-${i + 1}`,
+    pattern: line.trim(),
+    reason: line.trim(),
+    action: "BLOCK"
+  }));
+  const kernelJson = {
+    artifact_type: "kernel",
+    kernel_id: "demo-kernel",
+    version: "0.1.0",
+    domain: "demo",
+    enforcement_level: "standard",
+    input_boundaries: { forbidden_patterns: forbiddenPatterns },
+    output_boundaries: { forbidden_patterns: [] },
+    response_vocabulary: {},
+    metadata: {
+      compiled_by: "neuroverse-demo",
+      compiled_at: (/* @__PURE__ */ new Date()).toISOString(),
+      source_hash: "live-edit",
+      compiler_version: "0.2.2"
+    }
+  };
+  const metadataJson = {
+    format_version: "1.0.0",
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    last_modified: (/* @__PURE__ */ new Date()).toISOString(),
+    authoring_method: "manual-authoring"
+  };
+  await Promise.all([
+    writeFile(join(dir, "world.json"), JSON.stringify(worldJson, null, 2)),
+    writeFile(join(dir, "kernel.json"), JSON.stringify(kernelJson, null, 2)),
+    writeFile(join(dir, "metadata.json"), JSON.stringify(metadataJson, null, 2))
+  ]);
+}
+
+// src/engine/api.ts
+function handleHealthCheck() {
+  return {
+    status: "ok",
+    engine: "@neuroverseos/governance",
+    version: "0.2.2",
+    capabilities: [
+      "guard",
+      "simulate",
+      "validate",
+      "bootstrap",
+      "decision-flow",
+      "impact-report",
+      "behavioral-analysis"
+    ]
+  };
+}
+async function handleListPresets(policiesDir) {
+  const { readdir, readFile } = await import("fs/promises");
+  const { join } = await import("path");
+  const dir = policiesDir ?? join(process.cwd(), "policies");
+  const presets = [];
+  try {
+    const files = await readdir(dir);
+    for (const file of files.filter((f) => f.endsWith(".txt")).sort()) {
+      const content = await readFile(join(dir, file), "utf-8");
+      const id = file.replace(".txt", "");
+      const name = id.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+      const firstLine = content.split("\n").find((l) => l.trim().length > 0) ?? "";
+      presets.push({ id, name, description: firstLine, rules: content });
+    }
+  } catch {
+  }
+  return { presets };
+}
+async function handleReasonRequest(body) {
+  const intent = body.intent ?? body.scenario;
+  if (!intent) {
+    return { status: "error", error: "intent or scenario is required" };
+  }
+  const event = {
+    intent,
+    tool: body.tool,
+    roleId: body.roleId
+  };
+  if (body.worldPath) {
+    try {
+      const world = await loadWorld(body.worldPath);
+      const verdict = evaluateGuard(event, world);
+      return { status: "ok", verdict };
+    } catch (err) {
+      return { status: "error", error: `Failed to load world: ${err}` };
+    }
+  }
+  return { status: "error", error: "worldPath is required" };
+}
+function handleCreateCapsule(body) {
+  const capsuleId = `cap_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+  return {
+    capsuleId,
+    scenario: body.scenario ?? "Untitled scenario",
+    rules: body.rules ?? [],
+    events: body.events ?? [],
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+export {
+  actionToGuardEvent,
+  govern,
+  createGovernor,
+  writeTempWorld,
+  handleHealthCheck,
+  handleListPresets,
+  handleReasonRequest,
+  handleCreateCapsule
+};