metheus-governance-mcp-cli 0.2.270 → 0.2.272

package/cli.mjs

@@ -2669,39 +2669,47 @@ function saveBotRunnerState(nextState) {
   });
 }
 
-function normalizeBotRunnerExcludedComments(rawExcluded, nowMs = Date.now()) {
-  const normalized = {};
-  for (const [commentIDRaw, entryRaw] of Object.entries(safeObject(rawExcluded))) {
-    const commentID = String(commentIDRaw || "").trim();
-    if (!commentID) continue;
+function normalizeBotRunnerExcludedComments(rawExcluded, nowMs = Date.now()) {
+  const normalized = {};
+  for (const [commentIDRaw, entryRaw] of Object.entries(safeObject(rawExcluded))) {
+    const commentID = String(commentIDRaw || "").trim();
+    if (!commentID) continue;
     const entry = safeObject(entryRaw);
     const excludedAt = firstNonEmptyString([entry.excluded_at, entry.excludedAt, entry.updated_at, entry.updatedAt]);
     const excludedAtMs = Date.parse(excludedAt);
     if (Number.isFinite(excludedAtMs) && nowMs - excludedAtMs > BOT_RUNNER_EXCLUDED_COMMENT_KEEP_MS) {
       continue;
     }
-    normalized[commentID] = {
-      comment_id: commentID,
-      project_id: String(entry.project_id || entry.projectID || "").trim(),
-      provider: String(entry.provider || "").trim(),
-      request_key: String(entry.request_key || entry.requestKey || "").trim(),
-      route_key: String(entry.route_key || entry.routeKey || "").trim(),
-      excluded_at: excludedAt || new Date(nowMs).toISOString(),
-      reason_code: String(entry.reason_code || entry.reasonCode || entry.reason || "").trim(),
-      decision: String(entry.decision || "").trim().toLowerCase(),
-      action: String(entry.action || "").trim().toLowerCase(),
-      conversation_id: String(entry.conversation_id || entry.conversationId || "").trim(),
-      source_message_id: intFromRawAllowZero(entry.source_message_id || entry.sourceMessageID, 0) || undefined,
-      context_excluded: entry.context_excluded !== false,
-      closed_reason: String(entry.closed_reason || entry.closedReason || "").trim(),
-    };
-  }
-  return normalized;
+    normalized[commentID] = {
+      comment_id: commentID,
+      project_id: String(entry.project_id || entry.projectID || "").trim(),
+      provider: String(entry.provider || "").trim(),
+      request_key: String(entry.request_key || entry.requestKey || "").trim(),
+      route_key: String(entry.route_key || entry.routeKey || "").trim(),
+      excluded_at: excludedAt || new Date(nowMs).toISOString(),
+      reason_code: String(entry.reason_code || entry.reasonCode || entry.reason || "").trim(),
+        decision: String(entry.decision || "").trim().toLowerCase(),
+        action: String(entry.action || "").trim().toLowerCase(),
+        conversation_id: String(entry.conversation_id || entry.conversationId || "").trim(),
+        source_message_id: intFromRawAllowZero(entry.source_message_id || entry.sourceMessageID, 0) || undefined,
+        comment_kind: String(entry.comment_kind || entry.commentKind || "").trim().toLowerCase(),
+        request_status: normalizeRunnerRequestStatus(entry.request_status || entry.requestStatus),
+        source_occurred_at: String(entry.source_occurred_at || entry.sourceOccurredAt || "").trim(),
+        stale_after_at: String(entry.stale_after_at || entry.staleAfterAt || "").trim(),
+        selection_state: normalizeRunnerCommentSelectionState(
+          entry.selection_state || entry.selectionState,
+          "superseded",
+      ),
+      context_excluded: entry.context_excluded !== false,
+      closed_reason: String(entry.closed_reason || entry.closedReason || "").trim(),
+    };
+  }
+  return normalized;
 }
 
-function normalizeRunnerRequestStatus(rawStatus) {
-  const status = String(rawStatus || "").trim().toLowerCase();
-  return [
+function normalizeRunnerRequestStatus(rawStatus) {
+  const status = String(rawStatus || "").trim().toLowerCase();
+  return [
     "planned",
     "claimed",
     "running",
@@ -2710,9 +2718,54 @@ function normalizeRunnerRequestStatus(rawStatus) {
     "expired",
     "loop_closed",
   ].includes(status)
-    ? status
-    : "planned";
-}
+    ? status
+    : "planned";
+}
+
+function normalizeRunnerCommentSelectionState(rawState, fallback = "pending") {
+  const normalizedFallback = String(fallback || "").trim().toLowerCase() || "pending";
+  const normalized = String(rawState || "").trim().toLowerCase();
+  return [
+    "pending",
+    "consumed",
+    "closed",
+    "superseded",
+    "stale",
+  ].includes(normalized)
+    ? normalized
+    : normalizedFallback;
+}
+
+function resolveRunnerCommentStateSourceOccurredAt(recordRaw) {
+  const record = safeObject(recordRaw);
+  const parsed = safeObject(record.parsedArchive);
+  return firstNonEmptyString([
+    record.source_occurred_at,
+    record.sourceOccurredAt,
+    parsed.occurredAt,
+    parsed.occurred_at,
+    record.created_at,
+    record.createdAt,
+    record.updated_at,
+    record.updatedAt,
+  ]);
+}
+
+function resolveRunnerCommentStateStaleAfterAt(recordRaw, maxAgeMs = BOT_RUNNER_PENDING_COMMENT_MAX_AGE_MS) {
+  const explicit = firstNonEmptyString([
+    safeObject(recordRaw).stale_after_at,
+    safeObject(recordRaw).staleAfterAt,
+  ]);
+  if (explicit) {
+    return explicit;
+  }
+  const sourceOccurredAt = resolveRunnerCommentStateSourceOccurredAt(recordRaw);
+  const sourceOccurredAtMs = Date.parse(sourceOccurredAt);
+  if (!Number.isFinite(sourceOccurredAtMs) || !(maxAgeMs > 0)) {
+    return "";
+  }
+  return new Date(sourceOccurredAtMs + maxAgeMs).toISOString();
+}
 
 function isFinalRunnerRequestStatus(rawStatus) {
   const status = normalizeRunnerRequestStatus(rawStatus);
@@ -3245,9 +3298,9 @@ function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
   return normalized;
 }
 
-function normalizeBotRunnerConsumedComments(rawConsumed, nowMs = Date.now()) {
-  const normalized = {};
-  for (const [commentIDRaw, entryRaw] of Object.entries(safeObject(rawConsumed))) {
+function normalizeBotRunnerConsumedComments(rawConsumed, nowMs = Date.now()) {
+  const normalized = {};
+  for (const [commentIDRaw, entryRaw] of Object.entries(safeObject(rawConsumed))) {
     const entry = safeObject(entryRaw);
     const commentID = String(entry.comment_id || commentIDRaw || "").trim();
     if (!commentID) continue;
@@ -3257,21 +3310,27 @@ function normalizeBotRunnerConsumedComments(rawConsumed, nowMs = Date.now()) {
     if (Number.isFinite(consumedAtMs) && nowMs - consumedAtMs > BOT_RUNNER_REQUEST_KEEP_MS) {
       continue;
     }
-    normalized[ledgerKey] = {
-      ledger_key: ledgerKey,
-      comment_id: commentID,
-      project_id: String(entry.project_id || entry.projectID || "").trim(),
-      provider: String(entry.provider || "").trim(),
-      request_key: String(entry.request_key || entry.requestKey || "").trim(),
-      consumed_at: consumedAt || new Date(nowMs).toISOString(),
-      route_key: String(entry.route_key || entry.routeKey || "").trim(),
-      conversation_id: String(entry.conversation_id || entry.conversationId || "").trim(),
-      source_message_id: intFromRawAllowZero(entry.source_message_id || entry.sourceMessageID, 0) || undefined,
-      comment_kind: String(entry.comment_kind || entry.commentKind || "").trim().toLowerCase(),
-      request_status: normalizeRunnerRequestStatus(entry.request_status || entry.requestStatus),
-    };
-  }
-  return normalized;
+    normalized[ledgerKey] = {
+      ledger_key: ledgerKey,
+      comment_id: commentID,
+      project_id: String(entry.project_id || entry.projectID || "").trim(),
+      provider: String(entry.provider || "").trim(),
+      request_key: String(entry.request_key || entry.requestKey || "").trim(),
+      consumed_at: consumedAt || new Date(nowMs).toISOString(),
+      route_key: String(entry.route_key || entry.routeKey || "").trim(),
+      conversation_id: String(entry.conversation_id || entry.conversationId || "").trim(),
+      source_message_id: intFromRawAllowZero(entry.source_message_id || entry.sourceMessageID, 0) || undefined,
+      source_occurred_at: String(entry.source_occurred_at || entry.sourceOccurredAt || "").trim(),
+      stale_after_at: String(entry.stale_after_at || entry.staleAfterAt || "").trim(),
+      selection_state: normalizeRunnerCommentSelectionState(
+        entry.selection_state || entry.selectionState,
+        "consumed",
+      ),
+      comment_kind: String(entry.comment_kind || entry.commentKind || "").trim().toLowerCase(),
+      request_status: normalizeRunnerRequestStatus(entry.request_status || entry.requestStatus),
+    };
+  }
+  return normalized;
 }
 
 function buildRunnerConsumedCommentLedgerKey(commentIDRaw, routeKeyRaw = "", commentKindRaw = "") {
@@ -4788,10 +4847,10 @@ function upsertRunnerRequest(state, requestKey, patch = {}) {
   };
 }
 
-function upsertRunnerConsumedComment(state, commentIDRaw, patch = {}) {
-  const commentID = String(commentIDRaw || "").trim();
-  const currentState = safeObject(state);
-  const consumedComments = normalizeBotRunnerConsumedComments(currentState.consumedComments || currentState.consumed_comments);
+function upsertRunnerConsumedComment(state, commentIDRaw, patch = {}) {
+  const commentID = String(commentIDRaw || "").trim();
+  const currentState = safeObject(state);
+  const consumedComments = normalizeBotRunnerConsumedComments(currentState.consumedComments || currentState.consumed_comments);
   const ledgerKey = buildRunnerConsumedCommentLedgerKey(commentID, patch.route_key, patch.comment_kind);
   const existing = safeObject(consumedComments[ledgerKey]);
   const nextEntry = {
@@ -4799,10 +4858,22 @@ function upsertRunnerConsumedComment(state, commentIDRaw, patch = {}) {
     ...safeObject(patch),
     comment_id: commentID,
     project_id: String(patch.project_id || existing.project_id || "").trim(),
-    provider: String(patch.provider || existing.provider || "").trim(),
-    consumed_at: new Date().toISOString(),
-    request_status: normalizeRunnerRequestStatus(patch.request_status || existing.request_status),
-  };
+    provider: String(patch.provider || existing.provider || "").trim(),
+    consumed_at: new Date().toISOString(),
+    source_occurred_at: firstNonEmptyString([
+      patch.source_occurred_at,
+      existing.source_occurred_at,
+    ]),
+    stale_after_at: firstNonEmptyString([
+      patch.stale_after_at,
+      existing.stale_after_at,
+    ]),
+    selection_state: normalizeRunnerCommentSelectionState(
+      patch.selection_state || existing.selection_state,
+      "consumed",
+    ),
+    request_status: normalizeRunnerRequestStatus(patch.request_status || existing.request_status),
+  };
   consumedComments[ledgerKey] = nextEntry;
   return {
     consumedComments,
@@ -5128,16 +5199,19 @@ async function claimRunnerRequestForHumanComment({
     last_source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
     last_source_message_thread_id: intFromRawAllowZero(parsed.messageThreadID, 0) || undefined,
   });
-  const { consumedComments: nextConsumedComments } = upsertRunnerConsumedComment(stateForClaim, selectedRecord?.id, {
-    project_id: String(normalizedRoute?.projectID || "").trim(),
-    provider: String(normalizedRoute?.provider || "").trim(),
-    request_key: requestKey,
-    route_key: String(routeKey || "").trim(),
-    conversation_id: resolvedConversationID,
-    source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
-    comment_kind: commentKind,
-    request_status: "claimed",
-  });
+  const { consumedComments: nextConsumedComments } = upsertRunnerConsumedComment(stateForClaim, selectedRecord?.id, {
+    project_id: String(normalizedRoute?.projectID || "").trim(),
+    provider: String(normalizedRoute?.provider || "").trim(),
+    request_key: requestKey,
+    route_key: String(routeKey || "").trim(),
+    conversation_id: resolvedConversationID,
+    source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
+    source_occurred_at: resolveRunnerCommentStateSourceOccurredAt(selectedRecord),
+    stale_after_at: resolveRunnerCommentStateStaleAfterAt(selectedRecord),
+    selection_state: "consumed",
+    comment_kind: commentKind,
+    request_status: "claimed",
+  });
   saveBotRunnerState({
     routes: stateForClaim.routes,
     sharedInboxes: stateForClaim.sharedInboxes || stateForClaim.shared_inboxes,
@@ -6561,17 +6635,20 @@ function markRunnerRequestLifecycle({
   const commentID = String(selectedRecord?.id || "").trim();
   let nextConsumedComments = currentState.consumedComments || currentState.consumed_comments;
   if (commentID) {
-    ({ consumedComments: nextConsumedComments } = upsertRunnerConsumedComment(currentState, commentID, {
-      project_id: String(normalizedRoute?.projectID || "").trim(),
-      provider: String(normalizedRoute?.provider || "").trim(),
-      request_key: key,
-      route_key: String(routeKey || "").trim(),
-      conversation_id: conversationID,
-      source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
-      comment_kind: String(parsed.kind || "").trim().toLowerCase(),
-      request_status: nextStatus,
-    }));
-  }
+    ({ consumedComments: nextConsumedComments } = upsertRunnerConsumedComment(currentState, commentID, {
+      project_id: String(normalizedRoute?.projectID || "").trim(),
+      provider: String(normalizedRoute?.provider || "").trim(),
+      request_key: key,
+      route_key: String(routeKey || "").trim(),
+      conversation_id: conversationID,
+      source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
+      source_occurred_at: resolveRunnerCommentStateSourceOccurredAt(selectedRecord),
+      stale_after_at: resolveRunnerCommentStateStaleAfterAt(selectedRecord),
+      selection_state: isFinalRunnerRequestStatus(nextStatus) ? "closed" : "consumed",
+      comment_kind: String(parsed.kind || "").trim().toLowerCase(),
+      request_status: nextStatus,
+    }));
+  }
   saveBotRunnerState({
     routes: currentState.routes,
     sharedInboxes: currentState.sharedInboxes || currentState.shared_inboxes,
@@ -6900,16 +6977,22 @@ function mergeServerRunnerRequestLedgerIntoLocalState(currentState, normalizedRo
     const commentState = safeObject(commentStateRaw);
     const commentID = String(commentState.comment_id || commentState.commentID || "").trim();
     if (!commentID) continue;
-    const normalizedCommentState = normalizeBotRunnerConsumedComments({ [commentID]: commentState })[commentID];
-    if (normalizedCommentState) {
-      nextConsumedComments[commentID] = normalizedCommentState;
-    }
-    if (commentState.context_excluded === true) {
-      nextExcludedComments[commentID] = normalizeBotRunnerExcludedComments({
-        [commentID]: {
-          ...commentState,
-          excluded_at: commentState.updated_at || commentState.consumed_at,
-        },
+    const normalizedCommentState = normalizeBotRunnerConsumedComments({ [commentID]: commentState })[commentID];
+    if (normalizedCommentState) {
+      nextConsumedComments[commentID] = normalizedCommentState;
+    }
+    const normalizedSelectionState = normalizeRunnerCommentSelectionState(commentState.selection_state, "pending");
+    if (
+      commentState.context_excluded === true
+      || normalizedSelectionState === "stale"
+      || normalizedSelectionState === "superseded"
+      || normalizedSelectionState === "closed"
+    ) {
+      nextExcludedComments[commentID] = normalizeBotRunnerExcludedComments({
+        [commentID]: {
+          ...commentState,
+          excluded_at: commentState.updated_at || commentState.consumed_at,
+        },
       })[commentID];
     }
   }
@@ -6967,24 +7050,27 @@ function buildProjectRunnerRequestCommentStatesForSync(state, normalizedRoute) {
     if (!runnerLedgerEntryMatchesProject(entry, normalizedRoute, requestIndex)) continue;
     const commentID = String(entry.comment_id || "").trim();
     if (!commentID) continue;
-    commentStateMap.set(commentID, {
-      comment_id: commentID,
-      project_id: projectID,
-      request_key: String(entry.request_key || "").trim(),
-      provider: String(entry.provider || provider).trim(),
+    commentStateMap.set(commentID, {
+      comment_id: commentID,
+      project_id: projectID,
+      request_key: String(entry.request_key || "").trim(),
+      provider: String(entry.provider || provider).trim(),
       route_key: String(entry.route_key || "").trim(),
       conversation_id: String(entry.conversation_id || "").trim(),
       source_message_id: intFromRawAllowZero(entry.source_message_id, 0) || undefined,
       comment_kind: String(entry.comment_kind || "").trim(),
       request_status: String(entry.request_status || "").trim(),
-      reason_code: "",
-      decision: "",
-      action: "",
-      context_excluded: false,
-      closed_reason: "",
-      consumed_at: String(entry.consumed_at || "").trim(),
-    });
-  }
+      reason_code: "",
+      decision: "",
+      action: "",
+      context_excluded: false,
+      closed_reason: "",
+      source_occurred_at: String(entry.source_occurred_at || "").trim(),
+      stale_after_at: String(entry.stale_after_at || "").trim(),
+      selection_state: normalizeRunnerCommentSelectionState(entry.selection_state, "consumed"),
+      consumed_at: String(entry.consumed_at || "").trim(),
+    });
+  }
 
   for (const entryRaw of Object.values(excludedComments)) {
     const entry = safeObject(entryRaw);
@@ -7004,13 +7090,19 @@ function buildProjectRunnerRequestCommentStatesForSync(state, normalizedRoute) {
       comment_kind: String(entry.comment_kind || existing.comment_kind || "").trim(),
       request_status: String(entry.request_status || existing.request_status || "").trim(),
       reason_code: String(entry.reason_code || "").trim(),
-      decision: String(entry.decision || "").trim(),
-      action: String(entry.action || "").trim(),
-      context_excluded: entry.context_excluded !== false,
-      closed_reason: String(entry.closed_reason || existing.closed_reason || "").trim(),
-      consumed_at: String(existing.consumed_at || entry.excluded_at || "").trim(),
-    });
-  }
+      decision: String(entry.decision || "").trim(),
+      action: String(entry.action || "").trim(),
+      context_excluded: entry.context_excluded !== false,
+      closed_reason: String(entry.closed_reason || existing.closed_reason || "").trim(),
+      source_occurred_at: String(entry.source_occurred_at || existing.source_occurred_at || "").trim(),
+      stale_after_at: String(entry.stale_after_at || existing.stale_after_at || "").trim(),
+      selection_state: normalizeRunnerCommentSelectionState(
+        entry.selection_state || existing.selection_state,
+        entry.context_excluded !== false ? "superseded" : "pending",
+      ),
+      consumed_at: String(existing.consumed_at || entry.excluded_at || "").trim(),
+    });
+  }
 
   return Array.from(commentStateMap.values());
 }
@@ -10258,10 +10350,10 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
       }
       return true;
     });
-    const pendingWork = selectRunnerPendingWork({
-      comments: commentsForPending,
-      importOutcome,
-      refreshedState,
+    const pendingWork = selectRunnerPendingWork({
+      comments: commentsForPending,
+      importOutcome,
+      refreshedState,
       mode,
       parseArchivedChatComment,
       pendingSelectionOptions: {
@@ -10271,13 +10363,52 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         applyPendingAgeSelection,
         normalizeArchiveCommentRecord,
       },
-    });
-    const pending = pendingWork.pending;
-    if (pending.staleSkippedLatest) {
-      saveRunnerRouteState(routeKey, buildRunnerRouteStateFromComment(pending.staleSkippedLatest, {
-        last_reason: `skipped ${ensureArray(pending.staleSkipped).length} stale archive message(s) older than ${Math.floor(BOT_RUNNER_PENDING_COMMENT_MAX_AGE_MS / 60000)} minutes`,
-      }));
-      refreshedState = safeObject(loadBotRunnerState().routes[routeKey]);
+    });
+    const pending = pendingWork.pending;
+    if (pending.staleSkippedLatest) {
+      let staleStateChanged = false;
+      for (const staleRecordRaw of ensureArray(pending.staleSkipped)) {
+        const staleRecord = safeObject(staleRecordRaw);
+        const commentID = String(staleRecord.id || "").trim();
+        if (!commentID) continue;
+        const parsed = safeObject(staleRecord.parsedArchive);
+        const existingExcludedEntry = safeObject(excludedComments[commentID]);
+        const stalePatch = {
+          project_id: String(normalizedRoute.projectID || "").trim(),
+          provider: String(normalizedRoute.provider || "").trim(),
+          route_key: routeKey,
+          request_key: String(existingExcludedEntry.request_key || "").trim(),
+          conversation_id: String(parsed.conversationID || parsed.conversationId || existingExcludedEntry.conversation_id || "").trim(),
+          source_message_id: intFromRawAllowZero(parsed.messageID || existingExcludedEntry.source_message_id, 0) || undefined,
+          comment_kind: String(parsed.kind || existingExcludedEntry.comment_kind || "").trim().toLowerCase(),
+          request_status: "expired",
+          source_occurred_at: resolveRunnerCommentStateSourceOccurredAt(staleRecord),
+          stale_after_at: resolveRunnerCommentStateStaleAfterAt(staleRecord),
+          selection_state: "stale",
+          reason_code: "stale_archive_message",
+          decision: "skip",
+          action: "stale_skipped",
+          context_excluded: true,
+          closed_reason: "stale_source_message",
+        };
+        const updatedExcludedEntry = markBotRunnerExcludedComment(commentID, stalePatch);
+        if (
+          normalizeRunnerCommentSelectionState(updatedExcludedEntry.selection_state, "superseded") === "stale"
+          && String(updatedExcludedEntry.closed_reason || "").trim() === "stale_source_message"
+        ) {
+          staleStateChanged = true;
+        }
+      }
+      if (staleStateChanged) {
+        await syncRunnerRequestLedgerForProjectToServer({
+          normalizedRoute,
+          runtime,
+        });
+      }
+      saveRunnerRouteState(routeKey, buildRunnerRouteStateFromComment(pending.staleSkippedLatest, {
+        last_reason: `skipped ${ensureArray(pending.staleSkipped).length} stale archive message(s) older than ${Math.floor(BOT_RUNNER_PENDING_COMMENT_MAX_AGE_MS / 60000)} minutes`,
+      }));
+      refreshedState = safeObject(loadBotRunnerState().routes[routeKey]);
     }
     if (pending.shouldPrime && pending.latest) {
       saveRunnerRouteState(routeKey, buildRunnerRouteStateFromComment(pending.latest, { primed: true }));

package/lib/runner-data.mjs

@@ -478,6 +478,9 @@ export async function listProjectRunnerRequestCommentStates(
       action: String(row.action || row.Action || "").trim(),
       context_excluded: row.context_excluded === true || row.ContextExcluded === true,
       closed_reason: String(row.closed_reason || row.closedReason || row.ClosedReason || "").trim(),
+      source_occurred_at: String(row.source_occurred_at || row.sourceOccurredAt || row.SourceOccurredAt || "").trim(),
+      stale_after_at: String(row.stale_after_at || row.staleAfterAt || row.StaleAfterAt || "").trim(),
+      selection_state: String(row.selection_state || row.selectionState || row.SelectionState || "").trim(),
       consumed_at: String(row.consumed_at || row.consumedAt || row.ConsumedAt || "").trim(),
       updated_at: String(row.updated_at || row.updatedAt || row.UpdatedAt || "").trim(),
     };
@@ -513,6 +516,9 @@ export async function upsertProjectRunnerRequestCommentState(
     action: String(raw.action || "").trim(),
     context_excluded: raw.context_excluded === true,
     closed_reason: String(raw.closed_reason || "").trim(),
+    source_occurred_at: String(raw.source_occurred_at || "").trim() || undefined,
+    stale_after_at: String(raw.stale_after_at || "").trim() || undefined,
+    selection_state: String(raw.selection_state || "").trim() || undefined,
     consumed_at: String(raw.consumed_at || "").trim() || undefined,
   };
   const extraHeaders = actorUserID ? { "X-Actor-User-Id": actorUserID } : {};

package/lib/runner-helpers.mjs

@@ -254,12 +254,28 @@ 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 staleAfterTime = Date.parse(String(safeObject(record).staleAfterAt || ""));
+  if (Number.isFinite(staleAfterTime)) {
+    return options.nowMs <= staleAfterTime;
+  }
+  const recordTime = Date.parse(resolveArchiveRecordEventTime(record));
   if (!Number.isFinite(recordTime)) {
     return true;
   }
@@ -411,8 +427,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 +537,25 @@ 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([
+      comment.source_occurred_at,
+      comment.sourceOccurredAt,
+      safeObject(parsedArchive).occurredAt,
+      safeObject(parsedArchive).occurred_at,
+    ]),
+    staleAfterAt: firstNonEmptyString([
+      comment.stale_after_at,
+      comment.staleAfterAt,
+    ]),
+    selectionState: String(comment.selection_state || comment.selectionState || "").trim().toLowerCase(),
+    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,148 @@ 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 nowMs = Date.parse("2026-03-31T12:00:00.000Z");
+    const pendingSelection = selectPendingArchiveComments(
+      [
+        {
+          id: "cursor-comment-persisted-stale",
+          createdAt: "2026-03-31T11:55:00.000Z",
+          updatedAt: "2026-03-31T11:55:00.000Z",
+          parsedArchive: {
+            kind: "telegram_message",
+            chatID: "-1001",
+            messageID: 1148,
+            body: "@RyoAI_bot 기준 댓글",
+          },
+        },
+        {
+          id: "stale-by-persisted-cutoff",
+          createdAt: "2026-03-31T11:59:58.000Z",
+          updatedAt: "2026-03-31T11:59:58.000Z",
+          staleAfterAt: "2026-03-31T11:50:00.000Z",
+          parsedArchive: {
+            kind: "telegram_message",
+            chatID: "-1001",
+            messageID: 327,
+            body: "@RyoAI_bot archive created recently but source already stale",
+          },
+        },
+        {
+          id: "fresh-by-persisted-cutoff",
+          createdAt: "2026-03-31T11:59:59.000Z",
+          updatedAt: "2026-03-31T11:59:59.000Z",
+          staleAfterAt: "2026-03-31T12:05:00.000Z",
+          parsedArchive: {
+            kind: "telegram_message",
+            chatID: "-1001",
+            messageID: 1149,
+            body: "@RyoAI_bot still fresh by persisted cutoff",
+          },
+        },
+      ],
+      {
+        last_processed_comment_id: "cursor-comment-persisted-stale",
+      },
+      "start",
+      (record) => record,
+      {
+        maxPendingAgeMs: 15 * 60 * 1000,
+        nowMs,
+      },
+    );
+    push(
+      "runner_pending_selection_prefers_persisted_stale_after_at_over_recent_archive_created_at",
+      pendingSelection.pending.length === 1
+        && String(pendingSelection.pending[0]?.id || "") === "fresh-by-persisted-cutoff"
+        && ensureArray(pendingSelection.staleSkipped).some((record) => String(record?.id || "") === "stale-by-persisted-cutoff"),
+      `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_prefers_persisted_stale_after_at_over_recent_archive_created_at",
+      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 +3359,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.272",
   "description": "Metheus Governance MCP CLI (setup + stdio proxy)",
   "type": "module",
   "files": [