metheus-governance-mcp-cli 0.2.199 → 0.2.200

package/cli.mjs

@@ -3314,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,
@@ -3327,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 {
@@ -3746,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;
 }
 
@@ -3930,9 +4031,18 @@ 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(request.normalized_intent)
-        && !String(request.root_work_item_id || "").trim()
+        isActionableRunnerRequestIntent(recoveredRequest.normalized_intent)
+        && !String(recoveredRequest.root_work_item_id || "").trim()
       ) {
         continue;
       }
@@ -3942,7 +4052,7 @@ async function syncRunnerRequestLedgerForProjectToServer({ normalizedRoute, runt
         token: runtime.token,
         timeoutSeconds: runtime.timeoutSeconds,
         actorUserID: runtime.actor?.user_id,
-        request,
+        request: recoveredRequest,
       });
     }
     for (const commentState of commentStates) {

package/package.json

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