metheus-governance-mcp-cli 0.2.205 → 0.2.206

package/cli.mjs

@@ -2065,14 +2065,176 @@ function saveBotRunnerState(nextState) {
   try {
     current = safeObject(tryJsonParse(fs.readFileSync(filePath, "utf8")));
   } catch {}
+  const stateEntryTimestampMs = (...values) => {
+    for (const value of values) {
+      const ms = Date.parse(String(value || "").trim());
+      if (Number.isFinite(ms)) {
+        return ms;
+      }
+    }
+    return 0;
+  };
+  const mergeRunnerStateRoutes = (currentRoutesRaw, nextRoutesRaw) => {
+    const currentRoutes = safeObject(currentRoutesRaw);
+    const nextRoutes = safeObject(nextRoutesRaw);
+    const merged = {
+      ...currentRoutes,
+    };
+    const mergeConversationSessions = (currentSessionsRaw, nextSessionsRaw) => {
+      const currentSessions = safeObject(currentSessionsRaw);
+      const nextSessions = safeObject(nextSessionsRaw);
+      const mergedSessions = {
+        ...currentSessions,
+      };
+      for (const [conversationID, nextSessionRaw] of Object.entries(nextSessions)) {
+        const currentSession = safeObject(currentSessions[conversationID]);
+        const nextSession = safeObject(nextSessionRaw);
+        if (!Object.keys(currentSession).length) {
+          mergedSessions[conversationID] = nextSession;
+          continue;
+        }
+        const currentMs = stateEntryTimestampMs(
+          currentSession.updated_at,
+          currentSession.last_activity_at,
+          currentSession.closed_at,
+          currentSession.started_at,
+          currentSession.expires_at,
+        );
+        const nextMs = stateEntryTimestampMs(
+          nextSession.updated_at,
+          nextSession.last_activity_at,
+          nextSession.closed_at,
+          nextSession.started_at,
+          nextSession.expires_at,
+        );
+        mergedSessions[conversationID] = nextMs >= currentMs
+          ? {
+              ...currentSession,
+              ...nextSession,
+            }
+          : {
+              ...nextSession,
+              ...currentSession,
+            };
+      }
+      return mergedSessions;
+    };
+    for (const [routeKey, nextRouteRaw] of Object.entries(nextRoutes)) {
+      const currentRoute = safeObject(currentRoutes[routeKey]);
+      const nextRoute = safeObject(nextRouteRaw);
+      if (!Object.keys(currentRoute).length) {
+        merged[routeKey] = nextRoute;
+        continue;
+      }
+      const preferredRoute = prefersRunnerStateRecord(nextRoute, currentRoute) ? nextRoute : currentRoute;
+      const fallbackRoute = preferredRoute === nextRoute ? currentRoute : nextRoute;
+      merged[routeKey] = cleanupRunnerStateRecord({
+        ...mergeRunnerStateRecords(preferredRoute, fallbackRoute),
+        conversation_sessions: mergeConversationSessions(
+          currentRoute.conversation_sessions,
+          nextRoute.conversation_sessions,
+        ),
+      });
+    }
+    return merged;
+  };
+  const mergeRunnerStateRequests = (currentRequestsRaw, nextRequestsRaw) => {
+    const currentRequests = normalizeBotRunnerRequests(currentRequestsRaw);
+    const nextRequests = normalizeBotRunnerRequests(nextRequestsRaw);
+    const merged = {
+      ...currentRequests,
+    };
+    for (const [requestKey, nextRequestRaw] of Object.entries(nextRequests)) {
+      const currentRequest = safeObject(currentRequests[requestKey]);
+      const nextRequest = safeObject(nextRequestRaw);
+      const currentMs = stateEntryTimestampMs(
+        currentRequest.updated_at,
+        currentRequest.completed_at,
+        currentRequest.closed_at,
+        currentRequest.claimed_at,
+      );
+      const nextMs = stateEntryTimestampMs(
+        nextRequest.updated_at,
+        nextRequest.completed_at,
+        nextRequest.closed_at,
+        nextRequest.claimed_at,
+      );
+      if (!Object.keys(currentRequest).length) {
+        merged[requestKey] = nextRequest;
+        continue;
+      }
+      merged[requestKey] = nextMs >= currentMs
+        ? {
+            ...currentRequest,
+            ...nextRequest,
+          }
+        : currentRequest;
+    }
+    return normalizeBotRunnerRequests(merged);
+  };
+  const mergeRunnerStateExcludedComments = (currentExcludedRaw, nextExcludedRaw) => {
+    const currentExcluded = normalizeBotRunnerExcludedComments(currentExcludedRaw);
+    const nextExcluded = normalizeBotRunnerExcludedComments(nextExcludedRaw);
+    const merged = {
+      ...currentExcluded,
+    };
+    for (const [commentID, nextEntryRaw] of Object.entries(nextExcluded)) {
+      const currentEntry = safeObject(currentExcluded[commentID]);
+      const nextEntry = safeObject(nextEntryRaw);
+      const currentMs = stateEntryTimestampMs(currentEntry.excluded_at);
+      const nextMs = stateEntryTimestampMs(nextEntry.excluded_at);
+      if (!Object.keys(currentEntry).length || nextMs >= currentMs) {
+        merged[commentID] = {
+          ...currentEntry,
+          ...nextEntry,
+        };
+      }
+    }
+    return normalizeBotRunnerExcludedComments(merged);
+  };
+  const mergeRunnerStateConsumedComments = (currentConsumedRaw, nextConsumedRaw) => {
+    const currentConsumed = normalizeBotRunnerConsumedComments(currentConsumedRaw);
+    const nextConsumed = normalizeBotRunnerConsumedComments(nextConsumedRaw);
+    const merged = {
+      ...currentConsumed,
+    };
+    for (const [commentID, nextEntryRaw] of Object.entries(nextConsumed)) {
+      const currentEntry = safeObject(currentConsumed[commentID]);
+      const nextEntry = safeObject(nextEntryRaw);
+      const currentMs = stateEntryTimestampMs(currentEntry.consumed_at);
+      const nextMs = stateEntryTimestampMs(nextEntry.consumed_at);
+      if (!Object.keys(currentEntry).length || nextMs >= currentMs) {
+        merged[commentID] = {
+          ...currentEntry,
+          ...nextEntry,
+        };
+      }
+    }
+    return normalizeBotRunnerConsumedComments(merged);
+  };
   const payload = {
     version: 1,
     updated_at: new Date().toISOString(),
-    routes: safeObject(nextState?.routes ?? current.routes),
-    shared_inboxes: safeObject(nextState?.sharedInboxes ?? nextState?.shared_inboxes ?? current.shared_inboxes ?? current.sharedInboxes),
-    excluded_comments: normalizeBotRunnerExcludedComments(nextState?.excludedComments ?? nextState?.excluded_comments ?? current.excluded_comments ?? current.excludedComments),
-    requests: normalizeBotRunnerRequests(nextState?.requests ?? current.requests),
-    consumed_comments: normalizeBotRunnerConsumedComments(nextState?.consumedComments ?? nextState?.consumed_comments ?? current.consumed_comments ?? current.consumedComments),
+    routes: mergeRunnerStateRoutes(
+      current.routes,
+      nextState?.routes ?? current.routes,
+    ),
+    shared_inboxes: {
+      ...safeObject(current.shared_inboxes ?? current.sharedInboxes),
+      ...safeObject(nextState?.sharedInboxes ?? nextState?.shared_inboxes),
+    },
+    excluded_comments: mergeRunnerStateExcludedComments(
+      current.excluded_comments ?? current.excludedComments,
+      nextState?.excludedComments ?? nextState?.excluded_comments ?? current.excluded_comments ?? current.excludedComments,
+    ),
+    requests: mergeRunnerStateRequests(
+      current.requests,
+      nextState?.requests ?? current.requests,
+    ),
+    consumed_comments: mergeRunnerStateConsumedComments(
+      current.consumed_comments ?? current.consumedComments,
+      nextState?.consumedComments ?? nextState?.consumed_comments ?? current.consumed_comments ?? current.consumedComments,
+    ),
   };
   fs.mkdirSync(path.dirname(filePath), { recursive: true });
   fs.writeFileSync(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
@@ -2507,6 +2669,89 @@ function findRunnerRequestsForScope(state, normalizedRoute, selectors = {}) {
     });
 }
 
+function findScopedConversationSessionState(state, normalizedRoute, conversationIDRaw = "") {
+  const conversationID = String(conversationIDRaw || "").trim();
+  if (!conversationID) {
+    return {};
+  }
+  const config = loadBotRunnerConfig({ persistIfNeeded: true });
+  const nextRoutes = safeObject(state?.routes);
+  const candidates = [];
+  const seenRouteKeys = new Set();
+  const pushCandidateRoute = (routeRaw) => {
+    const routeObject = safeObject(routeRaw);
+    if (!Object.keys(routeObject).length) {
+      return;
+    }
+    const candidateRoute = normalizeRunnerRoute(routeObject);
+    const candidateRouteKey = runnerRouteKey(candidateRoute);
+    if (seenRouteKeys.has(candidateRouteKey)) {
+      return;
+    }
+    seenRouteKeys.add(candidateRouteKey);
+    candidates.push({
+      route: candidateRoute,
+      routeKey: candidateRouteKey,
+      routeState: safeObject(nextRoutes[candidateRouteKey]),
+    });
+  };
+  pushCandidateRoute(normalizedRoute);
+  for (const candidateRouteRaw of ensureArray(config.routes)) {
+    if (!runnerRouteMatchesProjectConversationScope(candidateRouteRaw, normalizedRoute)) {
+      continue;
+    }
+    pushCandidateRoute(candidateRouteRaw);
+  }
+  const ranked = candidates
+    .map((candidate) => {
+      const session = safeObject(safeObject(candidate.routeState.conversation_sessions)[conversationID]);
+      if (!Object.keys(session).length) {
+        return null;
+      }
+      const status = String(session.status || "").trim().toLowerCase();
+      const lastActivity = firstNonEmptyString([session.last_activity_at, session.closed_at, session.started_at]);
+      return {
+        ...candidate,
+        session,
+        status,
+        lastActivity,
+      };
+    })
+    .filter(Boolean)
+    .sort((left, right) => {
+      if (left.status !== right.status) {
+        if (left.status === "open") return -1;
+        if (right.status === "open") return 1;
+      }
+      if (left.lastActivity && right.lastActivity && left.lastActivity !== right.lastActivity) {
+        return left.lastActivity < right.lastActivity ? 1 : -1;
+      }
+      return String(left.routeKey || "").localeCompare(String(right.routeKey || ""));
+    });
+  return safeObject(ranked[0]);
+}
+
+function sessionAllowsConversationResponder(sessionRaw, responderSelectorRaw = "") {
+  const session = safeObject(sessionRaw);
+  const responderSelector = normalizeTelegramMentionUsername(responderSelectorRaw);
+  if (!responderSelector) {
+    return false;
+  }
+  if (String(session.status || "").trim().toLowerCase() !== "open") {
+    return false;
+  }
+  const nextExpectedResponders = ensureArray(session.next_expected_responders)
+    .map((value) => normalizeTelegramMentionUsername(value))
+    .filter(Boolean);
+  if (nextExpectedResponders.length > 0) {
+    return nextExpectedResponders.includes(responderSelector);
+  }
+  const allowedResponders = ensureArray(session.allowed_responders)
+    .map((value) => normalizeTelegramMentionUsername(value))
+    .filter(Boolean);
+  return allowedResponders.includes(responderSelector);
+}
+
 function findRunnerRequestsForMessageID(state, normalizedRoute, selectors = {}) {
   const chatID = String(selectors.chatID || "").trim();
   const messageID = intFromRawAllowZero(selectors.messageID, 0);
@@ -3895,11 +4140,80 @@ function resolveRunnerContinuationRequestForBotReply({
     };
   }
   const currentState = loadBotRunnerState();
-  const requests = findRunnerRequestsForScope(currentState, normalizedRoute, {
+  let requests = findRunnerRequestsForScope(currentState, normalizedRoute, {
     conversationID,
     chatID: String(parsed.chatID || parsed.chatId || "").trim(),
   }).filter((entry) => isActiveRunnerRequestStatus(entry.status));
-  const request = safeObject(requests[0]);
+  let request = safeObject(requests[0]);
+  if (!Object.keys(request).length) {
+    const sessionMatch = findScopedConversationSessionState(currentState, normalizedRoute, conversationID);
+    const session = safeObject(sessionMatch.session);
+    const fallbackRequestKey = String(
+      safeObject(sessionMatch.routeState).active_request_key
+      || safeObject(sessionMatch.routeState).last_request_key
+      || "",
+    ).trim();
+    if (
+      fallbackRequestKey
+      && String(session.status || "").trim().toLowerCase() === "open"
+    ) {
+      const fallbackRequest = safeObject(normalizeBotRunnerRequests(currentState.requests)[fallbackRequestKey]);
+      const nowISO = new Date().toISOString();
+      const seedRequest = Object.keys(fallbackRequest).length
+        ? fallbackRequest
+        : {
+          request_key: fallbackRequestKey,
+          project_id: String(normalizedRoute?.projectID || "").trim(),
+          provider: String(normalizedRoute?.provider || "").trim(),
+          chat_id: String(parsed.chatID || parsed.chatId || "").trim(),
+          conversation_id: conversationID,
+          selected_bot_usernames: ensureArray(session.participants),
+          conversation_allowed_responders: ensureArray(session.allowed_responders),
+          conversation_intent_mode: String(session.intent_mode || "").trim().toLowerCase(),
+          conversation_lead_bot: normalizeTelegramMentionUsername(session.lead_bot_username),
+          conversation_summary_bot: normalizeTelegramMentionUsername(session.summary_bot_username),
+          conversation_participants: ensureArray(session.participants),
+          conversation_initial_responders: ensureArray(session.initial_responders),
+          conversation_allow_bot_to_bot: session.allow_bot_to_bot === true,
+          conversation_reply_expectation: "",
+          execution_contract_type: String(session.last_execution_contract_type || "").trim().toLowerCase(),
+          execution_contract_actionable: session.last_execution_contract_actionable === true,
+          execution_contract_targets: ensureArray(session.last_execution_contract_targets),
+          next_expected_responders: ensureArray(session.next_expected_responders),
+          normalized_intent: String(safeObject(sessionMatch.routeState).last_intent_type || "").trim().toLowerCase(),
+          status: "running",
+          claimed_by_route: String(sessionMatch.routeKey || "").trim(),
+          claimed_at: firstNonEmptyString([session.started_at, nowISO]),
+          started_at: firstNonEmptyString([session.started_at, nowISO]),
+          root_work_item_id: String(
+            safeObject(sessionMatch.routeState).active_root_work_item_id
+            || safeObject(sessionMatch.routeState).last_root_work_item_id
+            || "",
+          ).trim(),
+          root_work_item_title: String(
+            safeObject(sessionMatch.routeState).active_root_work_item_title
+            || safeObject(sessionMatch.routeState).last_root_work_item_title
+            || "",
+          ).trim(),
+          root_work_item_status: String(
+            safeObject(sessionMatch.routeState).active_root_work_item_status
+            || safeObject(sessionMatch.routeState).last_root_work_item_status
+            || "",
+          ).trim().toLowerCase(),
+        };
+      const seededRequest = upsertRunnerRequest(currentState, fallbackRequestKey, seedRequest);
+      currentState.requests = seededRequest.requests;
+      request = safeObject(seededRequest.request);
+      saveBotRunnerState({
+        routes: currentState.routes,
+        sharedInboxes: currentState.sharedInboxes || currentState.shared_inboxes,
+        excludedComments: currentState.excludedComments || currentState.excluded_comments,
+        requests: currentState.requests,
+        consumedComments: currentState.consumedComments || currentState.consumed_comments,
+      });
+      requests = [request];
+    }
+  }
   if (!Object.keys(request).length) {
     return {
       ok: false,
@@ -4149,7 +4463,10 @@ function cleanupBotRunnerRequestState({
         && String(entry.conversation_id || "").trim() === String(conversationID || "").trim()
         && isActiveRunnerRequestStatus(entry.status)
       ));
-      if (!expired && activeRequests.length > 0) {
+      const pendingContinuationResponders = ensureArray(session.next_expected_responders)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean);
+      if (!expired && (activeRequests.length > 0 || pendingContinuationResponders.length > 0)) {
         continue;
       }
       const closedReason = expired ? "expired_session" : "orphaned_open_session";
@@ -7487,7 +7804,11 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           && String(entry.conversation_id || "").trim() === conversationID
           && isActiveRunnerRequestStatus(entry.status)
         ));
-        return activeRequests.length > 0;
+        if (activeRequests.length > 0) {
+          return true;
+        }
+        const sessionMatch = findScopedConversationSessionState(latestRunnerState, normalizedRoute, conversationID);
+        return sessionAllowsConversationResponder(sessionMatch.session, currentBotSelector);
       }
       return true;
     });

package/lib/selftest-runner-scenarios.mjs

@@ -2229,6 +2229,134 @@ export async function runSelftestRunnerScenarios(push, deps) {
     }
   }
 
+  const originalStateMergeHome = process.env.HOME;
+  const originalStateMergeUserProfile = process.env.USERPROFILE;
+  let runnerStateMergeTempRoot = "";
+  try {
+    runnerStateMergeTempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-state-merge-selftest-"));
+    const runnerStateMergeHome = path.join(runnerStateMergeTempRoot, "home");
+    fs.mkdirSync(path.join(runnerStateMergeHome, ".metheus"), { recursive: true });
+    process.env.HOME = runnerStateMergeHome;
+    process.env.USERPROFILE = runnerStateMergeHome;
+    const mergeRoute = normalizeRunnerRoute({
+      name: "telegram-monitor-state-merge",
+      project_id: selftestProjectID,
+      provider: "telegram",
+      role: "monitor",
+      destination_label: "Main Room",
+    });
+    const mergeRouteKey = runnerRouteKey(mergeRoute);
+    saveBotRunnerState({
+      routes: {
+        [mergeRouteKey]: {
+          updated_at: "2026-03-24T06:29:05.000Z",
+          last_request_key: "request-key-597",
+          last_action: "running",
+          conversation_sessions: {
+            "conversation-597": {
+              conversation_id: "conversation-597",
+              status: "open",
+              updated_at: "2026-03-24T06:29:05.000Z",
+              last_activity_at: "2026-03-24T06:29:05.000Z",
+              last_execution_contract_type: "delegation",
+              next_expected_responders: ["ryoai2_bot", "ryoai3_bot"],
+            },
+          },
+        },
+      },
+      sharedInboxes: {},
+      excludedComments: {},
+      requests: {
+        "request-key-597": {
+          request_key: "request-key-597",
+          project_id: selftestProjectID,
+          provider: "telegram",
+          chat_id: "-100123",
+          source_message_id: 597,
+          conversation_id: "conversation-597",
+          normalized_intent: "explanation_query",
+          execution_contract_type: "delegation",
+          execution_contract_actionable: true,
+          next_expected_responders: ["ryoai2_bot", "ryoai3_bot"],
+          status: "running",
+          claimed_by_route: mergeRouteKey,
+          root_work_item_id: "root-work-item-597",
+          root_thread_id: "root-thread-597",
+          updated_at: "2026-03-24T06:29:05.000Z",
+        },
+      },
+      consumedComments: {},
+    });
+    saveBotRunnerState({
+      routes: {
+        [mergeRouteKey]: {
+          updated_at: "2026-03-24T06:29:06.000Z",
+          last_request_key: "request-key-597",
+          last_action: "replied",
+          conversation_sessions: {
+            "conversation-597": {
+              conversation_id: "conversation-597",
+              status: "open",
+              updated_at: "2026-03-24T06:29:06.000Z",
+            },
+          },
+        },
+      },
+      sharedInboxes: {},
+      excludedComments: {},
+      requests: {
+        "request-key-597": {
+          request_key: "request-key-597",
+          project_id: selftestProjectID,
+          provider: "telegram",
+          chat_id: "-100123",
+          source_message_id: 597,
+          conversation_id: "conversation-597",
+          normalized_intent: "general_execution",
+          status: "claimed",
+          claimed_by_route: mergeRouteKey,
+          root_work_item_id: "",
+          root_thread_id: "",
+          next_expected_responders: [],
+          updated_at: "2026-03-24T06:28:30.000Z",
+        },
+      },
+      consumedComments: {},
+    });
+    const mergedState = loadBotRunnerState();
+    const mergedRouteState = safeObject(safeObject(mergedState.routes)[mergeRouteKey]);
+    const mergedSession = safeObject(safeObject(mergedRouteState.conversation_sessions)["conversation-597"]);
+    const mergedRequest = safeObject(safeObject(mergedState.requests)["request-key-597"]);
+    push(
+      "runner_state_save_preserves_newer_request_and_conversation_session",
+      String(mergedRequest.status || "") === "running"
+        && String(mergedRequest.root_work_item_id || "") === "root-work-item-597"
+        && ensureArray(mergedRequest.next_expected_responders).includes("ryoai2_bot")
+        && String(mergedSession.status || "") === "open"
+        && String(mergedSession.last_execution_contract_type || "") === "delegation"
+        && ensureArray(mergedSession.next_expected_responders).includes("ryoai3_bot"),
+      `request_status=${String(mergedRequest.status || "(none)")} root_work_item=${String(mergedRequest.root_work_item_id || "(none)")} session_contract=${String(mergedSession.last_execution_contract_type || "(none)")} next=${ensureArray(mergedSession.next_expected_responders).join(",")}`,
+    );
+  } catch (err) {
+    push("runner_state_save_preserves_newer_request_and_conversation_session", false, String(err?.message || err));
+  } finally {
+    if (typeof originalStateMergeHome === "string") {
+      process.env.HOME = originalStateMergeHome;
+    } else {
+      delete process.env.HOME;
+    }
+    if (typeof originalStateMergeUserProfile === "string") {
+      process.env.USERPROFILE = originalStateMergeUserProfile;
+    } else {
+      delete process.env.USERPROFILE;
+    }
+    if (runnerStateMergeTempRoot) {
+      try {
+        fs.rmSync(runnerStateMergeTempRoot, { recursive: true, force: true });
+      } catch {}
+    }
+  }
+
   const defaultMonitorTriggerPolicy = normalizeRunnerTriggerPolicy({}, { role: "monitor" });
   push(
     "bot_runner_default_monitor_trigger_policy",

package/package.json

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