metheus-governance-mcp-cli 0.2.271 → 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

@@ -271,6 +271,10 @@ function isArchiveRecordWithinPendingAgeLimit(record, rawOptions) {
   if (!(options.maxPendingAgeMs > 0)) {
     return true;
   }
+  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;
@@ -541,9 +545,16 @@ export function normalizeArchiveCommentRecord(rawComment, parseArchivedChatComme
     updatedAt: firstNonEmptyString([comment.updated_at, comment.updatedAt]),
     authorUserID: firstNonEmptyString([comment.author_user_id, comment.authorUserId, comment.created_by]),
     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/selftest-runner-scenarios.mjs

@@ -844,6 +844,71 @@ export async function runSelftestRunnerScenarios(push, deps) {
     );
   }
 
+  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 = [
       {

package/package.json

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