metheus-governance-mcp-cli 0.2.198 → 0.2.199

package/cli.mjs

@@ -2386,6 +2386,66 @@ function buildRunnerRequestKey({
   ].join("::");
 }
 
+function looksLikeRunnerClaimQuestion(rawText) {
+  return /[?？]/.test(String(rawText || ""));
+}
+
+function inferRunnerRequestClaimIntent(selectedRecord) {
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const commentKind = String(parsed.kind || "").trim().toLowerCase();
+  if (!isInboundArchiveKind(commentKind)) {
+    return "";
+  }
+  const rawText = String(parsed.body || "").trim();
+  const normalizedText = rawText.toLowerCase();
+  const replyToMessageID = intFromRawAllowZero(parsed.replyToMessageID, 0);
+  if (!rawText) {
+    return "";
+  }
+  if (/^(hi|hello|hey|thanks|thank you|good morning|good afternoon|good evening)\b/.test(normalizedText)) {
+    return "small_talk";
+  }
+  if (/\b(bot role|your role|what do you do|who are you|which bot|who should respond)\b/.test(normalizedText)) {
+    return "bot_role_query";
+  }
+  if (/\b(workspace|working directory|workdir|project folder|local folder)\b/.test(normalizedText)) {
+    return "workspace_query";
+  }
+  if (
+    (/\b(where|path|locate|find)\b/.test(normalizedText) || /\.[a-z0-9]{1,8}\b/.test(normalizedText))
+    && /\b(file|folder|path|doc|guide|readme|workspace)\b/.test(normalizedText)
+  ) {
+    return "artifact_location_query";
+  }
+  if (/\b(why|explain|what is|what does|how does|describe)\b/.test(normalizedText) && looksLikeRunnerClaimQuestion(rawText)) {
+    return "explanation_query";
+  }
+  if (
+    /\b(status|progress|done|finished|complete|completed|working on|current work|did you|handled|handle it|what are you working|check status)\b/
+      .test(normalizedText)
+  ) {
+    return "status_query";
+  }
+  if (replyToMessageID > 0 && looksLikeRunnerClaimQuestion(rawText)) {
+    return "status_query";
+  }
+  if (looksLikeRunnerClaimQuestion(rawText) && normalizedText.split(/\s+/).filter(Boolean).length <= 8) {
+    return "status_query";
+  }
+  return "general_execution";
+}
+
+function resolveRunnerRequestClaimIntent({
+  normalizedIntent = "",
+  selectedRecord,
+}) {
+  const explicitIntent = String(normalizedIntent || "").trim().toLowerCase();
+  if (explicitIntent) {
+    return explicitIntent;
+  }
+  return inferRunnerRequestClaimIntent(selectedRecord);
+}
+
 function buildSyntheticReplyChainConversationID(normalizedRoute, chatID, anchorMessageID) {
   const provider = String(normalizedRoute?.provider || "").trim() || "unknown";
   const normalizedChatID = String(chatID || "").trim() || "-";
@@ -2658,12 +2718,6 @@ async function claimRunnerRequestForHumanComment({
       reason: "non_human_comment_cannot_create_request",
     };
   }
-  const requestKey = buildRunnerRequestKey({
-    normalizedRoute,
-    selectedRecord,
-    selectedBotUsernames,
-    normalizedIntent,
-  });
   const currentState = loadBotRunnerState();
   const replyChainResolution = await resolveRunnerReplyChainConversationContextWithServerFallback({
     state: currentState,
@@ -2674,6 +2728,16 @@ async function claimRunnerRequestForHumanComment({
   const replyChainContext = safeObject(replyChainResolution.replyChainContext);
   const referencedRequest = safeObject(replyChainContext.referencedRequest);
   const conversationID = String(parsed.conversationID || replyChainContext.conversationID || "").trim();
+  const resolvedNormalizedIntent = resolveRunnerRequestClaimIntent({
+    normalizedIntent,
+    selectedRecord,
+  });
+  const requestKey = buildRunnerRequestKey({
+    normalizedRoute,
+    selectedRecord,
+    selectedBotUsernames,
+    normalizedIntent: resolvedNormalizedIntent,
+  });
   let stateForClaim = safeObject(replyChainResolution.state);
   if (
     Object.keys(referencedRequest).length > 0
@@ -2719,7 +2783,7 @@ async function claimRunnerRequestForHumanComment({
     root_comment_kind: commentKind,
     conversation_id: conversationID,
     selected_bot_usernames: uniqueOrderedStrings(selectedBotUsernames, normalizeTelegramMentionUsername),
-    normalized_intent: String(normalizedIntent || "").trim().toLowerCase(),
+    normalized_intent: resolvedNormalizedIntent,
     status: "claimed",
     claimed_by_route: String(routeKey || "").trim(),
     claimed_at: firstNonEmptyString([existing.claimed_at, nowISO]) || nowISO,
@@ -2767,6 +2831,22 @@ function isActionableRunnerRequestIntent(rawIntent) {
   return Boolean(normalizedIntent) && !isInformationalRunnerRequestIntent(normalizedIntent);
 }
 
+function loadRunnerRequestByKey(requestKey) {
+  const key = String(requestKey || "").trim();
+  if (!key) {
+    return {};
+  }
+  return safeObject(normalizeBotRunnerRequests(loadBotRunnerState().requests)[key]);
+}
+
+function actionableRunnerRequestMissingRootWorkItem(requestRaw) {
+  const request = safeObject(requestRaw);
+  return (
+    isActionableRunnerRequestIntent(request.normalized_intent)
+    && !String(request.root_work_item_id || "").trim()
+  );
+}
+
 function truncateRunnerWorkItemTitleText(rawText, maxLength = 96) {
   const text = String(rawText || "").replace(/\s+/g, " ").trim();
   if (!text) {
@@ -3850,6 +3930,12 @@ async function syncRunnerRequestLedgerForProjectToServer({ normalizedRoute, runt
     const commentStates = buildProjectRunnerRequestCommentStatesForSync(state, normalizedRoute);
 
     for (const request of requests) {
+      if (
+        isActionableRunnerRequestIntent(request.normalized_intent)
+        && !String(request.root_work_item_id || "").trim()
+      ) {
+        continue;
+      }
       await upsertProjectRunnerRequest({
         siteBaseURL: runtime.baseURL,
         projectID,
@@ -7070,7 +7156,19 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           runtime,
           requestKey: requestClaim.requestKey,
         });
-        if (!rootWorkItemClaim.ok) {
+        const claimedRequest = safeObject(
+          loadRunnerRequestByKey(requestClaim.requestKey)
+          || rootWorkItemClaim.request
+          || inheritedRootReference.request
+          || requestClaim.request,
+        );
+        const missingRequiredRootWorkItem = actionableRunnerRequestMissingRootWorkItem(claimedRequest);
+        if (!rootWorkItemClaim.ok || missingRequiredRootWorkItem) {
+          const rootWorkItemFailure = String(
+            rootWorkItemClaim.error
+            || rootWorkItemClaim.reason
+            || (missingRequiredRootWorkItem ? "root_work_item_missing" : "root_work_item_create_failed"),
+          ).trim() || "root_work_item_create_failed";
           if (String(requestClaim.requestKey || "").trim()) {
             markRunnerRequestLifecycle({
               normalizedRoute,
@@ -7078,7 +7176,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
               selectedRecord,
               routeKey,
               outcome: "closed",
-              closedReason: String(rootWorkItemClaim.error || rootWorkItemClaim.reason || "root_work_item_create_failed").trim(),
+              closedReason: rootWorkItemFailure,
             });
             await syncRunnerRequestLedgerForProjectToServer({
               normalizedRoute,
@@ -7089,22 +7187,21 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
             routeKey,
             buildRunnerRouteStateFromComment(selectedRecord, {
               last_action: "request_skipped",
-              last_reason: String(rootWorkItemClaim.error || rootWorkItemClaim.reason || "root_work_item_create_failed").trim() || "root_work_item_create_failed",
+              last_reason: rootWorkItemFailure,
               last_trigger: "work_item_root",
               last_request_key: String(requestClaim.requestKey || "").trim(),
             }),
           );
           skippedRecords.push({
             id: selectedRecord.id,
-            reason: String(rootWorkItemClaim.error || rootWorkItemClaim.reason || "root_work_item_create_failed").trim() || "root_work_item_create_failed",
+            reason: rootWorkItemFailure,
             messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
             diagnosticType: "skip",
             action: "skip_missing_root_work_item",
-            closedReason: String(rootWorkItemClaim.reason || "").trim(),
+            closedReason: rootWorkItemFailure,
           });
           continue;
         }
-        const claimedRequest = safeObject(rootWorkItemClaim.request || inheritedRootReference.request || requestClaim.request);
         saveRunnerRouteState(routeKey, {
           ...buildRunnerActiveExecutionPatch(selectedRecord, requestClaim.requestKey, {
             id: String(claimedRequest.root_work_item_id || "").trim(),
@@ -7299,7 +7396,19 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         runtime,
         requestKey: requestClaim.requestKey,
       });
-      if (!rootWorkItemClaim.ok) {
+      const claimedRequest = safeObject(
+        loadRunnerRequestByKey(requestClaim.requestKey)
+        || rootWorkItemClaim.request
+        || inheritedRootReference.request
+        || requestClaim.request,
+      );
+      const missingRequiredRootWorkItem = actionableRunnerRequestMissingRootWorkItem(claimedRequest);
+      if (!rootWorkItemClaim.ok || missingRequiredRootWorkItem) {
+        const rootWorkItemFailure = String(
+          rootWorkItemClaim.error
+          || rootWorkItemClaim.reason
+          || (missingRequiredRootWorkItem ? "root_work_item_missing" : "root_work_item_create_failed"),
+        ).trim() || "root_work_item_create_failed";
         if (String(requestClaim.requestKey || "").trim()) {
           markRunnerRequestLifecycle({
             normalizedRoute,
@@ -7307,7 +7416,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
             selectedRecord,
             routeKey,
             outcome: "closed",
-            closedReason: String(rootWorkItemClaim.error || rootWorkItemClaim.reason || "root_work_item_create_failed").trim(),
+            closedReason: rootWorkItemFailure,
           });
           await syncRunnerRequestLedgerForProjectToServer({
             normalizedRoute,
@@ -7318,22 +7427,21 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           routeKey,
           buildRunnerRouteStateFromComment(selectedRecord, {
             last_action: "request_skipped",
-            last_reason: String(rootWorkItemClaim.error || rootWorkItemClaim.reason || "root_work_item_create_failed").trim() || "root_work_item_create_failed",
+            last_reason: rootWorkItemFailure,
             last_trigger: "work_item_root",
             last_request_key: String(requestClaim.requestKey || "").trim(),
           }),
         );
         skippedRecords.push({
           id: selectedRecord.id,
-          reason: String(rootWorkItemClaim.error || rootWorkItemClaim.reason || "root_work_item_create_failed").trim() || "root_work_item_create_failed",
+          reason: rootWorkItemFailure,
           messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
           diagnosticType: "skip",
           action: "skip_missing_root_work_item",
-          closedReason: String(rootWorkItemClaim.reason || "").trim(),
+          closedReason: rootWorkItemFailure,
         });
         continue;
       }
-      const claimedRequest = safeObject(rootWorkItemClaim.request || inheritedRootReference.request || requestClaim.request);
       saveRunnerRouteState(routeKey, {
         ...buildRunnerActiveExecutionPatch(selectedRecord, requestClaim.requestKey, {
           id: String(claimedRequest.root_work_item_id || "").trim(),
@@ -9891,6 +9999,12 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                       last_error: errorText,
                     });
                     if (String(deferredExecution.requestKey || "").trim()) {
+                      const currentRequest = safeObject(loadRunnerRequestByKey(deferredExecution.requestKey));
+                      const resolvedIntentType = String(
+                        safeObject(loadBotRunnerState().routes[deferredExecution.routeKey]).last_intent_type
+                        || currentRequest.normalized_intent
+                        || "",
+                      ).trim();
                       markRunnerRequestLifecycle({
                         normalizedRoute: deferredExecution.normalizedRoute,
                         requestKey: deferredExecution.requestKey,
@@ -9898,6 +10012,14 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                         routeKey: deferredExecution.routeKey,
                         outcome: "error",
                         closedReason: errorText || "execution_error",
+                        normalizedIntent: resolvedIntentType,
+                      });
+                      await ensureRunnerRootWorkItemForRequest({
+                        normalizedRoute: deferredExecution.normalizedRoute,
+                        routeKey: deferredExecution.routeKey,
+                        selectedRecord: deferredExecution.selectedRecord,
+                        runtime: deferredExecution.runtime,
+                        requestKey: deferredExecution.requestKey,
                       });
                       const rootWorkItemSync = await syncRunnerRequestRootWorkItemForOutcome({
                         normalizedRoute: deferredExecution.normalizedRoute,

package/lib/runner-data.mjs

@@ -379,6 +379,7 @@ export async function upsertProjectRunnerRequest(
   const postJSONWithAuthHeaders = requireDependency(deps, "postJSONWithAuthHeaders");
   const parseJSONText = requireDependency(deps, "parseJSONText");
   const raw = safeObject(request);
+  const rootWorkItemID = String(raw.root_work_item_id || "").trim();
   const payload = {
     request_key: String(raw.request_key || "").trim(),
     project_id: String(raw.project_id || "").trim(),
@@ -398,12 +399,12 @@ export async function upsertProjectRunnerRequest(
     completed_at: String(raw.completed_at || "").trim() || undefined,
     closed_at: String(raw.closed_at || "").trim() || undefined,
     closed_reason: String(raw.closed_reason || "").trim(),
-    root_work_item_id: String(raw.root_work_item_id || "").trim(),
-    root_work_item_title: String(raw.root_work_item_title || "").trim(),
-    root_work_item_status: String(raw.root_work_item_status || "").trim(),
-    root_thread_id: String(raw.root_thread_id || "").trim(),
-    root_work_item_created_at: String(raw.root_work_item_created_at || "").trim() || undefined,
-    root_work_item_last_error: String(raw.root_work_item_last_error || "").trim(),
+    root_work_item_id: rootWorkItemID,
+    root_work_item_title: rootWorkItemID ? String(raw.root_work_item_title || "").trim() : "",
+    root_work_item_status: rootWorkItemID ? String(raw.root_work_item_status || "").trim() : "",
+    root_thread_id: rootWorkItemID ? String(raw.root_thread_id || "").trim() : "",
+    root_work_item_created_at: rootWorkItemID ? String(raw.root_work_item_created_at || "").trim() || undefined : undefined,
+    root_work_item_last_error: rootWorkItemID ? String(raw.root_work_item_last_error || "").trim() : "",
     last_comment_id: String(raw.last_comment_id || "").trim(),
     last_comment_kind: String(raw.last_comment_kind || "").trim(),
     last_source_message_id: Number.isFinite(Number(raw.last_source_message_id)) ? Number(raw.last_source_message_id) : undefined,

package/lib/selftest-runner-scenarios.mjs

@@ -1426,6 +1426,33 @@ export async function runSelftestRunnerScenarios(push, deps) {
       `request=${String(claimed.requestKey || "(none)")} status=${String(claimedRequest.status || "(none)")} consumed=${String(claimedConsumed.request_key || "(none)")}`,
     );
 
+    const inferredExecutionRecord = {
+      id: "comment-request-human-2",
+      createdAt: "2026-03-22T00:01:00.000Z",
+      updatedAt: "2026-03-22T00:01:00.000Z",
+      parsedArchive: {
+        kind: "telegram_message",
+        chatID: "-100123",
+        chatType: "supergroup",
+        body: "@RyoAI_bot draft the project charter and outline the deliverables",
+        messageID: 502,
+        senderIsBot: false,
+      },
+    };
+    const inferredExecutionClaim = await claimRunnerRequestForHumanComment({
+      normalizedRoute: requestRoute,
+      routeKey: requestRouteKey,
+      selectedRecord: inferredExecutionRecord,
+      selectedBotUsernames: ["ryoai_bot"],
+    });
+    const inferredExecutionRequest = safeObject(safeObject(loadBotRunnerState().requests)[inferredExecutionClaim.requestKey]);
+    push(
+      "runner_request_claim_defaults_actionable_messages_to_general_execution",
+      inferredExecutionClaim.ok === true
+        && String(inferredExecutionRequest.normalized_intent || "") === "general_execution",
+      `intent=${String(inferredExecutionRequest.normalized_intent || "(none)")} request=${String(inferredExecutionClaim.requestKey || "(none)")}`,
+    );
+
     const rootTaskRecord = {
       id: "comment-request-root-task-1",
       createdAt: "2026-03-22T00:05:00.000Z",
@@ -1468,6 +1495,34 @@ export async function runSelftestRunnerScenarios(push, deps) {
       selectedBotUsernames: ["ryoai_bot"],
       normalizedIntent: "status_query",
     });
+    const inferredReplyTaskRecord = {
+      id: "comment-request-root-task-2b",
+      createdAt: "2026-03-22T00:06:30.000Z",
+      updatedAt: "2026-03-22T00:06:30.000Z",
+      parsedArchive: {
+        kind: "telegram_message",
+        chatID: "-100123",
+        chatType: "supergroup",
+        body: "@RyoAI_bot did you handle it?",
+        messageID: 6021,
+        replyToMessageID: 601,
+        senderIsBot: false,
+        mentionUsernames: ["ryoai_bot"],
+      },
+    };
+    const inferredReplyTaskClaim = await claimRunnerRequestForHumanComment({
+      normalizedRoute: requestRoute,
+      routeKey: requestRouteKey,
+      selectedRecord: inferredReplyTaskRecord,
+      selectedBotUsernames: ["ryoai_bot"],
+    });
+    const inferredReplyTaskRequest = safeObject(safeObject(loadBotRunnerState().requests)[inferredReplyTaskClaim.requestKey]);
+    push(
+      "runner_request_claim_infers_status_query_for_short_reply_questions",
+      inferredReplyTaskClaim.ok === true
+        && String(inferredReplyTaskRequest.normalized_intent || "") === "status_query",
+      `intent=${String(inferredReplyTaskRequest.normalized_intent || "(none)")} request=${String(inferredReplyTaskClaim.requestKey || "(none)")}`,
+    );
     const syntheticConversationID = "reply_chain:telegram:-100123:601";
     const replyChainState = loadBotRunnerState();
     const rootTaskRequest = safeObject(safeObject(replyChainState.requests)[rootTaskClaim.requestKey]);

package/package.json

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