metheus-governance-mcp-cli 0.2.270 → 0.2.271

package/lib/runner-helpers.mjs

@@ -254,12 +254,24 @@ function normalizePendingSelectionOptions(rawOptions) {
   };
 }
 
+function resolveArchiveRecordEventTime(record) {
+  const normalizedRecord = safeObject(record);
+  const parsedArchive = safeObject(normalizedRecord.parsedArchive);
+  return firstNonEmptyString([
+    normalizedRecord.sourceOccurredAt,
+    parsedArchive.occurredAt,
+    parsedArchive.occurred_at,
+    normalizedRecord.createdAt,
+    normalizedRecord.updatedAt,
+  ]);
+}
+
 function isArchiveRecordWithinPendingAgeLimit(record, rawOptions) {
   const options = normalizePendingSelectionOptions(rawOptions);
   if (!(options.maxPendingAgeMs > 0)) {
     return true;
   }
-  const recordTime = Date.parse(firstNonEmptyString([record?.createdAt, record?.updatedAt]));
+  const recordTime = Date.parse(resolveArchiveRecordEventTime(record));
   if (!Number.isFinite(recordTime)) {
     return true;
   }
@@ -411,8 +423,8 @@ function contextRelatednessScore(record, selectedRecord, rawOptions) {
 }
 
 export function compareArchiveCommentRecords(left, right) {
-  const leftTime = firstNonEmptyString([left.createdAt, left.updatedAt]);
-  const rightTime = firstNonEmptyString([right.createdAt, right.updatedAt]);
+  const leftTime = resolveArchiveRecordEventTime(left);
+  const rightTime = resolveArchiveRecordEventTime(right);
   if (leftTime && rightTime && leftTime !== rightTime) {
     return leftTime < rightTime ? -1 : 1;
   }
@@ -521,13 +533,18 @@ export function buildRunnerRouteStateFromComment(record, patch = {}) {
 export function normalizeArchiveCommentRecord(rawComment, parseArchivedChatComment) {
   const comment = safeObject(rawComment);
   const body = String(comment.body || "").trim();
+  const parsedArchive = typeof parseArchivedChatComment === "function" ? parseArchivedChatComment(body) : null;
   return {
     id: String(comment.id || "").trim(),
     body,
     createdAt: firstNonEmptyString([comment.created_at, comment.createdAt, comment.updated_at, comment.updatedAt]),
     updatedAt: firstNonEmptyString([comment.updated_at, comment.updatedAt]),
     authorUserID: firstNonEmptyString([comment.author_user_id, comment.authorUserId, comment.created_by]),
-    parsedArchive: typeof parseArchivedChatComment === "function" ? parseArchivedChatComment(body) : null,
+    sourceOccurredAt: firstNonEmptyString([
+      safeObject(parsedArchive).occurredAt,
+      safeObject(parsedArchive).occurred_at,
+    ]),
+    parsedArchive,
   };
 }
 

package/lib/runner-orchestration-intent-contracts.mjs

@@ -51,6 +51,48 @@ function detectDirectedManagedReplyTarget({
   return "";
 }
 
+const DIRECTED_MANAGED_REPLY_ENGLISH_ACTION_PATTERN = "\\b(?:say|tell|greet|reply|answer|introduce|mention)\\b";
+const DIRECTED_MANAGED_REPLY_KOREAN_ACTION_PATTERN = "(?:\\uC778\\uC0AC|\\uB9D0|\\uC804\\uB2EC|\\uB2F5|\\uC18C\\uAC1C|\\uC5B8\\uAE09)";
+const DIRECTED_MANAGED_REPLY_ACTION_PATTERN = `(?:${DIRECTED_MANAGED_REPLY_ENGLISH_ACTION_PATTERN}|${DIRECTED_MANAGED_REPLY_KOREAN_ACTION_PATTERN})`;
+const DIRECTED_MANAGED_REPLY_POSTPOSITION_PATTERN = "(?:\\uC5D0\\uAC8C|\\uD55C\\uD14C|\\uAED8|\\uBCF4\\uACE0)";
+
+function detectDirectedManagedReplyTargetV2({
+  text,
+  currentBotSelector = "",
+  managedMentions = [],
+}) {
+  const normalizedText = String(text || "").trim();
+  const currentSelector = String(currentBotSelector || "").trim().toLowerCase();
+  if (!normalizedText || !currentSelector) {
+    return "";
+  }
+  const instructionPattern = new RegExp(DIRECTED_MANAGED_REPLY_ACTION_PATTERN, "iu");
+  if (!instructionPattern.test(normalizedText)) {
+    return "";
+  }
+  const candidates = ensureArray(managedMentions)
+    .map((item) => String(item || "").trim().toLowerCase())
+    .filter((item) => item && item !== currentSelector);
+  for (const selector of candidates) {
+    const escapedSelector = escapeRegexText(String(selector || "").replace(/^@+/, ""));
+    const explicitTargetPattern = new RegExp(
+      `(?:@${escapedSelector}\\s*(?:${DIRECTED_MANAGED_REPLY_POSTPOSITION_PATTERN})?|(?:to|for)\\s+@${escapedSelector}\\b)`,
+      "iu",
+    );
+    if (explicitTargetPattern.test(normalizedText)) {
+      return selector;
+    }
+    const instructionWindowPattern = new RegExp(
+      `@${escapedSelector}(?:\\s*(?:${DIRECTED_MANAGED_REPLY_POSTPOSITION_PATTERN}))?(?:[^@\\n]{0,32}?)${DIRECTED_MANAGED_REPLY_ACTION_PATTERN}`,
+      "iu",
+    );
+    if (instructionWindowPattern.test(normalizedText)) {
+      return selector;
+    }
+  }
+  return "";
+}
+
 export async function resolveHumanIntentContext({
   selectedRecord,
   normalizedRoute,
@@ -118,7 +160,7 @@ export async function resolveHumanIntentContext({
     runnerHumanIntentPromises.set(cacheKey, promise);
   }
   let humanIntent = await runnerHumanIntentPromises.get(cacheKey);
-  const directedReplyTargetSelector = detectDirectedManagedReplyTarget({
+  const directedReplyTargetSelector = detectDirectedManagedReplyTargetV2({
     text: parsed.body,
     currentBotSelector,
     managedMentions,

package/lib/selftest-runner-scenarios.mjs

@@ -740,11 +740,11 @@ export async function runSelftestRunnerScenarios(push, deps) {
     );
   }
 
-  try {
-    const pendingSelection = selectPendingArchiveComments(
-      [
-        {
-          id: "dup-comment-1",
+  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" },
@@ -770,14 +770,83 @@ export async function runSelftestRunnerScenarios(push, deps) {
   } catch (err) {
     push(
       "runner_pending_selection_ignores_duplicate_archived_inbound_message_ids",
-      false,
-      String(err?.message || err),
-    );
-  }
-
+      false,
+      String(err?.message || err),
+    );
+  }
+
+  try {
+    const nowMs = Date.parse("2026-03-31T12:00:00.000Z");
+    const pendingSelection = selectPendingArchiveComments(
+      [
+        {
+          id: "cursor-comment",
+          createdAt: "2026-03-31T11:55:00.000Z",
+          updatedAt: "2026-03-31T11:55:00.000Z",
+          sourceOccurredAt: "2026-03-31T09:55:00.000Z",
+          parsedArchive: {
+            kind: "telegram_message",
+            chatID: "-1001",
+            messageID: 1145,
+            occurredAt: "2026-03-31T09:55:00.000Z",
+            body: "@RyoAI_bot 기준 댓글",
+          },
+        },
+        {
+          id: "stale-source-comment",
+          createdAt: "2026-03-31T11:59:58.000Z",
+          updatedAt: "2026-03-31T11:59:58.000Z",
+          sourceOccurredAt: "2026-03-31T10:00:00.000Z",
+          parsedArchive: {
+            kind: "telegram_message",
+            chatID: "-1001",
+            messageID: 325,
+            occurredAt: "2026-03-31T10:00:00.000Z",
+            body: "@RyoAI_bot 오래된 하이",
+          },
+        },
+        {
+          id: "fresh-source-comment",
+          createdAt: "2026-03-31T11:59:59.000Z",
+          updatedAt: "2026-03-31T11:59:59.000Z",
+          sourceOccurredAt: "2026-03-31T11:57:00.000Z",
+          parsedArchive: {
+            kind: "telegram_message",
+            chatID: "-1001",
+            messageID: 1146,
+            occurredAt: "2026-03-31T11:57:00.000Z",
+            body: "@RyoAI_bot 최신 하이",
+          },
+        },
+      ],
+      {
+        last_processed_comment_id: "cursor-comment",
+      },
+      "start",
+      (record) => record,
+      {
+        maxPendingAgeMs: 15 * 60 * 1000,
+        nowMs,
+      },
+    );
+    push(
+      "runner_pending_selection_uses_source_occurrence_time_for_stale_filtering",
+      pendingSelection.pending.length === 1
+        && String(pendingSelection.pending[0]?.id || "") === "fresh-source-comment"
+        && ensureArray(pendingSelection.staleSkipped).some((record) => String(record?.id || "") === "stale-source-comment"),
+      `pending=${pendingSelection.pending.map((item) => item.id).join(",") || "(none)"} stale=${ensureArray(pendingSelection.staleSkipped).map((item) => item.id).join(",") || "(none)"}`,
+    );
+  } catch (err) {
+    push(
+      "runner_pending_selection_uses_source_occurrence_time_for_stale_filtering",
+      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",
@@ -3225,15 +3294,76 @@ export async function runSelftestRunnerScenarios(push, deps) {
         && aliasHumanIntentContext?.reusedPersistedContract === true,
       `managedMentions=${JSON.stringify(ensureArray(aliasHumanIntentContext?.managedMentions))} reused=${String(aliasHumanIntentContext?.reusedPersistedContract)}`,
     );
-  } catch (err) {
-    push(
-      "runner_human_intent_context_ignores_raw_alias_selector_for_managed_mentions",
-      false,
-      String(err?.message || err),
-    );
-  }
-
-  const mentionOverridesReplyForUnmentionedBot = evaluateTelegramRunnerTrigger(
+  } catch (err) {
+    push(
+      "runner_human_intent_context_ignores_raw_alias_selector_for_managed_mentions",
+      false,
+      String(err?.message || err),
+    );
+  }
+
+  try {
+    const replyTargetIntentContext = await resolveHumanIntentContext({
+      selectedRecord: {
+        id: "comment-directed-reply-target-korean",
+        parsedArchive: {
+          kind: "telegram_message",
+          body: "@RyoAI_bot 너가 @SangHoon01_bot 인사 시켜봐",
+          senderIsBot: false,
+        },
+      },
+      normalizedRoute: {
+        name: "telegram-monitor-ryoai-bot-2",
+      },
+      bot: {
+        username: "ryoai_bot",
+        name: "RyoAI_bot",
+      },
+      executionPlan: {},
+      deps: {
+        resolveConversationPeerBots: () => [
+          { id: "bot-self-1", name: "RyoAI_bot" },
+          { id: "bot-peer-1", name: "SangHoon01_bot" },
+        ],
+      },
+      intentDeps: {
+        normalizeMentionSelector: normalizeSelftestMentionSelector,
+        buildConversationPeerMap: (_bot, _route, runtimeDeps) => new Map(
+          ensureArray(runtimeDeps?.resolveConversationPeerBots?.() || []).map((item) => {
+            const selector = normalizeSelftestMentionSelector(item?.name || item?.username);
+            return [selector, item];
+          }).filter(([selector]) => selector),
+        ),
+        extractOrderedMentionSelectors: (text) => Array.from(String(text || "").matchAll(/@([A-Za-z0-9_]+)/g)).map((match) => normalizeSelftestMentionSelector(match[1] || "")),
+        uniqueOrdered: normalizeSelftestConversationSelectorList,
+        buildHumanIntentFromPersistedRunnerRequest: () => null,
+        buildRunnerHumanIntentCacheKey: () => "directed-reply-target-korean",
+        runnerHumanIntentPromises: new Map(),
+        analyzeHumanConversationIntentWithContractResolver: async () => ({
+          intentMode: "single_bot",
+          replyExpectation: "actionable",
+          intentType: "actionable_request",
+        }),
+        scheduleRunnerHumanIntentCacheCleanup: () => {},
+        isCompleteHumanIntentContract: () => true,
+        normalizeHumanIntentType: (value, fallback = "") => String(value || "").trim() || fallback,
+      },
+    });
+    push(
+      "runner_human_intent_context_detects_korean_directed_reply_target",
+      String(replyTargetIntentContext?.humanIntent?.replyTargetBotSelector || "") === "sanghoon01_bot"
+        && JSON.stringify(ensureArray(replyTargetIntentContext?.managedMentions || [])) === JSON.stringify(["ryoai_bot", "sanghoon01_bot"]),
+      `reply_target=${String(replyTargetIntentContext?.humanIntent?.replyTargetBotSelector || "(none)")} managed=${JSON.stringify(ensureArray(replyTargetIntentContext?.managedMentions || []))}`,
+    );
+  } catch (err) {
+    push(
+      "runner_human_intent_context_detects_korean_directed_reply_target",
+      false,
+      String(err?.message || err),
+    );
+  }
+
+  const mentionOverridesReplyForUnmentionedBot = evaluateTelegramRunnerTrigger(
     {
       id: "comment-2b",
       parsedArchive: {

package/package.json

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