metheus-governance-mcp-cli 0.2.273 → 0.2.274

package/cli.mjs

@@ -3333,37 +3333,46 @@ function normalizeBotRunnerConsumedComments(rawConsumed, nowMs = Date.now()) {
   return normalized;
 }
 
-function buildRunnerConsumedCommentLedgerKey(commentIDRaw, routeKeyRaw = "", commentKindRaw = "") {
-  const commentID = String(commentIDRaw || "").trim();
-  if (!commentID) return "";
-  const routeKey = String(routeKeyRaw || "").trim();
-  const commentKind = String(commentKindRaw || "").trim().toLowerCase();
-  if (commentKind === "bot_reply" && routeKey) {
-    return `${commentID}::${routeKey}`;
-  }
-  return commentID;
-}
-
-function findRunnerConsumedCommentEntry(rawConsumed, commentIDRaw, { routeKey = "", commentKind = "" } = {}) {
-  const commentID = String(commentIDRaw || "").trim();
-  if (!commentID) return {};
-  const consumedComments = normalizeBotRunnerConsumedComments(rawConsumed);
-  const ledgerKey = buildRunnerConsumedCommentLedgerKey(commentID, routeKey, commentKind);
-  const directEntry = safeObject(consumedComments[ledgerKey]);
-  if (Object.keys(directEntry).length) {
-    return directEntry;
-  }
-  const normalizedKind = String(commentKind || "").trim().toLowerCase();
-  if (normalizedKind === "bot_reply" && String(routeKey || "").trim()) {
-    const routeEntry = Object.values(consumedComments).find((entryRaw) => {
-      const entry = safeObject(entryRaw);
-      return String(entry.comment_id || "").trim() === commentID
-        && String(entry.route_key || "").trim() === String(routeKey || "").trim();
-    });
-    return safeObject(routeEntry);
-  }
-  return safeObject(consumedComments[commentID]);
-}
+function buildRunnerConsumedCommentLedgerKey(commentIDRaw, routeKeyRaw = "", commentKindRaw = "") {
+  const commentID = String(commentIDRaw || "").trim();
+  if (!commentID) return "";
+  const routeKey = String(routeKeyRaw || "").trim();
+  if (routeKey) {
+    return `${commentID}::${routeKey}`;
+  }
+  return commentID;
+}
+
+function findRunnerConsumedCommentEntry(rawConsumed, commentIDRaw, { routeKey = "", commentKind = "" } = {}) {
+  const commentID = String(commentIDRaw || "").trim();
+  if (!commentID) return {};
+  const consumedComments = normalizeBotRunnerConsumedComments(rawConsumed);
+  const normalizedRouteKey = String(routeKey || "").trim();
+  const ledgerKey = buildRunnerConsumedCommentLedgerKey(commentID, normalizedRouteKey, commentKind);
+  const directEntry = safeObject(consumedComments[ledgerKey]);
+  if (Object.keys(directEntry).length) {
+    return directEntry;
+  }
+  if (normalizedRouteKey) {
+    const routeEntry = Object.values(consumedComments).find((entryRaw) => {
+      const entry = safeObject(entryRaw);
+      return String(entry.comment_id || "").trim() === commentID
+        && String(entry.route_key || "").trim() === normalizedRouteKey;
+    });
+    if (Object.keys(safeObject(routeEntry)).length > 0) {
+      return safeObject(routeEntry);
+    }
+  }
+  const legacyGlobalEntry = safeObject(consumedComments[commentID]);
+  if (!Object.keys(legacyGlobalEntry).length) {
+    return {};
+  }
+  const legacyRouteKey = String(legacyGlobalEntry.route_key || "").trim();
+  if (normalizedRouteKey && legacyRouteKey && legacyRouteKey !== normalizedRouteKey) {
+    return {};
+  }
+  return legacyGlobalEntry;
+}
 
 function runnerRouteMatchesProjectConversationScope(candidateRouteRaw, normalizedRouteRaw) {
   const candidateRoute = normalizeRunnerRoute(candidateRouteRaw);

package/lib/runner-orchestration-entrypoints.mjs

@@ -51,6 +51,100 @@ function intFromRawAllowZero(raw, fallback = 0) {
   return Number.isFinite(parsed) ? parsed : fallback;
 }
 
+function buildRunnerArchiveSourceMessageKey(recordRaw) {
+  const parsed = safeObject(safeObject(recordRaw).parsedArchive);
+  const chatID = String(parsed.chatID || parsed.chatId || "").trim();
+  const messageID = intFromRawAllowZero(parsed.messageID || parsed.messageId, 0);
+  if (!chatID || !(messageID > 0)) {
+    return "";
+  }
+  return `${chatID}:${messageID}`;
+}
+
+function buildRunnerLocalInboundReceiptKey(receiptRaw) {
+  const receipt = safeObject(receiptRaw);
+  const chatID = String(receipt.chat_id || receipt.chatID || "").trim();
+  const messageID = intFromRawAllowZero(receipt.message_id || receipt.messageID, 0);
+  if (!chatID || !(messageID > 0)) {
+    return "";
+  }
+  return `${chatID}:${messageID}`;
+}
+
+function buildRunnerReceiptReplaySortTime(receiptRaw) {
+  const receipt = safeObject(receiptRaw);
+  const receiptTime = Date.parse(firstNonEmptyString([
+    receipt.occurred_at,
+    receipt.occurredAt,
+    receipt.received_at,
+    receipt.receivedAt,
+  ]));
+  return Number.isFinite(receiptTime) ? receiptTime : 0;
+}
+
+function buildRunnerReceiptBackedReplayRecord(recordRaw, receiptRaw, pendingSelectionOptions = {}) {
+  const record = safeObject(recordRaw);
+  const receipt = safeObject(receiptRaw);
+  const replayOccurredAt = firstNonEmptyString([
+    receipt.occurred_at,
+    receipt.occurredAt,
+    receipt.received_at,
+    receipt.receivedAt,
+    record.sourceOccurredAt,
+    safeObject(record.parsedArchive).occurredAt,
+    safeObject(record.parsedArchive).occurred_at,
+    record.createdAt,
+    record.updatedAt,
+  ]);
+  let staleAfterAt = String(record.staleAfterAt || "").trim();
+  const maxPendingAgeMs = intFromRawAllowZero(safeObject(pendingSelectionOptions).maxPendingAgeMs, 0);
+  const replayOccurredAtMs = Date.parse(replayOccurredAt);
+  if (!staleAfterAt && maxPendingAgeMs > 0 && Number.isFinite(replayOccurredAtMs)) {
+    staleAfterAt = new Date(replayOccurredAtMs + maxPendingAgeMs).toISOString();
+  }
+  return {
+    ...record,
+    sourceOccurredAt: replayOccurredAt,
+    staleAfterAt,
+    replayTriggeredByLocalReceipt: true,
+  };
+}
+
+function buildRunnerReceiptBackedPendingArchiveComments({
+  orderedComments,
+  currentPollLocalInboundReceipts,
+  existingPendingIDs,
+  pendingSelectionOptions,
+}) {
+  const pendingIDs = new Set(ensureArray(existingPendingIDs).map((value) => String(value || "").trim()).filter(Boolean));
+  const latestReceiptsByKey = new Map();
+  for (const receiptRaw of ensureArray(currentPollLocalInboundReceipts)) {
+    const receipt = safeObject(receiptRaw);
+    const receiptKey = buildRunnerLocalInboundReceiptKey(receipt);
+    if (!receiptKey) {
+      continue;
+    }
+    const previous = safeObject(latestReceiptsByKey.get(receiptKey));
+    if (buildRunnerReceiptReplaySortTime(receipt) >= buildRunnerReceiptReplaySortTime(previous)) {
+      latestReceiptsByKey.set(receiptKey, receipt);
+    }
+  }
+  const replayCandidates = [];
+  for (const [receiptKey, receipt] of latestReceiptsByKey.entries()) {
+    const matchedRecord = orderedComments.find((record) => buildRunnerArchiveSourceMessageKey(record) === receiptKey);
+    const matchedID = String(safeObject(matchedRecord).id || "").trim();
+    if (!matchedID || pendingIDs.has(matchedID)) {
+      continue;
+    }
+    replayCandidates.push(buildRunnerReceiptBackedReplayRecord(
+      matchedRecord,
+      receipt,
+      pendingSelectionOptions,
+    ));
+  }
+  return replayCandidates.sort(compareArchiveCommentRecords);
+}
+
 function buildContextSpeakerType(parsedArchiveRaw) {
   const parsed = safeObject(parsedArchiveRaw);
   const kind = String(parsed.kind || "").trim();
@@ -862,10 +956,24 @@ export function selectRunnerPendingWork({
         pending: importedPendingAfterCursor,
       }, pendingSelectionOptions)
       : fullPending;
+  const receiptBackedPending = buildRunnerReceiptBackedPendingArchiveComments({
+    orderedComments,
+    currentPollLocalInboundReceipts: ensureArray(importOutcome?.currentPollLocalInboundReceipts),
+    existingPendingIDs: ensureArray(safeObject(pending).pending).map((record) => String(safeObject(record).id || "").trim()),
+    pendingSelectionOptions,
+  });
+  const finalPending = ensureArray(safeObject(pending).pending).length === 0 && receiptBackedPending.length > 0
+    ? applyPendingAgeSelection({
+      ...safeObject(pending),
+      shouldPrime: false,
+      pending: receiptBackedPending,
+    }, pendingSelectionOptions)
+    : pending;
   return {
     orderedComments,
     inboundComments,
     importedRecords,
-    pending,
+    receiptBackedPending,
+    pending: finalPending,
   };
 }

package/lib/runner-runtime.mjs

@@ -575,6 +575,14 @@ function groupRunnerLocalInboundArtifactsByRoute(localInboundArtifacts) {
   return Object.fromEntries(grouped.entries());
 }
 
+function buildRunnerCurrentPollLocalInboundReceipts(localInboundArtifactsByRoute, routeKey) {
+  return ensureArray(safeObject(localInboundArtifactsByRoute)[String(routeKey || "").trim()])
+    .map((artifactRaw) => ensureArray(safeObject(artifactRaw).receiptEntry))
+    .filter((entry) => entry.length === 2)
+    .map((entry) => safeObject(entry[1]))
+    .filter((receipt) => Object.keys(receipt).length > 0);
+}
+
 function buildRunnerRecentLocalInboundEnvelopes(routeStateRaw, recentLocalInboundReceipts) {
   const routeState = safeObject(routeStateRaw);
   const relevantEnvelopes = Object.values(safeObject(recentLocalInboundReceipts))
@@ -1144,6 +1152,10 @@ export async function archiveLocalTelegramMessagesForRoute({
     managedConversationBots,
   );
   const localInboundArtifactsByRoute = groupRunnerLocalInboundArtifactsByRoute(localInboundArtifacts);
+  const currentPollLocalInboundReceipts = buildRunnerCurrentPollLocalInboundReceipts(
+    localInboundArtifactsByRoute,
+    routeKey,
+  );
   const recentLocalInboundReceipts = buildRunnerRecentLocalInboundReceipts(
     routeState,
     ensureArray(localInboundArtifactsByRoute[routeKey]),
@@ -1205,7 +1217,9 @@ export async function archiveLocalTelegramMessagesForRoute({
     persistPollingProgress([], lastUpdateID);
     return {
       importedCommentIDs: [],
+      importedComments: [],
       importedCount: 0,
+      currentPollLocalInboundReceipts,
       lastUpdateID,
     };
   }
@@ -1249,6 +1263,7 @@ export async function archiveLocalTelegramMessagesForRoute({
     importedCommentIDs,
     importedComments,
     importedCount: importedCommentIDs.length,
+    currentPollLocalInboundReceipts,
     lastUpdateID: Math.max(lastUpdateID, handledUpdateID),
   };
 }

package/lib/selftest-runner-scenarios.mjs

@@ -1007,6 +1007,63 @@ export async function runSelftestRunnerScenarios(push, deps) {
     );
   }
 
+  try {
+    const pendingWork = selectRunnerPendingWork({
+      comments: [
+        {
+          id: "archived-current-message",
+          createdAt: "2026-03-18T00:00:01.000Z",
+          updatedAt: "2026-03-18T00:00:01.000Z",
+          parsedArchive: { kind: "telegram_message", chatID: "-1001", messageID: 280, body: "@RyoAI3_bot 하이" },
+        },
+        {
+          id: "cursor-comment",
+          createdAt: "2026-03-18T00:04:00.000Z",
+          updatedAt: "2026-03-18T00:04:00.000Z",
+          parsedArchive: { kind: "telegram_message", chatID: "-1001", messageID: 281, body: "@RyoAI_bot already processed" },
+        },
+      ],
+      importOutcome: {
+        importedCommentIDs: [],
+        currentPollLocalInboundReceipts: [
+          {
+            chat_id: "-1001",
+            message_id: 280,
+            occurred_at: "2026-03-18T00:05:00.000Z",
+            received_at: "2026-03-18T00:05:00.000Z",
+            update_id: 2001,
+          },
+        ],
+      },
+      refreshedState: {
+        last_processed_comment_id: "cursor-comment",
+        last_processed_created_at: "2026-03-18T00:04:00.000Z",
+      },
+      mode: "start",
+      parseArchivedChatComment: () => null,
+      deps: {
+        normalizeArchiveCommentRecord: (record) => record,
+        applyPendingAgeSelection: (selection) => selection,
+      },
+      pendingSelectionOptions: {
+        maxPendingAgeMs: 15 * 60 * 1000,
+      },
+    });
+    push(
+      "runner_pending_selection_replays_current_poll_local_receipt_against_existing_archive_comment",
+      pendingWork.pending.pending.length === 1
+        && String(pendingWork.pending.pending[0]?.id || "").trim() === "archived-current-message"
+        && pendingWork.pending.pending[0]?.replayTriggeredByLocalReceipt === true,
+      `pending=${pendingWork.pending.pending.map((item) => `${item.id}:${String(item.replayTriggeredByLocalReceipt === true)}`).join(",") || "(none)"}`,
+    );
+  } catch (err) {
+    push(
+      "runner_pending_selection_replays_current_poll_local_receipt_against_existing_archive_comment",
+      false,
+      String(err?.message || err),
+    );
+  }
+
   try {
     const selected = selectProjectChatDestination(
       [
@@ -2042,10 +2099,16 @@ export async function runSelftestRunnerScenarios(push, deps) {
       selectedRecord: humanRecord,
       selectedBotUsernames: ["ryoai_bot"],
       normalizedIntent: "coordination_request",
-    });
-    const claimedState = loadBotRunnerState();
-    const claimedRequest = safeObject(safeObject(claimedState.requests)[claimed.requestKey]);
-    const claimedConsumed = safeObject(safeObject(claimedState.consumedComments)[humanRecord.id]);
+    });
+    const claimedState = loadBotRunnerState();
+    const claimedRequest = safeObject(safeObject(claimedState.requests)[claimed.requestKey]);
+    const claimedConsumed = safeObject(
+      Object.values(safeObject(claimedState.consumedComments)).find((entryRaw) => {
+        const entry = safeObject(entryRaw);
+        return String(entry.comment_id || "").trim() === humanRecord.id
+          && String(entry.route_key || "").trim() === requestRouteKey;
+      }),
+    );
     push(
       "runner_request_claim_persists_request_and_consumed_comment",
       claimed.ok === true

package/package.json

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