metheus-governance-mcp-cli 0.2.204 → 0.2.206

package/cli.mjs

@@ -184,6 +184,7 @@ import {
 } from "./lib/runner-execution.mjs";
 import {
   processRunnerSelectedRecord,
+  resolveHumanIntentContext,
   resolveRunnerResponderAdjudication,
   resolveRunnerStartupLoopAdjudication,
   selectRunnerPendingWork,
@@ -2064,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");
@@ -2506,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);
@@ -2986,6 +3232,7 @@ async function claimRunnerRequestForHumanComment({
   selectedRecord,
   selectedBotUsernames = [],
   normalizedIntent = "",
+  sharedHumanIntent = null,
   runtime = null,
   archiveThreadID = "",
 }) {
@@ -3039,6 +3286,7 @@ async function claimRunnerRequestForHumanComment({
   }
   const requests = normalizeBotRunnerRequests(stateForClaim.requests);
   const existing = safeObject(requests[requestKey]);
+  const normalizedSharedHumanIntent = safeObject(sharedHumanIntent);
   const currentMessageID = intFromRawAllowZero(parsed.messageID, 0);
   let sharedConversationSource = currentMessageID > 0
     ? pickRunnerSharedConversationSourceRequest(
@@ -3097,20 +3345,22 @@ async function claimRunnerRequestForHumanComment({
     conversation_id: resolvedConversationID,
     selected_bot_usernames: uniqueOrderedStrings(selectedBotUsernames, normalizeTelegramMentionUsername),
     conversation_intent_mode: String(
-      existing.conversation_intent_mode || sharedConversationSource.conversation_intent_mode || referencedRequest.conversation_intent_mode || "",
+      existing.conversation_intent_mode || sharedConversationSource.conversation_intent_mode || referencedRequest.conversation_intent_mode || normalizedSharedHumanIntent.intentMode || "",
     ).trim().toLowerCase(),
     conversation_lead_bot: normalizeTelegramMentionUsername(
-      existing.conversation_lead_bot || sharedConversationSource.conversation_lead_bot || referencedRequest.conversation_lead_bot,
+      existing.conversation_lead_bot || sharedConversationSource.conversation_lead_bot || referencedRequest.conversation_lead_bot || normalizedSharedHumanIntent.leadBotSelector,
     ),
     conversation_summary_bot: normalizeTelegramMentionUsername(
-      existing.conversation_summary_bot || sharedConversationSource.conversation_summary_bot || referencedRequest.conversation_summary_bot,
+      existing.conversation_summary_bot || sharedConversationSource.conversation_summary_bot || referencedRequest.conversation_summary_bot || normalizedSharedHumanIntent.summaryBotSelector,
     ),
     conversation_participants: uniqueOrderedStrings(
       ensureArray(existing.conversation_participants).length
         ? existing.conversation_participants
         : ensureArray(sharedConversationSource.conversation_participants).length
           ? sharedConversationSource.conversation_participants
-          : referencedRequest.conversation_participants,
+          : ensureArray(referencedRequest.conversation_participants).length
+            ? referencedRequest.conversation_participants
+            : normalizedSharedHumanIntent.participantSelectors,
       normalizeTelegramMentionUsername,
     ),
     conversation_initial_responders: uniqueOrderedStrings(
@@ -3118,7 +3368,9 @@ async function claimRunnerRequestForHumanComment({
         ? existing.conversation_initial_responders
         : ensureArray(sharedConversationSource.conversation_initial_responders).length
           ? sharedConversationSource.conversation_initial_responders
-          : referencedRequest.conversation_initial_responders,
+          : ensureArray(referencedRequest.conversation_initial_responders).length
+            ? referencedRequest.conversation_initial_responders
+            : normalizedSharedHumanIntent.initialResponderSelectors,
       normalizeTelegramMentionUsername,
     ),
     conversation_allowed_responders: uniqueOrderedStrings(
@@ -3126,14 +3378,17 @@ async function claimRunnerRequestForHumanComment({
         ? existing.conversation_allowed_responders
         : ensureArray(sharedConversationSource.conversation_allowed_responders).length
           ? sharedConversationSource.conversation_allowed_responders
-          : referencedRequest.conversation_allowed_responders,
+          : ensureArray(referencedRequest.conversation_allowed_responders).length
+            ? referencedRequest.conversation_allowed_responders
+            : normalizedSharedHumanIntent.allowedResponderSelectors,
       normalizeTelegramMentionUsername,
     ),
     conversation_allow_bot_to_bot: existing.conversation_allow_bot_to_bot === true
       || sharedConversationSource.conversation_allow_bot_to_bot === true
-      || referencedRequest.conversation_allow_bot_to_bot === true,
+      || referencedRequest.conversation_allow_bot_to_bot === true
+      || normalizedSharedHumanIntent.allowBotToBot === true,
     conversation_reply_expectation: String(
-      existing.conversation_reply_expectation || sharedConversationSource.conversation_reply_expectation || referencedRequest.conversation_reply_expectation || "",
+      existing.conversation_reply_expectation || sharedConversationSource.conversation_reply_expectation || referencedRequest.conversation_reply_expectation || normalizedSharedHumanIntent.replyExpectation || "",
     ).trim().toLowerCase(),
     execution_contract_type: String(
       existing.execution_contract_type || sharedConversationSource.execution_contract_type || referencedRequest.execution_contract_type || "",
@@ -3154,7 +3409,9 @@ async function claimRunnerRequestForHumanComment({
         ? existing.next_expected_responders
         : ensureArray(sharedConversationSource.next_expected_responders).length
           ? sharedConversationSource.next_expected_responders
-          : referencedRequest.next_expected_responders,
+          : ensureArray(referencedRequest.next_expected_responders).length
+            ? referencedRequest.next_expected_responders
+            : normalizedSharedHumanIntent.initialResponderSelectors,
       normalizeTelegramMentionUsername,
     ),
     normalized_intent: resolvedNormalizedIntent,
@@ -3883,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,
@@ -4137,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";
@@ -7475,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;
     });
@@ -7592,7 +7925,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
       }
       return null;
     };
-    const prepareRunnerRequestClaim = async (selectedRecord, selectedResponderSelectors = []) => {
+    const prepareRunnerRequestClaim = async (selectedRecord, selectedResponderSelectors = [], sharedHumanIntent = null) => {
       const parsed = safeObject(selectedRecord?.parsedArchive);
       const kind = String(parsed.kind || "").trim().toLowerCase();
       if (kind === "bot_reply") {
@@ -7622,6 +7955,8 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         routeKey,
         selectedRecord,
         selectedBotUsernames: selectedResponderSelectors,
+        normalizedIntent: String(safeObject(sharedHumanIntent).intentType || "").trim().toLowerCase(),
+        sharedHumanIntent,
         runtime,
         archiveThreadID: archiveThread.threadID,
       });
@@ -7679,17 +8014,26 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           skippedRecords.push(startupLoopSkipped.skippedRecord);
           continue;
         }
+        const routingExecutionDeps = {
+          ...buildRunnerExecutionDeps(),
+          managedConversationBots,
+          resolveConversationPeerBots: resolveRunnerConversationPeers,
+        };
+        const sharedHumanIntentContext = await resolveHumanIntentContext({
+          selectedRecord,
+          normalizedRoute,
+          bot,
+          executionPlan,
+          deps: routingExecutionDeps,
+        });
         const adjudication = await resolveRunnerResponderAdjudication({
           selectedRecord,
           pendingOrdered: pending.ordered,
           normalizedRoute,
           bot,
           executionPlan,
-          deps: {
-            ...buildRunnerExecutionDeps(),
-            managedConversationBots,
-            resolveConversationPeerBots: resolveRunnerConversationPeers,
-          },
+          deps: routingExecutionDeps,
+          precomputedHumanIntent: safeObject(sharedHumanIntentContext).humanIntent || null,
         });
         const currentBotSelected = ensureArray(adjudication.selected_bot_usernames)
           .map((value) => String(value || "").trim().replace(/^@+/, "").toLowerCase())
@@ -7710,7 +8054,11 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           });
           continue;
         }
-        const requestClaim = await prepareRunnerRequestClaim(selectedRecord, adjudication.selected_bot_usernames);
+        const requestClaim = await prepareRunnerRequestClaim(
+          selectedRecord,
+          adjudication.selected_bot_usernames,
+          safeObject(sharedHumanIntentContext).humanIntent || null,
+        );
         if (!requestClaim.ok) {
           await syncRunnerRequestLedgerForProjectToServer({
             normalizedRoute,
@@ -7836,6 +8184,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
             requestKey: String(requestClaim.requestKey || "").trim(),
             triggerDecision,
             responderAdjudication: adjudication,
+            humanIntentContext: sharedHumanIntentContext,
           },
         };
       }
@@ -7918,17 +8267,26 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         skippedRecords.push(startupLoopSkipped.skippedRecord);
         continue;
       }
+      const routingExecutionDeps = {
+        ...buildRunnerExecutionDeps(),
+        managedConversationBots,
+        resolveConversationPeerBots: resolveRunnerConversationPeers,
+      };
+      const sharedHumanIntentContext = await resolveHumanIntentContext({
+        selectedRecord,
+        normalizedRoute,
+        bot,
+        executionPlan,
+        deps: routingExecutionDeps,
+      });
       const inlineAdjudication = await resolveRunnerResponderAdjudication({
         selectedRecord,
         pendingOrdered: pending.ordered,
         normalizedRoute,
         bot,
         executionPlan,
-        deps: {
-          ...buildRunnerExecutionDeps(),
-          managedConversationBots,
-          resolveConversationPeerBots: resolveRunnerConversationPeers,
-        },
+        deps: routingExecutionDeps,
+        precomputedHumanIntent: safeObject(sharedHumanIntentContext).humanIntent || null,
       });
       const inlineCurrentBotSelected = ensureArray(inlineAdjudication.selected_bot_usernames)
         .map((value) => String(value || "").trim().replace(/^@+/, "").toLowerCase())
@@ -7950,7 +8308,11 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         continue;
       }
       const currentRouteState = safeObject(loadBotRunnerState().routes[routeKey]);
-      const requestClaim = await prepareRunnerRequestClaim(selectedRecord, inlineAdjudication.selected_bot_usernames);
+      const requestClaim = await prepareRunnerRequestClaim(
+        selectedRecord,
+        inlineAdjudication.selected_bot_usernames,
+        safeObject(sharedHumanIntentContext).humanIntent || null,
+      );
       if (!requestClaim.ok) {
         await syncRunnerRequestLedgerForProjectToServer({
           normalizedRoute,
@@ -8096,6 +8458,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         triggerDecision,
         responderAdjudication: inlineAdjudication,
         persistedHumanIntentRequest: claimedRequest,
+        precomputedHumanIntentContext: sharedHumanIntentContext,
         deps: {
           saveRunnerRouteState,
           startRunnerTypingHeartbeat,
@@ -10465,6 +10828,7 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                       triggerDecision: deferredExecution.triggerDecision,
                       responderAdjudication: deferredExecution.responderAdjudication,
                       persistedHumanIntentRequest: loadRunnerRequestByKey(deferredExecution.requestKey),
+                      precomputedHumanIntentContext: safeObject(deferredExecution.humanIntentContext),
                       deps: {
                         saveRunnerRouteState,
                         startRunnerTypingHeartbeat,
@@ -14951,6 +15315,7 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     safeObject,
     normalizeRunnerTriggerPolicy,
     evaluateTelegramRunnerTrigger,
+    resolveRunnerResponderAdjudication,
     selectPendingArchiveComments,
     selectRunnerPendingWork,
     processRunnerSelectedRecord,

package/lib/local-ai-adapters.mjs

@@ -2067,7 +2067,7 @@ function buildConversationIntentAnalysisPrompt({
     "You are a conversation intent contract parser for a public Telegram room with managed bots.",
     "Infer the human's intended bot participation contract from the human message only.",
     "Do not infer from prior bot replies. Do not invent bots outside managed_bots.",
-    "Be conservative. If the request is ambiguous, choose single_bot and keep only the directly addressed bot as the responder.",
+    "Be conservative only when the human truly does not indicate collaboration. If the message clearly asks multiple managed bots to discuss, review, brainstorm, compare perspectives, or talk together, do not collapse it to single_bot.",
     "Also decide whether the human is asking for immediate execution/work now or only asking for information/explanation.",
     "Also classify the current message intent type.",
     "",
@@ -2092,12 +2092,13 @@ function buildConversationIntentAnalysisPrompt({
     "- intent_type=bot_role_query for asking about bot roles, bot ownership, or how managed bots are meant to collaborate.",
     "- intent_type=workspace_query for asking about the current workspace, project folder, or working directory.",
     "- intent_type=artifact_location_query for asking where a file, document, pdf, guide, or artifact is located.",
-    "- intent_type=explanation_query for explanation, clarification, or informational questions that do not require execution.",
+    "- intent_type=explanation_query for explanation, clarification, informational questions, discussion requests, review requests, brainstorming requests, or requests for bots to talk together about a topic when no concrete work execution is explicitly requested.",
     "- intent_type=ctxpack_mutation for requests to create/update project guidance, instructions, rules, policies, or other ctxpack-backed source documents now.",
     "- intent_type=workitem_mutation for requests to create/update actionable work items, backlog tasks, or task breakdowns now.",
-    "- intent_type=general_execution for other concrete work requests that should execute now.",
+    "- intent_type=general_execution only for concrete work requests that should execute now, such as creating/updating files, running tools/commands, modifying project artifacts, or producing validated deliverables.",
+    "- If the human asks bots to discuss, debate, review, brainstorm, compare opinions, or hold a conversation about a topic, default to reply_expectation=informational unless they explicitly ask for concrete execution/output now.",
     "- reply_expectation=actionable when the human is asking the bot(s) to actually do work now, produce concrete results, create/update files, delegate concrete tasks, or otherwise execute immediately.",
-    "- reply_expectation=informational when the human is only asking for explanation, status, location, clarification, or other non-execution information.",
+    "- reply_expectation=informational when the human is only asking for explanation, status, location, clarification, discussion, review, brainstorming, or other non-execution information.",
     "",
     `managed_bots=${JSON.stringify(bots)}`,
     `human_message=${JSON.stringify(String(messageText || "").trim())}`,

package/lib/runner-orchestration.mjs

@@ -1004,7 +1004,7 @@ function buildHumanIntentFromPersistedRunnerRequest({
   };
 }
 
-async function resolveHumanIntentContext({
+export async function resolveHumanIntentContext({
   selectedRecord,
   normalizedRoute,
   bot,
@@ -3957,6 +3957,7 @@ export async function resolveRunnerResponderAdjudication({
   bot,
   executionPlan,
   deps,
+  precomputedHumanIntent = null,
 }) {
   const cacheKey = buildRunnerResponderAdjudicationCacheKey({ normalizedRoute, selectedRecord });
   if (runnerResponderAdjudicationPromises.has(cacheKey)) {
@@ -3972,6 +3973,11 @@ export async function resolveRunnerResponderAdjudication({
       bot,
       deps,
     });
+    const managedBotSelectors = new Set(
+      managedBots
+        .map((entry) => normalizeMentionSelector(entry.username))
+        .filter(Boolean),
+    );
     const triggerFacts = {
       message_kind: String(safeObject(selectedRecord?.parsedArchive).kind || "").trim(),
       chat_type: String(safeObject(selectedRecord?.parsedArchive).chatType || "").trim(),
@@ -3987,6 +3993,47 @@ export async function resolveRunnerResponderAdjudication({
         trigger_reason: String(entry.trigger_reason || "").trim(),
       })),
     };
+    const humanIntent = safeObject(precomputedHumanIntent);
+    const contractInitialResponders = uniqueOrdered(
+      ensureArray(humanIntent.initialResponderSelectors)
+        .map((value) => normalizeMentionSelector(value))
+        .filter((value) => value && managedBotSelectors.has(value)),
+    );
+    const contractAllowedResponders = uniqueOrdered(
+      ensureArray(humanIntent.allowedResponderSelectors)
+        .map((value) => normalizeMentionSelector(value))
+        .filter((value) => value && managedBotSelectors.has(value)),
+    );
+    const contractParticipants = uniqueOrdered(
+      ensureArray(humanIntent.participantSelectors)
+        .map((value) => normalizeMentionSelector(value))
+        .filter((value) => value && managedBotSelectors.has(value)),
+    );
+    const contractLeadBot = normalizeMentionSelector(humanIntent.leadBotSelector);
+    const selectedFromContract = uniqueOrdered(
+      (
+        contractInitialResponders.length
+          ? contractInitialResponders
+          : contractAllowedResponders.length
+            ? contractAllowedResponders
+            : contractParticipants.length
+              ? contractParticipants
+              : contractLeadBot && managedBotSelectors.has(contractLeadBot)
+                ? [contractLeadBot]
+                : []
+      ).filter(Boolean),
+    );
+    if (selectedFromContract.length > 0) {
+      return {
+        decision: selectedFromContract.length > 1 ? "multiple_responders" : "single_responder",
+        selected_bot_usernames: selectedFromContract,
+        referenced_bot_usernames: triggerFacts.mentioned_bot_usernames,
+        confidence: "high",
+        reason_code: "precomputed_human_intent_contract",
+        clarification: "",
+        managed_bots: managedBots,
+      };
+    }
     if (!adjudicator) {
       const fallbackSelected = managedBots
         .filter((entry) => entry.trigger_eligible === true)
@@ -4109,6 +4156,7 @@ export async function processRunnerSelectedRecord({
   triggerDecision: precomputedTriggerDecision = null,
   responderAdjudication: precomputedResponderAdjudication = null,
   persistedHumanIntentRequest = null,
+  precomputedHumanIntentContext = null,
   deps,
 }) {
   const saveRunnerRouteState = requireDependency(deps, "saveRunnerRouteState");
@@ -4128,6 +4176,8 @@ export async function processRunnerSelectedRecord({
     ...safeObject(buildRunnerExecutionDeps()),
     ...safeObject(deps),
   };
+  const normalizedPrecomputedHumanIntentContext = safeObject(precomputedHumanIntentContext);
+  const normalizedPrecomputedHumanIntent = safeObject(normalizedPrecomputedHumanIntentContext.humanIntent);
   const validateWorkspaceArtifacts = typeof executionDeps.validateWorkspaceArtifacts === "function"
     ? executionDeps.validateWorkspaceArtifacts
     : null;
@@ -4172,6 +4222,7 @@ export async function processRunnerSelectedRecord({
       bot,
       executionPlan,
       deps: executionDeps,
+      precomputedHumanIntent: normalizedPrecomputedHumanIntent,
     });
   const selectedResponderSelectors = ensureArray(responderAdjudication.selected_bot_usernames)
     .map((value) => normalizeMentionSelector(value))
@@ -4201,14 +4252,16 @@ export async function processRunnerSelectedRecord({
     };
   }
 
-  const humanIntentContext = await resolveHumanIntentContext({
-    selectedRecord,
-    normalizedRoute,
-    bot,
-    executionPlan,
-    deps: executionDeps,
-    persistedRequest: persistedHumanIntentRequest,
-  });
+  const humanIntentContext = Object.keys(normalizedPrecomputedHumanIntentContext).length > 0
+    ? normalizedPrecomputedHumanIntentContext
+    : await resolveHumanIntentContext({
+      selectedRecord,
+      normalizedRoute,
+      bot,
+      executionPlan,
+      deps: executionDeps,
+      persistedRequest: persistedHumanIntentRequest,
+    });
   const precomputedIntentType = normalizeHumanIntentType(
     safeObject(safeObject(humanIntentContext).humanIntent).intentType,
   );

package/lib/selftest-runner-scenarios.mjs

@@ -118,6 +118,7 @@ export async function runSelftestRunnerScenarios(push, deps) {
   const safeObject = requireDependency(deps, "safeObject");
   const normalizeRunnerTriggerPolicy = requireDependency(deps, "normalizeRunnerTriggerPolicy");
   const evaluateTelegramRunnerTrigger = requireDependency(deps, "evaluateTelegramRunnerTrigger");
+  const resolveRunnerResponderAdjudication = requireDependency(deps, "resolveRunnerResponderAdjudication");
   const selectPendingArchiveComments = requireDependency(deps, "selectPendingArchiveComments");
   const selectRunnerPendingWork = requireDependency(deps, "selectRunnerPendingWork");
   const processRunnerSelectedRecord = requireDependency(deps, "processRunnerSelectedRecord");
@@ -2228,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",
@@ -2935,6 +3064,108 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("public_multi_bot_human_intent_is_computed_once_per_message", false, String(err?.message || err));
   }
 
+  try {
+    let adjudicatorCalls = 0;
+    const adjudication = await resolveRunnerResponderAdjudication({
+      selectedRecord: {
+        id: "comment-precomputed-human-intent-adjudication",
+        parsedArchive: {
+          kind: "telegram_message",
+          chatID: "-100123",
+          chatType: "supergroup",
+          senderIsBot: false,
+          body: "@RyoAI_bot @RyoAI2_bot @RyoAI3_bot discuss this project together.",
+          mentionUsernames: ["RyoAI_bot", "RyoAI2_bot", "RyoAI3_bot"],
+          messageID: 1193,
+        },
+      },
+      pendingOrdered: [],
+      normalizedRoute: normalizeRunnerRoute({
+        name: "telegram-monitor-precomputed-human-intent-adjudication",
+        project_id: selftestProjectID,
+        provider: "telegram",
+        role: "monitor",
+        role_profile: "monitor",
+        destination_id: "dest-1",
+        destination_label: "Main Room",
+        server_bot_name: "RyoAI_bot",
+        server_bot_id: "bot-lead-1",
+        trigger_policy: {
+          mentions_only: true,
+          direct_messages: true,
+          reply_to_bot_messages: true,
+        },
+        archive_policy: {
+          mirror_replies: true,
+          dedupe_inbound: true,
+          dedupe_outbound: true,
+          skip_bot_messages: true,
+        },
+        dry_run_delivery: true,
+      }),
+      bot: {
+        id: "bot-lead-1",
+        name: "RyoAI_bot",
+        username: "RyoAI_bot",
+        role: "monitor",
+        provider: "telegram",
+      },
+      executionPlan: {
+        mode: "role_profile",
+        roleProfileName: "monitor",
+        roleProfile: {
+          client: "sample",
+          model: "",
+          permissionMode: "read_only",
+          reasoningEffort: "low",
+        },
+        workspaceDir: path.join(os.tmpdir(), "metheus-runner-selftest-precomputed-human-intent-adjudication"),
+        workspaceSource: "selftest",
+        usedCommandFallback: false,
+      },
+      precomputedHumanIntent: {
+        intentMode: "delegated_single_lead",
+        intentType: "explanation_query",
+        participantSelectors: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+        initialResponderSelectors: ["ryoai_bot"],
+        allowedResponderSelectors: ["ryoai_bot", "ryoai2_bot", "ryoai3_bot"],
+        leadBotSelector: "ryoai_bot",
+        summaryBotSelector: "ryoai_bot",
+        allowBotToBot: true,
+        replyExpectation: "informational",
+      },
+      deps: {
+        adjudicateRunnerRespondersWithAI: async () => {
+          adjudicatorCalls += 1;
+          return {
+            decision: "multiple_responders",
+            selected_bot_usernames: ["ryoai2_bot", "ryoai3_bot"],
+          };
+        },
+        managedConversationBots: [
+          { route: { serverBotName: "RyoAI_bot" }, bot: { username: "RyoAI_bot", name: "RyoAI_bot" } },
+          { route: { serverBotName: "RyoAI2_bot" }, bot: { username: "RyoAI2_bot", name: "RyoAI2_bot" } },
+          { route: { serverBotName: "RyoAI3_bot" }, bot: { username: "RyoAI3_bot", name: "RyoAI3_bot" } },
+        ],
+        resolveConversationPeerBots: () => [
+          { id: "bot-lead-1", name: "RyoAI_bot" },
+          { id: "bot-peer-1", name: "RyoAI2_bot" },
+          { id: "bot-peer-2", name: "RyoAI3_bot" },
+        ],
+      },
+    });
+    push(
+      "precomputed_human_intent_contract_drives_responder_selection",
+      adjudicatorCalls === 0
+        && ensureArray(adjudication.selected_bot_usernames).length === 1
+        && String(ensureArray(adjudication.selected_bot_usernames)[0] || "") === "ryoai_bot"
+        && String(adjudication.reason_code || "") === "precomputed_human_intent_contract",
+      `adjudicator_calls=${adjudicatorCalls} selected=${JSON.stringify(ensureArray(adjudication.selected_bot_usernames))} reason=${String(adjudication.reason_code || "(none)")}`,
+    );
+  } catch (err) {
+    push("precomputed_human_intent_contract_drives_responder_selection", false, String(err?.message || err));
+  }
+
   try {
     let humanIntentCalls = 0;
     const processed = await processRunnerSelectedRecord({

package/package.json

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