metheus-governance-mcp-cli 0.2.172 → 0.2.178

package/cli.mjs

@@ -11,6 +11,7 @@ import http from "node:http";
 import https from "node:https";
 import {
   DEFAULT_LOCAL_AI_CLIENT,
+  adjudicateRunnerRespondersWithAI,
   analyzeHumanConversationIntentWithAI,
   auditRoleExecutionPlanWithAI,
   auditDirectHumanReplyWithAI,
@@ -126,6 +127,7 @@ import {
   withWorkspaceDirArg,
 } from "./lib/client-registration.mjs";
 import {
+  applyPendingAgeSelection,
   buildRunnerRouteStateFromComment,
   isInboundArchiveKind,
   normalizeArchiveCommentRecord,
@@ -165,6 +167,7 @@ import {
 } from "./lib/runner-execution.mjs";
 import {
   processRunnerSelectedRecord,
+  resolveRunnerResponderAdjudication,
   selectRunnerPendingWork,
 } from "./lib/runner-orchestration.mjs";
 import {
@@ -196,6 +199,7 @@ const BOT_RUNNER_ROUTE_LOCK_STALE_MS = 30 * 60 * 1000;
 const BOT_RUNNER_ACTIVE_EXECUTION_STUCK_WARNING_MS = 20 * 60 * 1000;
 const BOT_RUNNER_ACTIVE_EXECUTION_HEARTBEAT_INTERVAL_MS = 5000;
 const BOT_RUNNER_ACTIVE_EXECUTION_HEARTBEAT_STALE_MS = 60 * 1000;
+const BOT_RUNNER_PENDING_COMMENT_MAX_AGE_MS = 15 * 60 * 1000;
 const BOT_RUNNER_DEFAULT_CONCURRENCY = 2;
 const BOT_RUNNER_MAX_CONCURRENCY = 8;
 const TELEGRAM_ROOT_LEGACY_ENV_RELATIVE_PATH = path.join(".metheus", "telegram.env");
@@ -3989,6 +3993,7 @@ async function resolveInformationalQueryReply({
 
 function buildRunnerExecutionDeps() {
   return {
+    adjudicateRunnerRespondersWithAI,
     analyzeHumanConversationIntentWithAI,
     auditRoleExecutionPlanWithAI,
     auditDirectHumanReplyWithAI,
@@ -4031,6 +4036,7 @@ function buildRunnerRuntimeDeps() {
     getTelegramUpdates,
     normalizeLocalTelegramUpdate,
     listThreadComments,
+    applyPendingAgeSelection,
     normalizeArchiveCommentRecord,
     isInboundArchiveKind,
     buildArchivedInboundMessageKey,
@@ -4223,6 +4229,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
       timeoutSeconds: runtime.timeoutSeconds,
     });
     const bot = selectRunnerBot(bots, normalizedRoute);
+    const managedConversationBots = resolveRunnerConversationManagedBots(normalizedRoute, bots);
     const executionPlan = resolveRunnerExecutionPlan(
       normalizedRoute,
       bot,
@@ -4293,11 +4300,21 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
       refreshedState,
       mode,
       parseArchivedChatComment,
+      pendingSelectionOptions: {
+        maxPendingAgeMs: BOT_RUNNER_PENDING_COMMENT_MAX_AGE_MS,
+      },
       deps: {
+        applyPendingAgeSelection,
         normalizeArchiveCommentRecord,
       },
     });
     const pending = pendingWork.pending;
+    if (pending.staleSkippedLatest) {
+      saveRunnerRouteState(routeKey, buildRunnerRouteStateFromComment(pending.staleSkippedLatest, {
+        last_reason: `skipped ${ensureArray(pending.staleSkipped).length} stale archive message(s) older than ${Math.floor(BOT_RUNNER_PENDING_COMMENT_MAX_AGE_MS / 60000)} minutes`,
+      }));
+      refreshedState = safeObject(loadBotRunnerState().routes[routeKey]);
+    }
     if (pending.shouldPrime && pending.latest) {
       saveRunnerRouteState(routeKey, buildRunnerRouteStateFromComment(pending.latest, { primed: true }));
       return {
@@ -4318,7 +4335,9 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         route_name: normalizedRoute.name,
         logical_signature: runnerRouteLogicalSignature(normalizedRoute),
         outcome: "idle",
-        detail: importOutcome.importedCount > 0
+        detail: pending.staleSkippedLatest
+          ? `skipped ${ensureArray(pending.staleSkipped).length} stale archive message(s)`
+          : importOutcome.importedCount > 0
           ? "local telegram updates imported but no pending archive comments were selected"
           : "no new local telegram messages or archived inbound messages",
         archive_source: String(archiveThread.source || "").trim() || "-",
@@ -4344,33 +4363,85 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
       };
     }
     if (deferExecution) {
-      const selectedRecord = pending.pending[0];
-      saveRunnerRouteState(routeKey, buildRunnerActiveExecutionPatch(selectedRecord));
-      return {
-        route_key: routeKey,
-        route_name: normalizedRoute.name,
-        logical_signature: runnerRouteLogicalSignature(normalizedRoute),
-        outcome: "accepted",
-        detail: `accepted comment ${selectedRecord.id} for background execution`,
-        archive_source: String(archiveThread.source || "").trim() || "-",
-        archive_work_item_id: String(archiveThread.workItemID || "").trim() || "",
-        thread_id: archiveThread.threadID,
-        comment_id: selectedRecord.id,
-        execution_mode: executionPlan.mode,
-        role_profile: executionPlan.roleProfileName,
-        deferred_execution: {
-          routeKey,
-          normalizedRoute,
-          routeState: refreshedState,
+      const skippedRecords = [];
+      for (const selectedRecord of pending.pending) {
+        const adjudication = await resolveRunnerResponderAdjudication({
           selectedRecord,
           pendingOrdered: pending.ordered,
+          normalizedRoute,
           bot,
-          destination,
-          archiveThread,
           executionPlan,
-          runtime,
-        },
-      };
+          deps: {
+            ...buildRunnerExecutionDeps(),
+            managedConversationBots,
+            resolveConversationPeerBots: resolveRunnerConversationPeers,
+          },
+        });
+        const currentBotSelector = String(bot?.username || bot?.name || "").trim().replace(/^@+/, "").toLowerCase();
+        const currentBotSelected = ensureArray(adjudication.selected_bot_usernames)
+          .map((value) => String(value || "").trim().replace(/^@+/, "").toLowerCase())
+          .includes(currentBotSelector);
+        if (!currentBotSelected) {
+          saveRunnerRouteState(
+            routeKey,
+            buildRunnerRouteStateFromComment(selectedRecord, {
+              last_action: "adjudication_skipped",
+              last_reason: String(adjudication.reason_code || "").trim() || "not_selected_by_adjudicator",
+              last_trigger: "responder_adjudication",
+            }),
+          );
+          skippedRecords.push({
+            id: selectedRecord.id,
+            reason: String(adjudication.reason_code || "").trim() || "not_selected_by_adjudicator",
+          });
+          continue;
+        }
+        saveRunnerRouteState(routeKey, buildRunnerActiveExecutionPatch(selectedRecord));
+        return {
+          route_key: routeKey,
+          route_name: normalizedRoute.name,
+          logical_signature: runnerRouteLogicalSignature(normalizedRoute),
+          outcome: "accepted",
+          detail: `accepted comment ${selectedRecord.id} for background execution`,
+          archive_source: String(archiveThread.source || "").trim() || "-",
+          archive_work_item_id: String(archiveThread.workItemID || "").trim() || "",
+          thread_id: archiveThread.threadID,
+          comment_id: selectedRecord.id,
+          execution_mode: executionPlan.mode,
+          role_profile: executionPlan.roleProfileName,
+          deferred_execution: {
+            routeKey,
+            normalizedRoute,
+            routeState: refreshedState,
+            selectedRecord,
+            pendingOrdered: pending.ordered,
+            bot,
+            destination,
+            archiveThread,
+            executionPlan,
+            runtime,
+            managedConversationBots,
+          },
+        };
+      }
+      if (skippedRecords.length > 0) {
+        const distinctReasons = Array.from(new Set(skippedRecords.map((item) => item.reason).filter(Boolean)));
+        const lastSkipped = skippedRecords[skippedRecords.length - 1];
+        return {
+          route_key: routeKey,
+          route_name: normalizedRoute.name,
+          logical_signature: runnerRouteLogicalSignature(normalizedRoute),
+          outcome: "skipped",
+          detail: distinctReasons.join("; ") || "all pending messages were skipped",
+          archive_source: String(archiveThread.source || "").trim() || "-",
+          archive_work_item_id: String(archiveThread.workItemID || "").trim() || "",
+          thread_id: archiveThread.threadID,
+          comment_id: lastSkipped.id,
+          skipped_count: skippedRecords.length,
+          execution_mode: executionPlan.mode,
+          role_profile: executionPlan.roleProfileName,
+        };
+      }
     }
     const skippedRecords = [];
     for (const selectedRecord of pending.pending) {
@@ -4396,6 +4467,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           buildRunnerExecutionDeps,
           buildRunnerDeliveryDeps,
           buildRunnerRuntimeDeps,
+          managedConversationBots,
           resolveConversationPeerBots: resolveRunnerConversationPeers,
         },
       });
@@ -5184,6 +5256,45 @@ function resolveRunnerConversationPeers(routeRaw) {
   return peers;
 }
 
+function resolveRunnerConversationManagedBots(routeRaw, availableBots = []) {
+  const normalizedRoute = normalizeRunnerRoute(routeRaw);
+  const config = loadBotRunnerConfig({ persistIfNeeded: true });
+  const seen = new Set();
+  const managed = [];
+  ensureArray(config.routes)
+    .map((rawRoute) => normalizeRunnerRoute(rawRoute))
+    .filter((route) => route.enabled)
+    .filter((route) => String(route.projectID || "").trim() === String(normalizedRoute.projectID || "").trim())
+    .filter((route) => String(route.provider || "").trim() === String(normalizedRoute.provider || "").trim())
+    .filter((route) => {
+      const routeDestinationID = String(route.destinationID || "").trim();
+      const targetDestinationID = String(normalizedRoute.destinationID || "").trim();
+      const routeDestinationLabel = normalizeRunnerRouteIdentityText(route.destinationLabel);
+      const targetDestinationLabel = normalizeRunnerRouteIdentityText(normalizedRoute.destinationLabel);
+      return targetDestinationID
+        ? (routeDestinationID === targetDestinationID || (!routeDestinationID && routeDestinationLabel === targetDestinationLabel))
+        : routeDestinationLabel === targetDestinationLabel;
+    })
+    .forEach((route) => {
+      try {
+        const bot = selectRunnerBot(availableBots, route);
+        const username = String(bot?.username || bot?.name || route.botName || "").trim().replace(/^@+/, "").toLowerCase();
+        if (!username || seen.has(username)) {
+          return;
+        }
+        seen.add(username);
+        managed.push({
+          username,
+          display_name: String(bot?.name || bot?.username || route.botName || username).trim(),
+          route_name: String(route.name || "").trim(),
+          route,
+          bot,
+        });
+      } catch {}
+    });
+  return managed;
+}
+
 function applyRunnerProjectUpRouteSuggestions(routeSuggestions) {
   const config = loadBotRunnerConfig({ persistIfNeeded: true });
   let nextConfig = config;
@@ -6591,6 +6702,7 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                         buildRunnerExecutionDeps,
                         buildRunnerDeliveryDeps,
                         buildRunnerRuntimeDeps,
+                        managedConversationBots: deferredExecution.managedConversationBots,
                         resolveConversationPeerBots: resolveRunnerConversationPeers,
                         reportRunnerStage: (stage) => {
                           runnerLogger?.append("execution_stage", {
@@ -11760,6 +11872,47 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     push("runner_active_execution_heartbeat_marks_live_execution_stale_when_expired", false, String(err?.message || err));
   }
 
+  try {
+    const nowMs = Date.now();
+    const pendingSelection = selectPendingArchiveComments(
+      [
+        {
+          id: "comment-seen",
+          created_at: new Date(nowMs - (BOT_RUNNER_PENDING_COMMENT_MAX_AGE_MS + 5 * 60_000)).toISOString(),
+          body: "[Telegram message]\nmessage_id: 100\n\nseen pending mention",
+        },
+        {
+          id: "comment-old",
+          created_at: new Date(nowMs - (BOT_RUNNER_PENDING_COMMENT_MAX_AGE_MS + 60_000)).toISOString(),
+          body: "[Telegram message]\nmessage_id: 101\n\nold pending mention",
+        },
+        {
+          id: "comment-fresh",
+          created_at: new Date(nowMs - 60_000).toISOString(),
+          body: "[Telegram message]\nmessage_id: 102\n\nfresh pending mention",
+        },
+      ],
+      {
+        last_processed_comment_id: "comment-seen",
+      },
+      "start",
+      (record) => normalizeArchiveCommentRecord(record, parseArchivedChatComment),
+      {
+        maxPendingAgeMs: BOT_RUNNER_PENDING_COMMENT_MAX_AGE_MS,
+        nowMs,
+      },
+    );
+    push(
+      "runner_pending_selection_skips_stale_archive_backlog",
+      ensureArray(pendingSelection.pending).length === 1
+        && String(ensureArray(pendingSelection.pending)[0]?.id || "").trim() === "comment-fresh"
+        && String(safeObject(pendingSelection.staleSkippedLatest).id || "").trim() === "comment-old",
+      `pending=${ensureArray(pendingSelection.pending).map((item) => String(item?.id || "").trim()).join(",") || "-"} stale=${String(safeObject(pendingSelection.staleSkippedLatest).id || "").trim() || "-"}`,
+    );
+  } catch (err) {
+    push("runner_pending_selection_skips_stale_archive_backlog", false, String(err?.message || err));
+  }
+
   try {
     const startResponse = await handleLocalProjectToolDispatchImpl(
       {