metheus-governance-mcp-cli 0.2.269 → 0.2.271

package/lib/local-ai-adapters.mjs

@@ -212,6 +212,67 @@ function readOutputFile(filePath) {
   return fs.readFileSync(filePath, "utf8");
 }
 
+export function looksLikeCodexCliSessionTranscript(rawText = "") {
+  const text = String(rawText || "").trim();
+  if (!text) {
+    return false;
+  }
+  return /OpenAI Codex v|session id:|^workdir:|^model:|^provider:|^approval:|^sandbox:|^reasoning effort:|^--------|^user$|^codex$|mcp:.*\b(starting|ready)\b/i.test(text);
+}
+
+function summarizeCodexCliFailure({
+  status = 0,
+  stdoutText = "",
+  stderrText = "",
+  spawnError = null,
+}) {
+  const genericMessage = status
+    ? `Codex CLI exited before returning a final reply (status ${status})`
+    : "Codex CLI exited before returning a final reply";
+  if (spawnError) {
+    const spawnMessage = String(spawnError?.message || spawnError || "").trim();
+    return spawnMessage
+      ? `${genericMessage}: ${spawnMessage}`
+      : genericMessage;
+  }
+  const candidateLines = `${String(stderrText || "")}\n${String(stdoutText || "")}`
+    .split(/\r?\n/)
+    .map((line) => String(line || "").trim())
+    .filter(Boolean)
+    .filter((line) => !looksLikeCodexCliSessionTranscript(line))
+    .filter((line) => /(error|failed|timeout|timed out|denied|missing|unavailable|not found|capacity)/i.test(line))
+    .slice(0, 2);
+  return candidateLines.length
+    ? `${genericMessage}: ${candidateLines.join(" | ")}`
+    : genericMessage;
+}
+
+export function resolveCodexRawTextProcessResult({
+  outputText = "",
+  stdoutText = "",
+  stderrText = "",
+  status = 0,
+  spawnError = null,
+}) {
+  const normalizedOutputText = String(outputText || "").trim();
+  if (normalizedOutputText && !looksLikeCodexCliSessionTranscript(normalizedOutputText)) {
+    return normalizedOutputText;
+  }
+  const normalizedStdoutText = String(stdoutText || "").trim();
+  if (normalizedStdoutText && !looksLikeCodexCliSessionTranscript(normalizedStdoutText)) {
+    return normalizedStdoutText;
+  }
+  if (spawnError || status !== 0) {
+    throw new Error(summarizeCodexCliFailure({
+      status,
+      stdoutText: normalizedStdoutText,
+      stderrText,
+      spawnError,
+    }));
+  }
+  throw new Error("Codex CLI did not return a usable final reply");
+}
+
 function tryParseEmbeddedJsonObject(text) {
   const raw = String(text || "").trim();
   if (!raw) return null;
@@ -686,13 +747,13 @@ function runCodexRawText({ promptText, workspaceDir, model, permissionMode, reas
         maxBuffer: 8 * 1024 * 1024,
       },
     );
-    if (result.error) {
-      throw new Error(String(result.error?.message || result.error));
-    }
-    if (result.status !== 0) {
-      throw new Error(String(result.stderr || result.stdout || `codex exited with status ${result.status}`));
-    }
-    return readOutputFile(outputPath) || String(result.stdout || "");
+    return resolveCodexRawTextProcessResult({
+      outputText: readOutputFile(outputPath),
+      stdoutText: String(result.stdout || ""),
+      stderrText: String(result.stderr || ""),
+      status: Number.isInteger(result.status) ? result.status : 0,
+      spawnError: result.error || null,
+    });
   } finally {
     if (fs.existsSync(outputPath)) {
       fs.rmSync(outputPath, { force: true });

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

@@ -85,6 +85,9 @@ import {
 import {
   finalizeRunnerRequestRootReferenceRecorderState,
 } from "./runner-recorder-request-root-reference-finalization-handoff.mjs";
+import {
+  resolveCodexRawTextProcessResult,
+} from "./local-ai-adapters.mjs";
 import {
   buildRunnerInheritedRootReferenceRecorderResult,
   buildRunnerRootThreadRecorderFailure,
@@ -737,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" },
@@ -767,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",
@@ -3222,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: {
@@ -18701,6 +18834,48 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("runner_selected_record_terminal_outcome_stays_within_module_4_boundary", false, String(err?.message || err));
   }
 
+  try {
+    const replyText = resolveCodexRawTextProcessResult({
+      outputText: "{\"reply\":\"하이\"}",
+      stdoutText: "",
+      stderrText: "OpenAI Codex v0.114.0\nsession id: test-session\nmcp: metheus ready",
+      status: 1,
+      spawnError: null,
+    });
+    push(
+      "codex_nonzero_exit_uses_final_output_file_when_available",
+      String(replyText || "").trim() === "{\"reply\":\"하이\"}",
+      `reply=${String(replyText || "(none)")}`,
+    );
+  } catch (err) {
+    push("codex_nonzero_exit_uses_final_output_file_when_available", false, String(err?.message || err));
+  }
+
+  try {
+    let errorMessage = "";
+    try {
+      resolveCodexRawTextProcessResult({
+        outputText: "",
+        stdoutText: "",
+        stderrText: "OpenAI Codex v0.114.0\nworkdir: C:\\LUSH KOREA CLI\nsession id: test-session\nmcp: metheus starting\nmcp: metheus ready",
+        status: 1,
+        spawnError: null,
+      });
+    } catch (err) {
+      errorMessage = String(err?.message || err);
+    }
+    push(
+      "codex_failure_summary_does_not_leak_session_transcript",
+      /Codex CLI exited before returning a final reply/i.test(errorMessage)
+        && !/OpenAI Codex v/i.test(errorMessage)
+        && !/session id:/i.test(errorMessage)
+        && !/mcp:/i.test(errorMessage),
+      errorMessage || "(no error message)",
+    );
+  } catch (err) {
+    push("codex_failure_summary_does_not_leak_session_transcript", false, String(err?.message || err));
+  }
+
   try {
     const prepared = await prepareRunnerSelectedRecordContractContext({
       selectedRecord: {

package/package.json

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