metheus-governance-mcp-cli 0.2.198 → 0.2.200

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) {
@@ -3234,6 +3314,81 @@ function buildRunnerRootWorkItemTransitionPath(currentStatusRaw, targetStatusRaw
   return [];
 }
 
+function buildRunnerRequestRecoveryPatchFromRouteState(currentStateRaw, requestRaw, routeKeyHint = "") {
+  const currentState = safeObject(currentStateRaw);
+  const request = safeObject(requestRaw);
+  const requestKey = String(request.request_key || "").trim();
+  if (!requestKey) {
+    return {};
+  }
+  const requestSourceMessageID = intFromRawAllowZero(request.last_source_message_id, 0)
+    || intFromRawAllowZero(request.source_message_id, 0);
+  const routeKeys = uniqueOrderedStrings(
+    [
+      routeKeyHint,
+      String(request.claimed_by_route || "").trim(),
+    ],
+    (value) => String(value || "").trim(),
+  ).filter(Boolean);
+  for (const routeKey of routeKeys) {
+    const routeState = safeObject(safeObject(currentState.routes)[routeKey]);
+    if (!Object.keys(routeState).length) {
+      continue;
+    }
+    const routeSourceMessageID = intFromRawAllowZero(routeState.last_source_message_id, 0)
+      || intFromRawAllowZero(routeState.source_message_id, 0);
+    if (requestSourceMessageID && routeSourceMessageID && requestSourceMessageID !== routeSourceMessageID) {
+      continue;
+    }
+    const patch = {};
+    const recoveredRootWorkItemID = firstNonEmptyString([
+      routeState.active_root_work_item_id,
+      routeState.last_root_work_item_id,
+    ]);
+    if (!String(request.root_work_item_id || "").trim() && recoveredRootWorkItemID) {
+      patch.root_work_item_id = recoveredRootWorkItemID;
+      patch.root_work_item_title = firstNonEmptyString([
+        request.root_work_item_title,
+        routeState.active_root_work_item_title,
+        routeState.last_root_work_item_title,
+      ]);
+      patch.root_work_item_status = normalizeRunnerWorkItemStatus(
+        request.root_work_item_status
+        || routeState.active_root_work_item_status
+        || routeState.last_root_work_item_status,
+      );
+    }
+    const requestStatus = normalizeRunnerRequestStatus(request.status);
+    if (!isFinalRunnerRequestStatus(requestStatus)) {
+      const routeAction = String(routeState.last_action || "").trim().toLowerCase();
+      if (routeAction === "replied") {
+        patch.status = "completed";
+        patch.completed_at = firstNonEmptyString([
+          request.completed_at,
+          request.updated_at,
+          new Date().toISOString(),
+        ]);
+      } else if (routeAction === "error" || routeAction === "skipped" || routeAction === "closed") {
+        patch.status = "closed";
+        patch.closed_at = firstNonEmptyString([
+          request.closed_at,
+          request.updated_at,
+          new Date().toISOString(),
+        ]);
+        patch.closed_reason = firstNonEmptyString([
+          request.closed_reason,
+          routeState.last_reason,
+          routeAction,
+        ]);
+      }
+    }
+    if (Object.keys(patch).length) {
+      return patch;
+    }
+  }
+  return {};
+}
+
 async function syncRunnerRequestRootWorkItemForOutcome({
   normalizedRoute,
   runtime,
@@ -3247,7 +3402,19 @@ async function syncRunnerRequestRootWorkItemForOutcome({
     };
   }
   const currentState = loadBotRunnerState();
-  const request = safeObject(normalizeBotRunnerRequests(currentState.requests)[key]);
+  let request = safeObject(normalizeBotRunnerRequests(currentState.requests)[key]);
+  const recoveryPatch = buildRunnerRequestRecoveryPatchFromRouteState(currentState, request);
+  if (Object.keys(recoveryPatch).length) {
+    const recovered = upsertRunnerRequest(currentState, key, recoveryPatch);
+    request = safeObject(recovered.request);
+    saveBotRunnerState({
+      routes: currentState.routes,
+      sharedInboxes: currentState.sharedInboxes || currentState.shared_inboxes,
+      excludedComments: currentState.excludedComments || currentState.excluded_comments,
+      requests: recovered.requests,
+      consumedComments: currentState.consumedComments || currentState.consumed_comments,
+    });
+  }
   const rootWorkItemID = String(request.root_work_item_id || "").trim();
   if (!rootWorkItemID) {
     return {
@@ -3666,6 +3833,20 @@ function mergeRunnerRequestForServerHydration(localEntryRaw, serverEntryRaw) {
   preserveLocalStringWhenServerBlank("root_thread_id");
   preserveLocalStringWhenServerBlank("root_work_item_created_at");
   preserveLocalStringWhenServerBlank("root_work_item_last_error");
+  const localStatus = normalizeRunnerRequestStatus(localEntry.status);
+  const serverStatus = normalizeRunnerRequestStatus(serverEntry.status);
+  if (isFinalRunnerRequestStatus(localStatus) && !isFinalRunnerRequestStatus(serverStatus)) {
+    merged.status = localStatus;
+    if (String(localEntry.completed_at || "").trim()) {
+      merged.completed_at = String(localEntry.completed_at || "").trim();
+    }
+    if (String(localEntry.closed_at || "").trim()) {
+      merged.closed_at = String(localEntry.closed_at || "").trim();
+    }
+    if (String(localEntry.closed_reason || "").trim()) {
+      merged.closed_reason = String(localEntry.closed_reason || "").trim();
+    }
+  }
   return merged;
 }
 
@@ -3850,13 +4031,28 @@ async function syncRunnerRequestLedgerForProjectToServer({ normalizedRoute, runt
     const commentStates = buildProjectRunnerRequestCommentStatesForSync(state, normalizedRoute);
 
     for (const request of requests) {
+      const recoveryPatch = buildRunnerRequestRecoveryPatchFromRouteState(state, request);
+      const recoveredRequest = Object.keys(recoveryPatch).length
+        ? normalizeBotRunnerRequests({
+          [String(request.request_key || "").trim()]: {
+            ...safeObject(request),
+            ...recoveryPatch,
+          },
+        })[String(request.request_key || "").trim()]
+        : request;
+      if (
+        isActionableRunnerRequestIntent(recoveredRequest.normalized_intent)
+        && !String(recoveredRequest.root_work_item_id || "").trim()
+      ) {
+        continue;
+      }
       await upsertProjectRunnerRequest({
         siteBaseURL: runtime.baseURL,
         projectID,
         token: runtime.token,
         timeoutSeconds: runtime.timeoutSeconds,
         actorUserID: runtime.actor?.user_id,
-        request,
+        request: recoveredRequest,
       });
     }
     for (const commentState of commentStates) {
@@ -7070,7 +7266,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 +7286,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 +7297,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 +7506,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 +7526,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 +7537,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 +10109,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 +10122,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.200",
   "description": "Metheus Governance MCP CLI (setup + stdio proxy)",
   "type": "module",
   "files": [