metheus-governance-mcp-cli 0.2.264 → 0.2.265

package/lib/runner-helpers.mjs

@@ -478,7 +478,7 @@ export function dedupeProcessableArchiveComments(records) {
   return deduped;
 }
 
-function isArchiveRecordAfterState(record, routeState) {
+export 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();

package/lib/runner-orchestration.mjs

@@ -8,6 +8,7 @@ import {
   compareArchiveCommentRecords,
   dedupeProcessableArchiveComments,
   findRecentTelegramMessageEnvelope,
+  isArchiveRecordAfterState,
   isTelegramLocalInboundEnvelopeForRoute,
   isInboundArchiveKind,
   normalizeTelegramMessageEnvelope,
@@ -6305,11 +6306,18 @@ export function selectRunnerPendingWork({
     .map((record) => normalizeArchiveCommentRecord(record, parseArchivedChatComment))
     .filter((record) => record.id && record.parsedArchive)
     .sort(compareArchiveCommentRecords);
+  const importedCommentRecords = ensureArray(importOutcome?.importedComments)
+    .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),
+    [
+      ...ensureArray(importOutcome?.importedCommentIDs)
+        .map((commentID) => orderedComments.find((record) => record.id === commentID))
+        .filter(Boolean),
+      ...importedCommentRecords,
+    ],
   );
   const hasCursor = Boolean(
     String(safeObject(refreshedState).active_comment_id || "").trim()
@@ -6324,6 +6332,18 @@ export function selectRunnerPendingWork({
     (record) => normalizeArchiveCommentRecord(record, parseArchivedChatComment),
     pendingSelectionOptions,
   );
+  const laggingImportedRecords = importedRecords.filter((record) => (
+    !orderedComments.some((orderedRecord) => String(orderedRecord.id || "").trim() === String(record.id || "").trim())
+  ));
+  const importedPendingAfterCursor = dedupeProcessableArchiveComments(
+    laggingImportedRecords.filter((record) => isArchiveRecordAfterState(record, {
+      ...safeObject(refreshedState),
+      last_processed_comment_id: String(safeObject(refreshedState).active_comment_id || "").trim()
+        || safeObject(refreshedState).last_processed_comment_id,
+      last_processed_created_at: String(safeObject(refreshedState).active_comment_created_at || "").trim()
+        || safeObject(refreshedState).last_processed_created_at,
+    })),
+  );
   const pending = importedRecords.length > 0 && !hasCursor
     ? applyPendingAgeSelection({
         ordered: orderedComments,
@@ -6331,6 +6351,13 @@ export function selectRunnerPendingWork({
         shouldPrime: false,
         pending: importedRecords,
       }, pendingSelectionOptions)
+    : importedPendingAfterCursor.length > 0 && ensureArray(fullPending.pending).length === 0
+    ? applyPendingAgeSelection({
+        ordered: orderedComments,
+        latest: inboundComments.length ? inboundComments[inboundComments.length - 1] : null,
+        shouldPrime: false,
+        pending: importedPendingAfterCursor,
+      }, pendingSelectionOptions)
     : fullPending;
   return {
     orderedComments,

package/lib/runner-runtime.mjs

@@ -767,6 +767,7 @@ async function archiveRunnerTelegramInboundUpdates({
 }) {
   let handledUpdateID = 0;
   const importedCommentIDs = [];
+  const importedComments = [];
   const retainedSharedUpdates = [];
   for (let index = 0; index < mergedSharedUpdates.length; index += 1) {
     const update = mergedSharedUpdates[index];
@@ -799,17 +800,19 @@ async function archiveRunnerTelegramInboundUpdates({
       continue;
     }
     let createdComment;
+    let archiveBody = "";
     try {
+      archiveBody = formatTelegramInboundArchiveComment({
+        ...update,
+        archiveSourceOrigin: "telegram_archive_context",
+      });
       createdComment = await createThreadComment({
         siteBaseURL: runtime.baseURL,
         token: runtime.token,
         timeoutSeconds: runtime.timeoutSeconds,
         threadID: archiveThread.threadID,
         actorUserID: runtime.actor.user_id,
-        body: formatTelegramInboundArchiveComment({
-          ...update,
-          archiveSourceOrigin: "telegram_archive_context",
-        }),
+        body: archiveBody,
       });
     } catch (err) {
       releaseRunnerInboundArchiveMessageReservation(reservation.reservationKey);
@@ -822,6 +825,19 @@ async function archiveRunnerTelegramInboundUpdates({
     if (String(createdComment.id || "").trim()) {
       importedCommentIDs.push(String(createdComment.id || "").trim());
     }
+    importedComments.push({
+      ...safeObject(createdComment),
+      id: String(createdComment?.id || "").trim(),
+      body: archiveBody,
+      created_at: String(createdComment?.created_at || createdComment?.createdAt || new Date().toISOString()).trim(),
+      updated_at: String(
+        createdComment?.updated_at
+        || createdComment?.updatedAt
+        || createdComment?.created_at
+        || createdComment?.createdAt
+        || new Date().toISOString()
+      ).trim(),
+    });
     if (boolFromRaw(archivePolicy.dedupeInbound, true)) {
       existingKeys.add(dedupeKey);
     }
@@ -829,6 +845,7 @@ async function archiveRunnerTelegramInboundUpdates({
   return {
     handledUpdateID,
     importedCommentIDs,
+    importedComments,
     retainedSharedUpdates,
   };
 }
@@ -1168,6 +1185,7 @@ export async function archiveLocalTelegramMessagesForRoute({
   const {
     handledUpdateID,
     importedCommentIDs,
+    importedComments,
     retainedSharedUpdates,
   } = await archiveRunnerTelegramInboundUpdates({
     mergedSharedUpdates,
@@ -1191,6 +1209,7 @@ export async function archiveLocalTelegramMessagesForRoute({
 
   return {
     importedCommentIDs,
+    importedComments,
     importedCount: importedCommentIDs.length,
     lastUpdateID: Math.max(lastUpdateID, handledUpdateID),
   };

package/lib/selftest-runner-scenarios.mjs

@@ -598,8 +598,8 @@ export async function runSelftestRunnerScenarios(push, deps) {
     );
   }
 
-  try {
-    const duplicateComments = [
+  try {
+    const duplicateComments = [
       {
         id: "dup-comment-earliest",
         createdAt: "2026-03-18T00:00:01.000Z",
@@ -636,15 +636,68 @@ export async function runSelftestRunnerScenarios(push, deps) {
       `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(
+    push(
+      "runner_pending_selection_does_not_requeue_imported_duplicate_after_cursor",
+      false,
+      String(err?.message || err),
+    );
+  }
+
+  try {
+    const pendingWork = selectRunnerPendingWork({
+      comments: [
+        {
+          id: "cursor-comment",
+          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" },
+        },
+      ],
+      importOutcome: {
+        importedCommentIDs: ["fresh-import-comment"],
+        importedComments: [
+          {
+            id: "fresh-import-comment",
+            created_at: "2026-03-18T00:00:05.000Z",
+            updated_at: "2026-03-18T00:00:05.000Z",
+            body: "[Telegram message]\nchat_id: -1001\nmessage_id: 354\n\nfresh imported mention",
+          },
+        ],
+      },
+      refreshedState: {
+        last_processed_comment_id: "cursor-comment",
+        last_processed_created_at: "2026-03-18T00:00:01.000Z",
+      },
+      mode: "start",
+      parseArchivedChatComment,
+      deps: {
+        normalizeArchiveCommentRecord: (record, parser) => ({
+          id: String(record?.id || "").trim(),
+          body: String(record?.body || "").trim(),
+          createdAt: String(record?.created_at || record?.createdAt || record?.updated_at || record?.updatedAt || "").trim(),
+          updatedAt: String(record?.updated_at || record?.updatedAt || "").trim(),
+          parsedArchive: typeof parser === "function" ? parser(String(record?.body || "").trim()) : null,
+        }),
+        applyPendingAgeSelection: (selection) => selection,
+      },
+      pendingSelectionOptions: {},
+    });
+    push(
+      "runner_pending_selection_uses_fresh_imported_comment_when_thread_read_lags",
+      pendingWork.pending.pending.length === 1
+        && String(pendingWork.pending.pending[0]?.id || "").trim() === "fresh-import-comment",
+      `pending=${pendingWork.pending.pending.map((item) => item.id).join(",") || "(none)"}`,
+    );
+  } catch (err) {
+    push(
+      "runner_pending_selection_uses_fresh_imported_comment_when_thread_read_lags",
+      false,
+      String(err?.message || err),
+    );
+  }
+
+  try {
+    const selected = selectProjectChatDestination(
       [
         { id: "dest-1", provider: "telegram", label: "Main Room", chat_id: "-1001", is_active: true },
         { id: "dest-2", provider: "slack", label: "Slack", chat_id: "C123", is_active: true },

package/package.json

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