metheus-governance-mcp-cli 0.2.200 → 0.2.201

package/cli.mjs

@@ -2553,6 +2553,76 @@ async function findServerRunnerRequestForMessageID({
   }
 }
 
+async function loadRunnerArchiveThreadMessageIndex({
+  runtime,
+  threadID,
+  cache = null,
+}) {
+  const normalizedThreadID = String(threadID || "").trim();
+  if (
+    cache
+    && String(cache.threadID || "").trim() === normalizedThreadID
+    && cache.messageIndex instanceof Map
+  ) {
+    return cache;
+  }
+  if (!normalizedThreadID || !runtime?.baseURL || !runtime?.token) {
+    return {
+      threadID: normalizedThreadID,
+      messageIndex: new Map(),
+    };
+  }
+  try {
+    const comments = await listThreadCommentsTail({
+      siteBaseURL: runtime.baseURL,
+      threadID: normalizedThreadID,
+      token: runtime.token,
+      timeoutSeconds: runtime.timeoutSeconds,
+      actorUserID: runtime.actor?.user_id,
+      tailLimit: 300,
+      scanLimit: 1200,
+    });
+    const messageIndex = new Map();
+    for (const commentRaw of ensureArray(comments)) {
+      const comment = safeObject(commentRaw);
+      const parsedArchive = safeObject(comment.parsedArchive || parseArchivedChatComment(comment.body));
+      const messageID = intFromRawAllowZero(parsedArchive.messageID, 0);
+      if (messageID > 0 && !messageIndex.has(messageID)) {
+        messageIndex.set(messageID, {
+          ...comment,
+          parsedArchive,
+        });
+      }
+    }
+    return {
+      threadID: normalizedThreadID,
+      messageIndex,
+    };
+  } catch {
+    return {
+      threadID: normalizedThreadID,
+      messageIndex: new Map(),
+    };
+  }
+}
+
+async function findRunnerArchiveThreadMessageByID({
+  runtime,
+  threadID,
+  messageID,
+  cache = null,
+}) {
+  const nextCache = await loadRunnerArchiveThreadMessageIndex({
+    runtime,
+    threadID,
+    cache,
+  });
+  return {
+    cache: nextCache,
+    record: safeObject(nextCache.messageIndex.get(intFromRawAllowZero(messageID, 0))),
+  };
+}
+
 function resolveRunnerReplyChainConversationContext(state, normalizedRoute, selectedRecord) {
   const parsed = safeObject(selectedRecord?.parsedArchive);
   const explicitConversationID = String(parsed.conversationID || "").trim();
@@ -2600,6 +2670,8 @@ async function resolveRunnerReplyChainConversationContextWithServerFallback({
   normalizedRoute,
   selectedRecord,
   runtime,
+  archiveThreadID = "",
+  hydrationAttempted = false,
 }) {
   const initialState = safeObject(state);
   const initialContext = resolveRunnerReplyChainConversationContext(initialState, normalizedRoute, selectedRecord);
@@ -2611,11 +2683,11 @@ async function resolveRunnerReplyChainConversationContextWithServerFallback({
     };
   }
   const parsed = safeObject(selectedRecord?.parsedArchive);
-  const replyToMessageID = intFromRawAllowZero(
+  const initialReplyToMessageID = intFromRawAllowZero(
     parsed.replyToMessageID || safeObject(initialContext).replyToMessageID,
     0,
   );
-  if (replyToMessageID <= 0 || !runtime?.baseURL || !runtime?.token) {
+  if (initialReplyToMessageID <= 0) {
     return {
       state: initialState,
       replyChainContext: initialContext,
@@ -2623,43 +2695,142 @@ async function resolveRunnerReplyChainConversationContextWithServerFallback({
     };
   }
   const chatID = String(parsed.chatID || parsed.chatId || "").trim();
-  const serverReferencedRequest = await findServerRunnerRequestForMessageID({
-    normalizedRoute,
-    runtime,
-    chatID,
-    messageID: replyToMessageID,
-  });
-  if (serverReferencedRequest.request_key) {
-    const requestIndex = normalizeBotRunnerRequests(initialState.requests);
-    requestIndex[String(serverReferencedRequest.request_key || "").trim()] = serverReferencedRequest;
-    const anchorMessageID = intFromRawAllowZero(serverReferencedRequest.source_message_id, 0) || replyToMessageID;
+  const normalizedArchiveThreadID = firstNonEmptyString([
+    archiveThreadID,
+    selectedRecord?.thread_id,
+    selectedRecord?.threadID,
+    selectedRecord?.threadId,
+  ]);
+  let stateForLookup = initialState;
+  let replyToMessageID = initialReplyToMessageID;
+  let archiveThreadCache = null;
+  let lastAnchorMessageID = intFromRawAllowZero(safeObject(initialContext).anchorMessageID, 0) || initialReplyToMessageID;
+  const visitedMessageIDs = new Set();
+
+  const buildContextFromRequest = (referencedRequestRaw, reasonSuffix = "") => {
+    const referencedRequest = safeObject(referencedRequestRaw);
+    const anchorMessageID = intFromRawAllowZero(referencedRequest.source_message_id, 0) || replyToMessageID;
     return {
-      state: {
-        ...initialState,
-        requests: requestIndex,
-      },
+      state: stateForLookup,
       replyChainContext: {
-        conversationID: String(serverReferencedRequest.conversation_id || "").trim()
+        conversationID: String(referencedRequest.conversation_id || "").trim()
           || buildSyntheticReplyChainConversationID(normalizedRoute, chatID, anchorMessageID),
-        replyToMessageID,
+        replyToMessageID: initialReplyToMessageID,
         anchorMessageID,
-        reason: String(serverReferencedRequest.conversation_id || "").trim()
-          ? "reply_request_conversation_server"
-          : "reply_request_synthetic_server",
-        referencedRequest: serverReferencedRequest,
+        reason: String(referencedRequest.conversation_id || "").trim()
+          ? `reply_request_conversation${reasonSuffix}`
+          : `reply_request_synthetic${reasonSuffix}`,
+        referencedRequest,
       },
-      hydrated: false,
+      hydrated: hydrationAttempted,
     };
+  };
+
+  for (let hop = 0; hop < 8 && replyToMessageID > 0; hop += 1) {
+    if (visitedMessageIDs.has(replyToMessageID)) {
+      break;
+    }
+    visitedMessageIDs.add(replyToMessageID);
+
+    const localReferencedRequest = safeObject(findRunnerRequestsForMessageID(stateForLookup, normalizedRoute, {
+      chatID,
+      messageID: replyToMessageID,
+    })[0]);
+    if (localReferencedRequest.request_key) {
+      return buildContextFromRequest(localReferencedRequest, hop > 0 ? "_chain" : "");
+    }
+
+    if (runtime?.baseURL && runtime?.token) {
+      const serverReferencedRequest = await findServerRunnerRequestForMessageID({
+        normalizedRoute,
+        runtime,
+        chatID,
+        messageID: replyToMessageID,
+      });
+      if (serverReferencedRequest.request_key) {
+        const requestIndex = normalizeBotRunnerRequests(stateForLookup.requests);
+        requestIndex[String(serverReferencedRequest.request_key || "").trim()] = serverReferencedRequest;
+        stateForLookup = {
+          ...stateForLookup,
+          requests: requestIndex,
+        };
+        return buildContextFromRequest(serverReferencedRequest, hop > 0 ? "_chain_server" : "_server");
+      }
+    }
+
+    if (!normalizedArchiveThreadID || !runtime?.baseURL || !runtime?.token) {
+      break;
+    }
+    const archivedMessageLookup = await findRunnerArchiveThreadMessageByID({
+      runtime,
+      threadID: normalizedArchiveThreadID,
+      messageID: replyToMessageID,
+      cache: archiveThreadCache,
+    });
+    archiveThreadCache = archivedMessageLookup.cache;
+    const archivedRecord = safeObject(archivedMessageLookup.record);
+    const archivedParsed = safeObject(archivedRecord.parsedArchive || parseArchivedChatComment(archivedRecord.body));
+    const archivedMessageID = intFromRawAllowZero(archivedParsed.messageID, 0) || replyToMessageID;
+    if (archivedMessageID > 0) {
+      lastAnchorMessageID = archivedMessageID;
+    }
+    const archivedConversationID = String(archivedParsed.conversationID || "").trim();
+    if (archivedConversationID) {
+      return {
+        state: stateForLookup,
+        replyChainContext: {
+          conversationID: archivedConversationID,
+          replyToMessageID: initialReplyToMessageID,
+          anchorMessageID: archivedMessageID,
+          reason: "reply_chain_archive_conversation",
+          referencedRequest: null,
+        },
+        hydrated: hydrationAttempted,
+      };
+    }
+    const nextReplyToMessageID = intFromRawAllowZero(archivedParsed.replyToMessageID, 0);
+    if (nextReplyToMessageID <= 0) {
+      return {
+        state: stateForLookup,
+        replyChainContext: {
+          conversationID: buildSyntheticReplyChainConversationID(normalizedRoute, chatID, lastAnchorMessageID || archivedMessageID),
+          replyToMessageID: initialReplyToMessageID,
+          anchorMessageID: lastAnchorMessageID || archivedMessageID,
+          reason: "reply_chain_archive_synthetic",
+          referencedRequest: null,
+        },
+        hydrated: hydrationAttempted,
+      };
+    }
+    replyToMessageID = nextReplyToMessageID;
   }
-  const hydratedState = await hydrateRunnerRequestLedgerFromServer({
-    normalizedRoute,
-    runtime,
-  });
-  const hydratedContext = resolveRunnerReplyChainConversationContext(hydratedState, normalizedRoute, selectedRecord);
+
+  if (!hydrationAttempted && runtime?.baseURL && runtime?.token) {
+    const hydratedState = await hydrateRunnerRequestLedgerFromServer({
+      normalizedRoute,
+      runtime,
+    });
+    const hydratedResolution = await resolveRunnerReplyChainConversationContextWithServerFallback({
+      state: hydratedState,
+      normalizedRoute,
+      selectedRecord,
+      runtime,
+      archiveThreadID: normalizedArchiveThreadID,
+      hydrationAttempted: true,
+    });
+    return {
+      state: hydratedResolution.state,
+      replyChainContext: hydratedResolution.replyChainContext,
+      hydrated: true,
+    };
+  }
+
   return {
-    state: hydratedState,
-    replyChainContext: hydratedContext,
-    hydrated: true,
+    state: stateForLookup,
+    replyChainContext: hydrationAttempted
+      ? resolveRunnerReplyChainConversationContext(stateForLookup, normalizedRoute, selectedRecord)
+      : initialContext,
+    hydrated: hydrationAttempted,
   };
 }
 
@@ -2709,6 +2880,7 @@ async function claimRunnerRequestForHumanComment({
   selectedBotUsernames = [],
   normalizedIntent = "",
   runtime = null,
+  archiveThreadID = "",
 }) {
   const parsed = safeObject(selectedRecord?.parsedArchive);
   const commentKind = String(parsed.kind || "").trim().toLowerCase();
@@ -2724,6 +2896,7 @@ async function claimRunnerRequestForHumanComment({
     normalizedRoute,
     selectedRecord,
     runtime,
+    archiveThreadID,
   });
   const replyChainContext = safeObject(replyChainResolution.replyChainContext);
   const referencedRequest = safeObject(replyChainContext.referencedRequest);
@@ -5431,9 +5604,6 @@ function formatTelegramInboundArchiveComment(normalized) {
   if (normalized.mentionUsernames.length > 0) {
     headerLines.push(`mention_usernames: ${normalized.mentionUsernames.map((item) => `@${item}`).join(", ")}`);
   }
-  if (normalized.messageThreadID) {
-    headerLines.push(`telegram_topic_id: ${normalized.messageThreadID}`);
-  }
   if (normalized.replyToMessageID > 0) {
     headerLines.push(`reply_to_message_id: ${normalized.replyToMessageID}`);
     headerLines.push(`reply_to_sender_is_bot: ${normalized.replyToFromIsBot ? "true" : "false"}`);
@@ -6186,6 +6356,29 @@ function buildRunnerSmallTalkReply({ route, executionPlan } = {}) {
   return templatePool[stableTextModulo(`${displayName}:${roleProfileName}`, templatePool.length)];
 }
 
+function buildInformationalMiniExecutionOverride({ route, executionPlan } = {}) {
+  const safeRoute = safeObject(route);
+  const safeExecutionPlan = safeObject(executionPlan);
+  const roleProfileName = normalizeRunnerRoleProfileName(
+    safeExecutionPlan.roleProfileName || safeRoute.roleProfile || safeRoute.role || "monitor",
+  ) || "monitor";
+  const lightweightModel = String(
+    resolveResponderAdjudicatorModelDisplayName({ client: "gpt", env: process.env }) || "gpt-5.3-codex-spark",
+  ).trim() || "gpt-5.3-codex-spark";
+  return {
+    mode: "role_profile",
+    role_profile_name: roleProfileName,
+    role_profile: normalizeRunnerRoleProfile(roleProfileName, {
+      client: "gpt",
+      model: lightweightModel,
+      permission_mode: "read_only",
+      reasoning_effort: "low",
+    }),
+    workspace_dir: String(safeExecutionPlan.workspaceDir || safeRoute.workspaceDir || "").trim(),
+    workspace_source: String(safeExecutionPlan.workspaceSource || "").trim(),
+  };
+}
+
 function summarizeRunnerRequestForStatusLookup(entryRaw) {
   const entry = safeObject(entryRaw);
   return {
@@ -6411,11 +6604,21 @@ async function resolveInformationalQueryReply({
 }) {
   const normalizedIntentType = String(intentType || "").trim();
   const messageText = String(safeObject(selectedRecord?.parsedArchive).body || "").trim();
+  const executionOverride = buildInformationalMiniExecutionOverride({ route, executionPlan });
   if (normalizedIntentType === "small_talk") {
     return {
       handled: true,
-      reply: buildRunnerSmallTalkReply({ route, executionPlan }),
+      response_mode: "lookup_only",
+      reply: "",
       source: "small_talk",
+      lookup: {
+        intent_type: "small_talk",
+        user_message: messageText,
+        bot_name: firstNonEmptyString([route?.botName, route?.serverBotName, route?.server_bot_name, route?.name]),
+        bot_role: String(route?.role || route?.roleProfile || "").trim(),
+        proposed_summary: buildRunnerSmallTalkReply({ route, executionPlan }),
+      },
+      execution_override: executionOverride,
     };
   }
   if (false && normalizedIntentType === "small_talk") {
@@ -6433,9 +6636,14 @@ async function resolveInformationalQueryReply({
       : "현재 이 프로젝트는 project-workspaces.json에 로컬 작업 폴더가 바인딩되어 있지 않습니다.";
     return {
       handled: true,
-      reply,
+      response_mode: "lookup_only",
+      reply: "",
       source: "project.workspace",
-      lookup: workspace,
+      lookup: {
+        ...workspace,
+        proposed_summary: reply,
+      },
+      execution_override: executionOverride,
     };
   }
   if (normalizedIntentType === "bot_role_query") {
@@ -6447,9 +6655,14 @@ async function resolveInformationalQueryReply({
     });
     return {
       handled: true,
-      reply: buildProjectBotRolesText(payload),
+      response_mode: "lookup_only",
+      reply: "",
       source: "project.bot_roles",
-      lookup: payload,
+      lookup: {
+        ...payload,
+        proposed_summary: buildProjectBotRolesText(payload),
+      },
+      execution_override: executionOverride,
     };
   }
   if (normalizedIntentType === "status_query") {
@@ -6512,9 +6725,14 @@ async function resolveInformationalQueryReply({
     });
     return {
       handled: true,
-      reply: buildProjectFileLocateText(payload),
+      response_mode: "lookup_only",
+      reply: "",
       source: "project.file.locate",
-      lookup: payload,
+      lookup: {
+        ...payload,
+        proposed_summary: buildProjectFileLocateText(payload),
+      },
+      execution_override: executionOverride,
     };
   }
   return null;
@@ -7142,6 +7360,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         selectedRecord,
         selectedBotUsernames: selectedResponderSelectors,
         runtime,
+        archiveThreadID: archiveThread.threadID,
       });
     };
     if (deferExecution) {
@@ -14190,6 +14409,44 @@ async function runSelftest(flags = {}) {
       && monitorGreeting !== reviewGreeting,
     `monitor=${monitorGreeting} review=${reviewGreeting}`,
   );
+  const informationalMiniReply = await resolveInformationalQueryReply({
+    intentType: "small_talk",
+    route: { botName: "RyoAI_bot", role: "monitor", roleProfile: "monitor" },
+    routeState: {},
+    selectedRecord: {
+      parsedArchive: {
+        body: "@RyoAI_bot 하이",
+      },
+    },
+    runtime: {},
+    executionPlan: {
+      mode: "role_profile",
+      roleProfileName: "monitor",
+      roleProfile: {
+        client: "gpt",
+        model: "gpt-5.4",
+        permissionMode: "workspace_write",
+        reasoningEffort: "medium",
+      },
+      workspaceDir: "C:\\selftest-workspace",
+      workspaceSource: "selftest",
+    },
+  });
+  const expectedInformationalModel = resolveResponderAdjudicatorModelDisplayName({
+    client: "gpt",
+    env: process.env,
+  });
+  push(
+    "small_talk_reply_uses_lookup_only_mini_override",
+    safeObject(informationalMiniReply).handled === true
+      && String(safeObject(informationalMiniReply).response_mode || "") === "lookup_only"
+      && String(safeObject(informationalMiniReply).reply || "") === ""
+      && String(safeObject(safeObject(informationalMiniReply).execution_override).role_profile?.client || "") === "gpt"
+      && String(safeObject(safeObject(informationalMiniReply).execution_override).role_profile?.model || "") === String(expectedInformationalModel || "")
+      && String(safeObject(safeObject(informationalMiniReply).execution_override).role_profile?.permissionMode || "") === "read_only"
+      && String(safeObject(safeObject(informationalMiniReply).execution_override).role_profile?.reasoningEffort || "") === "low",
+    JSON.stringify(safeObject(informationalMiniReply).execution_override || {}),
+  );
   const telegramEnvV2Parsed = parseSimpleEnvText(`
 TELEGRAM_API_BASE_URL=http://127.0.0.1:8999/api
 TELEGRAM_AUTO_CLEAR_WEBHOOK=false

package/lib/runner-data.mjs

@@ -827,6 +827,7 @@ export async function discoverArchiveThreadForDestination(
   const providerEnvConfig = requireDependency(deps, "providerEnvConfig");
   const parseArchivedChatComment = requireDependency(deps, "parseArchivedChatComment");
   const providerLabel = providerEnvConfig(provider).label;
+  const hasConfiguredArchiveWorkItem = archiveWorkItemID && isUUID(archiveWorkItemID);
 
   if (archiveThreadID && isUUID(archiveThreadID)) {
     return {
@@ -837,8 +838,7 @@ export async function discoverArchiveThreadForDestination(
   }
 
   const candidateWorkItemIDs = [];
-  let reusableWorkItemID = "";
-  if (archiveWorkItemID && isUUID(archiveWorkItemID)) {
+  if (hasConfiguredArchiveWorkItem) {
     candidateWorkItemIDs.push(archiveWorkItemID);
   } else {
     const workItems = await listProjectWorkItems({
@@ -864,11 +864,9 @@ export async function discoverArchiveThreadForDestination(
       token,
       timeoutSeconds,
     }, deps);
-    let fallbackThreadID = "";
     for (const thread of threads) {
       const threadID = String(thread.id || "").trim();
       if (!threadID) continue;
-      if (!fallbackThreadID) fallbackThreadID = threadID;
       const comments = await listThreadComments({
         siteBaseURL,
         threadID,
@@ -889,15 +887,8 @@ export async function discoverArchiveThreadForDestination(
         };
       }
     }
-    if (fallbackThreadID) {
-      return {
-        threadID: fallbackThreadID,
-        workItemID,
-        source: "fallback-thread",
-      };
-    }
-    if (!reusableWorkItemID) {
-      reusableWorkItemID = workItemID;
+    if (hasConfiguredArchiveWorkItem) {
+      break;
     }
   }
 
@@ -907,7 +898,9 @@ export async function discoverArchiveThreadForDestination(
     const archiveDescription = `Auto-created archive work item for ${providerLabel} destination ${destinationLabel}.`;
     try {
       const threadBody = `Auto-created archive thread for ${providerLabel} destination ${destinationLabel} (chat_id=${destination.chatID}).`;
-      let resolvedWorkItemID = String(reusableWorkItemID || "").trim();
+      let resolvedWorkItemID = hasConfiguredArchiveWorkItem
+        ? String(archiveWorkItemID || "").trim()
+        : "";
       if (!resolvedWorkItemID) {
         const createdWorkItem = await createProjectWorkItem(
           {
@@ -941,7 +934,9 @@ export async function discoverArchiveThreadForDestination(
           return {
             threadID: createdThreadID,
             workItemID: resolvedWorkItemID,
-            source: reusableWorkItemID ? "auto-created-thread-on-existing-work-item" : "auto-created-thread",
+            source: hasConfiguredArchiveWorkItem
+              ? "auto-created-thread-on-configured-work-item"
+              : "auto-created-thread",
           };
         }
       }

package/lib/runner-orchestration.mjs

@@ -653,6 +653,62 @@ function isInformationalHumanIntentType(intentType) {
   ].includes(normalizeHumanIntentType(intentType));
 }
 
+function resolveInformationalQueryExecutionPlan(executionPlan, directInformationalReply, route) {
+  const basePlan = safeObject(executionPlan);
+  const override = safeObject(safeObject(directInformationalReply).execution_override);
+  const overrideRoleProfile = safeObject(override.role_profile || override.roleProfile);
+  if (String(override.mode || "").trim().toLowerCase() !== "role_profile") {
+    return basePlan;
+  }
+  if (!String(overrideRoleProfile.client || "").trim()) {
+    return basePlan;
+  }
+  return {
+    ...basePlan,
+    mode: "role_profile",
+    roleProfileName: String(
+      override.role_profile_name
+      || override.roleProfileName
+      || basePlan.roleProfileName
+      || route?.roleProfile
+      || route?.role
+      || "",
+    ).trim(),
+    roleProfile: {
+      ...safeObject(basePlan.roleProfile),
+      client: String(overrideRoleProfile.client || safeObject(basePlan.roleProfile).client || "").trim(),
+      model: String(overrideRoleProfile.model || safeObject(basePlan.roleProfile).model || "").trim(),
+      permissionMode: String(
+        overrideRoleProfile.permission_mode
+        || overrideRoleProfile.permissionMode
+        || safeObject(basePlan.roleProfile).permissionMode
+        || "",
+      ).trim(),
+      reasoningEffort: String(
+        overrideRoleProfile.reasoning_effort
+        || overrideRoleProfile.reasoningEffort
+        || safeObject(basePlan.roleProfile).reasoningEffort
+        || "",
+      ).trim(),
+    },
+    workspaceDir: String(
+      override.workspace_dir
+      || override.workspaceDir
+      || basePlan.workspaceDir
+      || route?.workspaceDir
+      || "",
+    ).trim(),
+    workspaceSource: String(
+      override.workspace_source
+      || override.workspaceSource
+      || basePlan.workspaceSource
+      || "",
+    ).trim(),
+    usedCommandFallback: false,
+    fallbackReason: "",
+  };
+}
+
 function buildHumanIntentContextWindowOptions(intentType) {
   const normalizedIntentType = normalizeHumanIntentType(intentType);
   if (normalizedIntentType === "small_talk") {
@@ -3168,7 +3224,7 @@ async function resolvePublicConversationContext({
       managedMentions,
       peerMap,
       deps,
-      executionPlan,
+      executionPlan: effectiveExecutionPlan,
     });
     const participantSelectors = uniqueOrdered(ensureArray(humanIntent.participantSelectors));
     const initialResponderSelectors = uniqueOrdered(
@@ -4263,6 +4319,11 @@ export async function processRunnerSelectedRecord({
       };
     }
   }
+  const effectiveExecutionPlan = resolveInformationalQueryExecutionPlan(
+    executionPlan,
+    directInformationalReply,
+    normalizedRoute,
+  );
   const aiPayload = buildRunnerInputPayload({
     route: normalizedRoute,
     bot: {
@@ -4277,7 +4338,7 @@ export async function processRunnerSelectedRecord({
     selectedRecord,
     contextWindow,
     projectContextItems,
-    executionPlan,
+    executionPlan: effectiveExecutionPlan,
     serializedTriggerPolicy: serializeRunnerTriggerPolicy(normalizedRoute.triggerPolicy),
     serializedArchivePolicy: serializeRunnerArchivePolicy(normalizedRoute.archivePolicy),
     triggerDecision: effectiveTriggerDecision,
@@ -4402,7 +4463,7 @@ export async function processRunnerSelectedRecord({
       bot,
       destination,
       archiveThread,
-      executionPlan,
+      executionPlan: effectiveExecutionPlan,
       runtime,
       executionDeps,
       triggerDecision: effectiveTriggerDecision,
@@ -4426,7 +4487,7 @@ export async function processRunnerSelectedRecord({
         inputPayload: aiPayload,
         route: normalizedRoute,
         destination,
-        executionPlan,
+        executionPlan: effectiveExecutionPlan,
         deps: executionDeps,
       });
     }
@@ -4482,12 +4543,12 @@ export async function processRunnerSelectedRecord({
 
   const artifactValidation = artifactValidationOverride && Object.keys(artifactValidationOverride).length > 0
     ? artifactValidationOverride
-    : validateWorkspaceArtifacts && String(executionPlan.workspaceDir || "").trim()
+    : validateWorkspaceArtifacts && String(effectiveExecutionPlan.workspaceDir || "").trim()
       ? validateWorkspaceArtifacts(
         ensureArray(aiResult?.artifacts),
-        executionPlan.workspaceDir,
+        effectiveExecutionPlan.workspaceDir,
         {
-          permissionMode: String(executionPlan.roleProfile?.permissionMode || "workspace_write").trim() || "workspace_write",
+          permissionMode: String(effectiveExecutionPlan.roleProfile?.permissionMode || "workspace_write").trim() || "workspace_write",
         },
       )
       : {
@@ -4520,7 +4581,7 @@ export async function processRunnerSelectedRecord({
         last_artifact_paths: summarizeValidatedArtifactPaths(artifactValidation),
         last_artifact_errors: artifactErrors,
         last_boundary_violations: boundaryViolations,
-        last_workspace_dir: String(executionPlan.workspaceDir || "").trim(),
+        last_workspace_dir: String(effectiveExecutionPlan.workspaceDir || "").trim(),
         ...intentStatePatch,
       }),
     );
@@ -4541,8 +4602,8 @@ export async function processRunnerSelectedRecord({
         conversation_lead_bot: String(conversationContext?.leadBotUsername || "").trim(),
         conversation_summary_bot: String(conversationContext?.summaryBotUsername || "").trim(),
         conversation_allowed_responders: ensureArray(conversationContext?.allowedResponderSelectors),
-        execution_mode: executionPlan.mode,
-        role_profile: executionPlan.roleProfileName,
+        execution_mode: effectiveExecutionPlan.mode,
+        role_profile: effectiveExecutionPlan.roleProfileName,
         artifact_validation: String(artifactValidation.status || "").trim() || "policy_violation",
         artifact_paths: summarizeValidatedArtifactPaths(artifactValidation),
         artifact_errors: artifactErrors,
@@ -4615,7 +4676,7 @@ export async function processRunnerSelectedRecord({
         botReplyText: String(aiResult.reply || "").trim(),
         currentBotUsername: String(bot?.username || bot?.name || "").trim(),
         managedBots: buildConversationParticipantViews(Array.from(auditPeerMap.keys()), auditPeerMap),
-        workspaceDir: String(executionPlan.workspaceDir || process.cwd()).trim() || process.cwd(),
+        workspaceDir: String(effectiveExecutionPlan.workspaceDir || process.cwd()).trim() || process.cwd(),
       });
       if (audit?.requires_actionable_contract === true && audit?.reply_satisfies_request !== true) {
         requiresActionableContract = true;
@@ -4661,7 +4722,7 @@ export async function processRunnerSelectedRecord({
       inputPayload: forcedContractPayload,
       route: normalizedRoute,
       destination,
-      executionPlan,
+      executionPlan: effectiveExecutionPlan,
       deps: executionDeps,
     });
     executionContract = conversationContext?.mode === "public_multi_bot"
@@ -4727,7 +4788,7 @@ export async function processRunnerSelectedRecord({
           last_reason: reason,
           last_conversation_id: String(conversationContext?.id || "").trim(),
           last_conversation_stage: String(conversationContext?.stage || "").trim(),
-          last_workspace_dir: String(executionPlan.workspaceDir || "").trim(),
+          last_workspace_dir: String(effectiveExecutionPlan.workspaceDir || "").trim(),
           ...intentStatePatch,
         }),
       );
@@ -5022,7 +5083,7 @@ export async function processRunnerSelectedRecord({
               ? "error"
               : "",
         last_context_suggestion_error: String(projectContextSuggestion?.error || "").trim(),
-        last_workspace_dir: String(executionPlan.workspaceDir || "").trim(),
+        last_workspace_dir: String(effectiveExecutionPlan.workspaceDir || "").trim(),
         last_execution_plan: executedRolePlan && Object.keys(executedRolePlan).length > 0 ? executedRolePlan : undefined,
         ...intentStatePatch,
       }),
@@ -5036,7 +5097,7 @@ export async function processRunnerSelectedRecord({
       route_name: normalizedRoute.name,
       outcome: deliveryResult.delivery.dryRun ? "dry_run" : "replied",
       detail: [
-        `${deliveryResult.delivery.dryRun ? "dry-run prepared" : "replied"} as ${bot.name || bot.id}${executionPlan.usedCommandFallback ? " (legacy command fallback)" : ""}`,
+        `${deliveryResult.delivery.dryRun ? "dry-run prepared" : "replied"} as ${bot.name || bot.id}${effectiveExecutionPlan.usedCommandFallback ? " (legacy command fallback)" : ""}`,
         effectiveTriggerDecision?.trigger ? `trigger=${String(effectiveTriggerDecision.trigger || "").trim()}` : "",
         effectiveConversationContext?.mode === "public_multi_bot"
           ? [
@@ -5082,8 +5143,8 @@ export async function processRunnerSelectedRecord({
       evidence_ids: ensureArray(aiResult?.evidenceItems).map((item) => String(safeObject(item).id || "").trim()).filter(Boolean),
       evidence_paths: ensureArray(aiResult?.evidenceItems).map((item) => String(safeObject(item).path || "").trim()).filter(Boolean),
       reply_chars: String(sanitizedReplyText || "").length,
-      execution_mode: executionPlan.mode,
-      role_profile: executionPlan.roleProfileName,
+      execution_mode: effectiveExecutionPlan.mode,
+      role_profile: effectiveExecutionPlan.roleProfileName,
       executed_role_plan: executedRolePlan && Object.keys(executedRolePlan).length > 0 ? executedRolePlan : undefined,
       archive_status: deliveryResult.archive?.dry_run
         ? "dry_run"

package/lib/selftest-runner-scenarios.mjs

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import http from "node:http";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
@@ -22,6 +23,67 @@ function ensureArray(value) {
   return Array.isArray(value) ? value : [];
 }
 
+async function startReplyChainSelftestServer({
+  projectID,
+  threadID,
+  comments = [],
+}) {
+  const state = {
+    comments: ensureArray(comments).slice(),
+  };
+  const writeJSON = (res, statusCode, payload) => {
+    const body = `${JSON.stringify(payload)}\n`;
+    res.writeHead(statusCode, {
+      "content-type": "application/json",
+      "content-length": Buffer.byteLength(body),
+      connection: "close",
+    });
+    res.end(body);
+  };
+  const server = http.createServer((req, res) => {
+    const requestURL = new URL(req.url || "/", `http://${req.headers.host || "127.0.0.1"}`);
+    const pathname = requestURL.pathname;
+    if (req.method === "GET" && pathname === `/api/v1/projects/${encodeURIComponent(projectID)}/runner-requests`) {
+      writeJSON(res, 200, []);
+      return;
+    }
+    if (req.method === "GET" && pathname === `/api/v1/projects/${encodeURIComponent(projectID)}/runner-request-comments`) {
+      writeJSON(res, 200, []);
+      return;
+    }
+    if (req.method === "GET" && pathname === `/api/v1/threads/${encodeURIComponent(threadID)}/comments`) {
+      writeJSON(res, 200, state.comments);
+      return;
+    }
+    writeJSON(res, 404, { error: "not_found" });
+  });
+  await new Promise((resolve, reject) => {
+    server.listen(0, "127.0.0.1", (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+  const address = server.address();
+  const port = typeof address === "object" && address ? address.port : 0;
+  return {
+    baseURL: `http://127.0.0.1:${port}`,
+    async close() {
+      await new Promise((resolve, reject) => {
+        server.close((error) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve();
+        });
+      });
+    },
+  };
+}
+
 export async function runSelftestRunnerScenarios(push, deps) {
   const selftestProjectID = String(requireValue(deps, "selftestProjectID"));
   const allowLegacyRunnerCommandEnvKey = String(requireValue(deps, "allowLegacyRunnerCommandEnvKey"));
@@ -569,8 +631,11 @@ export async function runSelftestRunnerScenarios(push, deps) {
         },
         postJSONWithAuthHeaders: async (url, _timeoutSeconds, _token, payload) => {
           createdCalls.push({ url, payload });
-          if (url.includes("/api/v1/workitems/existing-workitem-1/threads")) {
-            return JSON.stringify({ id: "thread-existing-1" });
+          if (url.endsWith("/api/v1/workitems")) {
+            return JSON.stringify({ work_item_id: "workitem-new-1" });
+          }
+          if (url.includes("/api/v1/workitems/workitem-new-1/threads")) {
+            return JSON.stringify({ id: "thread-new-1" });
           }
           throw new Error(`unexpected url ${url}`);
         },
@@ -585,16 +650,72 @@ export async function runSelftestRunnerScenarios(push, deps) {
       },
     );
     push(
-      "archive_thread_reuses_existing_work_item_without_thread",
-      archiveThread.threadID === "thread-existing-1"
-        && archiveThread.workItemID === "existing-workitem-1"
-        && archiveThread.source === "auto-created-thread-on-existing-work-item"
+      "archive_thread_does_not_reuse_title_only_work_item_without_chat_match",
+      archiveThread.threadID === "thread-new-1"
+        && archiveThread.workItemID === "workitem-new-1"
+        && archiveThread.source === "auto-created-thread"
         && workItemListHeaders[0]?.["X-Actor-User-Id"] === "99999999-9999-9999-9999-999999999999"
-        && createdCalls.length === 1,
+        && createdCalls.length === 2,
       `thread=${archiveThread.threadID} work_item=${archiveThread.workItemID} created_calls=${createdCalls.length} actor_header=${String(workItemListHeaders[0]?.["X-Actor-User-Id"] || "")}`,
     );
   } catch (err) {
-    push("archive_thread_reuses_existing_work_item_without_thread", false, String(err?.message || err));
+    push("archive_thread_does_not_reuse_title_only_work_item_without_chat_match", false, String(err?.message || err));
+  }
+
+  try {
+    const createdCalls = [];
+    const archiveThread = await discoverArchiveThreadForDestination(
+      {
+        siteBaseURL: "https://example.test",
+        projectID: selftestProjectID,
+        provider: "telegram",
+        destination: {
+          id: "dest-1",
+          provider: "telegram",
+          label: "Main Room",
+          chatID: "-1001",
+          isActive: true,
+        },
+        token: "test-token",
+        timeoutSeconds: 10,
+        actorUserID: "99999999-9999-9999-9999-999999999999",
+        archiveWorkItemID: "12345678-1234-1234-1234-1234567890ab",
+      },
+      {
+        getJSONWithAuth: async () => [],
+        getJSONWithAuthHeaders: async (url) => {
+          if (url.includes("/api/v1/workitems/12345678-1234-1234-1234-1234567890ab/threads")) {
+            return [];
+          }
+          return [];
+        },
+        postJSONWithAuthHeaders: async (url, _timeoutSeconds, _token, payload) => {
+          createdCalls.push({ url, payload });
+          if (url.includes("/api/v1/workitems/12345678-1234-1234-1234-1234567890ab/threads")) {
+            return JSON.stringify({ id: "thread-configured-1" });
+          }
+          throw new Error(`unexpected url ${url}`);
+        },
+        parseJSONText: JSON.parse,
+        normalizeChatDestination: (value) => value,
+        normalizeBotProvider: (value) => value,
+        normalizeBotRole: (value) => value,
+        normalizeRunnerRoute: (value) => value,
+        providerEnvConfig: () => ({ label: "Telegram" }),
+        parseArchivedChatComment: () => null,
+        isUUID: (value) => /^[0-9a-f-]{36}$/i.test(String(value || "")),
+      },
+    );
+    push(
+      "archive_thread_reuses_only_configured_archive_work_item_without_chat_match",
+      archiveThread.threadID === "thread-configured-1"
+        && archiveThread.workItemID === "12345678-1234-1234-1234-1234567890ab"
+        && archiveThread.source === "auto-created-thread-on-configured-work-item"
+        && createdCalls.length === 1,
+      `thread=${archiveThread.threadID} work_item=${archiveThread.workItemID} created_calls=${createdCalls.length}`,
+    );
+  } catch (err) {
+    push("archive_thread_reuses_only_configured_archive_work_item_without_chat_match", false, String(err?.message || err));
   }
 
   const aliasMaps = buildToolAliasMaps([
@@ -1716,6 +1837,103 @@ export async function runSelftestRunnerScenarios(push, deps) {
       `conversation=${String(replyChainStatusLoopLookup.resolved_conversation_id || "(none)")} source_message=${String(safeObject(replyChainStatusLoopLookup.related_request).source_message_id || "(none)")} intent=${String(safeObject(replyChainStatusLoopLookup.related_request).normalized_intent || "(none)")} root_work_item=${String(safeObject(replyChainStatusLoopLookup.root_work_item).id || "(none)")}`,
     );
 
+    const multihopConversationID = "reply_chain:telegram:-100123:701";
+    const multihopThreadID = "reply-chain-thread-701";
+    const multihopBotReplyBody = formatBotReplyArchiveComment({
+      provider: "telegram",
+      bot: {
+        id: "bot-ryoai",
+        name: "RyoAI_bot",
+        username: "RyoAI_bot",
+        role: "monitor",
+      },
+      destination: {
+        chatID: "-100123",
+        label: "Main Room",
+      },
+      replyText: "Still working on the original task.",
+      messageID: 702,
+      replyToMessageID: 701,
+    });
+    const multihopServer = await startReplyChainSelftestServer({
+      projectID: selftestProjectID,
+      threadID: multihopThreadID,
+      comments: [
+        {
+          id: "comment-bot-reply-702",
+          body: multihopBotReplyBody,
+        },
+      ],
+    });
+    try {
+      saveBotRunnerState({
+        routes: {},
+        sharedInboxes: {},
+        excludedComments: {},
+        requests: {
+          "request-key-701": {
+            request_key: "request-key-701",
+            project_id: selftestProjectID,
+            provider: "telegram",
+            chat_id: "-100123",
+            source_message_id: 701,
+            conversation_id: "",
+            selected_bot_usernames: ["ryoai_bot"],
+            normalized_intent: "ctxpack_mutation",
+            status: "running",
+            claimed_by_route: requestRouteKey,
+            root_work_item_id: "root-work-item-701",
+            root_work_item_title: "Root reply-chain task",
+            root_work_item_status: "doing",
+            root_thread_id: "root-thread-701",
+            updated_at: "2026-03-22T02:03:00.000Z",
+          },
+        },
+        consumedComments: {},
+      });
+      const multihopReplyClaim = await claimRunnerRequestForHumanComment({
+        normalizedRoute: requestRoute,
+        routeKey: requestRouteKey,
+        selectedRecord: {
+          id: "comment-request-root-task-5",
+          createdAt: "2026-03-22T00:07:00.000Z",
+          updatedAt: "2026-03-22T00:07:00.000Z",
+          parsedArchive: {
+            kind: "telegram_message",
+            chatID: "-100123",
+            chatType: "supergroup",
+            body: "@RyoAI_bot is the original task done now?",
+            messageID: 704,
+            replyToMessageID: 702,
+            senderIsBot: false,
+            mentionUsernames: ["ryoai_bot"],
+          },
+        },
+        selectedBotUsernames: ["ryoai_bot"],
+        normalizedIntent: "status_query",
+        runtime: {
+          baseURL: multihopServer.baseURL,
+          token: "selftest-token",
+          timeoutSeconds: 5,
+          actor: { user_id: "selftest-user" },
+        },
+        archiveThreadID: multihopThreadID,
+      });
+      const multihopClaimedRequest = safeObject(
+        safeObject(loadBotRunnerState().requests)[multihopReplyClaim.requestKey],
+      );
+      push(
+        "runner_request_claim_resolves_multihop_reply_chain_anchor",
+        multihopReplyClaim.ok === true
+          && String(multihopClaimedRequest.conversation_id || "") === multihopConversationID
+          && String(multihopClaimedRequest.root_work_item_id || "") === "root-work-item-701"
+          && String(multihopClaimedRequest.root_thread_id || "") === "root-thread-701",
+        `conversation=${String(multihopClaimedRequest.conversation_id || "(none)")} root_work_item=${String(multihopClaimedRequest.root_work_item_id || "(none)")} root_thread=${String(multihopClaimedRequest.root_thread_id || "(none)")}`,
+      );
+    } finally {
+      await multihopServer.close();
+    }
+
     const stateBeforeCleanup = loadBotRunnerState();
     saveBotRunnerState({
       ...stateBeforeCleanup,
@@ -8401,6 +8619,159 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("small_talk_direct_mention_skips_dynamic_execution_plan", false, String(err?.message || err));
   }
 
+  try {
+    let capturedExecutionPlan = null;
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-selftest-small-talk-mini-"));
+    const processed = await processRunnerSelectedRecord({
+      routeKey: "small-talk-mini-execution-key",
+      normalizedRoute: normalizeRunnerRoute({
+        name: "telegram-monitor-small-talk-mini",
+        project_id: selftestProjectID,
+        provider: "telegram",
+        role: "monitor",
+        role_profile: "monitor",
+        destination_id: "dest-1",
+        destination_label: "Main Room",
+        server_bot_name: "RyoAI_bot",
+        server_bot_id: "bot-1",
+        trigger_policy: {
+          mentions_only: true,
+          direct_messages: true,
+          reply_to_bot_messages: true,
+        },
+        archive_policy: {
+          mirror_replies: true,
+          dedupe_inbound: true,
+          dedupe_outbound: true,
+          skip_bot_messages: true,
+        },
+        dry_run_delivery: true,
+      }),
+      selectedRecord: {
+        id: "comment-small-talk-mini-execution",
+        createdAt: "2026-03-24T00:11:00.000Z",
+        parsedArchive: {
+          kind: "telegram_message",
+          chatID: "-100123",
+          chatType: "supergroup",
+          body: "@RyoAI_bot 하이",
+          messageID: 212,
+          sender: "human",
+          senderIsBot: false,
+          mentionUsernames: ["ryoai_bot"],
+        },
+      },
+      pendingOrdered: [],
+      bot: {
+        id: "bot-1",
+        name: "RyoAI_bot",
+        username: "RyoAI_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: "gpt",
+          model: "gpt-5.4",
+          permissionMode: "workspace_write",
+          reasoningEffort: "medium",
+        },
+        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 ({ executionPlan }) => {
+          capturedExecutionPlan = safeObject(executionPlan);
+          return {
+            skip: false,
+            reply: "안녕하세요.",
+            replyToMessageID: 212,
+          };
+        },
+        performLocalBotDelivery: async () => ({
+          delivery: { dryRun: true, body: {} },
+          archive: {},
+        }),
+        serializeRunnerTriggerPolicy: (value) => value,
+        serializeRunnerArchivePolicy: (value) => value,
+        buildRunnerExecutionDeps: () => ({
+          resolveInformationalQueryReply: async () => ({
+            handled: true,
+            response_mode: "lookup_only",
+            reply: "",
+            source: "small_talk",
+            lookup: { intent_type: "small_talk" },
+            execution_override: {
+              mode: "role_profile",
+              role_profile_name: "monitor",
+              role_profile: {
+                client: "gpt",
+                model: "gpt-5-mini",
+                permissionMode: "read_only",
+                reasoningEffort: "low",
+              },
+              workspace_dir: workspaceDir,
+              workspace_source: "selftest",
+            },
+          }),
+          planRoleExecutionWithAI: async () => ({
+            requiresExecution: true,
+            summaryRole: "worker",
+            steps: [{ role: "worker", goal: "unexpected", artifactsRequired: true }],
+          }),
+          resolveRunnerExecutionPlanForRole: () => ({
+            mode: "role_profile",
+            roleProfileName: "worker",
+            roleProfile: {
+              client: "sample",
+              model: "",
+              permissionMode: "workspace_write",
+              reasoningEffort: "medium",
+            },
+            workspaceDir,
+            workspaceSource: "selftest",
+            usedCommandFallback: false,
+          }),
+        }),
+        buildRunnerDeliveryDeps: () => ({}),
+        buildRunnerRuntimeDeps: () => ({}),
+        resolveConversationPeerBots: () => [],
+      },
+    });
+    push(
+      "small_talk_lookup_only_uses_mini_execution_plan",
+      processed.kind === "replied"
+        && String(safeObject(capturedExecutionPlan).roleProfile?.client || "") === "gpt"
+        && ["gpt-5-mini", "gpt-5.3-codex-spark"].includes(String(safeObject(capturedExecutionPlan).roleProfile?.model || ""))
+        && String(safeObject(capturedExecutionPlan).roleProfile?.permissionMode || "") === "read_only"
+        && String(safeObject(capturedExecutionPlan).roleProfile?.reasoningEffort || "") === "low",
+      JSON.stringify(capturedExecutionPlan || {}),
+    );
+  } catch (err) {
+    push("small_talk_lookup_only_uses_mini_execution_plan", false, String(err?.message || err));
+  }
+
   try {
     let aiCalls = 0;
     let capturedInputPayload = null;

package/lib/selftest-telegram-e2e.mjs

@@ -868,6 +868,57 @@ export async function runSelftestTelegramE2E(push, deps) {
       `count=${telegramE2EServer.state.comments.filter((item) => String(item.body || "").includes("message_id: 353")).length}`,
     );
 
+    telegramE2EServer.state.comments = [];
+    telegramE2EServer.state.updates = [
+      {
+        update_id: 354,
+        message: {
+          message_id: 354,
+          message_thread_id: 999,
+          date: Math.floor(Date.now() / 1000),
+          chat: {
+            id: Number(e2eDestination.chat_id),
+            type: "supergroup",
+            title: e2eDestination.label,
+          },
+          from: {
+            id: 5001,
+            is_bot: false,
+            first_name: "Operator",
+            username: "operator_user",
+          },
+          text: "topic metadata should not be archived",
+        },
+      },
+    ];
+    await archiveLocalTelegramMessagesForRoute({
+      routeKey: pruneRouteKey,
+      route: pruneRoute,
+      routeState: safeObject(loadBotRunnerState().routes[pruneRouteKey]),
+      runtime: {
+        baseURL: telegramE2EServer.baseURL,
+        timeoutSeconds: 10,
+        token: e2eToken,
+        actor: {
+          user_id: e2eActorUserID,
+        },
+      },
+      bot: e2eBot,
+      destination: {
+        chatID: e2eDestination.chat_id,
+      },
+      archiveThread: {
+        threadID: e2eThreadID,
+      },
+      deps: buildRunnerRuntimeDeps(),
+    });
+    const topicArchiveBody = String(safeObject(telegramE2EServer.state.comments[0]).body || "");
+    push(
+      "telegram_inbound_archive_omits_unused_topic_metadata",
+      topicArchiveBody.includes("message_id: 354") && !topicArchiveBody.includes("telegram_topic_id:"),
+      topicArchiveBody,
+    );
+
     telegramE2EServer.state.comments = [];
     telegramE2EServer.state.updates = [
       {

package/package.json

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