metheus-governance-mcp-cli 0.2.184 → 0.2.185

package/cli.mjs

@@ -130,6 +130,8 @@ import {
 import {
   applyPendingAgeSelection,
   buildRunnerRouteStateFromComment,
+  buildProcessableArchiveLogicalKey,
+  findEarlierProcessableArchiveDuplicate,
   isInboundArchiveKind,
   normalizeArchiveCommentRecord,
   selectPendingArchiveComments,
@@ -148,6 +150,7 @@ import {
   listProjectContextItems as listProjectContextItemsImpl,
   listProjectCtxpackFiles as listProjectCtxpackFilesImpl,
   listThreadComments as listThreadCommentsImpl,
+  listThreadCommentsTail as listThreadCommentsTailImpl,
   listUserBotsForRunner as listUserBotsForRunnerImpl,
   selectProjectChatDestination as selectProjectChatDestinationImpl,
   selectRunnerBot as selectRunnerBotImpl,
@@ -3977,6 +3980,10 @@ async function listThreadComments(params) {
   return listThreadCommentsImpl(params, buildRunnerDataDeps());
 }
 
+async function listThreadCommentsTail(params) {
+  return listThreadCommentsTailImpl(params, buildRunnerDataDeps());
+}
+
 async function createThreadComment(params) {
   return createThreadCommentImpl(params, buildRunnerDataDeps());
 }
@@ -4005,6 +4012,7 @@ function buildRunnerDeliveryDeps() {
     providerEnvConfig,
     discoverArchiveThreadForDestination,
     listThreadComments,
+    listThreadCommentsTail,
     createThreadComment,
     parseArchivedChatComment,
   };
@@ -4377,6 +4385,7 @@ function buildRunnerRuntimeDeps() {
     getTelegramUpdates,
     normalizeLocalTelegramUpdate,
     listThreadComments,
+    listThreadCommentsTail,
     applyPendingAgeSelection,
     normalizeArchiveCommentRecord,
     isInboundArchiveKind,
@@ -4819,9 +4828,67 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         pending_count: pending.pending.length,
       };
     }
+    const maybeBuildDuplicateArchivedSkip = (selectedRecord, routeStateForDuplicate) => {
+      const selectedParsed = safeObject(selectedRecord?.parsedArchive);
+      const selectedLogicalKey = buildProcessableArchiveLogicalKey(selectedRecord);
+      if (!selectedLogicalKey) {
+        return null;
+      }
+      const earlierDuplicate = findEarlierProcessableArchiveDuplicate(pending.ordered, selectedRecord);
+      if (earlierDuplicate) {
+        return {
+          id: selectedRecord.id,
+          reason: "duplicate_archived_source_message",
+          messageID: intFromRawAllowZero(selectedParsed.messageID, 0),
+          diagnosticType: "skip",
+          contextExcluded: true,
+          action: "skip_duplicate_archived_message",
+          closedReason: "",
+        };
+      }
+      const duplicateState = safeObject(routeStateForDuplicate);
+      const lastSourceMessageID = intFromRawAllowZero(duplicateState.last_source_message_id, 0);
+      const lastSourceKind = String(duplicateState.last_source_kind || "").trim().toLowerCase();
+      const selectedMessageID = intFromRawAllowZero(selectedParsed.messageID, 0);
+      const selectedKind = String(selectedParsed.kind || "").trim().toLowerCase();
+      const lastCommentID = String(duplicateState.last_processed_comment_id || "").trim();
+      if (
+        selectedMessageID > 0
+        && lastSourceMessageID > 0
+        && selectedMessageID === lastSourceMessageID
+        && selectedKind
+        && lastSourceKind === selectedKind
+        && lastCommentID
+        && lastCommentID !== String(selectedRecord?.id || "").trim()
+      ) {
+        return {
+          id: selectedRecord.id,
+          reason: "duplicate_archived_source_message",
+          messageID: selectedMessageID,
+          diagnosticType: "skip",
+          contextExcluded: true,
+          action: "skip_duplicate_archived_message",
+          closedReason: "",
+        };
+      }
+      return null;
+    };
     if (deferExecution) {
       const skippedRecords = [];
       for (const selectedRecord of pending.pending) {
+        const duplicateArchivedSkip = maybeBuildDuplicateArchivedSkip(selectedRecord, refreshedState);
+        if (duplicateArchivedSkip) {
+          saveRunnerRouteState(
+            routeKey,
+            buildRunnerRouteStateFromComment(selectedRecord, {
+              last_action: "duplicate_skipped",
+              last_reason: String(duplicateArchivedSkip.reason || "duplicate_archived_source_message").trim(),
+              last_trigger: "archive_dedupe",
+            }),
+          );
+          skippedRecords.push(duplicateArchivedSkip);
+          continue;
+        }
         const startupLoopSkipped = await maybeHandleRunnerStartupLoopCandidate({
           routeKey,
           normalizedRoute,
@@ -4929,6 +4996,19 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
     }
     const skippedRecords = [];
     for (const selectedRecord of pending.pending) {
+      const duplicateArchivedSkip = maybeBuildDuplicateArchivedSkip(selectedRecord, refreshedState);
+      if (duplicateArchivedSkip) {
+        saveRunnerRouteState(
+          routeKey,
+          buildRunnerRouteStateFromComment(selectedRecord, {
+            last_action: "duplicate_skipped",
+            last_reason: String(duplicateArchivedSkip.reason || "duplicate_archived_source_message").trim(),
+            last_trigger: "archive_dedupe",
+          }),
+        );
+        skippedRecords.push(duplicateArchivedSkip);
+        continue;
+      }
       const startupLoopSkipped = await maybeHandleRunnerStartupLoopCandidate({
         routeKey,
         normalizedRoute,
@@ -11341,6 +11421,7 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     normalizeRunnerTriggerPolicy,
     evaluateTelegramRunnerTrigger,
     selectPendingArchiveComments,
+    selectRunnerPendingWork,
     processRunnerSelectedRecord,
     resolveRunnerStartupLoopAdjudication,
     runRunnerAIExecution,

package/lib/runner-data.mjs

@@ -348,6 +348,55 @@ export async function listThreadComments(
   return items;
 }
 
+export async function listThreadCommentsTail(
+  {
+    siteBaseURL,
+    threadID,
+    token,
+    timeoutSeconds,
+    tailLimit = 200,
+    scanLimit = 5000,
+    actorUserID = "",
+  },
+  deps,
+) {
+  const getJSONWithAuthHeaders = requireDependency(deps, "getJSONWithAuthHeaders");
+  const extraHeaders = actorUserID ? { "X-Actor-User-Id": actorUserID } : {};
+  const maxTail = Math.max(1, parsePositiveInt(tailLimit, 200));
+  const maxScan = Math.max(maxTail, parsePositiveInt(scanLimit, 5000));
+  const items = [];
+  let nextOffset = 0;
+  let scanned = 0;
+  let previousPageSignature = "";
+
+  while (scanned < maxScan) {
+    const pageSize = Math.min(100, maxScan - scanned);
+    if (pageSize <= 0) break;
+    const url = `${siteBaseURL}/api/v1/threads/${encodeURIComponent(threadID)}/comments?limit=${pageSize}&offset=${nextOffset}`;
+    const page = ensureArray(await getJSONWithAuthHeaders(url, timeoutSeconds, token, extraHeaders))
+      .map((row) => safeObject(row));
+    if (!page.length) {
+      break;
+    }
+    const pageSignature = `${page.length}:${String(page[0]?.id || "").trim()}:${String(page[page.length - 1]?.id || "").trim()}`;
+    if (nextOffset > 0 && pageSignature === previousPageSignature) {
+      break;
+    }
+    previousPageSignature = pageSignature;
+    items.push(...page);
+    if (items.length > maxTail) {
+      items.splice(0, items.length - maxTail);
+    }
+    scanned += page.length;
+    if (page.length < pageSize) {
+      break;
+    }
+    nextOffset += page.length;
+  }
+
+  return items;
+}
+
 export async function createThreadComment(
   {
     siteBaseURL,

package/lib/runner-delivery.mjs

@@ -251,6 +251,9 @@ export async function performLocalBotDelivery({
   const providerEnvConfig = requireDependency(deps, "providerEnvConfig");
   const discoverArchiveThreadForDestination = requireDependency(deps, "discoverArchiveThreadForDestination");
   const listThreadComments = requireDependency(deps, "listThreadComments");
+  const listThreadCommentsTail = typeof deps?.listThreadCommentsTail === "function"
+    ? deps.listThreadCommentsTail
+    : listThreadComments;
   const createThreadComment = requireDependency(deps, "createThreadComment");
   const parseArchivedChatComment = requireDependency(deps, "parseArchivedChatComment");
 
@@ -352,12 +355,13 @@ export async function performLocalBotDelivery({
       );
       const archiveReplyToMessageID = intFromRawAllowZero(delivery.effectiveReplyToMessageID, replyToMessageID);
       if (archiveDedupeOutbound && deliveredMessageID > 0) {
-        const existingComments = await listThreadComments({
+        const existingComments = await listThreadCommentsTail({
           siteBaseURL,
           threadID: thread.threadID,
           token,
           timeoutSeconds,
-          limit: 200,
+          tailLimit: 500,
+          scanLimit: 5000,
           actorUserID,
         });
         const existingRecord = findArchivedBotReplyRecord(existingComments, {

package/lib/runner-helpers.mjs

@@ -192,15 +192,70 @@ function isRunnerProcessableArchiveKind(kind) {
   return isInboundArchiveKind(kind) || String(kind || "").trim().toLowerCase() === "bot_reply";
 }
 
+export function buildProcessableArchiveLogicalKey(recordRaw) {
+  const record = safeObject(recordRaw);
+  const parsed = safeObject(record.parsedArchive);
+  const kind = String(parsed.kind || "").trim().toLowerCase();
+  if (!isRunnerProcessableArchiveKind(kind)) {
+    return "";
+  }
+  const chatID = firstNonEmptyString([parsed.chatID, parsed.chatId]);
+  const messageID = intFromRawAllowZero(parsed.messageID, 0);
+  if (!chatID || !(messageID > 0)) {
+    return "";
+  }
+  return `${kind}:${chatID}:${messageID}`;
+}
+
+export function findEarlierProcessableArchiveDuplicate(records, selectedRecord) {
+  const selected = safeObject(selectedRecord);
+  const selectedID = String(selected.id || "").trim();
+  if (!selectedID) return null;
+  const selectedLogicalKey = buildProcessableArchiveLogicalKey(selected);
+  if (!selectedLogicalKey) return null;
+  const ordered = ensureArray(records).filter(Boolean).sort(compareArchiveCommentRecords);
+  for (const record of ordered) {
+    const recordID = String(safeObject(record).id || "").trim();
+    if (!recordID || recordID === selectedID) {
+      break;
+    }
+    if (buildProcessableArchiveLogicalKey(record) === selectedLogicalKey) {
+      return record;
+    }
+  }
+  return null;
+}
+
+export function dedupeProcessableArchiveComments(records) {
+  const deduped = [];
+  const seenLogicalKeys = new Set();
+  for (const record of ensureArray(records)) {
+    const logicalKey = buildProcessableArchiveLogicalKey(record);
+    if (logicalKey) {
+      if (seenLogicalKeys.has(logicalKey)) {
+        continue;
+      }
+      seenLogicalKeys.add(logicalKey);
+    }
+    deduped.push(record);
+  }
+  return deduped;
+}
+
 function isArchiveRecordAfterState(record, routeState) {
   const state = safeObject(routeState);
   const lastCommentID = String(state.last_processed_comment_id || "").trim();
   const lastCreatedAt = String(state.last_processed_created_at || "").trim();
+  const createdAt = firstNonEmptyString([record.createdAt, record.updatedAt]);
+  if (lastCreatedAt && createdAt) {
+    if (createdAt > lastCreatedAt) return true;
+    if (createdAt < lastCreatedAt) return false;
+    return lastCommentID ? String(record.id || "").trim() !== lastCommentID : false;
+  }
   if (lastCommentID) {
     return String(record.id || "").trim() !== lastCommentID;
   }
   if (!lastCreatedAt) return true;
-  const createdAt = firstNonEmptyString([record.createdAt, record.updatedAt]);
   if (!createdAt) return true;
   return createdAt > lastCreatedAt;
 }
@@ -244,7 +299,9 @@ export function selectPendingArchiveComments(records, routeState, mode, normaliz
     .map((record) => normalizeArchiveCommentRecord(record))
     .filter((record) => record.id && record.parsedArchive)
     .sort(compareArchiveCommentRecords);
-  const processable = ordered.filter((record) => isRunnerProcessableArchiveKind(record.parsedArchive.kind));
+  const processable = dedupeProcessableArchiveComments(
+    ordered.filter((record) => isRunnerProcessableArchiveKind(record.parsedArchive.kind)),
+  );
   const latest = processable.length ? processable[processable.length - 1] : null;
   const state = safeObject(routeState);
   const activeCommentID = String(state.active_comment_id || "").trim();
@@ -282,6 +339,19 @@ export function selectPendingArchiveComments(records, routeState, mode, normaliz
         pending: processable.slice(activeIndex + 1),
       }, rawOptions);
     }
+    const activeRaw = ordered.find((record) => record.id === activeCommentID);
+    const activeLogicalKey = buildProcessableArchiveLogicalKey(activeRaw);
+    if (activeLogicalKey) {
+      const activeLogicalIndex = processable.findIndex((record) => buildProcessableArchiveLogicalKey(record) === activeLogicalKey);
+      if (activeLogicalIndex >= 0) {
+        return applyPendingAgeSelection({
+          ordered,
+          latest,
+          shouldPrime: false,
+          pending: processable.slice(activeLogicalIndex + 1),
+        }, rawOptions);
+      }
+    }
   }
 
   const lastCommentID = String(state.last_processed_comment_id || "").trim();
@@ -295,6 +365,19 @@ export function selectPendingArchiveComments(records, routeState, mode, normaliz
         pending: processable.slice(seenIndex + 1),
       }, rawOptions);
     }
+    const lastRaw = ordered.find((record) => record.id === lastCommentID);
+    const lastLogicalKey = buildProcessableArchiveLogicalKey(lastRaw);
+    if (lastLogicalKey) {
+      const seenLogicalIndex = processable.findIndex((record) => buildProcessableArchiveLogicalKey(record) === lastLogicalKey);
+      if (seenLogicalIndex >= 0) {
+        return applyPendingAgeSelection({
+          ordered,
+          latest,
+          shouldPrime: false,
+          pending: processable.slice(seenLogicalIndex + 1),
+        }, rawOptions);
+      }
+    }
   }
 
   return applyPendingAgeSelection({

package/lib/runner-orchestration.mjs

@@ -4,9 +4,10 @@ import {
   buildRunnerContextWindow,
   buildRunnerRouteStateFromComment,
   compareArchiveCommentRecords,
+  dedupeProcessableArchiveComments,
   isInboundArchiveKind,
-  selectPendingArchiveComments,
-} from "./runner-helpers.mjs";
+  selectPendingArchiveComments,
+} from "./runner-helpers.mjs";
 import {
   buildRunnerInputPayload,
   evaluateTelegramRunnerTrigger,
@@ -3538,31 +3539,40 @@ export function selectRunnerPendingWork({
   const normalizeArchiveCommentRecord = requireDependency(deps, "normalizeArchiveCommentRecord");
   const applyPendingAgeSelection = requireDependency(deps, "applyPendingAgeSelection");
   const orderedComments = ensureArray(comments)
-    .map((record) => normalizeArchiveCommentRecord(record, parseArchivedChatComment))
-    .filter((record) => record.id && record.parsedArchive)
-    .sort(compareArchiveCommentRecords);
-  const inboundComments = orderedComments.filter((record) => isInboundArchiveKind(record.parsedArchive.kind));
-  const importedRecords = ensureArray(importOutcome?.importedCommentIDs)
-    .map((commentID) => orderedComments.find((record) => record.id === commentID))
-    .filter(Boolean);
-  const pending = importedRecords.length > 0
+    .map((record) => normalizeArchiveCommentRecord(record, parseArchivedChatComment))
+    .filter((record) => record.id && record.parsedArchive)
+    .sort(compareArchiveCommentRecords);
+  const inboundComments = orderedComments.filter((record) => isInboundArchiveKind(record.parsedArchive.kind));
+  const importedRecords = dedupeProcessableArchiveComments(
+    ensureArray(importOutcome?.importedCommentIDs)
+    .map((commentID) => orderedComments.find((record) => record.id === commentID))
+    .filter(Boolean),
+  );
+  const hasCursor = Boolean(
+    String(safeObject(refreshedState).active_comment_id || "").trim()
+    || String(safeObject(refreshedState).active_comment_created_at || "").trim()
+    || String(safeObject(refreshedState).last_processed_comment_id || "").trim()
+    || String(safeObject(refreshedState).last_processed_created_at || "").trim(),
+  );
+  const fullPending = selectPendingArchiveComments(
+    comments,
+    refreshedState,
+    mode,
+    (record) => normalizeArchiveCommentRecord(record, parseArchivedChatComment),
+    pendingSelectionOptions,
+  );
+  const pending = importedRecords.length > 0 && !hasCursor
     ? applyPendingAgeSelection({
         ordered: orderedComments,
         latest: inboundComments.length ? inboundComments[inboundComments.length - 1] : null,
         shouldPrime: false,
         pending: importedRecords,
       }, pendingSelectionOptions)
-    : selectPendingArchiveComments(
-      comments,
-      refreshedState,
-      mode,
-      (record) => normalizeArchiveCommentRecord(record, parseArchivedChatComment),
-      pendingSelectionOptions,
-    );
-  return {
-    orderedComments,
-    inboundComments,
-    importedRecords,
+    : fullPending;
+  return {
+    orderedComments,
+    inboundComments,
+    importedRecords,
     pending,
   };
 }

package/lib/runner-runtime.mjs

@@ -198,6 +198,57 @@ function mergeRunnerSharedInboxUpdates(existingUpdates, incomingUpdates) {
     .slice(-500);
 }
 
+const RUNNER_INBOUND_ARCHIVE_RESERVATION_TTL_MS = 10 * 60 * 1000;
+const runnerInboundArchiveReservations = new Map();
+
+function buildRunnerInboundArchiveReservationKey(threadID, chatID, messageID) {
+  const normalizedThreadID = String(threadID || "").trim();
+  const normalizedChatID = String(chatID || "").trim();
+  const normalizedMessageID = intFromRawAllowZero(messageID, 0);
+  if (!normalizedThreadID || !normalizedChatID || !(normalizedMessageID > 0)) {
+    return "";
+  }
+  return `${normalizedThreadID}::${normalizedChatID}:${normalizedMessageID}`;
+}
+
+function cleanupRunnerInboundArchiveReservations(nowMs = Date.now()) {
+  for (const [key, expiresAtMs] of runnerInboundArchiveReservations.entries()) {
+    if (!(Number(expiresAtMs) > nowMs)) {
+      runnerInboundArchiveReservations.delete(key);
+    }
+  }
+}
+
+function reserveRunnerInboundArchiveMessage(threadID, chatID, messageID) {
+  const reservationKey = buildRunnerInboundArchiveReservationKey(threadID, chatID, messageID);
+  if (!reservationKey) {
+    return {
+      ok: false,
+      reservationKey: "",
+    };
+  }
+  cleanupRunnerInboundArchiveReservations();
+  if (runnerInboundArchiveReservations.has(reservationKey)) {
+    return {
+      ok: false,
+      reservationKey,
+    };
+  }
+  runnerInboundArchiveReservations.set(reservationKey, Date.now() + RUNNER_INBOUND_ARCHIVE_RESERVATION_TTL_MS);
+  return {
+    ok: true,
+    reservationKey,
+  };
+}
+
+function releaseRunnerInboundArchiveMessageReservation(reservationKey) {
+  const normalizedKey = String(reservationKey || "").trim();
+  if (!normalizedKey) {
+    return;
+  }
+  runnerInboundArchiveReservations.delete(normalizedKey);
+}
+
 export async function maybeSendRunnerChatAction({
   provider,
   bot,
@@ -346,6 +397,9 @@ export async function archiveLocalTelegramMessagesForRoute({
   const getTelegramUpdates = requireDependency(deps, "getTelegramUpdates");
   const normalizeLocalTelegramUpdate = requireDependency(deps, "normalizeLocalTelegramUpdate");
   const listThreadComments = requireDependency(deps, "listThreadComments");
+  const listThreadCommentsTail = typeof deps?.listThreadCommentsTail === "function"
+    ? deps.listThreadCommentsTail
+    : listThreadComments;
   const normalizeArchiveCommentRecord = requireDependency(deps, "normalizeArchiveCommentRecord");
   const isInboundArchiveKind = requireDependency(deps, "isInboundArchiveKind");
   const buildArchivedInboundMessageKey = requireDependency(deps, "buildArchivedInboundMessageKey");
@@ -417,7 +471,7 @@ export async function archiveLocalTelegramMessagesForRoute({
   let handledUpdateID = lastUpdateID;
   const mergedSharedUpdates = mergeRunnerSharedInboxUpdates(sharedInbox.updates, updates);
 
-  const persistPollingProgress = () => {
+  const persistPollingProgress = (remainingSharedUpdates = []) => {
     if (sharedInboxKey && saveBotRunnerState) {
       saveBotRunnerState({
         sharedInboxes: {
@@ -425,7 +479,7 @@ export async function archiveLocalTelegramMessagesForRoute({
           [sharedInboxKey]: serializeRunnerSharedInbox({
             lastProviderUpdateID: handledUpdateID,
             updatedAt: new Date().toISOString(),
-            updates: mergedSharedUpdates,
+            updates: remainingSharedUpdates,
           }),
         },
       });
@@ -447,12 +501,13 @@ export async function archiveLocalTelegramMessagesForRoute({
     };
   }
 
-  const existingComments = await listThreadComments({
+  const existingComments = await listThreadCommentsTail({
     siteBaseURL: runtime.baseURL,
     threadID: archiveThread.threadID,
     token: runtime.token,
     timeoutSeconds: runtime.timeoutSeconds,
-    limit: 200,
+    tailLimit: 500,
+    scanLimit: 5000,
     actorUserID: runtime.actor.user_id,
   });
   const existingKeys = new Set(
@@ -466,10 +521,13 @@ export async function archiveLocalTelegramMessagesForRoute({
   );
 
   const importedCommentIDs = [];
-  for (const update of mergedSharedUpdates) {
+  const retainedSharedUpdates = [];
+  for (let index = 0; index < mergedSharedUpdates.length; index += 1) {
+    const update = mergedSharedUpdates[index];
     const updateID = intFromRawAllowZero(update.updateID, 0);
     if (String(update.chatID || "").trim() !== String(destination.chatID || "").trim()) {
       handledUpdateID = Math.max(handledUpdateID, updateID);
+      retainedSharedUpdates.push(update);
       continue;
     }
     const allowManagedBotImport = shouldImportManagedBotMessageForRoute({
@@ -491,6 +549,13 @@ export async function archiveLocalTelegramMessagesForRoute({
       handledUpdateID = Math.max(handledUpdateID, updateID);
       continue;
     }
+    const reservation = boolFromRaw(archivePolicy.dedupeInbound, true)
+      ? reserveRunnerInboundArchiveMessage(archiveThread?.threadID, update.chatID, update.messageID)
+      : { ok: true, reservationKey: "" };
+    if (!reservation.ok) {
+      handledUpdateID = Math.max(handledUpdateID, updateID);
+      continue;
+    }
     let createdComment;
     try {
       createdComment = await createThreadComment({
@@ -502,7 +567,10 @@ export async function archiveLocalTelegramMessagesForRoute({
         body: formatTelegramInboundArchiveComment(update),
       });
     } catch (err) {
-      persistPollingProgress();
+      releaseRunnerInboundArchiveMessageReservation(reservation.reservationKey);
+      persistPollingProgress(
+        mergeRunnerSharedInboxUpdates(retainedSharedUpdates, mergedSharedUpdates.slice(index)),
+      );
       throw err;
     }
     if (String(createdComment.id || "").trim()) {
@@ -513,7 +581,7 @@ export async function archiveLocalTelegramMessagesForRoute({
     }
     handledUpdateID = Math.max(handledUpdateID, updateID);
   }
-  persistPollingProgress();
+  persistPollingProgress(retainedSharedUpdates);
 
   return {
     importedCommentIDs,

package/lib/selftest-runner-scenarios.mjs

@@ -50,6 +50,7 @@ export async function runSelftestRunnerScenarios(push, deps) {
   const normalizeRunnerTriggerPolicy = requireDependency(deps, "normalizeRunnerTriggerPolicy");
   const evaluateTelegramRunnerTrigger = requireDependency(deps, "evaluateTelegramRunnerTrigger");
   const selectPendingArchiveComments = requireDependency(deps, "selectPendingArchiveComments");
+  const selectRunnerPendingWork = requireDependency(deps, "selectRunnerPendingWork");
   const processRunnerSelectedRecord = requireDependency(deps, "processRunnerSelectedRecord");
   const resolveRunnerStartupLoopAdjudication = requireDependency(deps, "resolveRunnerStartupLoopAdjudication");
   const runRunnerAIExecution = requireDependency(deps, "runRunnerAIExecution");
@@ -348,6 +349,86 @@ export async function runSelftestRunnerScenarios(push, deps) {
     );
   }
 
+  try {
+    const pendingSelection = selectPendingArchiveComments(
+      [
+        {
+          id: "dup-comment-1",
+          createdAt: "2026-03-18T00:00:01.000Z",
+          updatedAt: "2026-03-18T00:00:01.000Z",
+          parsedArchive: { kind: "telegram_message", chatID: "-1001", messageID: 353, body: "@RyoAI_bot first copy" },
+        },
+        {
+          id: "dup-comment-2",
+          createdAt: "2026-03-18T00:00:02.000Z",
+          updatedAt: "2026-03-18T00:00:02.000Z",
+          parsedArchive: { kind: "telegram_message", chatID: "-1001", messageID: 353, body: "@RyoAI_bot duplicate copy" },
+        },
+      ],
+      {
+        last_processed_comment_id: "dup-comment-1",
+      },
+      "start",
+      (record) => record,
+    );
+    push(
+      "runner_pending_selection_ignores_duplicate_archived_inbound_message_ids",
+      pendingSelection.pending.length === 0,
+      `pending=${pendingSelection.pending.map((item) => item.id).join(",") || "(none)"}`,
+    );
+  } catch (err) {
+    push(
+      "runner_pending_selection_ignores_duplicate_archived_inbound_message_ids",
+      false,
+      String(err?.message || err),
+    );
+  }
+
+  try {
+    const duplicateComments = [
+      {
+        id: "dup-comment-earliest",
+        createdAt: "2026-03-18T00:00:01.000Z",
+        updatedAt: "2026-03-18T00:00:01.000Z",
+        parsedArchive: { kind: "telegram_message", chatID: "-1001", messageID: 353, body: "@RyoAI_bot first copy" },
+      },
+      {
+        id: "dup-comment-imported",
+        createdAt: "2026-03-18T00:00:05.000Z",
+        updatedAt: "2026-03-18T00:00:05.000Z",
+        parsedArchive: { kind: "telegram_message", chatID: "-1001", messageID: 353, body: "@RyoAI_bot imported duplicate" },
+      },
+    ];
+    const pendingWork = selectRunnerPendingWork({
+      comments: duplicateComments,
+      importOutcome: {
+        importedCommentIDs: ["dup-comment-imported"],
+      },
+      refreshedState: {
+        last_processed_comment_id: "dup-comment-earliest",
+        last_processed_created_at: "2026-03-18T00:00:01.000Z",
+      },
+      mode: "start",
+      parseArchivedChatComment: () => null,
+      deps: {
+        normalizeArchiveCommentRecord: (record) => record,
+        applyPendingAgeSelection: (selection) => selection,
+      },
+      pendingSelectionOptions: {},
+    });
+    push(
+      "runner_pending_selection_does_not_requeue_imported_duplicate_after_cursor",
+      pendingWork.pending.pending.length === 0,
+      `pending=${pendingWork.pending.pending.map((item) => item.id).join(",") || "(none)"}`,
+    );
+  } catch (err) {
+    push(
+      "runner_pending_selection_does_not_requeue_imported_duplicate_after_cursor",
+      false,
+      String(err?.message || err),
+    );
+  }
+
   try {
     const selected = selectProjectChatDestination(
       [

package/lib/selftest-telegram-e2e.mjs

@@ -106,17 +106,22 @@ async function startLocalTelegramRunnerSelftestServer({
         return;
       }
 
-      const commentsMatch = pathname.match(/^\/api\/v1\/threads\/([^/]+)\/comments$/);
-      if (commentsMatch) {
-        const requestedThreadID = decodeURIComponent(String(commentsMatch[1] || "").trim());
-        if (requestedThreadID !== threadID) {
-          writeJSON(res, 404, { error: "thread not found" });
-          return;
-        }
-        if (req.method === "GET") {
-          writeJSON(res, 200, state.comments);
-          return;
-        }
+      const commentsMatch = pathname.match(/^\/api\/v1\/threads\/([^/]+)\/comments$/);
+      if (commentsMatch) {
+        const requestedThreadID = decodeURIComponent(String(commentsMatch[1] || "").trim());
+        if (requestedThreadID !== threadID) {
+          writeJSON(res, 404, { error: "thread not found" });
+          return;
+        }
+        if (req.method === "GET") {
+          const limit = Math.max(0, intFromRawAllowZero(requestURL.searchParams.get("limit"), state.comments.length || 0));
+          const offset = Math.max(0, intFromRawAllowZero(requestURL.searchParams.get("offset"), 0));
+          const paged = limit > 0
+            ? state.comments.slice(offset, offset + limit)
+            : state.comments.slice(offset);
+          writeJSON(res, 200, paged);
+          return;
+        }
         if (req.method === "POST") {
           const payload = await readJSONBody(req);
           const created = {
@@ -609,6 +614,260 @@ export async function runSelftestTelegramE2E(push, deps) {
       `comments=${sharedInboxBodies.length} bodies=${sharedInboxBodies.join(" || ")}`,
     );
 
+    telegramE2EServer.state.comments = [];
+    telegramE2EServer.state.updates = [
+      {
+        update_id: 330,
+        message: {
+          message_id: 79,
+          date: Math.floor(Date.now() / 1000),
+          chat: {
+            id: Number(e2eDestination.chat_id),
+            type: "supergroup",
+            title: e2eDestination.label,
+          },
+          from: {
+            id: 5001,
+            is_bot: false,
+            first_name: "Operator",
+            username: "operator_user",
+          },
+          text: `shared inbox prune @${String(e2eBot.name || "monitor_bot").replace(/^@+/, "")}`,
+        },
+      },
+    ];
+    const pruneRoute = {
+      ...e2eRoute,
+      name: "selftest-runner-e2e-shared-inbox-prune",
+    };
+    const pruneRouteKey = runnerRouteKey(normalizeRunnerRoute(pruneRoute));
+    await archiveLocalTelegramMessagesForRoute({
+      routeKey: pruneRouteKey,
+      route: pruneRoute,
+      routeState: {},
+      runtime: {
+        baseURL: telegramE2EServer.baseURL,
+        timeoutSeconds: 10,
+        token: e2eToken,
+        actor: {
+          user_id: e2eActorUserID,
+        },
+      },
+      bot: e2eBot,
+      destination: {
+        chatID: e2eDestination.chat_id,
+      },
+      archiveThread: {
+        threadID: e2eThreadID,
+      },
+      deps: buildRunnerRuntimeDeps(),
+    });
+    telegramE2EServer.state.updates = [];
+    const pruneRouteState = safeObject(loadBotRunnerState().routes[pruneRouteKey]);
+    await archiveLocalTelegramMessagesForRoute({
+      routeKey: pruneRouteKey,
+      route: pruneRoute,
+      routeState: pruneRouteState,
+      runtime: {
+        baseURL: telegramE2EServer.baseURL,
+        timeoutSeconds: 10,
+        token: e2eToken,
+        actor: {
+          user_id: e2eActorUserID,
+        },
+      },
+      bot: e2eBot,
+      destination: {
+        chatID: e2eDestination.chat_id,
+      },
+      archiveThread: {
+        threadID: e2eThreadID,
+      },
+      deps: buildRunnerRuntimeDeps(),
+    });
+    const prunedSharedBodies = telegramE2EServer.state.comments.map((item) => String(item.body || ""));
+    push(
+      "telegram_shared_inbox_prunes_handled_updates_after_import",
+      prunedSharedBodies.filter((item) => item.includes("message_id: 79")).length === 1,
+      `count=${prunedSharedBodies.filter((item) => item.includes("message_id: 79")).length} comments=${prunedSharedBodies.length}`,
+    );
+
+    telegramE2EServer.state.comments = Array.from({ length: 240 }, (_, index) => ({
+      id: `historical-comment-${index + 1}`,
+      body: [
+        "[Telegram message]",
+        `chat_id: ${e2eDestination.chat_id}`,
+        "chat_type: supergroup",
+        `message_id: ${1000 + index}`,
+        `occurred_at: ${new Date(Date.now() - ((241 - index) * 1000)).toISOString()}`,
+        `sender_id: ${5000 + index}`,
+        `sender: Historical User ${index + 1}`,
+        "sender_is_bot: false",
+        "",
+        `historical message ${index + 1}`,
+      ].join("\n"),
+      created_at: new Date(Date.now() - ((241 - index) * 1000)).toISOString(),
+      updated_at: new Date(Date.now() - ((241 - index) * 1000)).toISOString(),
+      author_user_id: e2eActorUserID,
+    }));
+    telegramE2EServer.state.comments.push({
+      id: "historical-tail-duplicate",
+      body: [
+        "[Telegram message]",
+        `chat_id: ${e2eDestination.chat_id}`,
+        "chat_type: supergroup",
+        "message_id: 353",
+        `occurred_at: ${new Date().toISOString()}`,
+        "sender_id: 5001",
+        "sender: Operator",
+        "sender_is_bot: false",
+        "telegram_username: @operator_user",
+        "",
+        "tail duplicate should dedupe",
+      ].join("\n"),
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+      author_user_id: e2eActorUserID,
+    });
+    telegramE2EServer.state.updates = [
+      {
+        update_id: 351,
+        message: {
+          message_id: 353,
+          date: Math.floor(Date.now() / 1000),
+          chat: {
+            id: Number(e2eDestination.chat_id),
+            type: "supergroup",
+            title: e2eDestination.label,
+          },
+          from: {
+            id: 5001,
+            is_bot: false,
+            first_name: "Operator",
+            username: "operator_user",
+          },
+          text: "tail duplicate should dedupe",
+        },
+      },
+    ];
+    await archiveLocalTelegramMessagesForRoute({
+      routeKey: pruneRouteKey,
+      route: pruneRoute,
+      routeState: safeObject(loadBotRunnerState().routes[pruneRouteKey]),
+      runtime: {
+        baseURL: telegramE2EServer.baseURL,
+        timeoutSeconds: 10,
+        token: e2eToken,
+        actor: {
+          user_id: e2eActorUserID,
+        },
+      },
+      bot: e2eBot,
+      destination: {
+        chatID: e2eDestination.chat_id,
+      },
+      archiveThread: {
+        threadID: e2eThreadID,
+      },
+      deps: buildRunnerRuntimeDeps(),
+    });
+    push(
+      "telegram_inbound_archive_dedupe_checks_recent_thread_tail",
+      telegramE2EServer.state.comments.filter((item) => String(item.body || "").includes("message_id: 353")).length === 1,
+      `count=${telegramE2EServer.state.comments.filter((item) => String(item.body || "").includes("message_id: 353")).length}`,
+    );
+
+    telegramE2EServer.state.comments = [];
+    telegramE2EServer.state.updates = [
+      {
+        update_id: 350,
+        message: {
+          message_id: 91,
+          date: Math.floor(Date.now() / 1000),
+          chat: {
+            id: Number(e2eDestination.chat_id),
+            type: "supergroup",
+            title: e2eDestination.label,
+          },
+          from: {
+            id: 5001,
+            is_bot: false,
+            first_name: "Operator",
+            username: "operator_user",
+          },
+          text: "same inbound message for concurrent routes",
+        },
+      },
+    ];
+    const concurrentRouteA = {
+      ...e2eRoute,
+      name: "selftest-runner-e2e-concurrent-archive-a",
+      server_bot_name: "ConcurrentBotA",
+    };
+    const concurrentRouteB = {
+      ...e2eRoute,
+      name: "selftest-runner-e2e-concurrent-archive-b",
+      server_bot_name: "ConcurrentBotB",
+    };
+    await Promise.all([
+      archiveLocalTelegramMessagesForRoute({
+        routeKey: runnerRouteKey(normalizeRunnerRoute(concurrentRouteA)),
+        route: concurrentRouteA,
+        routeState: {},
+        runtime: {
+          baseURL: telegramE2EServer.baseURL,
+          timeoutSeconds: 10,
+          token: e2eToken,
+          actor: {
+            user_id: e2eActorUserID,
+          },
+        },
+        bot: {
+          id: "concurrent-bot-a",
+          name: "ConcurrentBotA",
+          role: "monitor",
+        },
+        destination: {
+          chatID: e2eDestination.chat_id,
+        },
+        archiveThread: {
+          threadID: e2eThreadID,
+        },
+        deps: buildRunnerRuntimeDeps(),
+      }),
+      archiveLocalTelegramMessagesForRoute({
+        routeKey: runnerRouteKey(normalizeRunnerRoute(concurrentRouteB)),
+        route: concurrentRouteB,
+        routeState: {},
+        runtime: {
+          baseURL: telegramE2EServer.baseURL,
+          timeoutSeconds: 10,
+          token: e2eToken,
+          actor: {
+            user_id: e2eActorUserID,
+          },
+        },
+        bot: {
+          id: "concurrent-bot-b",
+          name: "ConcurrentBotB",
+          role: "monitor",
+        },
+        destination: {
+          chatID: e2eDestination.chat_id,
+        },
+        archiveThread: {
+          threadID: e2eThreadID,
+        },
+        deps: buildRunnerRuntimeDeps(),
+      }),
+    ]);
+    const concurrentBodies = telegramE2EServer.state.comments.map((item) => String(item.body || ""));
+    push(
+      "telegram_concurrent_routes_archive_same_inbound_message_only_once",
+      concurrentBodies.filter((item) => item.includes("message_id: 91")).length === 1,
+      `count=${concurrentBodies.filter((item) => item.includes("message_id: 91")).length} comments=${concurrentBodies.length}`,
+    );
+
     telegramE2EServer.state.comments = [];
     telegramE2EServer.state.updates = [
       {

package/package.json

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