metheus-governance-mcp-cli 0.2.200 → 0.2.202

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"}`);
@@ -6149,6 +6319,7 @@ function stableTextModulo(rawValue, modulo = 1) {
   return hash % normalizedModulo;
 }
 
+/* Dead small_talk helper kept only as commented legacy code after lookup-only migration.
 function buildRunnerSmallTalkReply({ route, executionPlan } = {}) {
   const normalizedRoute = safeObject(route);
   const roleProfileName = normalizeRunnerRoleProfileName(
@@ -6185,6 +6356,30 @@ function buildRunnerSmallTalkReply({ route, executionPlan } = {}) {
   const templatePool = roleSpecificReplies[roleProfileName] || roleSpecificReplies.monitor;
   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);
@@ -6411,13 +6606,23 @@ 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(),
+      },
+      execution_override: executionOverride,
     };
   }
+  /* Dead legacy direct small_talk branch kept commented for reference.
   if (false && normalizedIntentType === "small_talk") {
     return {
       handled: true,
@@ -6425,6 +6630,7 @@ async function resolveInformationalQueryReply({
       source: "small_talk",
     };
   }
+  */
   if (normalizedIntentType === "workspace_query") {
     const workspace = resolveProjectWorkspaceBindingSummary(route?.projectID, executionPlan?.workspaceDir || route?.workspaceDir || "");
     const workspaceDir = String(workspace.workspace_dir || "").trim();
@@ -6433,9 +6639,13 @@ async function resolveInformationalQueryReply({
       : "현재 이 프로젝트는 project-workspaces.json에 로컬 작업 폴더가 바인딩되어 있지 않습니다.";
     return {
       handled: true,
-      reply,
+      response_mode: "lookup_only",
+      reply: "",
       source: "project.workspace",
-      lookup: workspace,
+      lookup: {
+        ...workspace,
+      },
+      execution_override: executionOverride,
     };
   }
   if (normalizedIntentType === "bot_role_query") {
@@ -6447,9 +6657,13 @@ async function resolveInformationalQueryReply({
     });
     return {
       handled: true,
-      reply: buildProjectBotRolesText(payload),
+      response_mode: "lookup_only",
+      reply: "",
       source: "project.bot_roles",
-      lookup: payload,
+      lookup: {
+        ...payload,
+      },
+      execution_override: executionOverride,
     };
   }
   if (normalizedIntentType === "status_query") {
@@ -6512,9 +6726,13 @@ async function resolveInformationalQueryReply({
     });
     return {
       handled: true,
-      reply: buildProjectFileLocateText(payload),
+      response_mode: "lookup_only",
+      reply: "",
       source: "project.file.locate",
-      lookup: payload,
+      lookup: {
+        ...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) {
@@ -14175,20 +14394,44 @@ async function runSelftest(flags = {}) {
     String(parsedEnv.SLACK_BOT_TOKEN || "") === "xoxb-test",
     `token=${String(parsedEnv.SLACK_BOT_TOKEN || "(missing)")}`,
   );
-  const monitorGreeting = buildRunnerSmallTalkReply({
-    route: { botName: "RyoAI_bot", roleProfile: "monitor" },
-    executionPlan: { roleProfileName: "monitor" },
+  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 reviewGreeting = buildRunnerSmallTalkReply({
-    route: { botName: "RyoAI2_bot", roleProfile: "review" },
-    executionPlan: { roleProfileName: "review" },
+  const expectedInformationalModel = resolveResponderAdjudicatorModelDisplayName({
+    client: "gpt",
+    env: process.env,
   });
   push(
-    "small_talk_reply_varies_by_bot_and_role",
-    monitorGreeting.includes("RyoAI_bot")
-      && reviewGreeting.includes("RyoAI2_bot")
-      && monitorGreeting !== reviewGreeting,
-    `monitor=${monitorGreeting} review=${reviewGreeting}`,
+    "small_talk_reply_uses_lookup_only_mini_override",
+    safeObject(informationalMiniReply).handled === true
+      && String(safeObject(informationalMiniReply).response_mode || "") === "lookup_only"
+      && String(safeObject(informationalMiniReply).reply || "") === ""
+      && !Object.prototype.hasOwnProperty.call(safeObject(safeObject(informationalMiniReply).lookup), "proposed_summary")
+      && 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

package/lib/local-ai-adapters.mjs

@@ -1786,9 +1786,6 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
     if (queryLookupResponseMode) {
       lines.push(`- Response mode: ${queryLookupResponseMode}`);
     }
-    if (String(queryLookup.proposed_reply || "").trim()) {
-      lines.push(`- Proposed factual reply: ${String(queryLookup.proposed_reply || "").trim()}`);
-    }
     if (queryLookupFacts != null) {
       lines.push("Structured lookup facts:");
       lines.push(JSON.stringify(queryLookupFacts, null, 2));
@@ -1994,7 +1991,7 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
         String(conversation.intent_mode || "").trim() === "delegated_single_lead"
           ? (selfIsLeadBot
             ? "This bot is the lead bot for a delegated public collaboration. It may assign work publicly only to allowed responders, and it may not expand the participant set."
-            : "This bot is not the lead bot. Respond only when the lead bot or the human explicitly addresses this bot, and do not start peer-to-peer chains.")
+            : "This bot is not the lead bot. Prefer replying when the human, the lead bot, or another managed bot explicitly addresses this bot in the live room context. Do not expand the participant set beyond the allowed responders.")
           : "Use the human conversation contract as the source of truth for who may reply.",
         conversation.allow_bot_to_bot === true
           ? "If another bot explicitly mentioned you and you are in the allowed responders list, you may answer that bot publicly in the room."

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",
           };
         }
       }