metheus-governance-mcp-cli 0.2.196 → 0.2.197

package/cli.mjs

@@ -2363,6 +2363,16 @@ function buildRunnerRequestKey({
   ].join("::");
 }
 
+function buildSyntheticReplyChainConversationID(normalizedRoute, chatID, anchorMessageID) {
+  const provider = String(normalizedRoute?.provider || "").trim() || "unknown";
+  const normalizedChatID = String(chatID || "").trim() || "-";
+  const normalizedAnchorMessageID = intFromRawAllowZero(anchorMessageID, 0);
+  if (normalizedAnchorMessageID <= 0) {
+    return "";
+  }
+  return `reply_chain:${provider}:${normalizedChatID}:${normalizedAnchorMessageID}`;
+}
+
 function findRunnerRequestsForScope(state, normalizedRoute, selectors = {}) {
   const requests = normalizeBotRunnerRequests(state?.requests);
   const projectID = String(normalizedRoute?.projectID || "").trim();
@@ -2386,6 +2396,61 @@ function findRunnerRequestsForScope(state, normalizedRoute, selectors = {}) {
     });
 }
 
+function findRunnerRequestsForMessageID(state, normalizedRoute, selectors = {}) {
+  const chatID = String(selectors.chatID || "").trim();
+  const messageID = intFromRawAllowZero(selectors.messageID, 0);
+  if (!chatID || messageID <= 0) {
+    return [];
+  }
+  return findRunnerRequestsForScope(state, normalizedRoute, { chatID })
+    .filter((entry) => (
+      intFromRawAllowZero(entry.source_message_id, 0) === messageID
+      || intFromRawAllowZero(entry.last_source_message_id, 0) === messageID
+    ));
+}
+
+function resolveRunnerReplyChainConversationContext(state, normalizedRoute, selectedRecord) {
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const explicitConversationID = String(parsed.conversationID || "").trim();
+  if (explicitConversationID) {
+    return {
+      conversationID: explicitConversationID,
+      replyToMessageID: intFromRawAllowZero(parsed.replyToMessageID, 0),
+      anchorMessageID: 0,
+      reason: "archive_conversation",
+      referencedRequest: null,
+    };
+  }
+  const chatID = String(parsed.chatID || parsed.chatId || "").trim();
+  const replyToMessageID = intFromRawAllowZero(parsed.replyToMessageID, 0);
+  if (!chatID || replyToMessageID <= 0) {
+    return {
+      conversationID: "",
+      replyToMessageID,
+      anchorMessageID: 0,
+      reason: "",
+      referencedRequest: null,
+    };
+  }
+  const referencedRequest = safeObject(findRunnerRequestsForMessageID(state, normalizedRoute, {
+    chatID,
+    messageID: replyToMessageID,
+  })[0]);
+  const referencedConversationID = String(referencedRequest.conversation_id || "").trim();
+  const anchorMessageID = intFromRawAllowZero(referencedRequest.source_message_id, 0) || replyToMessageID;
+  return {
+    conversationID: referencedConversationID || buildSyntheticReplyChainConversationID(normalizedRoute, chatID, anchorMessageID),
+    replyToMessageID,
+    anchorMessageID,
+    reason: referencedConversationID
+      ? "reply_request_conversation"
+      : Object.keys(referencedRequest).length > 0
+        ? "reply_request_synthetic"
+        : "reply_message_synthetic",
+    referencedRequest: Object.keys(referencedRequest).length > 0 ? referencedRequest : null,
+  };
+}
+
 function upsertRunnerRequest(state, requestKey, patch = {}) {
   const currentState = safeObject(state);
   const requests = normalizeBotRunnerRequests(currentState.requests);
@@ -2447,7 +2512,24 @@ function claimRunnerRequestForHumanComment({
     normalizedIntent,
   });
   const currentState = loadBotRunnerState();
-  const requests = normalizeBotRunnerRequests(currentState.requests);
+  const replyChainContext = resolveRunnerReplyChainConversationContext(currentState, normalizedRoute, selectedRecord);
+  const conversationID = String(parsed.conversationID || replyChainContext.conversationID || "").trim();
+  let stateForClaim = currentState;
+  if (
+    replyChainContext.referencedRequest
+    && conversationID
+    && !String(replyChainContext.referencedRequest.conversation_id || "").trim()
+    && String(replyChainContext.referencedRequest.request_key || "").trim()
+  ) {
+    const backfilled = upsertRunnerRequest(stateForClaim, replyChainContext.referencedRequest.request_key, {
+      conversation_id: conversationID,
+    });
+    stateForClaim = {
+      ...stateForClaim,
+      requests: backfilled.requests,
+    };
+  }
+  const requests = normalizeBotRunnerRequests(stateForClaim.requests);
   const existing = safeObject(requests[requestKey]);
   if (isFinalRunnerRequestStatus(existing.status)) {
     return {
@@ -2468,14 +2550,14 @@ function claimRunnerRequestForHumanComment({
     };
   }
   const nowISO = new Date().toISOString();
-  const { requests: nextRequests, request } = upsertRunnerRequest(currentState, requestKey, {
+  const { requests: nextRequests, request } = upsertRunnerRequest(stateForClaim, requestKey, {
     project_id: String(normalizedRoute?.projectID || "").trim(),
     provider: String(normalizedRoute?.provider || "").trim(),
     chat_id: String(parsed.chatID || parsed.chatId || "").trim(),
     source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
     root_comment_id: String(selectedRecord?.id || "").trim(),
     root_comment_kind: commentKind,
-    conversation_id: String(parsed.conversationID || "").trim(),
+    conversation_id: conversationID,
     selected_bot_usernames: uniqueOrderedStrings(selectedBotUsernames, normalizeTelegramMentionUsername),
     normalized_intent: String(normalizedIntent || "").trim().toLowerCase(),
     status: "claimed",
@@ -2485,20 +2567,20 @@ function claimRunnerRequestForHumanComment({
     last_comment_kind: commentKind,
     last_source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
   });
-  const { consumedComments: nextConsumedComments } = upsertRunnerConsumedComment(currentState, selectedRecord?.id, {
+  const { consumedComments: nextConsumedComments } = upsertRunnerConsumedComment(stateForClaim, selectedRecord?.id, {
     project_id: String(normalizedRoute?.projectID || "").trim(),
     provider: String(normalizedRoute?.provider || "").trim(),
     request_key: requestKey,
     route_key: String(routeKey || "").trim(),
-    conversation_id: String(parsed.conversationID || "").trim(),
+    conversation_id: conversationID,
     source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
     comment_kind: commentKind,
     request_status: "claimed",
   });
   saveBotRunnerState({
-    routes: currentState.routes,
-    sharedInboxes: currentState.sharedInboxes || currentState.shared_inboxes,
-    excludedComments: currentState.excludedComments || currentState.excluded_comments,
+    routes: stateForClaim.routes,
+    sharedInboxes: stateForClaim.sharedInboxes || stateForClaim.shared_inboxes,
+    excludedComments: stateForClaim.excludedComments || stateForClaim.excluded_comments,
     requests: nextRequests,
     consumedComments: nextConsumedComments,
   });
@@ -5149,20 +5231,77 @@ function summarizeRunnerRequestForStatusLookup(entryRaw) {
   return {
     status: String(entry.status || "").trim(),
     normalized_intent: String(entry.normalized_intent || "").trim(),
+    conversation_id: String(entry.conversation_id || "").trim(),
+    closed_reason: String(entry.closed_reason || "").trim(),
     claimed_at: firstNonEmptyString([entry.claimed_at, entry.started_at]),
     started_at: firstNonEmptyString([entry.started_at, entry.claimed_at]),
     updated_at: String(entry.updated_at || "").trim(),
     source_message_id: intFromRawAllowZero(entry.source_message_id, 0) || undefined,
+    last_source_message_id: intFromRawAllowZero(entry.last_source_message_id, 0) || undefined,
     selected_bot_usernames: ensureArray(entry.selected_bot_usernames)
       .map((value) => normalizeTelegramMentionUsername(value))
       .filter(Boolean),
   };
 }
 
+function isInformationalRunnerRequestIntent(intentType) {
+  return new Set([
+    "status_query",
+    "bot_role_query",
+    "workspace_query",
+    "explanation_query",
+    "small_talk",
+  ]).has(String(intentType || "").trim().toLowerCase());
+}
+
+function requestEligibleForStatusLookup(entryRaw, routeKey, selfBotUsername, currentMessageID) {
+  const entry = safeObject(entryRaw);
+  const sourceMessageID = intFromRawAllowZero(entry.source_message_id, 0);
+  const lastSourceMessageID = intFromRawAllowZero(entry.last_source_message_id, 0);
+  if (
+    (currentMessageID > 0 && sourceMessageID === currentMessageID)
+    || (currentMessageID > 0 && lastSourceMessageID === currentMessageID)
+  ) {
+    return false;
+  }
+  if (String(entry.claimed_by_route || "").trim() === routeKey) {
+    return true;
+  }
+  if (!selfBotUsername) {
+    return true;
+  }
+  return ensureArray(entry.selected_bot_usernames)
+    .map((value) => normalizeTelegramMentionUsername(value))
+    .filter(Boolean)
+    .includes(selfBotUsername);
+}
+
+function pickPreferredStatusLookupRequest(entries = []) {
+  const candidates = ensureArray(entries).map((entry) => safeObject(entry)).filter((entry) => Object.keys(entry).length > 0);
+  if (!candidates.length) {
+    return null;
+  }
+  const activeNonInformational = candidates.filter((entry) => (
+    isActiveRunnerRequestStatus(entry.status)
+    && !isInformationalRunnerRequestIntent(entry.normalized_intent)
+  ));
+  if (activeNonInformational.length) {
+    return activeNonInformational[0];
+  }
+  const nonInformational = candidates.filter((entry) => !isInformationalRunnerRequestIntent(entry.normalized_intent));
+  if (nonInformational.length) {
+    return nonInformational[0];
+  }
+  const activeAny = candidates.filter((entry) => isActiveRunnerRequestStatus(entry.status));
+  if (activeAny.length) {
+    return activeAny[0];
+  }
+  return candidates[0];
+}
+
 function buildRunnerStatusQueryLookup({ route, routeState, selectedRecord }) {
   const parsed = safeObject(selectedRecord?.parsedArchive);
   const currentMessageID = intFromRawAllowZero(parsed.messageID, 0);
-  const currentConversationID = String(parsed.conversationID || "").trim();
   const currentChatID = String(parsed.chatID || parsed.chatId || "").trim();
   const routeKey = runnerRouteKey(route);
   const selfBotUsername = normalizeTelegramMentionUsername(firstNonEmptyString([
@@ -5179,34 +5318,52 @@ function buildRunnerStatusQueryLookup({ route, routeState, selectedRecord }) {
     && activeSourceMessageID > 0
     && currentMessageID === activeSourceMessageID
   );
-  let relatedActiveRequest = null;
+  let runnerState = { requests: {} };
   try {
-    const runnerState = loadBotRunnerState();
-    const selectors = currentConversationID
-      ? { conversationID: currentConversationID, chatID: currentChatID }
-      : { chatID: currentChatID };
-    let scopedRequests = findRunnerRequestsForScope(runnerState, route, selectors);
-    if (!scopedRequests.length && currentConversationID) {
-      scopedRequests = findRunnerRequestsForScope(runnerState, route, { chatID: currentChatID });
-    }
-    relatedActiveRequest = scopedRequests
-      .filter((entry) => isActiveRunnerRequestStatus(entry.status))
-      .filter((entry) => intFromRawAllowZero(entry.source_message_id, 0) !== currentMessageID)
-      .filter((entry) => {
-        if (String(entry.claimed_by_route || "").trim() === routeKey) return true;
-        if (!selfBotUsername) return true;
-        return ensureArray(entry.selected_bot_usernames)
-          .map((value) => normalizeTelegramMentionUsername(value))
-          .filter(Boolean)
-          .includes(selfBotUsername);
-      })[0] || null;
+    runnerState = loadBotRunnerState();
   } catch {}
+  const replyChainContext = resolveRunnerReplyChainConversationContext(runnerState, route, selectedRecord);
+  const currentConversationID = String(parsed.conversationID || replyChainContext.conversationID || "").trim();
+  const requestMatchesCurrentRoute = (entry) => requestEligibleForStatusLookup(
+    entry,
+    routeKey,
+    selfBotUsername,
+    currentMessageID,
+  );
+  let relatedActiveRequest = null;
+  let relatedRequest = null;
+  const selectors = currentConversationID
+    ? { conversationID: currentConversationID, chatID: currentChatID }
+    : { chatID: currentChatID };
+  let scopedRequests = findRunnerRequestsForScope(runnerState, route, selectors);
+  if (!scopedRequests.length && currentConversationID) {
+    scopedRequests = findRunnerRequestsForScope(runnerState, route, { chatID: currentChatID });
+  }
+  const eligibleScopedRequests = scopedRequests.filter(requestMatchesCurrentRoute);
+  relatedActiveRequest = eligibleScopedRequests
+    .filter((entry) => isActiveRunnerRequestStatus(entry.status))[0] || null;
+  relatedRequest = pickPreferredStatusLookupRequest(
+    eligibleScopedRequests.length
+      ? eligibleScopedRequests
+      : (replyChainContext.referencedRequest ? [replyChainContext.referencedRequest] : []).filter(requestMatchesCurrentRoute),
+  );
   const lastAction = String(safeObject(routeState).last_action || "").trim();
   const lastReason = String(safeObject(routeState).last_reason || "").trim();
   const lastIntentType = String(safeObject(routeState).last_intent_type || "").trim();
+  const routeConversationID = String(safeObject(routeState).last_conversation_id || "").trim();
+  const routeWorkItemIDs = ensureArray(safeObject(routeState).last_work_item_ids).map((item) => String(item || "").trim()).filter(Boolean);
+  const routeWorkItemTitles = ensureArray(safeObject(routeState).last_work_item_titles).map((item) => String(item || "").trim()).filter(Boolean);
   return {
     kind: "runner_status",
-    status: (!selfBusyFiltered && activeExecution.active) || relatedActiveRequest ? "running" : "idle",
+    status: (!selfBusyFiltered && activeExecution.active) || relatedActiveRequest
+      ? "running"
+      : String(safeObject(relatedRequest).status || "").trim() || "idle",
+    resolved_conversation_id: currentConversationID,
+    reply_chain_resolution: {
+      reason: String(replyChainContext.reason || "").trim(),
+      reply_to_message_id: intFromRawAllowZero(replyChainContext.replyToMessageID, 0) || undefined,
+      anchor_message_id: intFromRawAllowZero(replyChainContext.anchorMessageID, 0) || undefined,
+    },
     self_busy_filtered: selfBusyFiltered,
     active_execution: activeExecution.active && !selfBusyFiltered
       ? {
@@ -5218,6 +5375,13 @@ function buildRunnerStatusQueryLookup({ route, routeState, selectedRecord }) {
         }
       : null,
     related_active_request: relatedActiveRequest ? summarizeRunnerRequestForStatusLookup(relatedActiveRequest) : null,
+    related_request: relatedRequest ? summarizeRunnerRequestForStatusLookup(relatedRequest) : null,
+    route_work_items: currentConversationID && routeConversationID === currentConversationID && (routeWorkItemIDs.length > 0 || routeWorkItemTitles.length > 0)
+      ? {
+          ids: routeWorkItemIDs,
+          titles: routeWorkItemTitles,
+        }
+      : null,
     last_route_result: {
       action: lastAction,
       reason: lastReason,
@@ -12966,6 +13130,7 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     runnerRouteLogicalSignature,
     loadBotRunnerState,
     saveBotRunnerState,
+    buildRunnerStatusQueryLookup,
     tryJsonParse,
     safeObject,
     normalizeRunnerTriggerPolicy,

package/lib/selftest-runner-scenarios.mjs

@@ -46,6 +46,7 @@ export async function runSelftestRunnerScenarios(push, deps) {
   const runnerRouteLogicalSignature = requireDependency(deps, "runnerRouteLogicalSignature");
   const loadBotRunnerState = requireDependency(deps, "loadBotRunnerState");
   const saveBotRunnerState = requireDependency(deps, "saveBotRunnerState");
+  const buildRunnerStatusQueryLookup = requireDependency(deps, "buildRunnerStatusQueryLookup");
   const claimRunnerRequestForHumanComment = requireDependency(deps, "claimRunnerRequestForHumanComment");
   const markRunnerRequestLifecycle = requireDependency(deps, "markRunnerRequestLifecycle");
   const resolveRunnerContinuationRequestForBotReply = requireDependency(deps, "resolveRunnerContinuationRequestForBotReply");
@@ -1424,10 +1425,106 @@ export async function runSelftestRunnerScenarios(push, deps) {
       `request=${String(claimed.requestKey || "(none)")} status=${String(claimedRequest.status || "(none)")} consumed=${String(claimedConsumed.request_key || "(none)")}`,
     );
 
+    const rootTaskRecord = {
+      id: "comment-request-root-task-1",
+      createdAt: "2026-03-22T00:05:00.000Z",
+      updatedAt: "2026-03-22T00:05:00.000Z",
+      parsedArchive: {
+        kind: "telegram_message",
+        chatID: "-100123",
+        chatType: "supergroup",
+        body: "@RyoAI_bot remove the implementation guide entry",
+        messageID: 601,
+        senderIsBot: false,
+      },
+    };
+    const rootTaskClaim = claimRunnerRequestForHumanComment({
+      normalizedRoute: requestRoute,
+      routeKey: requestRouteKey,
+      selectedRecord: rootTaskRecord,
+      selectedBotUsernames: ["ryoai_bot"],
+      normalizedIntent: "ctxpack_mutation",
+    });
+    const replyTaskRecord = {
+      id: "comment-request-root-task-2",
+      createdAt: "2026-03-22T00:06:00.000Z",
+      updatedAt: "2026-03-22T00:06:00.000Z",
+      parsedArchive: {
+        kind: "telegram_message",
+        chatID: "-100123",
+        chatType: "supergroup",
+        body: "@RyoAI_bot did you handle it?",
+        messageID: 602,
+        replyToMessageID: 601,
+        senderIsBot: false,
+        mentionUsernames: ["ryoai_bot"],
+      },
+    };
+    const replyTaskClaim = claimRunnerRequestForHumanComment({
+      normalizedRoute: requestRoute,
+      routeKey: requestRouteKey,
+      selectedRecord: replyTaskRecord,
+      selectedBotUsernames: ["ryoai_bot"],
+      normalizedIntent: "status_query",
+    });
+    const syntheticConversationID = "reply_chain:telegram:-100123:601";
+    const replyChainState = loadBotRunnerState();
+    const rootTaskRequest = safeObject(safeObject(replyChainState.requests)[rootTaskClaim.requestKey]);
+    const replyTaskRequest = safeObject(safeObject(replyChainState.requests)[replyTaskClaim.requestKey]);
+    push(
+      "runner_request_reply_chain_assigns_synthetic_conversation",
+      replyTaskClaim.ok === true
+        && String(rootTaskRequest.conversation_id || "") === syntheticConversationID
+        && String(replyTaskRequest.conversation_id || "") === syntheticConversationID,
+      `root_conversation=${String(rootTaskRequest.conversation_id || "(none)")} reply_conversation=${String(replyTaskRequest.conversation_id || "(none)")}`,
+    );
+
+    markRunnerRequestLifecycle({
+      normalizedRoute: requestRoute,
+      requestKey: rootTaskClaim.requestKey,
+      selectedRecord: rootTaskRecord,
+      routeKey: requestRouteKey,
+      outcome: "replied",
+      conversationIDRaw: syntheticConversationID,
+      normalizedIntent: "ctxpack_mutation",
+    });
+    const replyChainLookup = buildRunnerStatusQueryLookup({
+      route: requestRoute,
+      routeState: {
+        last_conversation_id: syntheticConversationID,
+        last_work_item_ids: ["work-item-601"],
+        last_work_item_titles: ["Remove implementation guide entry"],
+      },
+      selectedRecord: {
+        id: "comment-request-root-task-3",
+        parsedArchive: {
+          kind: "telegram_message",
+          chatID: "-100123",
+          chatType: "supergroup",
+          body: "@RyoAI_bot was that task done?",
+          messageID: 603,
+          replyToMessageID: 602,
+          senderIsBot: false,
+          mentionUsernames: ["ryoai_bot"],
+        },
+      },
+    });
+    push(
+      "status_query_lookup_resolves_reply_chain_conversation_context",
+      String(replyChainLookup.resolved_conversation_id || "") === syntheticConversationID
+        && String(safeObject(replyChainLookup.related_request).normalized_intent || "") === "ctxpack_mutation"
+        && String(safeObject(replyChainLookup.related_request).source_message_id || "") === "601"
+        && String(safeObject(replyChainLookup.route_work_items).ids?.[0] || "") === "work-item-601",
+      `conversation=${String(replyChainLookup.resolved_conversation_id || "(none)")} intent=${String(safeObject(replyChainLookup.related_request).normalized_intent || "(none)")} source_message=${String(safeObject(replyChainLookup.related_request).source_message_id || "(none)")} work_item=${String(safeObject(replyChainLookup.route_work_items).ids?.[0] || "(none)")}`,
+    );
+
+    const stateBeforeCleanup = loadBotRunnerState();
     saveBotRunnerState({
-      ...claimedState,
+      ...stateBeforeCleanup,
       routes: {
+        ...safeObject(stateBeforeCleanup.routes),
         [requestRouteKey]: {
+          ...safeObject(safeObject(stateBeforeCleanup.routes)[requestRouteKey]),
           conversation_sessions: {
             "conv-stale-1": {
               status: "open",

package/package.json

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