metheus-governance-mcp-cli 0.2.192 → 0.2.193

package/cli.mjs

@@ -213,6 +213,7 @@ const BOT_RUNNER_ACTIVE_EXECUTION_HEARTBEAT_INTERVAL_MS = 5000;
 const BOT_RUNNER_ACTIVE_EXECUTION_HEARTBEAT_STALE_MS = 60 * 1000;
 const BOT_RUNNER_PENDING_COMMENT_MAX_AGE_MS = 15 * 60 * 1000;
 const BOT_RUNNER_EXCLUDED_COMMENT_KEEP_MS = 14 * 24 * 60 * 60 * 1000;
+const BOT_RUNNER_REQUEST_KEEP_MS = 14 * 24 * 60 * 60 * 1000;
 const BOT_RUNNER_DEFAULT_CONCURRENCY = 2;
 const BOT_RUNNER_MAX_CONCURRENCY = 8;
 const TELEGRAM_ROOT_LEGACY_ENV_RELATIVE_PATH = path.join(".metheus", "telegram.env");
@@ -1998,6 +1999,8 @@ function loadBotRunnerState() {
         routes: {},
         sharedInboxes: {},
         excludedComments: {},
+        requests: {},
+        consumedComments: {},
         migrated: false,
         migratedKeys: [],
         remainingAnonymousKeys: [],
@@ -2011,6 +2014,8 @@ function loadBotRunnerState() {
         routes: migratedState.routes,
         sharedInboxes: safeObject(parsed?.shared_inboxes || parsed?.sharedInboxes),
         excludedComments: safeObject(parsed?.excluded_comments || parsed?.excludedComments),
+        requests: safeObject(parsed?.requests),
+        consumedComments: safeObject(parsed?.consumed_comments || parsed?.consumedComments),
       });
     }
     return {
@@ -2018,6 +2023,8 @@ function loadBotRunnerState() {
       routes: migratedState.routes,
       sharedInboxes: safeObject(parsed?.shared_inboxes || parsed?.sharedInboxes),
       excludedComments: normalizeBotRunnerExcludedComments(parsed?.excluded_comments || parsed?.excludedComments),
+      requests: normalizeBotRunnerRequests(parsed?.requests),
+      consumedComments: normalizeBotRunnerConsumedComments(parsed?.consumed_comments || parsed?.consumedComments),
       migrated: migratedState.changed,
       migratedKeys: migratedState.migratedKeys,
       remainingAnonymousKeys: migratedState.remainingAnonymousKeys,
@@ -2028,6 +2035,8 @@ function loadBotRunnerState() {
       routes: {},
       sharedInboxes: {},
       excludedComments: {},
+      requests: {},
+      consumedComments: {},
       migrated: false,
       migratedKeys: [],
       remainingAnonymousKeys: [],
@@ -2047,6 +2056,8 @@ function saveBotRunnerState(nextState) {
     routes: safeObject(nextState?.routes ?? current.routes),
     shared_inboxes: safeObject(nextState?.sharedInboxes ?? nextState?.shared_inboxes ?? current.shared_inboxes ?? current.sharedInboxes),
     excluded_comments: normalizeBotRunnerExcludedComments(nextState?.excludedComments ?? nextState?.excluded_comments ?? current.excluded_comments ?? current.excludedComments),
+    requests: normalizeBotRunnerRequests(nextState?.requests ?? current.requests),
+    consumed_comments: normalizeBotRunnerConsumedComments(nextState?.consumedComments ?? nextState?.consumed_comments ?? current.consumed_comments ?? current.consumedComments),
   };
   fs.mkdirSync(path.dirname(filePath), { recursive: true });
   fs.writeFileSync(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
@@ -2079,6 +2090,100 @@ function normalizeBotRunnerExcludedComments(rawExcluded, nowMs = Date.now()) {
   return normalized;
 }
 
+function normalizeRunnerRequestStatus(rawStatus) {
+  const status = String(rawStatus || "").trim().toLowerCase();
+  return [
+    "planned",
+    "claimed",
+    "running",
+    "completed",
+    "closed",
+    "expired",
+    "loop_closed",
+  ].includes(status)
+    ? status
+    : "planned";
+}
+
+function isFinalRunnerRequestStatus(rawStatus) {
+  const status = normalizeRunnerRequestStatus(rawStatus);
+  return status === "completed" || status === "closed" || status === "expired" || status === "loop_closed";
+}
+
+function isActiveRunnerRequestStatus(rawStatus) {
+  const status = normalizeRunnerRequestStatus(rawStatus);
+  return status === "planned" || status === "claimed" || status === "running";
+}
+
+function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
+  const normalized = {};
+  for (const [requestKeyRaw, entryRaw] of Object.entries(safeObject(rawRequests))) {
+    const requestKey = String(requestKeyRaw || safeObject(entryRaw).request_key || "").trim();
+    if (!requestKey) continue;
+    const entry = safeObject(entryRaw);
+    const status = normalizeRunnerRequestStatus(entry.status);
+    const updatedAt = firstNonEmptyString([entry.updated_at, entry.updatedAt, entry.completed_at, entry.completedAt, entry.closed_at, entry.closedAt, entry.claimed_at, entry.claimedAt]);
+    const updatedAtMs = Date.parse(updatedAt);
+    if (isFinalRunnerRequestStatus(status) && Number.isFinite(updatedAtMs) && nowMs - updatedAtMs > BOT_RUNNER_REQUEST_KEEP_MS) {
+      continue;
+    }
+    normalized[requestKey] = {
+      request_key: requestKey,
+      project_id: String(entry.project_id || entry.projectID || "").trim(),
+      provider: String(entry.provider || "").trim(),
+      chat_id: String(entry.chat_id || entry.chatID || "").trim(),
+      source_message_id: intFromRawAllowZero(entry.source_message_id || entry.sourceMessageID, 0) || undefined,
+      root_comment_id: String(entry.root_comment_id || entry.rootCommentID || "").trim(),
+      root_comment_kind: String(entry.root_comment_kind || entry.rootCommentKind || "").trim().toLowerCase(),
+      conversation_id: String(entry.conversation_id || entry.conversationId || "").trim(),
+      selected_bot_usernames: ensureArray(entry.selected_bot_usernames || entry.selectedBotUsernames)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
+      conversation_allowed_responders: ensureArray(entry.conversation_allowed_responders || entry.conversationAllowedResponders)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
+      normalized_intent: String(entry.normalized_intent || entry.normalizedIntent || "").trim().toLowerCase(),
+      status,
+      claimed_by_route: String(entry.claimed_by_route || entry.claimedByRoute || "").trim(),
+      claimed_at: firstNonEmptyString([entry.claimed_at, entry.claimedAt]),
+      started_at: firstNonEmptyString([entry.started_at, entry.startedAt]),
+      completed_at: firstNonEmptyString([entry.completed_at, entry.completedAt]),
+      closed_at: firstNonEmptyString([entry.closed_at, entry.closedAt]),
+      closed_reason: String(entry.closed_reason || entry.closedReason || "").trim(),
+      last_comment_id: String(entry.last_comment_id || entry.lastCommentID || "").trim(),
+      last_comment_kind: String(entry.last_comment_kind || entry.lastCommentKind || "").trim().toLowerCase(),
+      last_source_message_id: intFromRawAllowZero(entry.last_source_message_id || entry.lastSourceMessageID, 0) || undefined,
+      updated_at: updatedAt || new Date(nowMs).toISOString(),
+    };
+  }
+  return normalized;
+}
+
+function normalizeBotRunnerConsumedComments(rawConsumed, nowMs = Date.now()) {
+  const normalized = {};
+  for (const [commentIDRaw, entryRaw] of Object.entries(safeObject(rawConsumed))) {
+    const commentID = String(commentIDRaw || safeObject(entryRaw).comment_id || "").trim();
+    if (!commentID) continue;
+    const entry = safeObject(entryRaw);
+    const consumedAt = firstNonEmptyString([entry.consumed_at, entry.consumedAt, entry.updated_at, entry.updatedAt]);
+    const consumedAtMs = Date.parse(consumedAt);
+    if (Number.isFinite(consumedAtMs) && nowMs - consumedAtMs > BOT_RUNNER_REQUEST_KEEP_MS) {
+      continue;
+    }
+    normalized[commentID] = {
+      comment_id: commentID,
+      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;
+}
+
 function runnerRouteMatchesProjectConversationScope(candidateRouteRaw, normalizedRouteRaw) {
   const candidateRoute = normalizeRunnerRoute(candidateRouteRaw);
   const normalizedRoute = normalizeRunnerRoute(normalizedRouteRaw);
@@ -2211,6 +2316,452 @@ function collectBotRunnerConversationSessionFacts(routeRaw, conversationIDRaw) {
   };
 }
 
+function uniqueOrderedStrings(values, normalizer = (value) => String(value || "").trim()) {
+  const output = [];
+  const seen = new Set();
+  for (const value of ensureArray(values)) {
+    const normalized = normalizer(value);
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    output.push(normalized);
+  }
+  return output;
+}
+
+function buildRunnerRequestKey({
+  normalizedRoute,
+  selectedRecord,
+  selectedBotUsernames = [],
+  normalizedIntent = "",
+}) {
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const chatID = String(parsed.chatID || parsed.chatId || "").trim() || "-";
+  const messageID = intFromRawAllowZero(parsed.messageID, 0);
+  const kind = String(parsed.kind || "").trim().toLowerCase() || "-";
+  const responders = uniqueOrderedStrings(selectedBotUsernames, normalizeTelegramMentionUsername).join(",") || "-";
+  const intent = String(normalizedIntent || "").trim().toLowerCase() || "-";
+  const conversationID = String(parsed.conversationID || "").trim() || "-";
+  return [
+    String(normalizedRoute?.projectID || "").trim() || "-",
+    String(normalizedRoute?.provider || "").trim() || "-",
+    chatID,
+    String(messageID || "-"),
+    kind,
+    responders,
+    intent,
+    conversationID,
+  ].join("::");
+}
+
+function findRunnerRequestsForScope(state, normalizedRoute, selectors = {}) {
+  const requests = normalizeBotRunnerRequests(state?.requests);
+  const projectID = String(normalizedRoute?.projectID || "").trim();
+  const provider = String(normalizedRoute?.provider || "").trim();
+  const conversationID = String(selectors.conversationID || "").trim();
+  const chatID = String(selectors.chatID || "").trim();
+  const requestKey = String(selectors.requestKey || "").trim();
+  return Object.values(requests)
+    .filter((entry) => !requestKey || entry.request_key === requestKey)
+    .filter((entry) => !projectID || entry.project_id === projectID)
+    .filter((entry) => !provider || entry.provider === provider)
+    .filter((entry) => !chatID || entry.chat_id === chatID)
+    .filter((entry) => !conversationID || entry.conversation_id === conversationID)
+    .sort((left, right) => {
+      const leftTime = firstNonEmptyString([left.updated_at, left.completed_at, left.closed_at, left.claimed_at]);
+      const rightTime = firstNonEmptyString([right.updated_at, right.completed_at, right.closed_at, right.claimed_at]);
+      if (leftTime && rightTime && leftTime !== rightTime) {
+        return leftTime < rightTime ? 1 : -1;
+      }
+      return String(left.request_key || "").localeCompare(String(right.request_key || ""));
+    });
+}
+
+function upsertRunnerRequest(state, requestKey, patch = {}) {
+  const currentState = safeObject(state);
+  const requests = normalizeBotRunnerRequests(currentState.requests);
+  const existing = safeObject(requests[requestKey]);
+  const nextEntry = {
+    ...existing,
+    ...safeObject(patch),
+    request_key: requestKey,
+    status: normalizeRunnerRequestStatus(patch.status || existing.status),
+    updated_at: new Date().toISOString(),
+  };
+  requests[requestKey] = nextEntry;
+  return {
+    requests,
+    request: nextEntry,
+  };
+}
+
+function upsertRunnerConsumedComment(state, commentIDRaw, patch = {}) {
+  const commentID = String(commentIDRaw || "").trim();
+  const currentState = safeObject(state);
+  const consumedComments = normalizeBotRunnerConsumedComments(currentState.consumedComments || currentState.consumed_comments);
+  const existing = safeObject(consumedComments[commentID]);
+  const nextEntry = {
+    ...existing,
+    ...safeObject(patch),
+    comment_id: commentID,
+    consumed_at: new Date().toISOString(),
+    request_status: normalizeRunnerRequestStatus(patch.request_status || existing.request_status),
+  };
+  consumedComments[commentID] = nextEntry;
+  return {
+    consumedComments,
+    consumedComment: nextEntry,
+  };
+}
+
+function claimRunnerRequestForHumanComment({
+  normalizedRoute,
+  routeKey,
+  selectedRecord,
+  selectedBotUsernames = [],
+  normalizedIntent = "",
+}) {
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const commentKind = String(parsed.kind || "").trim().toLowerCase();
+  if (!isInboundArchiveKind(commentKind)) {
+    return {
+      ok: false,
+      reason: "non_human_comment_cannot_create_request",
+    };
+  }
+  const requestKey = buildRunnerRequestKey({
+    normalizedRoute,
+    selectedRecord,
+    selectedBotUsernames,
+    normalizedIntent,
+  });
+  const currentState = loadBotRunnerState();
+  const requests = normalizeBotRunnerRequests(currentState.requests);
+  const existing = safeObject(requests[requestKey]);
+  if (isFinalRunnerRequestStatus(existing.status)) {
+    return {
+      ok: false,
+      reason: "request_already_finalized",
+      requestKey,
+    };
+  }
+  if (
+    isActiveRunnerRequestStatus(existing.status)
+    && String(existing.claimed_by_route || "").trim()
+    && String(existing.claimed_by_route || "").trim() !== String(routeKey || "").trim()
+  ) {
+    return {
+      ok: false,
+      reason: "request_already_claimed",
+      requestKey,
+    };
+  }
+  const nowISO = new Date().toISOString();
+  const { requests: nextRequests, request } = upsertRunnerRequest(currentState, requestKey, {
+    project_id: String(normalizedRoute?.projectID || "").trim(),
+    provider: String(normalizedRoute?.provider || "").trim(),
+    chat_id: String(parsed.chatID || parsed.chatId || "").trim(),
+    source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
+    root_comment_id: String(selectedRecord?.id || "").trim(),
+    root_comment_kind: commentKind,
+    conversation_id: String(parsed.conversationID || "").trim(),
+    selected_bot_usernames: uniqueOrderedStrings(selectedBotUsernames, normalizeTelegramMentionUsername),
+    normalized_intent: String(normalizedIntent || "").trim().toLowerCase(),
+    status: "claimed",
+    claimed_by_route: String(routeKey || "").trim(),
+    claimed_at: firstNonEmptyString([existing.claimed_at, nowISO]) || nowISO,
+    last_comment_id: String(selectedRecord?.id || "").trim(),
+    last_comment_kind: commentKind,
+    last_source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
+  });
+  const { consumedComments: nextConsumedComments } = upsertRunnerConsumedComment(currentState, selectedRecord?.id, {
+    request_key: requestKey,
+    route_key: String(routeKey || "").trim(),
+    conversation_id: String(parsed.conversationID || "").trim(),
+    source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
+    comment_kind: commentKind,
+    request_status: "claimed",
+  });
+  saveBotRunnerState({
+    routes: currentState.routes,
+    sharedInboxes: currentState.sharedInboxes || currentState.shared_inboxes,
+    excludedComments: currentState.excludedComments || currentState.excluded_comments,
+    requests: nextRequests,
+    consumedComments: nextConsumedComments,
+  });
+  return {
+    ok: true,
+    requestKey,
+    request,
+  };
+}
+
+function resolveRunnerContinuationRequestForBotReply({
+  normalizedRoute,
+  routeKey,
+  selectedRecord,
+}) {
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const commentKind = String(parsed.kind || "").trim().toLowerCase();
+  if (commentKind !== "bot_reply") {
+    return {
+      ok: false,
+      reason: "not_a_bot_reply",
+    };
+  }
+  const conversationID = String(parsed.conversationID || "").trim();
+  if (!conversationID) {
+    return {
+      ok: false,
+      reason: "bot_reply_without_conversation",
+    };
+  }
+  const currentState = loadBotRunnerState();
+  const requests = findRunnerRequestsForScope(currentState, normalizedRoute, {
+    conversationID,
+    chatID: String(parsed.chatID || parsed.chatId || "").trim(),
+  }).filter((entry) => isActiveRunnerRequestStatus(entry.status));
+  const request = safeObject(requests[0]);
+  if (!Object.keys(request).length) {
+    return {
+      ok: false,
+      reason: "bot_reply_without_active_request",
+      conversationID,
+    };
+  }
+  const { consumedComments: nextConsumedComments } = upsertRunnerConsumedComment(currentState, selectedRecord?.id, {
+    request_key: request.request_key,
+    route_key: String(routeKey || "").trim(),
+    conversation_id: conversationID,
+    source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
+    comment_kind: commentKind,
+    request_status: request.status,
+  });
+  const { requests: nextRequests, request: nextRequest } = upsertRunnerRequest(currentState, request.request_key, {
+    last_comment_id: String(selectedRecord?.id || "").trim(),
+    last_comment_kind: commentKind,
+    last_source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
+  });
+  saveBotRunnerState({
+    routes: currentState.routes,
+    sharedInboxes: currentState.sharedInboxes || currentState.shared_inboxes,
+    excludedComments: currentState.excludedComments || currentState.excluded_comments,
+    requests: nextRequests,
+    consumedComments: nextConsumedComments,
+  });
+  return {
+    ok: true,
+    requestKey: nextRequest.request_key,
+    request: nextRequest,
+  };
+}
+
+function markRunnerRequestLifecycle({
+  normalizedRoute,
+  requestKey,
+  selectedRecord,
+  routeKey,
+  outcome,
+  conversationIDRaw = "",
+  allowedResponders = [],
+  normalizedIntent = "",
+  closedReason = "",
+}) {
+  const key = String(requestKey || "").trim();
+  if (!key) return null;
+  const currentState = loadBotRunnerState();
+  const existing = safeObject(normalizeBotRunnerRequests(currentState.requests)[key]);
+  if (!Object.keys(existing).length) return null;
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const conversationID = String(conversationIDRaw || existing.conversation_id || parsed.conversationID || "").trim();
+  const conversationFacts = conversationID
+    ? collectBotRunnerConversationSessionFacts(normalizedRoute, conversationID)
+    : {};
+  const normalizedOutcome = String(outcome || "").trim().toLowerCase();
+  const nextStatus = (() => {
+    if (normalizedOutcome === "claimed") return "claimed";
+    if (normalizedOutcome === "running") return "running";
+    if (normalizedOutcome === "replied") {
+      return conversationFacts.any_open ? "running" : "completed";
+    }
+    if (normalizedOutcome === "loop_closed") return "loop_closed";
+    if (normalizedOutcome === "expired") return "expired";
+    if (normalizedOutcome === "error" || normalizedOutcome === "skipped" || normalizedOutcome === "closed") {
+      return conversationFacts.any_open ? "running" : "closed";
+    }
+    return normalizeRunnerRequestStatus(existing.status);
+  })();
+  const nowISO = new Date().toISOString();
+  const patch = {
+    conversation_id: conversationID,
+    conversation_allowed_responders: uniqueOrderedStrings(
+      ensureArray(allowedResponders).length ? allowedResponders : existing.conversation_allowed_responders,
+      normalizeTelegramMentionUsername,
+    ),
+    normalized_intent: String(normalizedIntent || existing.normalized_intent || "").trim().toLowerCase(),
+    status: nextStatus,
+    started_at: firstNonEmptyString([existing.started_at, nowISO]),
+    completed_at: nextStatus === "completed" ? nowISO : String(existing.completed_at || "").trim(),
+    closed_at: (nextStatus === "closed" || nextStatus === "expired" || nextStatus === "loop_closed")
+      ? nowISO
+      : String(existing.closed_at || "").trim(),
+    closed_reason: (nextStatus === "closed" || nextStatus === "expired" || nextStatus === "loop_closed")
+      ? String(closedReason || existing.closed_reason || normalizedOutcome).trim()
+      : String(existing.closed_reason || "").trim(),
+    last_comment_id: String(selectedRecord?.id || existing.last_comment_id || "").trim(),
+    last_comment_kind: String(parsed.kind || existing.last_comment_kind || "").trim().toLowerCase(),
+    last_source_message_id: intFromRawAllowZero(parsed.messageID, 0) || existing.last_source_message_id,
+  };
+  const { requests: nextRequests, request } = upsertRunnerRequest(currentState, key, patch);
+  const commentID = String(selectedRecord?.id || "").trim();
+  let nextConsumedComments = currentState.consumedComments || currentState.consumed_comments;
+  if (commentID) {
+    ({ consumedComments: nextConsumedComments } = upsertRunnerConsumedComment(currentState, commentID, {
+      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,
+    }));
+  }
+  saveBotRunnerState({
+    routes: currentState.routes,
+    sharedInboxes: currentState.sharedInboxes || currentState.shared_inboxes,
+    excludedComments: currentState.excludedComments || currentState.excluded_comments,
+    requests: nextRequests,
+    consumedComments: nextConsumedComments,
+  });
+  return request;
+}
+
+function cleanupBotRunnerRequestState({
+  normalizedRoute,
+  comments = [],
+}) {
+  const currentState = loadBotRunnerState();
+  const config = loadBotRunnerConfig({ persistIfNeeded: true });
+  const nextRoutes = {
+    ...safeObject(currentState.routes),
+  };
+  let nextRequests = normalizeBotRunnerRequests(currentState.requests);
+  let nextExcludedComments = normalizeBotRunnerExcludedComments(currentState.excludedComments || currentState.excluded_comments);
+  let changed = false;
+  const orderedComments = ensureArray(comments)
+    .map((comment) => normalizeArchiveCommentRecord(comment, parseArchivedChatComment))
+    .filter((record) => record.id && record.parsedArchive);
+  const nowMs = Date.now();
+  const nowISO = new Date(nowMs).toISOString();
+  const candidateRoutes = [];
+  const seenRouteKeys = new Set();
+  const pushCandidateRoute = (routeRaw) => {
+    const routeObject = safeObject(routeRaw);
+    if (!Object.keys(routeObject).length) {
+      return;
+    }
+    const candidateRoute = normalizeRunnerRoute(routeObject);
+    const candidateRouteKey = runnerRouteKey(candidateRoute);
+    if (seenRouteKeys.has(candidateRouteKey)) {
+      return;
+    }
+    seenRouteKeys.add(candidateRouteKey);
+    candidateRoutes.push(candidateRoute);
+  };
+  pushCandidateRoute(normalizedRoute);
+  for (const candidateRouteRaw of ensureArray(config.routes)) {
+    if (!runnerRouteMatchesProjectConversationScope(candidateRouteRaw, normalizedRoute)) {
+      continue;
+    }
+    pushCandidateRoute(candidateRouteRaw);
+  }
+  for (const candidateRoute of candidateRoutes) {
+    const routeKey = runnerRouteKey(candidateRoute);
+    const currentRouteState = safeObject(nextRoutes[routeKey]);
+    const conversationSessions = {
+      ...safeObject(currentRouteState.conversation_sessions),
+    };
+    let routeChanged = false;
+    for (const [conversationID, sessionRaw] of Object.entries(safeObject(conversationSessions))) {
+      const session = safeObject(sessionRaw);
+      if (String(session.status || "").trim() !== "open") {
+        continue;
+      }
+      const expiresAtMs = Date.parse(String(session.expires_at || "").trim());
+      const expired = Number.isFinite(expiresAtMs) && expiresAtMs <= nowMs;
+      const activeRequests = Object.values(nextRequests).filter((entry) => (
+        String(entry.project_id || "").trim() === String(candidateRoute.projectID || "").trim()
+        && String(entry.provider || "").trim() === String(candidateRoute.provider || "").trim()
+        && String(entry.conversation_id || "").trim() === String(conversationID || "").trim()
+        && isActiveRunnerRequestStatus(entry.status)
+      ));
+      if (!expired && activeRequests.length > 0) {
+        continue;
+      }
+      const closedReason = expired ? "expired_session" : "orphaned_open_session";
+      conversationSessions[conversationID] = {
+        ...session,
+        status: "closed",
+        closed_reason: closedReason,
+        closed_at: nowISO,
+        last_activity_at: nowISO,
+      };
+      routeChanged = true;
+      changed = true;
+      for (const request of activeRequests) {
+        nextRequests[request.request_key] = {
+          ...request,
+          status: expired ? "expired" : "closed",
+          closed_reason: closedReason,
+          closed_at: nowISO,
+          updated_at: nowISO,
+        };
+      }
+      for (const record of orderedComments) {
+        const parsed = safeObject(record.parsedArchive);
+        if (String(parsed.conversationID || "").trim() !== String(conversationID || "").trim()) {
+          continue;
+        }
+        if (String(parsed.kind || "").trim().toLowerCase() !== "bot_reply") {
+          continue;
+        }
+        nextExcludedComments[String(record.id || "").trim()] = {
+          ...safeObject(nextExcludedComments[String(record.id || "").trim()]),
+          comment_id: String(record.id || "").trim(),
+          excluded_at: nowISO,
+          reason_code: closedReason,
+          decision: expired ? "expired" : "closed",
+          action: "skip_closed_request_comment",
+          conversation_id: String(conversationID || "").trim(),
+          source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
+          context_excluded: true,
+          closed_reason: closedReason,
+        };
+      }
+    }
+    if (routeChanged) {
+      nextRoutes[routeKey] = {
+        ...currentRouteState,
+        conversation_sessions: conversationSessions,
+        updated_at: nowISO,
+      };
+    }
+  }
+  if (changed) {
+    saveBotRunnerState({
+      routes: nextRoutes,
+      sharedInboxes: currentState.sharedInboxes || currentState.shared_inboxes,
+      excludedComments: nextExcludedComments,
+      requests: nextRequests,
+      consumedComments: currentState.consumedComments || currentState.consumed_comments,
+    });
+  }
+  return {
+    routes: nextRoutes,
+    requests: nextRequests,
+    excludedComments: nextExcludedComments,
+    changed,
+  };
+}
+
 function normalizeRunnerProcessLaunchEntry(rawEntry) {
   const entry = safeObject(rawEntry);
   return cleanupRunnerStateRecord({
@@ -4435,6 +4986,7 @@ function emptyRunnerActiveExecutionPatch() {
     active_comment_id: "",
     active_comment_created_at: "",
     active_source_message_id: undefined,
+    active_request_key: "",
     active_started_at: "",
     active_heartbeat_at: "",
     active_runner_pid: undefined,
@@ -4442,13 +4994,14 @@ function emptyRunnerActiveExecutionPatch() {
   };
 }
 
-function buildRunnerActiveExecutionPatch(selectedRecord) {
+function buildRunnerActiveExecutionPatch(selectedRecord, requestKey = "") {
   const nowISO = new Date().toISOString();
   const parsed = safeObject(selectedRecord?.parsedArchive);
   return {
     active_comment_id: String(selectedRecord?.id || "").trim(),
     active_comment_created_at: firstNonEmptyString([selectedRecord?.createdAt, selectedRecord?.updatedAt]),
     active_source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
+    active_request_key: String(requestKey || "").trim(),
     active_started_at: nowISO,
     active_heartbeat_at: nowISO,
     active_runner_pid: process.pid,
@@ -4762,12 +5315,43 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
       actorUserID: runtime.actor.user_id,
       limit: Math.max(1000, normalizedRoute.contextComments * 20),
     });
+    cleanupBotRunnerRequestState({
+      normalizedRoute,
+      comments,
+    });
+    const latestRunnerState = loadBotRunnerState();
     const excludedComments = normalizeBotRunnerExcludedComments(
-      loadBotRunnerState().excludedComments || loadBotRunnerState().excluded_comments,
+      latestRunnerState.excludedComments || latestRunnerState.excluded_comments,
+    );
+    const consumedComments = normalizeBotRunnerConsumedComments(
+      latestRunnerState.consumedComments || latestRunnerState.consumed_comments,
     );
+    const requests = normalizeBotRunnerRequests(latestRunnerState.requests);
     const commentsForPending = ensureArray(comments).filter((comment) => {
-      const commentID = String(safeObject(comment).id || "").trim();
-      return commentID ? !safeObject(excludedComments)[commentID] : true;
+      const normalizedComment = normalizeArchiveCommentRecord(comment, parseArchivedChatComment);
+      const commentID = String(normalizedComment.id || "").trim();
+      if (commentID && safeObject(excludedComments)[commentID]) {
+        return false;
+      }
+      if (commentID && safeObject(consumedComments)[commentID]) {
+        return false;
+      }
+      const parsed = safeObject(normalizedComment.parsedArchive);
+      if (String(parsed.kind || "").trim().toLowerCase() === "bot_reply") {
+        const conversationID = String(parsed.conversationID || "").trim();
+        if (!conversationID) {
+          return false;
+        }
+        const activeRequests = Object.values(requests).filter((entry) => (
+          String(entry.project_id || "").trim() === String(normalizedRoute.projectID || "").trim()
+          && String(entry.provider || "").trim() === String(normalizedRoute.provider || "").trim()
+          && String(entry.chat_id || "").trim() === String(parsed.chatID || "").trim()
+          && String(entry.conversation_id || "").trim() === conversationID
+          && isActiveRunnerRequestStatus(entry.status)
+        ));
+        return activeRequests.length > 0;
+      }
+      return true;
     });
     const pendingWork = selectRunnerPendingWork({
       comments: commentsForPending,
@@ -4882,6 +5466,35 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
       }
       return null;
     };
+    const prepareRunnerRequestClaim = (selectedRecord, selectedResponderSelectors = []) => {
+      const parsed = safeObject(selectedRecord?.parsedArchive);
+      const kind = String(parsed.kind || "").trim().toLowerCase();
+      if (kind === "bot_reply") {
+        const continuation = resolveRunnerContinuationRequestForBotReply({
+          normalizedRoute,
+          routeKey,
+          selectedRecord,
+        });
+        if (!continuation.ok) {
+          markBotRunnerExcludedComment(selectedRecord?.id, {
+            reason_code: String(continuation.reason || "bot_reply_without_active_request").trim() || "bot_reply_without_active_request",
+            decision: "closed",
+            action: "skip_bot_reply_without_active_request",
+            conversation_id: String(parsed.conversationID || "").trim(),
+            source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
+            context_excluded: true,
+            closed_reason: String(continuation.reason || "bot_reply_without_active_request").trim() || "bot_reply_without_active_request",
+          });
+        }
+        return continuation;
+      }
+      return claimRunnerRequestForHumanComment({
+        normalizedRoute,
+        routeKey,
+        selectedRecord,
+        selectedBotUsernames: selectedResponderSelectors,
+      });
+    };
     if (deferExecution) {
       const skippedRecords = [];
       for (const selectedRecord of pending.pending) {
@@ -4948,7 +5561,31 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           });
           continue;
         }
-        saveRunnerRouteState(routeKey, buildRunnerActiveExecutionPatch(selectedRecord));
+        const requestClaim = prepareRunnerRequestClaim(selectedRecord, adjudication.selected_bot_usernames);
+        if (!requestClaim.ok) {
+          saveRunnerRouteState(
+            routeKey,
+            buildRunnerRouteStateFromComment(selectedRecord, {
+              last_action: "request_skipped",
+              last_reason: String(requestClaim.reason || "request_unavailable").trim() || "request_unavailable",
+              last_trigger: "request_ledger",
+            }),
+          );
+          skippedRecords.push({
+            id: selectedRecord.id,
+            reason: String(requestClaim.reason || "request_unavailable").trim() || "request_unavailable",
+            messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
+            diagnosticType: "skip",
+            contextExcluded: String(requestClaim.reason || "").trim() === "bot_reply_without_active_request",
+            action: "skip_invalid_request_state",
+            closedReason: String(requestClaim.reason || "").trim(),
+          });
+          continue;
+        }
+        saveRunnerRouteState(routeKey, {
+          ...buildRunnerActiveExecutionPatch(selectedRecord, requestClaim.requestKey),
+          last_request_key: String(requestClaim.requestKey || "").trim(),
+        });
         return {
           route_key: routeKey,
           route_name: normalizedRoute.name,
@@ -4964,7 +5601,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           deferred_execution: {
             routeKey,
             normalizedRoute,
-            routeState: refreshedState,
+            routeState: safeObject(loadBotRunnerState().routes[routeKey]),
             selectedRecord,
             pendingOrdered: pending.ordered,
             bot,
@@ -4973,6 +5610,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
             executionPlan,
             runtime,
             managedConversationBots,
+            requestKey: String(requestClaim.requestKey || "").trim(),
           },
         };
       }
@@ -5037,11 +5675,79 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         skippedRecords.push(startupLoopSkipped.skippedRecord);
         continue;
       }
+      const inlineAdjudication = await resolveRunnerResponderAdjudication({
+        selectedRecord,
+        pendingOrdered: pending.ordered,
+        normalizedRoute,
+        bot,
+        executionPlan,
+        deps: {
+          ...buildRunnerExecutionDeps(),
+          managedConversationBots,
+          resolveConversationPeerBots: resolveRunnerConversationPeers,
+        },
+      });
+      const inlineCurrentBotSelected = ensureArray(inlineAdjudication.selected_bot_usernames)
+        .map((value) => String(value || "").trim().replace(/^@+/, "").toLowerCase())
+        .includes(currentBotSelector);
+      if (!inlineCurrentBotSelected) {
+        saveRunnerRouteState(
+          routeKey,
+          buildRunnerRouteStateFromComment(selectedRecord, {
+            last_action: "adjudication_skipped",
+            last_reason: String(inlineAdjudication.reason_code || "").trim() || "not_selected_by_adjudicator",
+            last_trigger: "responder_adjudication",
+          }),
+        );
+        skippedRecords.push({
+          id: selectedRecord.id,
+          reason: String(inlineAdjudication.reason_code || "").trim() || "not_selected_by_adjudicator",
+          messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
+        });
+        continue;
+      }
       const currentRouteState = safeObject(loadBotRunnerState().routes[routeKey]);
+      const requestClaim = prepareRunnerRequestClaim(selectedRecord, inlineAdjudication.selected_bot_usernames);
+      if (!requestClaim.ok) {
+        saveRunnerRouteState(
+          routeKey,
+          buildRunnerRouteStateFromComment(selectedRecord, {
+            last_action: "request_skipped",
+            last_reason: String(requestClaim.reason || "request_unavailable").trim() || "request_unavailable",
+            last_trigger: "request_ledger",
+          }),
+        );
+        skippedRecords.push({
+          id: selectedRecord.id,
+          reason: String(requestClaim.reason || "request_unavailable").trim() || "request_unavailable",
+          messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
+          diagnosticType: "skip",
+          contextExcluded: String(requestClaim.reason || "").trim() === "bot_reply_without_active_request",
+          action: "skip_invalid_request_state",
+          closedReason: String(requestClaim.reason || "").trim(),
+        });
+        continue;
+      }
+      saveRunnerRouteState(routeKey, {
+        active_request_key: String(requestClaim.requestKey || "").trim(),
+        last_request_key: String(requestClaim.requestKey || "").trim(),
+      });
+      if (String(requestClaim.requestKey || "").trim()) {
+        markRunnerRequestLifecycle({
+          normalizedRoute,
+          requestKey: requestClaim.requestKey,
+          selectedRecord,
+          routeKey,
+          outcome: "running",
+        });
+      }
       const processed = await processRunnerSelectedRecord({
         routeKey,
         normalizedRoute,
-        routeState: currentRouteState,
+        routeState: {
+          ...currentRouteState,
+          active_request_key: String(requestClaim.requestKey || "").trim(),
+        },
         selectedRecord,
         pendingOrdered: pending.ordered,
         bot,
@@ -5064,9 +5770,31 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         },
       });
       if (processed.kind === "skipped") {
+        if (String(requestClaim.requestKey || "").trim()) {
+          markRunnerRequestLifecycle({
+            normalizedRoute,
+            requestKey: requestClaim.requestKey,
+            selectedRecord,
+            routeKey,
+            outcome: "skipped",
+            closedReason: String(processed.skippedRecord?.reason || "skipped").trim() || "skipped",
+          });
+        }
         skippedRecords.push(processed.skippedRecord);
         continue;
       }
+      if (String(requestClaim.requestKey || "").trim()) {
+        markRunnerRequestLifecycle({
+          normalizedRoute,
+          requestKey: requestClaim.requestKey,
+          selectedRecord,
+          routeKey,
+          outcome: String(processed.result?.outcome || "replied").trim().toLowerCase(),
+          conversationIDRaw: String(processed.result?.conversation_id || "").trim(),
+          allowedResponders: ensureArray(processed.result?.conversation_allowed_responders),
+          normalizedIntent: String(safeObject(loadBotRunnerState().routes[routeKey]).last_intent_type || "").trim(),
+        });
+      }
       return {
         logical_signature: runnerRouteLogicalSignature(normalizedRoute),
         archive_source: String(archiveThread.source || "").trim() || "-",
@@ -7297,6 +8025,15 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                   deferredExecution.routeKey,
                   deferredExecution.selectedRecord,
                 );
+                if (String(deferredExecution.requestKey || "").trim()) {
+                  markRunnerRequestLifecycle({
+                    normalizedRoute: deferredExecution.normalizedRoute,
+                    requestKey: deferredExecution.requestKey,
+                    selectedRecord: deferredExecution.selectedRecord,
+                    routeKey: deferredExecution.routeKey,
+                    outcome: "running",
+                  });
+                }
                 const executionPromise = (async () => {
                   try {
                     const processed = await processRunnerSelectedRecord({
@@ -7343,6 +8080,16 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                       },
                     });
                     if (processed.kind === "skipped") {
+                      if (String(deferredExecution.requestKey || "").trim()) {
+                        markRunnerRequestLifecycle({
+                          normalizedRoute: deferredExecution.normalizedRoute,
+                          requestKey: deferredExecution.requestKey,
+                          selectedRecord: deferredExecution.selectedRecord,
+                          routeKey: deferredExecution.routeKey,
+                          outcome: "skipped",
+                          closedReason: String(processed.skippedRecord?.reason || "skipped").trim() || "skipped",
+                        });
+                      }
                       return {
                         route_key: deferredExecution.routeKey,
                         route_name: deferredExecution.normalizedRoute.name,
@@ -7357,6 +8104,18 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                         role_profile: deferredExecution.executionPlan.roleProfileName,
                       };
                     }
+                    if (String(deferredExecution.requestKey || "").trim()) {
+                      markRunnerRequestLifecycle({
+                        normalizedRoute: deferredExecution.normalizedRoute,
+                        requestKey: deferredExecution.requestKey,
+                        selectedRecord: deferredExecution.selectedRecord,
+                        routeKey: deferredExecution.routeKey,
+                        outcome: String(processed.result?.outcome || "replied").trim().toLowerCase(),
+                        conversationIDRaw: String(processed.result?.conversation_id || "").trim(),
+                        allowedResponders: ensureArray(processed.result?.conversation_allowed_responders),
+                        normalizedIntent: String(safeObject(loadBotRunnerState().routes[deferredExecution.routeKey]).last_intent_type || "").trim(),
+                      });
+                    }
                     return {
                       logical_signature: runnerRouteLogicalSignature(deferredExecution.normalizedRoute),
                       archive_source: String(deferredExecution.archiveThread.source || "").trim() || "-",
@@ -7371,6 +8130,16 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                       ...emptyRunnerActiveExecutionPatch(),
                       last_error: errorText,
                     });
+                    if (String(deferredExecution.requestKey || "").trim()) {
+                      markRunnerRequestLifecycle({
+                        normalizedRoute: deferredExecution.normalizedRoute,
+                        requestKey: deferredExecution.requestKey,
+                        selectedRecord: deferredExecution.selectedRecord,
+                        routeKey: deferredExecution.routeKey,
+                        outcome: "error",
+                        closedReason: errorText || "execution_error",
+                      });
+                    }
                     return {
                       route_key: deferredExecution.routeKey,
                       route_name: deferredExecution.normalizedRoute.name,
@@ -11629,6 +12398,7 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     runnerRouteKey,
     runnerRouteLogicalSignature,
     loadBotRunnerState,
+    saveBotRunnerState,
     tryJsonParse,
     safeObject,
     normalizeRunnerTriggerPolicy,
@@ -11637,6 +12407,9 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     selectRunnerPendingWork,
     processRunnerSelectedRecord,
     resolveRunnerStartupLoopAdjudication,
+    claimRunnerRequestForHumanComment,
+    resolveRunnerContinuationRequestForBotReply,
+    cleanupBotRunnerRequestState,
     runRunnerAIExecution,
     buildLocalBotPrompt,
     formatBotReplyArchiveComment,

package/lib/runner-helpers.mjs

@@ -267,6 +267,7 @@ export function buildRunnerRouteStateFromComment(record, patch = {}) {
     last_processed_created_at: firstNonEmptyString([record?.createdAt, record?.updatedAt]),
     last_source_message_id: intFromRawAllowZero(parsed.messageID, 0),
     last_source_kind: String(parsed.kind || "").trim(),
+    active_request_key: "",
     last_intent_type: "",
     last_error: "",
     active_comment_id: "",

package/lib/selftest-runner-scenarios.mjs

@@ -45,6 +45,10 @@ export async function runSelftestRunnerScenarios(push, deps) {
   const runnerRouteKey = requireDependency(deps, "runnerRouteKey");
   const runnerRouteLogicalSignature = requireDependency(deps, "runnerRouteLogicalSignature");
   const loadBotRunnerState = requireDependency(deps, "loadBotRunnerState");
+  const saveBotRunnerState = requireDependency(deps, "saveBotRunnerState");
+  const claimRunnerRequestForHumanComment = requireDependency(deps, "claimRunnerRequestForHumanComment");
+  const resolveRunnerContinuationRequestForBotReply = requireDependency(deps, "resolveRunnerContinuationRequestForBotReply");
+  const cleanupBotRunnerRequestState = requireDependency(deps, "cleanupBotRunnerRequestState");
   const tryJsonParse = requireDependency(deps, "tryJsonParse");
   const safeObject = requireDependency(deps, "safeObject");
   const normalizeRunnerTriggerPolicy = requireDependency(deps, "normalizeRunnerTriggerPolicy");
@@ -1362,6 +1366,137 @@ export async function runSelftestRunnerScenarios(push, deps) {
     }
   }
 
+  const originalRequestLedgerHome = process.env.HOME;
+  const originalRequestLedgerUserProfile = process.env.USERPROFILE;
+  let requestLedgerTempRoot = "";
+  try {
+    requestLedgerTempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-request-ledger-selftest-"));
+    const requestLedgerHome = path.join(requestLedgerTempRoot, "home");
+    fs.mkdirSync(path.join(requestLedgerHome, ".metheus"), { recursive: true });
+    process.env.HOME = requestLedgerHome;
+    process.env.USERPROFILE = requestLedgerHome;
+    saveBotRunnerState({
+      routes: {},
+      sharedInboxes: {},
+      excludedComments: {},
+      requests: {},
+      consumedComments: {},
+    });
+    const requestRoute = normalizeRunnerRoute({
+      name: "telegram-monitor-request-ledger",
+      project_id: selftestProjectID,
+      provider: "telegram",
+      role: "monitor",
+      destination_label: "Main Room",
+    });
+    const requestRouteKey = runnerRouteKey(requestRoute);
+    const humanRecord = {
+      id: "comment-request-human-1",
+      createdAt: "2026-03-22T00:00:00.000Z",
+      updatedAt: "2026-03-22T00:00:00.000Z",
+      parsedArchive: {
+        kind: "telegram_message",
+        chatID: "-100123",
+        chatType: "supergroup",
+        body: "@RyoAI_bot please coordinate this",
+        messageID: 501,
+        senderIsBot: false,
+      },
+    };
+    const claimed = claimRunnerRequestForHumanComment({
+      normalizedRoute: requestRoute,
+      routeKey: requestRouteKey,
+      selectedRecord: humanRecord,
+      selectedBotUsernames: ["ryoai_bot"],
+      normalizedIntent: "coordination_request",
+    });
+    const claimedState = loadBotRunnerState();
+    const claimedRequest = safeObject(safeObject(claimedState.requests)[claimed.requestKey]);
+    const claimedConsumed = safeObject(safeObject(claimedState.consumedComments)[humanRecord.id]);
+    push(
+      "runner_request_claim_persists_request_and_consumed_comment",
+      claimed.ok === true
+        && String(claimedRequest.status || "") === "claimed"
+        && String(claimedRequest.source_message_id || "") === "501"
+        && String(claimedRequest.normalized_intent || "") === "coordination_request"
+        && String(claimedConsumed.request_key || "") === String(claimed.requestKey || ""),
+      `request=${String(claimed.requestKey || "(none)")} status=${String(claimedRequest.status || "(none)")} consumed=${String(claimedConsumed.request_key || "(none)")}`,
+    );
+
+    saveBotRunnerState({
+      ...claimedState,
+      routes: {
+        [requestRouteKey]: {
+          conversation_sessions: {
+            "conv-stale-1": {
+              status: "open",
+              expires_at: "2026-03-20T00:00:00.000Z",
+              conversation_id: "conv-stale-1",
+            },
+          },
+        },
+      },
+    });
+    const botReplyComments = [
+      {
+        id: "comment-stale-bot-reply-1",
+        body: [
+          "[Bot reply]",
+          "chat_id: -100123",
+          "chat_type: supergroup",
+          "message_id: 777",
+          "bot_username: @RyoAI3_bot",
+          "conversation_id: conv-stale-1",
+          "",
+          "@RyoAI3_bot stale follow-up",
+        ].join("\n"),
+      },
+    ];
+    cleanupBotRunnerRequestState({
+      normalizedRoute: requestRoute,
+      comments: botReplyComments,
+    });
+    const cleanedState = loadBotRunnerState();
+    const cleanedSession = safeObject(safeObject(safeObject(cleanedState.routes)[requestRouteKey]).conversation_sessions)["conv-stale-1"];
+    const excludedEntry = safeObject(safeObject(cleanedState.excludedComments)["comment-stale-bot-reply-1"]);
+    const continuation = resolveRunnerContinuationRequestForBotReply({
+      normalizedRoute: requestRoute,
+      routeKey: requestRouteKey,
+      selectedRecord: {
+        id: "comment-stale-bot-reply-1",
+        parsedArchive: parseArchivedChatComment(botReplyComments[0].body),
+      },
+    });
+    push(
+      "runner_stale_open_session_cleanup_excludes_bot_reply_replay",
+      String(cleanedSession.status || "") === "closed"
+        && String(cleanedSession.closed_reason || "") === "expired_session"
+        && String(excludedEntry.reason_code || "") === "expired_session"
+        && continuation.ok === false
+        && String(continuation.reason || "") === "bot_reply_without_active_request",
+      `session=${String(cleanedSession.status || "(none)")} reason=${String(cleanedSession.closed_reason || "(none)")} excluded=${String(excludedEntry.reason_code || "(none)")} continuation=${String(continuation.reason || "(none)")}`,
+    );
+  } catch (err) {
+    push("runner_request_claim_persists_request_and_consumed_comment", false, String(err?.message || err));
+    push("runner_stale_open_session_cleanup_excludes_bot_reply_replay", false, String(err?.message || err));
+  } finally {
+    if (typeof originalRequestLedgerHome === "string") {
+      process.env.HOME = originalRequestLedgerHome;
+    } else {
+      delete process.env.HOME;
+    }
+    if (typeof originalRequestLedgerUserProfile === "string") {
+      process.env.USERPROFILE = originalRequestLedgerUserProfile;
+    } else {
+      delete process.env.USERPROFILE;
+    }
+    if (requestLedgerTempRoot) {
+      try {
+        fs.rmSync(requestLedgerTempRoot, { recursive: true, force: true });
+      } catch {}
+    }
+  }
+
   const defaultMonitorTriggerPolicy = normalizeRunnerTriggerPolicy({}, { role: "monitor" });
   push(
     "bot_runner_default_monitor_trigger_policy",

package/package.json

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