metheus-governance-mcp-cli 0.2.262 → 0.2.263

package/cli.mjs

@@ -13302,21 +13302,27 @@ async function maybeDeliverRunnerExecutionFailureAfterRecord({
 
 async function finalizeRunnerDeferredExecutionProcessed(deferredExecution, processed) {
   if (String(deferredExecution?.requestKey || "").trim()) {
-    const resolvedIntentType = String(
-      safeObject(loadBotRunnerState().routes[deferredExecution.routeKey]).last_intent_type || "",
-    ).trim();
-    markRunnerRequestLifecycle({
-      normalizedRoute: deferredExecution.normalizedRoute,
-      requestKey: deferredExecution.requestKey,
-      selectedRecord: deferredExecution.selectedRecord,
-      routeKey: deferredExecution.routeKey,
-      outcome: processed.kind === "delivery_failed"
-        ? "delivery_failed_after_generation"
-        : String(processed.result?.outcome || "replied").trim().toLowerCase(),
-      conversationIDRaw: String(processed.result?.conversation_id || "").trim(),
-      conversationParticipants: ensureArray(processed.result?.conversation_participants),
-      conversationInitialResponders: ensureArray(processed.result?.conversation_initial_responders),
-      allowedResponders: ensureArray(processed.result?.conversation_allowed_responders),
+    const resolvedIntentType = String(
+      safeObject(loadBotRunnerState().routes[deferredExecution.routeKey]).last_intent_type || "",
+    ).trim();
+    const normalizedDeferredOutcome = processed.kind === "delivery_failed"
+      ? "delivery_failed_after_generation"
+      : processed.kind === "skipped"
+        ? "skipped"
+        : String(processed.result?.outcome || "replied").trim().toLowerCase();
+    markRunnerRequestLifecycle({
+      normalizedRoute: deferredExecution.normalizedRoute,
+      requestKey: deferredExecution.requestKey,
+      selectedRecord: deferredExecution.selectedRecord,
+      routeKey: deferredExecution.routeKey,
+      outcome: normalizedDeferredOutcome,
+      closedReason: processed.kind === "skipped"
+        ? String(processed.skippedRecord?.reason || processed.result?.detail || "skipped").trim()
+        : "",
+      conversationIDRaw: String(processed.result?.conversation_id || "").trim(),
+      conversationParticipants: ensureArray(processed.result?.conversation_participants),
+      conversationInitialResponders: ensureArray(processed.result?.conversation_initial_responders),
+      allowedResponders: ensureArray(processed.result?.conversation_allowed_responders),
       conversationLeadBot: String(processed.result?.conversation_lead_bot || "").trim(),
       conversationSummaryBot: String(processed.result?.conversation_summary_bot || "").trim(),
       conversationAllowBotToBot: processed.result?.conversation_allow_bot_to_bot === true,
@@ -13349,17 +13355,17 @@ async function finalizeRunnerDeferredExecutionProcessed(deferredExecution, proce
       lastReplyMessageID: intFromRawAllowZero(processed.result?.last_reply_message_id, 0),
       lastReplyMessageThreadID: intFromRawAllowZero(processed.result?.last_reply_message_thread_id, 0),
       replyToMessageID: intFromRawAllowZero(processed.result?.reply_to_message_id, 0),
-      replyFallbackUsed: processed.result?.reply_fallback_used === true,
-      authoritativeSourceMessageEnvelope: safeObject(
-        safeObject(deferredExecution.humanInboundVisibility).sourceMessageEnvelope,
-      ),
-    });
-    if (processed.kind !== "delivery_failed") {
-      await ensureRunnerRootWorkItemForRequest({
-        normalizedRoute: deferredExecution.normalizedRoute,
-        routeKey: deferredExecution.routeKey,
-        selectedRecord: deferredExecution.selectedRecord,
-        runtime: deferredExecution.runtime,
+      replyFallbackUsed: processed.result?.reply_fallback_used === true,
+      authoritativeSourceMessageEnvelope: safeObject(
+        safeObject(deferredExecution.humanInboundVisibility).sourceMessageEnvelope,
+      ),
+    });
+    if (processed.kind !== "delivery_failed" && processed.kind !== "skipped") {
+      await ensureRunnerRootWorkItemForRequest({
+        normalizedRoute: deferredExecution.normalizedRoute,
+        routeKey: deferredExecution.routeKey,
+        selectedRecord: deferredExecution.selectedRecord,
+        runtime: deferredExecution.runtime,
         requestKey: deferredExecution.requestKey,
       });
     }

package/lib/runner-delivery.mjs

@@ -187,6 +187,17 @@ function assertLocalTelegramReplyAnchor({
   }
 }
 
+function buildLocalDeliveryError(message, code, extra = {}) {
+  const error = new Error(message);
+  error.code = String(code || "").trim();
+  Object.assign(error, safeObject(extra));
+  return error;
+}
+
+function isTelegramReplyTargetMissingError(detail) {
+  return /message to be replied not found/i.test(String(detail || ""));
+}
+
 function throwLocalDeliveryFailure({
   provider,
   delivery,
@@ -198,6 +209,17 @@ function throwLocalDeliveryFailure({
   const errorDetail =
     String(responseJSON.description || responseJSON.error || JSON.stringify(delivery.body || "")).trim()
     || `${normalizedProvider} api status ${delivery.statusCode}`;
+  if (normalizedProvider === "telegram" && isTelegramReplyTargetMissingError(errorDetail)) {
+    throw buildLocalDeliveryError(
+      `local ${normalizedProvider} delivery skipped stale reply anchor (${errorDetail})`,
+      "TELEGRAM_STALE_REPLY_ANCHOR",
+      {
+        staleReplyAnchor: true,
+        provider: normalizedProvider,
+        detail: errorDetail,
+      },
+    );
+  }
   if (delivery.statusCode === 401 || /unauthorized|invalid_auth/i.test(errorDetail)) {
     throw new Error(
       `local ${normalizedProvider} delivery failed (Unauthorized). Check ${String(providerEnv.tokenKey || providerEnvConfig(normalizedProvider).tokenKey)} in ${providerEnv.filePath}`,

package/lib/runner-orchestration.mjs

@@ -7362,6 +7362,91 @@ export async function processRunnerSelectedRecord({
     });
   } catch (err) {
     const transportError = String(err?.message || err).trim() || "delivery_failed";
+    const staleReplyAnchor = err?.staleReplyAnchor === true
+      || String(err?.code || "").trim() === "TELEGRAM_STALE_REPLY_ANCHOR";
+    if (staleReplyAnchor) {
+      saveRunnerRouteState(
+        routeKey,
+        buildRunnerRouteStateFromComment(selectedRecord, {
+          last_action: "stale_reply_anchor_skipped",
+          last_reason: transportError,
+          last_trigger: String(effectiveTriggerDecision.trigger || "").trim(),
+          last_conversation_id: String(effectiveConversationContext?.id || "").trim(),
+          last_conversation_stage: String(effectiveConversationContext?.stage || "").trim(),
+          last_contract_validation_status: String(responseContractValidation.status || "").trim(),
+          last_contract_validation_reason: String(responseContractValidation.reason || "").trim(),
+          last_contract_validation_targets: ensureArray(responseContractValidation.targets),
+          last_assignment_validation_status: String(assignmentExecutionValidation.status || "").trim(),
+          last_assignment_validation_reason: String(assignmentExecutionValidation.reason || "").trim(),
+          last_speaker_bot_username: normalizeMentionSelector(bot?.username || bot?.name),
+          last_workspace_dir: String(effectiveExecutionPlan.workspaceDir || "").trim(),
+          ...responderStatePatch,
+          ...intentStatePatch,
+          ...visibilityStatePatch,
+        }),
+      );
+      return {
+        kind: "skipped",
+        skippedRecord: {
+          id: selectedRecord.id,
+          reason: "stale_reply_anchor",
+          messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
+          diagnosticType: "delivery",
+        },
+        result: {
+          route_key: routeKey,
+          route_name: normalizedRoute.name,
+          outcome: "skipped",
+          detail: `skipped stale reply anchor (${transportError})`,
+          thread_id: archiveThread.threadID,
+          comment_id: selectedRecord.id,
+          trigger_kind: String(effectiveTriggerDecision.trigger || "").trim(),
+          conversation_id: String(effectiveConversationContext?.id || "").trim(),
+          conversation_stage: String(effectiveConversationContext?.stage || "").trim(),
+          conversation_intent_mode: String(effectiveConversationContext?.intentMode || "").trim(),
+          conversation_lead_bot: String(effectiveConversationContext?.leadBotUsername || "").trim(),
+          conversation_summary_bot: String(effectiveConversationContext?.summaryBotUsername || "").trim(),
+          conversation_participants: ensureArray(effectiveConversationContext?.participantSelectors),
+          conversation_initial_responders: ensureArray(effectiveConversationContext?.initialResponderSelectors),
+          conversation_allowed_responders: ensureArray(effectiveConversationContext?.allowedResponderSelectors),
+          conversation_allow_bot_to_bot: effectiveConversationContext?.allowBotToBot === true,
+          conversation_reply_expectation: String(effectiveConversationContext?.replyExpectation || "").trim(),
+          execution_contract_type: String(executionContract?.type || "").trim(),
+          execution_contract_actionable: executionContract?.actionable === true,
+          execution_contract_targets: ensureArray(executionContract?.assignments).map((item) => normalizeMentionSelector(item.targetBot)).filter(Boolean),
+          next_expected_responders: collectExecutionContractNextResponders(executionContract),
+          normalized_execution_contract_type: normalizedExecutionContractType,
+          normalized_execution_contract_targets: normalizedExecutionTargets,
+          normalized_execution_next_responders: normalizedExecutionNextResponders,
+          artifact_validation: String(artifactValidation.status || "").trim() || "none",
+          artifact_paths: summarizeValidatedArtifactPaths(artifactValidation),
+          ai_reply_generated: true,
+          ai_reply_generated_at: aiReplyGeneratedAt,
+          ai_reply_preview: aiReplyPreview,
+          source_message_envelope: sourceMessageEnvelope,
+          attempted_delivery_envelope: attemptedDeliveryEnvelope,
+          visibility_status: String(humanInboundVisibility.visibilityStatus || "").trim(),
+          visibility_reason: String(humanInboundVisibility.visibilityReason || "").trim(),
+          visibility_source: String(humanInboundVisibility.visibilitySource || "").trim(),
+          reply_to_message_id: replyToMessageID,
+          reply_message_thread_id: replyMessageThreadID,
+          delivery_status: "skipped_stale_reply_anchor",
+          archive_status: "not_attempted",
+          transport_error: transportError,
+          archive_error: "",
+          response_contract_validation_status: String(responseContractValidation.status || "").trim(),
+          response_contract_validation_reason: String(responseContractValidation.reason || "").trim(),
+          response_contract_validation_targets: ensureArray(responseContractValidation.targets),
+          assignment_validation_status: String(assignmentExecutionValidation.status || "").trim(),
+          assignment_validation_reason: String(assignmentExecutionValidation.reason || "").trim(),
+          assignment_validation_modes: ensureArray(assignmentExecutionValidation.assignmentModes),
+          reply_chars: String(sanitizedReplyText || "").length,
+          execution_mode: effectiveExecutionPlan.mode,
+          role_profile: effectiveExecutionPlan.roleProfileName,
+          executed_role_plan: executedRolePlan && Object.keys(executedRolePlan).length > 0 ? executedRolePlan : undefined,
+        },
+      };
+    }
     saveRunnerRouteState(
       routeKey,
       buildRunnerRouteStateFromComment(selectedRecord, {

package/lib/selftest-runner-scenarios.mjs

@@ -13246,14 +13246,139 @@ export async function runSelftestRunnerScenarios(push, deps) {
         && /ECONNRESET/i.test(String(processed.result?.transport_error || "")),
       `kind=${String(processed.kind || "(none)")} outcome=${String(processed.result?.outcome || "(none)")} ai_generated=${String(processed.result?.ai_reply_generated || false)} delivery=${String(processed.result?.delivery_status || "(none)")} transport=${String(processed.result?.transport_error || "(none)")}`,
     );
-  } catch (err) {
-    push("runner_delivery_failure_after_generation_records_ai_state_without_execution_error", false, String(err?.message || err));
-  }
-
+  } catch (err) {
+    push("runner_delivery_failure_after_generation_records_ai_state_without_execution_error", false, String(err?.message || err));
+  }
+
+  try {
+    const processed = await processRunnerSelectedRecord({
+      routeKey: "delivery-stale-reply-anchor-key",
+      normalizedRoute: normalizeRunnerRoute({
+        name: "telegram-monitor-delivery-stale-reply-anchor",
+        project_id: selftestProjectID,
+        provider: "telegram",
+        role: "monitor",
+        role_profile: "monitor",
+        destination_id: "dest-1",
+        destination_label: "Main Room",
+        server_bot_name: "RyoAI_bot",
+        server_bot_id: "bot-1",
+        trigger_policy: {
+          mentions_only: true,
+          direct_messages: true,
+          reply_to_bot_messages: true,
+        },
+        archive_policy: {
+          mirror_replies: true,
+          dedupe_inbound: true,
+          dedupe_outbound: true,
+          skip_bot_messages: true,
+        },
+        dry_run_delivery: false,
+      }),
+      selectedRecord: {
+        id: "comment-delivery-stale-reply-anchor",
+        createdAt: "2026-03-17T00:00:22.000Z",
+        parsedArchive: {
+          kind: "telegram_message",
+          chatID: "-100123",
+          chatType: "supergroup",
+          body: "@RyoAI_bot hi",
+          messageID: 127,
+          sender: "human",
+          senderIsBot: false,
+          mentionUsernames: ["ryoai_bot"],
+        },
+      },
+      pendingOrdered: [],
+      bot: {
+        id: "bot-1",
+        name: "RyoAI_bot",
+        username: "RyoAI_bot",
+        role: "monitor",
+        provider: "telegram",
+      },
+      destination: {
+        id: "dest-1",
+        label: "Main Room",
+        provider: "telegram",
+        chatID: "-100123",
+      },
+      archiveThread: {
+        threadID: "thread-1",
+        workItemID: "work-item-1",
+      },
+      executionPlan: {
+        mode: "role_profile",
+        roleProfileName: "monitor",
+        roleProfile: {
+          client: "sample",
+          model: "",
+          permissionMode: "read_only",
+          reasoningEffort: "low",
+        },
+        workspaceDir: "",
+        workspaceSource: "selftest",
+        usedCommandFallback: false,
+      },
+      runtime: {
+        baseURL: "https://example.test",
+        token: "selftest-token",
+        timeoutSeconds: 30,
+        actor: { user_id: "user-1" },
+      },
+      deps: {
+        saveRunnerRouteState: () => {},
+        startRunnerTypingHeartbeat: () => ({ async stop() {} }),
+        runRunnerAIExecution: async () => ({
+          skip: false,
+          reply: "Hello from RyoAI_bot.",
+        }),
+        performLocalBotDelivery: async () => {
+          const err = new Error("local telegram delivery skipped stale reply anchor (Bad Request: message to be replied not found)");
+          err.code = "TELEGRAM_STALE_REPLY_ANCHOR";
+          err.staleReplyAnchor = true;
+          throw err;
+        },
+        serializeRunnerTriggerPolicy: (value) => value,
+        serializeRunnerArchivePolicy: (value) => value,
+        buildRunnerExecutionDeps: () => ({
+          validateWorkspaceArtifacts,
+          analyzeHumanConversationIntentWithAI: async () => ({
+            mode: "single_bot",
+            lead_bot: "ryoai_bot",
+            participants: ["ryoai_bot"],
+            initial_responders: ["ryoai_bot"],
+            allowed_responders: ["ryoai_bot"],
+            summary_bot: "",
+            allow_bot_to_bot: false,
+            reply_expectation: "informational",
+            intent_type: "small_talk",
+          }),
+        }),
+        buildRunnerDeliveryDeps: () => ({}),
+        buildRunnerRuntimeDeps: () => ({}),
+        resolveConversationPeerBots: () => [],
+      },
+    });
+    push(
+      "runner_stale_reply_anchor_skips_generated_reply_without_delivery_failure",
+      processed.kind === "skipped"
+        && String(processed.skippedRecord?.reason || "") === "stale_reply_anchor"
+        && String(processed.result?.outcome || "") === "skipped"
+        && processed.result?.ai_reply_generated === true
+        && String(processed.result?.delivery_status || "") === "skipped_stale_reply_anchor"
+        && /message to be replied not found/i.test(String(processed.result?.transport_error || "")),
+      `kind=${String(processed.kind || "(none)")} reason=${String(processed.skippedRecord?.reason || "(none)")} outcome=${String(processed.result?.outcome || "(none)")} delivery=${String(processed.result?.delivery_status || "(none)")} transport=${String(processed.result?.transport_error || "(none)")}`,
+    );
+  } catch (err) {
+    push("runner_stale_reply_anchor_skips_generated_reply_without_delivery_failure", false, String(err?.message || err));
+  }
+
   try {
     let capturedReplyToMessageID = 0;
     let capturedMessageThreadID = 0;
-    let capturedSourceMessageEnvelope = {};
+    let capturedSourceMessageEnvelope = {};
     const processed = await processRunnerSelectedRecord({
       routeKey: "delivery-prefers-route-local-inbound-envelope-key",
       normalizedRoute: normalizeRunnerRoute({

package/lib/selftest-telegram-e2e.mjs

@@ -17,6 +17,10 @@ function safeObject(value) {
   return value;
 }
 
+function ensureArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
 function buildTelegramMentionEntities(text) {
   const entities = [];
   const source = String(text || "");
@@ -58,7 +62,8 @@ async function startLocalTelegramRunnerSelftestServer({
     // on Windows CI shells.
     sendMessageTransientFailuresRemaining: 0,
     sendChatActionTransientFailuresRemaining: 0,
-    updates: [
+    missingReplyTargetMessageIDs: [],
+    updates: [
       {
         update_id: 11,
         message: {
@@ -294,13 +299,24 @@ async function startLocalTelegramRunnerSelftestServer({
             state.sendMessageTransientFailuresRemaining -= 1;
             req.socket.destroy(new Error("socket hang up"));
             return;
-          }
-          const payload = await readJSONBody(req);
-          const messageID = state.nextTelegramMessageID++;
-          state.sentMessages.push({
-            ...payload,
-            message_id: messageID,
-          });
+          }
+          const payload = await readJSONBody(req);
+          const replyToMessageID = intFromRawAllowZero(payload.reply_to_message_id, 0);
+          if (
+            replyToMessageID > 0
+            && ensureArray(state.missingReplyTargetMessageIDs).includes(replyToMessageID)
+          ) {
+            writeJSON(res, 400, {
+              ok: false,
+              description: "Bad Request: message to be replied not found",
+            });
+            return;
+          }
+          const messageID = state.nextTelegramMessageID++;
+          state.sentMessages.push({
+            ...payload,
+            message_id: messageID,
+          });
           writeJSON(res, 200, {
             ok: true,
             result: {
@@ -581,6 +597,45 @@ export async function runSelftestTelegramE2E(push, deps) {
       `error=${unsafeAnchorError || "(none)"} sent=${telegramE2EServer.state.sentMessages.length}`,
     );
 
+    telegramE2EServer.state.missingReplyTargetMessageIDs = [999];
+    const sentCountBeforeStaleAnchor = telegramE2EServer.state.sentMessages.length;
+    let staleAnchorError = "";
+    try {
+      await performLocalBotDelivery({
+        siteBaseURL: telegramE2EServer.baseURL,
+        token: e2eToken,
+        timeoutSeconds: 10,
+        actorUserID: e2eActorUserID,
+        bot: e2eBot,
+        projectID: selftestProjectID,
+        provider: "telegram",
+        destinationSelectors: {
+          destinationLabel: e2eDestination.label,
+        },
+        text: "stale reply anchor",
+        replyToMessageID: 999,
+        sourceMessageEnvelope: {
+          chat_id: e2eDestination.chat_id,
+          message_id: 999,
+          source_origin: "local_telegram_inbound",
+        },
+        archiveReplies: false,
+        dryRun: false,
+        deps: buildRunnerDeliveryDeps(),
+      });
+    } catch (err) {
+      staleAnchorError = String(err?.message || err);
+    } finally {
+      telegramE2EServer.state.missingReplyTargetMessageIDs = [];
+    }
+    push(
+      "telegram_delivery_classifies_missing_reply_target_as_stale_anchor",
+      /stale reply anchor/i.test(staleAnchorError)
+        && /message to be replied not found/i.test(staleAnchorError)
+        && telegramE2EServer.state.sentMessages.length === sentCountBeforeStaleAnchor,
+      `error=${staleAnchorError || "(none)"} sent=${telegramE2EServer.state.sentMessages.length}`,
+    );
+
     const sentCountBeforeDirectDelivery = telegramE2EServer.state.sentMessages.length;
     const commentCountBeforeDirectDelivery = telegramE2EServer.state.comments.length;
     const requestCountBeforeDirectDelivery = telegramE2EServer.state.runnerRequests.length;

package/package.json

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