metheus-governance-mcp-cli 0.2.250 → 0.2.252

package/cli.mjs

@@ -141,6 +141,7 @@ import {
   buildProcessableArchiveLogicalKey,
   findEarlierProcessableArchiveDuplicate,
   findRecentTelegramMessageEnvelope,
+  isTelegramLocalInboundEnvelopeForRoute,
   isInboundArchiveKind,
   normalizeTelegramMessageEnvelope as normalizeRunnerTelegramMessageEnvelope,
   normalizeArchiveCommentRecord,
@@ -2665,14 +2666,17 @@ function buildRunnerSourceMessageEnvelope({
   parsedArchive = null,
 }) {
   const localEnvelope = findRunnerRouteLocalInboundEnvelope(routeState, parsedArchive);
-  if (String(localEnvelope.source_origin || "").trim().toLowerCase() === "local_telegram_inbound") {
-    return localEnvelope;
-  }
   const fallbackBotSelector = normalizeTelegramMentionUsername(
     normalizedRoute?.botName
       || normalizedRoute?.serverBotName
       || "",
   );
+  if (isTelegramLocalInboundEnvelopeForRoute(localEnvelope, {
+    routeKey,
+    botUsername: fallbackBotSelector,
+  })) {
+    return localEnvelope;
+  }
   return buildRunnerTelegramMessageEnvelopeFromParsedArchive(parsedArchive, {
     source_origin: "archive_reconstructed",
     source_route_key: String(routeKey || "").trim(),
@@ -7865,30 +7869,23 @@ function extractTelegramEntityText(text, entity) {
   return body.slice(offset, offset + length);
 }
 
-function extractTelegramMentionUsernames(text, entities) {
-  const set = new Set();
-  for (const entityRaw of ensureArray(entities)) {
-    const entity = safeObject(entityRaw);
+function extractTelegramMentionUsernames(text, entities) {
+  const set = new Set();
+  for (const entityRaw of ensureArray(entities)) {
+    const entity = safeObject(entityRaw);
     const type = String(entity.type || "").trim().toLowerCase();
     if (type === "mention") {
       const username = normalizeTelegramMentionUsername(extractTelegramEntityText(text, entity));
       if (username) set.add(username);
       continue;
     }
-    if (type === "text_mention") {
-      const username = normalizeTelegramMentionUsername(entity.user?.username);
-      if (username) set.add(username);
-    }
-  }
-  const regex = /(^|[^A-Za-z0-9_])@([A-Za-z0-9_]{3,})\b/g;
-  let match = regex.exec(String(text || ""));
-  while (match) {
-    const username = normalizeTelegramMentionUsername(match[2]);
-    if (username) set.add(username);
-    match = regex.exec(String(text || ""));
-  }
-  return Array.from(set);
-}
+    if (type === "text_mention") {
+      const username = normalizeTelegramMentionUsername(entity.user?.username);
+      if (username) set.add(username);
+    }
+  }
+  return Array.from(set);
+}
 
 function normalizeLocalTelegramUpdate(rawUpdate) {
   const update = safeObject(rawUpdate);
@@ -17539,11 +17536,12 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     mergeServerRunnerRequestLedgerIntoLocalState,
     buildRunnerStatusQueryLookup,
     tryJsonParse,
-    safeObject,
-    normalizeRunnerTriggerPolicy,
-    evaluateTelegramRunnerTrigger,
-    resolveRunnerResponderAdjudication,
-    selectPendingArchiveComments,
+    safeObject,
+    normalizeRunnerTriggerPolicy,
+    evaluateTelegramRunnerTrigger,
+    resolveHumanIntentContext,
+    resolveRunnerResponderAdjudication,
+    selectPendingArchiveComments,
     selectRunnerPendingWork,
     processRunnerSelectedRecord,
     resolveRunnerStartupLoopAdjudication,

package/lib/bot-commands.mjs

@@ -2669,7 +2669,7 @@ function suggestedAIModelsForClient(clientName) {
       { value: "Opus 4.6", label: "Opus 4.6", description: "display label; runs as opus" },
     ];
     }
-    if (normalizedClient === "gemini") {
+  if (normalizedClient === "gemini") {
       return [
         { value: "gemini-3.1-pro", label: "gemini-3.1-pro", description: "display label; runs as auto-gemini-3" },
       ];

package/lib/local-ai-adapters.mjs

@@ -18,6 +18,7 @@ const GEMINI_HOME_SYNC_FILES = [
   "settings.json",
 ];
 const GEMINI_STDIN_BRIDGE_PROMPT = "Use the full task provided on standard input as the authoritative prompt. Follow it exactly and output only the final answer.";
+const GEMINI_CLI_TIMEOUT_MS = 90 * 1000;
 const LOCAL_AI_MODEL_MAPPINGS = {
   gpt: [
     {
@@ -769,13 +770,36 @@ function runGeminiRawText({ promptText, workspaceDir, model, permissionMode, rea
         env: runtime.env,
         input: String(promptText || ""),
         maxBuffer: 8 * 1024 * 1024,
+        timeout: GEMINI_CLI_TIMEOUT_MS,
       },
     );
     if (result.error) {
+      const errorCode = String(result.error?.code || "").trim().toUpperCase();
+      if (errorCode === "ETIMEDOUT") {
+        const stderrText = String(result.stderr || "").trim();
+        const stdoutText = String(result.stdout || "").trim();
+        const details = [stderrText, stdoutText]
+          .filter(Boolean)
+          .map((value) => value.replace(/\s+/g, " ").trim())
+          .filter(Boolean)
+          .slice(0, 2)
+          .join(" | ");
+        throw new Error(
+          details
+            ? `Gemini CLI timed out after ${Math.round(GEMINI_CLI_TIMEOUT_MS / 1000)}s while waiting for a model response (${details})`
+            : `Gemini CLI timed out after ${Math.round(GEMINI_CLI_TIMEOUT_MS / 1000)}s while waiting for a model response`,
+        );
+      }
       throw new Error(String(result.error?.message || result.error));
     }
     if (result.status !== 0) {
-      throw new Error(String(result.stderr || result.stdout || `gemini exited with status ${result.status}`));
+      const stderrText = String(result.stderr || "");
+      const stdoutText = String(result.stdout || "");
+      const combinedText = `${stderrText}\n${stdoutText}`.trim();
+      if (/MODEL_CAPACITY_EXHAUSTED|No capacity available for model/i.test(combinedText)) {
+        throw new Error(`Gemini model capacity is currently unavailable for ${String(model || "").trim() || "the configured model"}`);
+      }
+      throw new Error(combinedText || `gemini exited with status ${result.status}`);
     }
     return String(result.stdout || "");
   } finally {
@@ -1377,7 +1401,8 @@ function buildGeminiArgs({ model, permissionMode }) {
     "--allowed-mcp-server-names",
     "none",
   ];
-  if (model) {
+  const normalizedModel = normalizeModelAliasText(model);
+  if (model && normalizedModel !== "auto-gemini-3") {
     args.push("--model", model);
   }
   return args;
@@ -1433,6 +1458,9 @@ function buildGeminiThinkingConfig(model, reasoningEffort) {
 
 export function resolveGeminiReasoningConfig(rawModelValue = "", reasoningEffort = "medium") {
   const executionModel = resolveLocalAIExecutionModel("gemini", rawModelValue);
+  if (!executionModel || executionModel === "auto-gemini-3") {
+    return null;
+  }
   const thinkingConfig = buildGeminiThinkingConfig(executionModel, reasoningEffort);
   if (!thinkingConfig) {
     return null;

package/lib/runner-helpers.mjs

@@ -284,6 +284,28 @@ function normalizeMentionSelector(rawValue) {
   return String(rawValue || "").trim().replace(/^@+/, "").toLowerCase();
 }
 
+export function isTelegramLocalInboundEnvelopeForRoute(rawEnvelope, {
+  routeKey = "",
+  botUsername = "",
+} = {}) {
+  const envelope = normalizeTelegramMessageEnvelope(rawEnvelope);
+  const sourceOrigin = String(envelope.source_origin || "").trim().toLowerCase();
+  if (sourceOrigin !== "local_telegram_inbound") {
+    return false;
+  }
+  const expectedRouteKey = String(routeKey || "").trim();
+  const actualRouteKey = String(envelope.source_route_key || "").trim();
+  if (expectedRouteKey && expectedRouteKey !== actualRouteKey) {
+    return false;
+  }
+  const expectedBotUsername = normalizeMentionSelector(botUsername);
+  const actualBotUsername = normalizeMentionSelector(envelope.source_bot_username || "");
+  if (expectedBotUsername && expectedBotUsername !== actualBotUsername) {
+    return false;
+  }
+  return true;
+}
+
 function uniqueNormalizedSelectors(values) {
   return Array.from(new Set(
     ensureArray(values)

package/lib/runner-orchestration.mjs

@@ -8,6 +8,7 @@ import {
   compareArchiveCommentRecords,
   dedupeProcessableArchiveComments,
   findRecentTelegramMessageEnvelope,
+  isTelegramLocalInboundEnvelopeForRoute,
   isInboundArchiveKind,
   normalizeTelegramMessageEnvelope,
   selectPendingArchiveComments,
@@ -402,18 +403,23 @@ function resolveRunnerDeliverySourceMessageEnvelope({
       messageID: archiveMessageID,
     },
   );
-  if (String(routeLocalEnvelope.source_origin || "").trim().toLowerCase() === "local_telegram_inbound") {
+  if (isTelegramLocalInboundEnvelopeForRoute(routeLocalEnvelope, {
+    routeKey,
+    botUsername: currentBotSelector,
+  })) {
     return routeLocalEnvelope;
   }
   const persistedSourceEnvelope = normalizeTelegramMessageEnvelope(
     safeObject(persistedRequest).source_message_envelope
       || safeObject(persistedRequest).sourceMessageEnvelope,
   );
-  const persistedOrigin = String(persistedSourceEnvelope.source_origin || "").trim().toLowerCase();
   const persistedChatID = String(persistedSourceEnvelope.chat_id || "").trim();
   const persistedMessageID = intFromRawAllowZero(persistedSourceEnvelope.message_id, 0);
   if (
-    persistedOrigin === "local_telegram_inbound"
+    isTelegramLocalInboundEnvelopeForRoute(persistedSourceEnvelope, {
+      routeKey,
+      botUsername: currentBotSelector,
+    })
     && archiveChatID
     && archiveChatID === persistedChatID
     && archiveMessageID > 0
@@ -3382,21 +3388,22 @@ async function maybeExecuteDynamicRolePlan({
   };
 }
 
-function buildConversationPeerMap(bot, normalizedRoute, deps) {
-  const peers = typeof deps?.resolveConversationPeerBots === "function"
-    ? ensureArray(deps.resolveConversationPeerBots(normalizedRoute))
-    : [];
-  const output = new Map();
-  const register = (peerRaw) => {
-    const peer = safeObject(peerRaw);
-    const displayName = String(peer.name || peer.username || peer.id || "").trim();
-    const selectors = uniqueOrdered([
-      normalizeMentionSelector(peer.username),
-      normalizeMentionSelector(peer.name),
-    ]);
-    for (const selector of selectors) {
-      output.set(selector, {
-        selector,
+function buildConversationPeerMap(bot, normalizedRoute, deps) {
+  const peers = typeof deps?.resolveConversationPeerBots === "function"
+    ? ensureArray(deps.resolveConversationPeerBots(normalizedRoute))
+    : [];
+  const output = new Map();
+  const register = (peerRaw) => {
+    const peer = safeObject(peerRaw);
+    const displayName = String(peer.name || peer.username || peer.id || "").trim();
+    const explicitUsername = normalizeMentionSelector(peer.username);
+    const selectors = uniqueOrdered([
+      explicitUsername,
+      explicitUsername ? "" : normalizeMentionSelector(peer.name),
+    ]);
+    for (const selector of selectors) {
+      output.set(selector, {
+        selector,
         displayName: displayName || selector,
         id: String(peer.id || "").trim(),
       });
@@ -4935,7 +4942,10 @@ export async function processRunnerSelectedRecord({
     && !precomputedConversationResponderSelection;
   if (!currentBotSelected && !shouldDeferBotReplyConversationAuthorization) {
     const adjudicationDecision = String(responderAdjudication.decision || "").trim() || "no_responder";
-    const adjudicationReason = String(responderAdjudication.reason_code || "").trim() || "not_selected_by_adjudicator";
+    const rawAdjudicationReason = String(responderAdjudication.reason_code || "").trim() || "not_selected_by_adjudicator";
+    const adjudicationReason = rawAdjudicationReason === "precomputed_human_intent_contract" && selectedResponderSelectors.length > 0
+      ? "precomputed_human_intent_contract_selected_other_responder"
+      : rawAdjudicationReason;
     saveRunnerRouteState(
       routeKey,
       buildRunnerRouteStateFromComment(selectedRecord, {

package/lib/runner-trigger.mjs

@@ -35,19 +35,11 @@ function normalizeTelegramMentionUsername(rawValue) {
 }
 
 function listTelegramMentionUsernames(parsedArchive) {
-  const usernames = new Set(
+  return uniqueOrdered(
     ensureArray(parsedArchive?.mentionUsernames)
       .map((value) => normalizeTelegramMentionUsername(value))
       .filter(Boolean),
   );
-  const text = String(parsedArchive?.body || "").trim().toLowerCase();
-  for (const match of text.matchAll(/@([a-z0-9_]{3,})/gi)) {
-    const normalized = normalizeTelegramMentionUsername(match?.[1]);
-    if (normalized) {
-      usernames.add(normalized);
-    }
-  }
-  return Array.from(usernames);
 }
 
 function inferTelegramArchiveChatType(parsedArchive) {
@@ -60,10 +52,13 @@ function inferTelegramArchiveChatType(parsedArchive) {
 
 function buildTelegramBotUsernameCandidates(bot, route) {
   const set = new Set();
+  const explicitUsername = normalizeTelegramMentionUsername(bot?.username);
+  const fallbackDisplayCandidates = explicitUsername
+    ? []
+    : [bot?.name, route?.botName];
   for (const candidate of [
-    bot?.username,
-    bot?.name,
-    route?.botName,
+    explicitUsername,
+    ...fallbackDisplayCandidates,
   ]) {
     const normalized = normalizeTelegramMentionUsername(candidate);
     if (normalized) {
@@ -74,13 +69,11 @@ function buildTelegramBotUsernameCandidates(bot, route) {
 }
 
 function doesTelegramArchiveMentionBot(parsedArchive, bot, route) {
-  const text = String(parsedArchive?.body || "").trim().toLowerCase();
   const mentions = new Set(listTelegramMentionUsernames(parsedArchive));
   const candidates = buildTelegramBotUsernameCandidates(bot, route);
   for (const username of candidates) {
     if (!username) continue;
     if (mentions.has(username)) return true;
-    if (text.includes(`@${username}`)) return true;
   }
   return false;
 }

package/lib/selftest-runner-scenarios.mjs

@@ -117,7 +117,8 @@ export async function runSelftestRunnerScenarios(push, deps) {
   const tryJsonParse = requireDependency(deps, "tryJsonParse");
   const safeObject = requireDependency(deps, "safeObject");
   const normalizeRunnerTriggerPolicy = requireDependency(deps, "normalizeRunnerTriggerPolicy");
-  const evaluateTelegramRunnerTrigger = requireDependency(deps, "evaluateTelegramRunnerTrigger");
+  const evaluateTelegramRunnerTrigger = requireDependency(deps, "evaluateTelegramRunnerTrigger");
+  const resolveHumanIntentContext = requireDependency(deps, "resolveHumanIntentContext");
   const resolveRunnerResponderAdjudication = requireDependency(deps, "resolveRunnerResponderAdjudication");
   const selectPendingArchiveComments = requireDependency(deps, "selectPendingArchiveComments");
   const selectRunnerPendingWork = requireDependency(deps, "selectRunnerPendingWork");
@@ -2464,13 +2465,80 @@ export async function runSelftestRunnerScenarios(push, deps) {
     mentionOnlyRoute,
     { name: "ServerProtocolMonitorBot", role: "monitor" },
   );
-  push(
-    "telegram_trigger_mentions_only_accepts_bot_mention",
-    mentionOnlyMatched.shouldRespond === true && mentionOnlyMatched.trigger === "mention",
-    `shouldRespond=${mentionOnlyMatched.shouldRespond} trigger=${mentionOnlyMatched.trigger}`,
-  );
-
-  const mentionOverridesReplyForUnmentionedBot = evaluateTelegramRunnerTrigger(
+  push(
+    "telegram_trigger_mentions_only_accepts_bot_mention",
+    mentionOnlyMatched.shouldRespond === true && mentionOnlyMatched.trigger === "mention",
+    `shouldRespond=${mentionOnlyMatched.shouldRespond} trigger=${mentionOnlyMatched.trigger}`,
+  );
+
+  const mentionOnlyAliasCandidate = evaluateTelegramRunnerTrigger(
+    {
+      id: "comment-2a",
+      parsedArchive: {
+        kind: "telegram_message",
+        chatID: "-100123",
+        chatType: "supergroup",
+        body: "hello @RyoAI_bot2",
+        mentionUsernames: [],
+        replyToSenderIsBot: false,
+      },
+    },
+    mentionOnlyRoute,
+    { username: "ryoai2_bot", name: "RyoAI_bot2", role: "monitor" },
+  );
+  push(
+    "telegram_trigger_does_not_treat_raw_alias_text_as_authoritative_mention",
+    mentionOnlyAliasCandidate.shouldRespond === true
+      && mentionOnlyAliasCandidate.trigger === "mentions_only_unaddressed_candidate",
+    `shouldRespond=${mentionOnlyAliasCandidate.shouldRespond} trigger=${mentionOnlyAliasCandidate.trigger}`,
+  );
+
+  try {
+    const aliasHumanIntentContext = await resolveHumanIntentContext({
+      selectedRecord: {
+        id: "comment-alias-managed-mention",
+        parsedArchive: {
+          kind: "telegram_message",
+          body: "@RyoAI_bot2 hi",
+          senderIsBot: false,
+        },
+      },
+      normalizedRoute: {
+        name: "telegram-monitor-ryoai2-bot-2",
+      },
+      bot: {
+        username: "ryoai2_bot",
+        name: "RyoAI_bot2",
+      },
+      executionPlan: {},
+      deps: {
+        resolveConversationPeerBots: () => [],
+      },
+      persistedRequest: {
+        conversation_intent_mode: "single_bot",
+        conversation_reply_expectation: "informational",
+        conversation_initial_responders: ["ryoai2_bot"],
+        conversation_allowed_responders: ["ryoai2_bot"],
+        conversation_participants: ["ryoai2_bot"],
+        conversation_lead_bot: "ryoai2_bot",
+        conversation_summary_bot: "ryoai2_bot",
+      },
+    });
+    push(
+      "runner_human_intent_context_ignores_raw_alias_selector_for_managed_mentions",
+      ensureArray(aliasHumanIntentContext?.managedMentions).length === 0
+        && aliasHumanIntentContext?.reusedPersistedContract === true,
+      `managedMentions=${JSON.stringify(ensureArray(aliasHumanIntentContext?.managedMentions))} reused=${String(aliasHumanIntentContext?.reusedPersistedContract)}`,
+    );
+  } catch (err) {
+    push(
+      "runner_human_intent_context_ignores_raw_alias_selector_for_managed_mentions",
+      false,
+      String(err?.message || err),
+    );
+  }
+
+  const mentionOverridesReplyForUnmentionedBot = evaluateTelegramRunnerTrigger(
     {
       id: "comment-2b",
       parsedArchive: {
@@ -12986,6 +13054,141 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("runner_delivery_prefers_route_local_inbound_provenance_envelope", false, String(err?.message || err));
   }
 
+  try {
+    let capturedSourceMessageEnvelope = {};
+    const processed = await processRunnerSelectedRecord({
+      routeKey: "telegram-monitor-ryoai2-bot-2::project::telegram::monitor::dest::actor",
+      normalizedRoute: {
+        name: "telegram-monitor-ryoai2-bot-2",
+        provider: "telegram",
+        role: "monitor",
+        roleProfile: "monitor",
+        botName: "RyoAI2_bot",
+        archivePolicy: { mirrorReplies: true, dedupeOutbound: true },
+        triggerPolicy: {
+          directMessages: true,
+          mentionsOnly: false,
+          replyToBotMessages: true,
+          ignoreEditedMessages: true,
+        },
+      },
+      routeState: {
+        recent_local_inbound_envelopes: {},
+      },
+      selectedRecord: {
+        id: "comment-foreign-provenance",
+        threadID: "thread-1",
+        parsedArchive: {
+          kind: "telegram_message",
+          chatID: "-100123",
+          chatType: "supergroup",
+          body: "@RyoAI2_bot hi",
+          messageID: 228,
+          sender: "human",
+          senderIsBot: false,
+          mentionUsernames: ["ryoai2_bot"],
+        },
+      },
+      persistedHumanIntentRequest: {
+        source_message_envelope: {
+          chat_id: "-100123",
+          message_id: 228,
+          source_origin: "local_telegram_inbound",
+          source_route_key: "telegram-monitor-ryoai-bot-2::project::telegram::monitor::dest::actor",
+          source_bot_username: "ryoai_bot",
+        },
+      },
+      pendingOrdered: [],
+      bot: {
+        id: "bot-2",
+        name: "RyoAI2_bot",
+        username: "RyoAI2_bot",
+        role: "monitor",
+        provider: "telegram",
+      },
+      destination: {
+        id: "dest-1",
+        label: "Main Room",
+        provider: "telegram",
+        chatID: "-100123",
+      },
+      archiveThread: {
+        threadID: "thread-1",
+        workItemID: "work-item-1",
+      },
+      executionPlan: {
+        mode: "role_profile",
+        roleProfileName: "monitor",
+        roleProfile: {
+          client: "sample",
+          model: "",
+          permissionMode: "read_only",
+          reasoningEffort: "low",
+        },
+        workspaceDir: "",
+        workspaceSource: "selftest",
+        usedCommandFallback: false,
+      },
+      runtime: {
+        baseURL: "https://example.test",
+        token: "selftest-token",
+        timeoutSeconds: 30,
+        actor: { user_id: "user-1" },
+      },
+      deps: {
+        saveRunnerRouteState: () => {},
+        startRunnerTypingHeartbeat: () => ({ async stop() {} }),
+        runRunnerAIExecution: async () => ({
+          skip: false,
+          reply: "Hello from RyoAI2_bot.",
+        }),
+        performLocalBotDelivery: async ({ sourceMessageEnvelope }) => {
+          capturedSourceMessageEnvelope = safeObject(sourceMessageEnvelope);
+          return {
+            delivery: {
+              dryRun: false,
+              body: {
+                result: {
+                  message_id: 9002,
+                },
+              },
+            },
+            archive: {},
+          };
+        },
+        serializeRunnerTriggerPolicy: (value) => value,
+        serializeRunnerArchivePolicy: (value) => value,
+        buildRunnerExecutionDeps: () => ({
+          validateWorkspaceArtifacts,
+          analyzeHumanConversationIntentWithAI: async () => ({
+            mode: "single_bot",
+            lead_bot: "ryoai2_bot",
+            participants: ["ryoai2_bot"],
+            initial_responders: ["ryoai2_bot"],
+            allowed_responders: ["ryoai2_bot"],
+            summary_bot: "",
+            allow_bot_to_bot: false,
+            reply_expectation: "informational",
+            intent_type: "small_talk",
+          }),
+        }),
+        buildRunnerDeliveryDeps: () => ({}),
+        buildRunnerRuntimeDeps: () => ({}),
+        resolveConversationPeerBots: () => [],
+      },
+    });
+    push(
+      "runner_delivery_rejects_foreign_route_local_provenance",
+      processed.kind === "replied"
+        && String(capturedSourceMessageEnvelope.source_origin || "") === "archive_reconstructed"
+        && String(capturedSourceMessageEnvelope.source_route_key || "").includes("telegram-monitor-ryoai2-bot-2")
+        && String(capturedSourceMessageEnvelope.source_bot_username || "") === "ryoai2_bot",
+      `kind=${String(processed.kind || "(none)")} origin=${String(capturedSourceMessageEnvelope.source_origin || "(none)")} route=${String(capturedSourceMessageEnvelope.source_route_key || "(none)")} bot=${String(capturedSourceMessageEnvelope.source_bot_username || "(none)")}`,
+    );
+  } catch (err) {
+    push("runner_delivery_rejects_foreign_route_local_provenance", false, String(err?.message || err));
+  }
+
   try {
     const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-selftest-observed-artifacts-"));
     const scriptDir = path.join(workspaceDir, ".metheus", "runner-runtime", "local-ai-scratch");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metheus-governance-mcp-cli",
-  "version": "0.2.250",
+  "version": "0.2.252",
   "description": "Metheus Governance MCP CLI (setup + stdio proxy)",
   "type": "module",
   "files": [