@askexenow/exe-os 0.9.288 → 0.9.290

package/dist/chunk-QODXLGH2.js

@@ -0,0 +1,70 @@
+import {
+  loadEmployees
+} from "./chunk-3X2ZT5FN.js";
+
+// src/lib/agent-symlinks.ts
+import os from "os";
+import path from "path";
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readlinkSync,
+  symlinkSync
+} from "fs";
+function claudeAgentsDir(homeDir) {
+  return path.join(homeDir, ".claude", "agents");
+}
+function identitySourcePath(homeDir, agentId) {
+  return path.join(homeDir, ".exe-os", "identity", `${agentId}.md`);
+}
+function claudeAgentLinkPath(homeDir, agentId) {
+  return path.join(claudeAgentsDir(homeDir), `${agentId}.md`);
+}
+function ensureAgentSymlink(agentId, homeDir = os.homedir()) {
+  const target = identitySourcePath(homeDir, agentId);
+  const link = claudeAgentLinkPath(homeDir, agentId);
+  mkdirSync(claudeAgentsDir(homeDir), { recursive: true });
+  if (existsSync(link)) {
+    let stat;
+    try {
+      stat = lstatSync(link);
+    } catch {
+      return { agentId, action: "conflict", target, link, conflict: "stat_failed" };
+    }
+    if (!stat.isSymbolicLink()) {
+      return { agentId, action: "conflict", target, link, conflict: "regular_file" };
+    }
+    let currentTarget;
+    try {
+      currentTarget = readlinkSync(link);
+    } catch {
+      return { agentId, action: "conflict", target, link, conflict: "readlink_failed" };
+    }
+    if (currentTarget === target) {
+      return { agentId, action: "already_correct", target, link };
+    }
+    return { agentId, action: "conflict", target, link, conflict: `points_to:${currentTarget}` };
+  }
+  try {
+    symlinkSync(target, link);
+  } catch (err) {
+    return {
+      agentId,
+      action: "conflict",
+      target,
+      link,
+      conflict: err instanceof Error ? err.message : String(err)
+    };
+  }
+  return { agentId, action: "created", target, link };
+}
+async function ensureAllAgentSymlinks(homeDir = os.homedir()) {
+  const employees = await loadEmployees();
+  return employees.map((emp) => ensureAgentSymlink(emp.name, homeDir));
+}
+
+export {
+  ensureAgentSymlink,
+  ensureAllAgentSymlinks
+};

package/dist/chunk-RAV356E6.js

@@ -0,0 +1,30 @@
+import {
+  createReminder
+} from "./chunk-TMCKL43Q.js";
+
+// src/mcp/tools/create-reminder.ts
+import { z } from "zod";
+function registerCreateReminder(server) {
+  server.registerTool(
+    "create_reminder",
+    {
+      title: "Create Reminder",
+      description: "Set a reminder for the founder. Shown in the boot brief every session.",
+      inputSchema: {
+        text: z.string().describe("What to remind about"),
+        due_date: z.string().optional().describe("Optional due date \u2014 ISO date (2026-04-01) or null for persistent")
+      }
+    },
+    async ({ text, due_date }) => {
+      const reminder = await createReminder(text, due_date);
+      const dueStr = reminder.dueDate ? ` (due: ${reminder.dueDate})` : "";
+      return {
+        content: [{ type: "text", text: `Reminder set: "${reminder.text}"${dueStr}` }]
+      };
+    }
+  );
+}
+
+export {
+  registerCreateReminder
+};

package/dist/chunk-RHC57KVT.js

@@ -0,0 +1,85 @@
+import {
+  deactivateBehavior
+} from "./chunk-HLFNLJSB.js";
+import {
+  getActiveAgent
+} from "./chunk-HJQQ7746.js";
+import {
+  canCoordinate,
+  getClient
+} from "./chunk-3X2ZT5FN.js";
+
+// src/mcp/tools/deactivate-behavior.ts
+import { z } from "zod";
+function registerDeactivateBehavior(server) {
+  server.registerTool(
+    "deactivate_behavior",
+    {
+      title: "Deactivate Behavior",
+      description: "Soft-delete a behavior by setting active = 0. RESTRICTED: only coordinator or founder sessions can use this. Use list_behaviors to find the behavior ID first.",
+      inputSchema: {
+        behavior_id: z.string().describe("UUID of the behavior to deactivate")
+      }
+    },
+    async ({ behavior_id }) => {
+      const caller = getActiveAgent();
+      try {
+        const { StewardGate } = await import("./steward-gate-KC4NOULU.js");
+        const steward = new StewardGate();
+        const gateDecision = await steward.checkAuthority(caller.agentId || "unknown", "deactivate_behavior", behavior_id);
+        if (!gateDecision.allowed) {
+          return { content: [{ type: "text", text: `Steward gate denied: ${gateDecision.reason}` }], isError: true };
+        }
+      } catch {
+      }
+      const allowed = canCoordinate(caller.agentId, caller.agentRole);
+      if (!allowed) {
+        return {
+          content: [{
+            type: "text",
+            text: `Permission denied. Only the coordinator or founder sessions can deactivate behaviors. You are "${caller.agentId}".`
+          }],
+          isError: true
+        };
+      }
+      const client = getClient();
+      const result = await client.execute({
+        sql: `SELECT id, agent_id, content, domain, priority FROM behaviors WHERE id = ?`,
+        args: [behavior_id]
+      });
+      if (result.rows.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: `Behavior not found: ${behavior_id}`
+          }],
+          isError: true
+        };
+      }
+      const row = result.rows[0];
+      const wasActive = await deactivateBehavior(behavior_id);
+      if (!wasActive) {
+        return {
+          content: [{
+            type: "text",
+            text: `Behavior ${behavior_id} was already inactive.`
+          }]
+        };
+      }
+      return {
+        content: [{
+          type: "text",
+          text: `Deactivated behavior for ${row.agent_id}.
+ID: ${row.id}
+Domain: ${row.domain ?? "none"}
+Priority: ${row.priority}
+Content: ${row.content}`
+        }]
+      };
+    }
+  );
+}
+
+export {
+  registerDeactivateBehavior
+};

package/dist/chunk-RHE7SHZJ.js

@@ -0,0 +1,345 @@
+import {
+  employeeSessionName,
+  isEmployeeAlive,
+  resolveExeSession,
+  sendIntercom,
+  strictSessionScopeFilter
+} from "./chunk-F23GFLKY.js";
+import {
+  parseMessage,
+  serializeMessage
+} from "./chunk-4JERP7NT.js";
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-CMDKYYFK.js";
+import {
+  getClient
+} from "./chunk-3X2ZT5FN.js";
+
+// src/lib/messaging.ts
+import crypto from "crypto";
+function generateUlid() {
+  const timestamp = Date.now().toString(36).padStart(10, "0");
+  const random = crypto.randomBytes(10).toString("hex").slice(0, 16);
+  return (timestamp + random).toUpperCase();
+}
+function rowToMessage(row) {
+  return {
+    id: row.id,
+    fromAgent: row.from_agent,
+    fromDevice: row.from_device,
+    targetAgent: row.target_agent,
+    targetProject: row.target_project ?? null,
+    targetDevice: row.target_device,
+    sessionScope: row.session_scope ?? null,
+    content: row.content,
+    priority: row.priority ?? "normal",
+    status: row.status ?? "pending",
+    serverSeq: row.server_seq != null ? Number(row.server_seq) : null,
+    retryCount: Number(row.retry_count ?? 0),
+    createdAt: row.created_at,
+    deliveredAt: row.delivered_at ?? null,
+    processedAt: row.processed_at ?? null,
+    failedAt: row.failed_at ?? null,
+    failureReason: row.failure_reason ?? null
+  };
+}
+var MAX_RETRIES = 10;
+async function countUnreadMessages(targetAgent, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT COUNT(*) AS count FROM messages
+          WHERE target_agent = ? AND status IN ('pending', 'delivered')${scope.sql}`,
+    args: [targetAgent, ...scope.args]
+  });
+  return Number(result.rows[0]?.count ?? 0);
+}
+async function sendMessage(input) {
+  const client = getClient();
+  const id = generateUlid();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const targetDevice = input.targetDevice ?? "local";
+  const sessionScope = input.sessionScope === void 0 ? resolveExeSession() : input.sessionScope;
+  await client.execute({
+    sql: `INSERT INTO messages (id, from_agent, from_device, target_agent, target_project, target_device, session_scope, content, priority, status, founder_id, created_at)
+          VALUES (?, ?, 'local', ?, ?, ?, ?, ?, ?, 'pending', ?, ?)`,
+    args: [
+      id,
+      input.fromAgent,
+      input.targetAgent,
+      input.targetProject ?? null,
+      targetDevice,
+      sessionScope,
+      input.content,
+      input.priority ?? "normal",
+      input.founderId ?? null,
+      now
+    ]
+  });
+  recordOrchestrationEventBestEffort({
+    eventType: "message.sent",
+    source: "messaging.sendMessage",
+    agentId: input.fromAgent,
+    payload: { targetAgent: input.targetAgent, priority: input.priority ?? "normal", targetDevice },
+    sessionScope: sessionScope ?? null
+  });
+  try {
+    if (targetDevice !== "local") {
+      await deliverCrossMachineMessage(id, targetDevice);
+    } else {
+      await deliverLocalMessage(id);
+    }
+  } catch {
+  }
+  const sentScope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages WHERE id = ?${sentScope.sql}`,
+    args: [id, ...sentScope.args]
+  });
+  return rowToMessage(result.rows[0]);
+}
+var _wsClientSend = null;
+function setWsClientSend(fn) {
+  _wsClientSend = fn;
+}
+async function deliverCrossMachineMessage(messageId, targetDevice) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT * FROM messages WHERE id = ?",
+    args: [messageId]
+  });
+  if (result.rows.length === 0) return false;
+  const msg = rowToMessage(result.rows[0]);
+  if (msg.status !== "pending") return false;
+  if (!_wsClientSend) {
+    return false;
+  }
+  const payload = JSON.stringify({
+    id: msg.id,
+    fromAgent: msg.fromAgent,
+    targetAgent: msg.targetAgent,
+    targetProject: msg.targetProject,
+    sessionScope: msg.sessionScope,
+    content: msg.content,
+    priority: msg.priority,
+    createdAt: msg.createdAt
+  });
+  const sent = _wsClientSend(targetDevice, payload);
+  if (sent) {
+    await client.execute({
+      sql: "UPDATE messages SET status = 'synced' WHERE id = ?",
+      args: [messageId]
+    });
+    return true;
+  }
+  return false;
+}
+async function deliverLocalMessage(messageId) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT * FROM messages WHERE id = ?",
+    args: [messageId]
+  });
+  if (result.rows.length === 0) return false;
+  const msg = rowToMessage(result.rows[0]);
+  if (msg.status !== "pending") return false;
+  const targetAgent = msg.targetAgent;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const exeSession = resolveExeSession();
+    if (!exeSession) {
+      throw new Error("No coordinator session found");
+    }
+    process.stderr.write(`[messaging] ENTER deliverLocal: target=${targetAgent} exeSession=${exeSession}
+`);
+    const { isCoordinatorName: isCoord } = await import("./lib/employees.js");
+    const isCOO = isCoord(targetAgent);
+    process.stderr.write(`[messaging] COO check: targetAgent="${targetAgent}" isCOO=${isCOO}
+`);
+    const sessionName = isCOO ? exeSession : employeeSessionName(targetAgent, exeSession);
+    process.stderr.write(`[messaging] delivery attempt: target=${targetAgent} session=${sessionName} isCOO=${isCOO}
+`);
+    if (!isCOO && !isEmployeeAlive(sessionName)) {
+      throw new Error("Session not running \u2014 message stays queued");
+    }
+    const unreadCount = await countUnreadMessages(targetAgent, msg.sessionScope);
+    if (unreadCount <= 0) {
+      return false;
+    }
+    const intercomResult = sendIntercom(sessionName, { force: true, reason: "message" });
+    process.stderr.write(`[messaging] intercom result for ${sessionName}: ${intercomResult}
+`);
+    await client.execute({
+      sql: "UPDATE messages SET status = 'delivered', delivered_at = ? WHERE id = ?",
+      args: [now, messageId]
+    });
+    recordOrchestrationEventBestEffort({
+      eventType: "message.delivered",
+      source: "messaging.deliverLocalMessage",
+      agentId: msg.targetAgent,
+      payload: { fromAgent: msg.fromAgent, priority: msg.priority }
+    });
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[messaging] delivery failed for message ${messageId}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    const newRetryCount = msg.retryCount + 1;
+    if (newRetryCount >= MAX_RETRIES) {
+      await markFailed(messageId, "session unavailable after 10 retries", msg.sessionScope);
+    } else {
+      await client.execute({
+        sql: "UPDATE messages SET retry_count = ? WHERE id = ?",
+        args: [newRetryCount, messageId]
+      });
+    }
+    return false;
+  }
+}
+async function getPendingMessages(targetAgent, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages
+          WHERE target_agent = ? AND status IN ('pending', 'delivered')${scope.sql}
+          ORDER BY id`,
+    args: [targetAgent, ...scope.args]
+  });
+  return result.rows.map((row) => rowToMessage(row));
+}
+async function markRead(messageId, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  await client.execute({
+    sql: `UPDATE messages SET status = 'read'
+          WHERE id = ? AND status IN ('pending', 'delivered')${scope.sql}`,
+    args: [messageId, ...scope.args]
+  });
+  recordOrchestrationEventBestEffort({
+    eventType: "message.read",
+    source: "messaging.markRead",
+    payload: { messageId }
+  });
+}
+async function markAcknowledged(messageId, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  await client.execute({
+    sql: `UPDATE messages SET status = 'acknowledged', processed_at = ?
+          WHERE id = ? AND status = 'read'${scope.sql}`,
+    args: [(/* @__PURE__ */ new Date()).toISOString(), messageId, ...scope.args]
+  });
+}
+async function markProcessed(messageId, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  await client.execute({
+    sql: `UPDATE messages SET status = 'processed', processed_at = ?
+          WHERE id = ?${scope.sql}`,
+    args: [(/* @__PURE__ */ new Date()).toISOString(), messageId, ...scope.args]
+  });
+}
+async function getMessageStatus(messageId, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT status FROM messages WHERE id = ?${scope.sql}`,
+    args: [messageId, ...scope.args]
+  });
+  return result.rows[0]?.status ?? null;
+}
+async function getUnacknowledgedMessages(targetAgent, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages
+          WHERE target_agent = ? AND status IN ('pending', 'delivered', 'read')${scope.sql}
+          ORDER BY id`,
+    args: [targetAgent, ...scope.args]
+  });
+  return result.rows.map((row) => rowToMessage(row));
+}
+async function getReadMessages(targetAgent, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages
+          WHERE target_agent = ? AND status = 'read'${scope.sql}
+          ORDER BY id`,
+    args: [targetAgent, ...scope.args]
+  });
+  return result.rows.map((row) => rowToMessage(row));
+}
+async function markFailed(messageId, reason, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  await client.execute({
+    sql: `UPDATE messages SET status = 'failed', failed_at = ?, failure_reason = ?
+          WHERE id = ?${scope.sql}`,
+    args: [(/* @__PURE__ */ new Date()).toISOString(), reason, messageId, ...scope.args]
+  });
+}
+async function getFailedMessages(sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages WHERE status = 'failed'${scope.sql} ORDER BY created_at DESC`,
+    args: [...scope.args]
+  });
+  return result.rows.map((row) => rowToMessage(row));
+}
+async function retryPendingMessages(sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages
+          WHERE status = 'pending' AND retry_count < ?${scope.sql}
+          ORDER BY id`,
+    args: [MAX_RETRIES, ...scope.args]
+  });
+  let delivered = 0;
+  for (const row of result.rows) {
+    const msg = rowToMessage(row);
+    try {
+      const success = await deliverLocalMessage(msg.id);
+      if (success) delivered++;
+    } catch {
+    }
+  }
+  return delivered;
+}
+async function sendTypedMessage(envelope, targetAgent, opts) {
+  return sendMessage({
+    fromAgent: envelope.from,
+    targetAgent,
+    targetProject: opts?.targetProject,
+    targetDevice: opts?.targetDevice,
+    content: serializeMessage(envelope),
+    priority: opts?.priority,
+    sessionScope: opts?.sessionScope
+  });
+}
+function parseIncomingMessage(content) {
+  return parseMessage(content);
+}
+
+export {
+  countUnreadMessages,
+  sendMessage,
+  setWsClientSend,
+  deliverLocalMessage,
+  getPendingMessages,
+  markRead,
+  markAcknowledged,
+  markProcessed,
+  getMessageStatus,
+  getUnacknowledgedMessages,
+  getReadMessages,
+  markFailed,
+  getFailedMessages,
+  retryPendingMessages,
+  sendTypedMessage,
+  parseIncomingMessage
+};

package/dist/chunk-RJY45A5J.js

@@ -0,0 +1,133 @@
+import {
+  DEFAULT_RUNTIME,
+  RUNTIME_TABLE
+} from "./chunk-NGP6LSV2.js";
+import {
+  EXE_AI_DIR
+} from "./chunk-5P3HOBZX.js";
+import {
+  atomicWriteJsonSync,
+  ensurePrivateDirSync
+} from "./chunk-LYH5HE24.js";
+
+// src/lib/agent-config.ts
+import { readFileSync, existsSync } from "fs";
+import path from "path";
+var AGENT_CONFIG_PATH = path.join(EXE_AI_DIR, "agent-config.json");
+var KNOWN_RUNTIMES = {
+  claude: ["claude-opus-4.8", "claude-opus-4.8-1m", "claude-opus-4.6", "claude-opus-4", "claude-sonnet-4.8", "claude-sonnet-4.6", "claude-sonnet-4", "claude-haiku-4.5", "claude-fable-5"],
+  codex: ["gpt-5.4", "gpt-5.5", "gpt-5.3-codex-spark", "o3", "o4-mini"],
+  opencode: ["anthropic/claude-opus-4-8", "anthropic/claude-sonnet-4-8", "anthropic/claude-sonnet-4-6", "openai/gpt-5.4", "google/gemini-2.5-pro", "deepseek/deepseek-r3", "minimax/minimax-m2.5"]
+};
+var MODEL_ALIASES = {
+  claude: {
+    fable: "claude-fable-5"
+  }
+};
+var RUNTIME_LABELS = {
+  claude: "Claude Code (Anthropic)",
+  codex: "Codex (OpenAI)",
+  opencode: "OpenCode (open source)"
+};
+var DEFAULT_MODELS = {
+  claude: "claude-opus-4.6",
+  codex: RUNTIME_TABLE.codex?.defaultModel ?? "gpt-5.4",
+  opencode: RUNTIME_TABLE.opencode?.defaultModel ?? "anthropic/claude-sonnet-4-6"
+};
+function loadAgentConfig() {
+  if (!existsSync(AGENT_CONFIG_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync(AGENT_CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveAgentConfig(config) {
+  const dir = path.dirname(AGENT_CONFIG_PATH);
+  ensurePrivateDirSync(dir);
+  atomicWriteJsonSync(AGENT_CONFIG_PATH, config);
+}
+function getAgentRuntime(agentId) {
+  const config = loadAgentConfig();
+  const entry = config[agentId];
+  if (entry) return entry;
+  const orgDefault = config["default"];
+  if (orgDefault) return orgDefault;
+  return { runtime: DEFAULT_RUNTIME, model: DEFAULT_MODELS[DEFAULT_RUNTIME] };
+}
+function normalizeCcModelName(model) {
+  let ccModel = model.replace(/(\d+)\.(\d+)/g, "$1-$2");
+  const isExplicit1m = /-1m$/.test(ccModel) || ccModel.includes("[1m]");
+  if ((/claude-(opus|sonnet)-4-[6-9]/.test(ccModel) || /claude-fable-\d+/.test(ccModel)) && !isExplicit1m) {
+    ccModel += "[1m]";
+  }
+  return ccModel;
+}
+function normalizeRuntimeModel(runtime, model) {
+  return MODEL_ALIASES[runtime]?.[model] ?? model;
+}
+function validateRuntimeModel(runtime, model) {
+  const knownModels = KNOWN_RUNTIMES[runtime];
+  if (!knownModels) {
+    return {
+      ok: false,
+      error: `Unknown runtime "${runtime}". Valid: ${Object.keys(KNOWN_RUNTIMES).join(", ")}`
+    };
+  }
+  const normalizedModel = normalizeRuntimeModel(runtime, model);
+  if (!knownModels.includes(normalizedModel)) {
+    const aliases = Object.keys(MODEL_ALIASES[runtime] ?? {});
+    const valid = aliases.length > 0 ? `${knownModels.join(", ")} (aliases: ${aliases.join(", ")})` : knownModels.join(", ");
+    return {
+      ok: false,
+      error: `Unknown model "${model}" for runtime "${runtime}". Valid: ${valid}`
+    };
+  }
+  return { ok: true, model: normalizedModel };
+}
+function setAgentRuntime(agentId, runtime, model, reasoning_effort, mcps) {
+  const validated = validateRuntimeModel(runtime, model);
+  if (!validated.ok) return validated;
+  const config = loadAgentConfig();
+  const existing = config[agentId];
+  const entry = { runtime, model: validated.model };
+  if (reasoning_effort) entry.reasoning_effort = reasoning_effort;
+  if (mcps !== void 0) {
+    entry.mcps = mcps.includes("exe-os") ? mcps : ["exe-os", ...mcps];
+  } else if (existing?.mcps) {
+    entry.mcps = existing.mcps;
+  }
+  config[agentId] = entry;
+  saveAgentConfig(config);
+  return { ok: true };
+}
+function setAgentMcps(agentId, mcps) {
+  const config = loadAgentConfig();
+  const existing = config[agentId] ?? getAgentRuntime(agentId);
+  existing.mcps = mcps.includes("exe-os") ? mcps : ["exe-os", ...mcps];
+  config[agentId] = existing;
+  saveAgentConfig(config);
+  return { ok: true };
+}
+function clearAgentRuntime(agentId) {
+  const config = loadAgentConfig();
+  delete config[agentId];
+  saveAgentConfig(config);
+}
+
+export {
+  AGENT_CONFIG_PATH,
+  KNOWN_RUNTIMES,
+  MODEL_ALIASES,
+  RUNTIME_LABELS,
+  DEFAULT_MODELS,
+  loadAgentConfig,
+  saveAgentConfig,
+  getAgentRuntime,
+  normalizeCcModelName,
+  normalizeRuntimeModel,
+  validateRuntimeModel,
+  setAgentRuntime,
+  setAgentMcps,
+  clearAgentRuntime
+};