metheus-governance-mcp-cli 0.2.283 → 0.2.285

package/cli.mjs

@@ -145,10 +145,10 @@ import {
   findEarlierProcessableArchiveDuplicate,
   findRecentTelegramMessageEnvelope,
   isTelegramLocalInboundEnvelopeForRoute,
-  isInboundArchiveKind,
-  normalizeTelegramMessageEnvelope as normalizeRunnerTelegramMessageEnvelope,
-  normalizeArchiveCommentRecord,
-  selectPendingArchiveComments,
+  isInboundArchiveKind,
+  normalizeTelegramMessageEnvelope as normalizeRunnerTelegramMessageEnvelope,
+  normalizeArchiveCommentRecord,
+  selectPendingArchiveComments,
   printRunnerResult,
 } from "./lib/runner-helpers.mjs";
 import {
@@ -2812,25 +2812,23 @@ function buildRunnerReplyChainSpeakerType(parsedArchiveRaw) {
   return "human";
 }
 
-function buildRunnerReplyChainSpeakerLabel(parsedArchiveRaw) {
-  const parsedArchive = safeObject(parsedArchiveRaw);
-  const username = normalizeTelegramMentionUsername(
-    parsedArchive.botUsername
-    || parsedArchive.username
-    || parsedArchive.replyToUsername
-    || parsedArchive.conversationTargetBotUsername,
-  );
-  if (username) {
-    return `@${username}`;
-  }
-  return firstNonEmptyString([
-    parsedArchive.sender,
-    parsedArchive.botName,
-    parsedArchive.replyToSender,
-    parsedArchive.chatTitle,
-    buildRunnerReplyChainSpeakerType(parsedArchive) === "bot" ? "bot" : "human",
-  ]);
-}
+function buildRunnerReplyChainSpeakerLabel(parsedArchiveRaw) {
+  const parsedArchive = safeObject(parsedArchiveRaw);
+  const username = normalizeTelegramMentionUsername(
+    parsedArchive.botUsername
+    || parsedArchive.username
+    || parsedArchive.conversationTargetBotUsername,
+  );
+  if (username) {
+    return `@${username}`;
+  }
+  return firstNonEmptyString([
+    parsedArchive.sender,
+    parsedArchive.botName,
+    parsedArchive.chatTitle,
+    buildRunnerReplyChainSpeakerType(parsedArchive) === "bot" ? "bot" : "human",
+  ]);
+}
 
 function normalizeRunnerReplyChainSnapshot(rawSnapshot) {
   const snapshot = safeObject(rawSnapshot);
@@ -4015,17 +4013,18 @@ function runnerRequestPreferredAuthoritySelectedBotUsernames(entryRaw) {
   );
 }
 
-function extractRunnerExplicitSelectedBotUsernamesFromParsed(parsedArchiveRaw) {
-  const parsedArchive = safeObject(parsedArchiveRaw);
-  return uniqueOrderedStrings(
-    ensureArray(parsedArchive.mentionUsernames).length
-      ? parsedArchive.mentionUsernames
-      : String(parsedArchive.replyToUsername || "").trim()
-        ? [parsedArchive.replyToUsername]
-        : [],
-    normalizeTelegramMentionUsername,
-  );
-}
+function extractRunnerExplicitSelectedBotUsernamesFromParsed(parsedArchiveRaw) {
+  const parsedArchive = safeObject(parsedArchiveRaw);
+  return uniqueOrderedStrings(
+    ensureArray(parsedArchive.mentionUsernames).length
+      ? parsedArchive.mentionUsernames
+      : parsedArchive.replyToSenderIsBot === true
+        && String(parsedArchive.replyToUsername || "").trim()
+        ? [parsedArchive.replyToUsername]
+        : [],
+    normalizeTelegramMentionUsername,
+  );
+}
 
 function runnerRequestPreferredAIReplyPreview(entryRaw) {
   const entry = safeObject(entryRaw);
@@ -6430,10 +6429,7 @@ function markRunnerRequestLifecycle({
   const authoritativeDecisionBundle = resolvedDecisionBundleValidation.ok === true
     ? safeObject(resolvedDecisionBundleValidation.bundle)
     : runnerRequestAuthoritativeDecisionBundle(existing);
-  const effectiveReplyToMessageID = intFromRawAllowZero(
-    replyToMessageID,
-    intFromRawAllowZero(existing.last_reply_to_message_id, 0),
-  );
+  const effectiveReplyToMessageID = intFromRawAllowZero(replyToMessageID, 0);
   const lastReplyMessageEnvelope = buildTelegramBotReplyEnvelope({
     sourceEnvelope: sourceMessageEnvelope,
     chatID: existing.chat_id,
@@ -6454,14 +6450,14 @@ function markRunnerRequestLifecycle({
     senderUsername: normalizedCurrentBotSelector,
     body: aiReplyPreview,
   });
-  const shouldRefreshAttemptedDeliveryEnvelope = (
-    aiReplyGenerated === true
-    || String(aiReplyPreview || "").trim().length > 0
-    || String(deliveryStatus || "").trim().length > 0
-    || String(transportError || "").trim().length > 0
-    || intFromRawAllowZero(replyToMessageID, 0) > 0
-    || intFromRawAllowZero(lastReplyMessageThreadID, 0) > 0
-  );
+  const shouldRefreshAttemptedDeliveryEnvelope = (
+    aiReplyGenerated === true
+    || String(aiReplyPreview || "").trim().length > 0
+    || String(deliveryStatus || "").trim().length > 0
+    || String(transportError || "").trim().length > 0
+    || intFromRawAllowZero(replyToMessageID, 0) > 0
+    || intFromRawAllowZero(lastReplyMessageThreadID, 0) > 0
+  );
   const rootEffectiveExecutionContractTargets = uniqueOrderedStrings(
     [
       ...ensureArray(authoritativeDecisionBundle.execution_contract_targets),
@@ -6504,6 +6500,13 @@ function markRunnerRequestLifecycle({
   const normalizedOutcome = String(outcome || "").trim().toLowerCase();
   const normalizedFailureReplyClassification = String(failureReplyClassification || "").trim().toLowerCase();
   const normalizedFailureFacts = safeObject(failureFacts);
+  const shouldPersistReplyAnchor = (
+    aiReplyGenerated === true
+    || intFromRawAllowZero(lastReplyMessageID, 0) > 0
+    || ["delivered", "dry_run", "archive_error", "failed_transport"].includes(normalizedDeliveryStatus)
+    || String(transportError || "").trim().length > 0
+    || ["replied", "delivery_failed_after_generation"].includes(normalizedOutcome)
+  );
   const shouldRemainRunningAfterReply = authoritativeDecisionBundle.should_close_after_reply === true
     ? false
     : authoritativeDecisionBundle.should_close_after_reply === false
@@ -6907,7 +6910,9 @@ function markRunnerRequestLifecycle({
     last_source_message_thread_id: intFromRawAllowZero(parsed.messageThreadID, 0) || existing.last_source_message_thread_id,
     last_reply_message_id: intFromRawAllowZero(lastReplyMessageID, 0) || existing.last_reply_message_id,
     last_reply_message_thread_id: intFromRawAllowZero(lastReplyMessageThreadID, 0) || existing.last_reply_message_thread_id,
-    last_reply_to_message_id: intFromRawAllowZero(replyToMessageID, 0) || existing.last_reply_to_message_id,
+    last_reply_to_message_id: shouldPersistReplyAnchor
+      ? effectiveReplyToMessageID
+      : existing.last_reply_to_message_id,
     last_reply_message_envelope: persistSuccessfulReplyEnvelope
       ? lastReplyMessageEnvelope
       : safeObject(existing.last_reply_message_envelope),
@@ -18679,13 +18684,14 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
         workspaceDir: "",
         workspaceSignalTrusted: true,
       },
-      {
-        ...buildLocalProjectDispatchDeps(),
-        extractActorFromToken: () => ({ user_id: "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb" }),
-        createProjectContextItem: async (input) => {
-          capturedCreateArgs = input;
-          return {
-            id: "99999999-8888-4777-8666-555555555555",
+      {
+        ...buildLocalProjectDispatchDeps(),
+        extractActorFromToken: () => ({ user_id: "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb" }),
+        listProjectContextItems: async () => ([]),
+        createProjectContextItem: async (input) => {
+          capturedCreateArgs = input;
+          return {
+            id: "99999999-8888-4777-8666-555555555555",
             project_id: input.projectID,
             title: input.title,
             body: input.body,
@@ -18709,11 +18715,81 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
         && String(safeObject(capturedCreateArgs).category || "").trim() === "bot_role",
       `status=${String(safeObject(suggestStructured.item).status || "").trim() || "(none)"} category=${String(safeObject(capturedCreateArgs).category || "").trim() || "(none)"}`,
     );
-  } catch (err) {
-    push("local_project_context_suggest_tool_dispatches", false, String(err?.message || err));
-  }
-
-  const previousRunnerBotID = process.env.METHEUS_RUNNER_BOT_ID;
+  } catch (err) {
+    push("local_project_context_suggest_tool_dispatches", false, String(err?.message || err));
+  }
+
+  try {
+    let duplicateCreateCalls = 0;
+    const duplicateSuggestResponse = await handleLocalProjectToolDispatchImpl(
+      {
+        requestObj: {
+          jsonrpc: "2.0",
+          id: 5,
+          method: "tools/call",
+          params: {
+            name: "project.context.suggest",
+            arguments: {
+              project_id: selftestProjectID,
+              title: "Bot role split",
+              body: "RyoAI2_bot handles deep review when explicitly asked.",
+              category: "bot_role",
+              importance: "high",
+            },
+          },
+        },
+        toolName: "project.context.suggest",
+        toolArgs: {
+          project_id: selftestProjectID,
+          title: "Bot role split",
+          body: "RyoAI2_bot handles deep review when explicitly asked.",
+          category: "bot_role",
+          importance: "high",
+        },
+        args: {
+          baseURL: DEFAULT_SITE_URL,
+          timeoutSeconds: 30,
+        },
+        token: "selftest-token",
+        workspaceDir: "",
+        workspaceSignalTrusted: true,
+      },
+      {
+        ...buildLocalProjectDispatchDeps(),
+        extractActorFromToken: () => ({ user_id: "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb" }),
+        listProjectContextItems: async () => ([
+          {
+            id: "ctx-duplicate-suggested",
+            project_id: selftestProjectID,
+            title: "Bot role split",
+            body: "RyoAI2_bot handles deep review when explicitly asked.",
+            category: "bot_role",
+            importance: "high",
+            status: "suggested",
+          },
+        ]),
+        createProjectContextItem: async () => {
+          duplicateCreateCalls += 1;
+          return {};
+        },
+      },
+    );
+    const duplicateSuggestStructured = safeObject(safeObject(duplicateSuggestResponse).result)?.structuredContent || {};
+    push(
+      "local_project_context_suggest_tool_skips_exact_duplicate",
+      duplicateSuggestStructured.ok === true
+        && duplicateSuggestStructured.created === false
+        && duplicateSuggestStructured.duplicate === true
+        && String(duplicateSuggestStructured.reason || "").trim() === "duplicate_suggested"
+        && duplicateCreateCalls === 0
+        && String(safeObject(duplicateSuggestStructured.item).id || "").trim() === "ctx-duplicate-suggested",
+      `created=${String(duplicateSuggestStructured.created)} duplicate=${String(duplicateSuggestStructured.duplicate)} reason=${String(duplicateSuggestStructured.reason || "").trim() || "(none)"} create_calls=${duplicateCreateCalls}`,
+    );
+  } catch (err) {
+    push("local_project_context_suggest_tool_skips_exact_duplicate", false, String(err?.message || err));
+  }
+
+  const previousRunnerBotID = process.env.METHEUS_RUNNER_BOT_ID;
   const previousRunnerBotName = process.env.METHEUS_RUNNER_BOT_NAME;
   try {
     process.env.METHEUS_RUNNER_BOT_ID = "bot-selftest-123";

package/lib/local-ai-adapters.mjs

@@ -1772,11 +1772,12 @@ function importanceRankForProjectContext(value) {
 
 function formatProjectContextLine(item) {
   const contextItem = safeObject(item);
+  const status = String(contextItem.status || "active").trim() || "active";
   const category = String(contextItem.category || "general").trim() || "general";
   const importance = String(contextItem.importance || "normal").trim() || "normal";
   const title = truncatePromptLineText(contextItem.title || "-", 100) || "-";
   const body = truncatePromptLineText(contextItem.body || "(empty)", 240) || "(empty)";
-  return `- [${category}/${importance}] ${title} | ${body}`;
+  return `- [${status}/${category}/${importance}] ${title} | ${body}`;
 }
 
 function inferCurrentTurnPurpose({ trigger, conversation, selfBotUsername, otherMentionedBots }) {
@@ -1815,8 +1816,15 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
   const context = Array.isArray(safePayload.context_comments) ? safePayload.context_comments : [];
   const projectContextItems = ensureArray(safePayload.project_context_items)
     .map((item) => safeObject(item))
-    .filter((item) => String(item.status || "active").trim().toLowerCase() === "active")
+    .filter((item) => ["active", "suggested"].includes(String(item.status || "active").trim().toLowerCase()))
     .sort((left, right) => {
+      const leftStatus = String(left.status || "active").trim().toLowerCase();
+      const rightStatus = String(right.status || "active").trim().toLowerCase();
+      const leftStatusRank = leftStatus === "active" ? 0 : 1;
+      const rightStatusRank = rightStatus === "active" ? 0 : 1;
+      if (leftStatusRank !== rightStatusRank) {
+        return leftStatusRank - rightStatusRank;
+      }
       const importanceDelta = importanceRankForProjectContext(right.importance) - importanceRankForProjectContext(left.importance);
       if (importanceDelta !== 0) return importanceDelta;
       const leftUpdated = Date.parse(firstNonEmptyString([left.updated_at, left.updatedAt, left.created_at, left.createdAt]));
@@ -1994,11 +2002,13 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
     `- Workspace: ${workspaceDir || "-"}`,
     `- Destination: ${destinationLabel || "-"} (${firstNonEmptyString([safePayload.destination?.chat_id, safePayload.destination?.chatID, process.env.METHEUS_RUNNER_CHAT_ID]) || "-"})`,
     "",
-    "Active project context (stable facts and operating rules):",
+    "Existing project context memory (active and suggested):",
     projectContextItems.length
       ? projectContextItems.map(formatProjectContextLine).join("\n")
       : "- none",
-    "Prefer these active project context items over stale room chatter when they conflict.",
+    "Active items are authoritative shared memory.",
+    "Suggested items are pending shared-memory candidates and must not be duplicated if they already capture the same durable fact, rule, focus, or risk.",
+    "Prefer active items over stale room chatter when they conflict.",
     "",
     "Recent human messages (prioritized context):",
     recentHumanMessages.length ? recentHumanMessages.map(formatContextCommentLine).join("\n") : "- none",
@@ -2164,6 +2174,7 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
     "- Only include context_suggestion when the human explicitly establishes a durable shared project rule, bot role assignment, project fact, current focus, or risk that should be remembered beyond this chat.",
     "- Never include context_suggestion for greetings, questions, status checks, file-location questions, workspace paths, or temporary/personal requests.",
     "- Do not use category \"workspace\" for chat-room context memory. Workspace paths must be answered from tools, not stored as shared chat context.",
+    "- If an existing active or suggested project context item already captures the same durable meaning, do not emit a new context_suggestion with should_store=true.",
     "- When you include context_suggestion, set should_store=true and keep title/body concise and durable.",
     "",
     isInternalExecutionStep

package/lib/local-project-dispatch.mjs

@@ -1,5 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
+import {
+  findExactProjectContextDuplicate,
+} from "./project-context-dedupe.mjs";
 
 function requireDependency(deps, key) {
   const candidate = deps?.[key];
@@ -112,6 +115,22 @@ function buildProjectContextListText(projectID, items, statusFilter = "") {
   return lines.join("\n");
 }
 
+function buildProjectContextDuplicateText(projectID, duplicate, attemptedStatus) {
+  const item = normalizeProjectContextRecord(duplicate);
+  return [
+    `project_id: ${projectID}`,
+    "created: false",
+    "duplicate: true",
+    `reason: duplicate_${String(item.status || "existing").trim().toLowerCase() || "existing"}`,
+    `existing_context_id: ${item.id || "-"}`,
+    `existing_status: ${item.status || "-"}`,
+    `attempted_status: ${String(attemptedStatus || "").trim() || "-"}`,
+    `title: ${item.title || "-"}`,
+    "",
+    item.body || "",
+  ].join("\n").trim();
+}
+
 function resolveProjectID(toolArgs, args, workspaceDir, deps) {
   const resolveProjectIDForRequest = requireDependency(deps, "resolveProjectIDForRequest");
   return String(
@@ -478,6 +497,35 @@ export async function handleLocalProjectToolDispatch(
         if (!body) {
           return jsonRpcError(requestObj, -32001, "body is required");
         }
+        const requestedStatus = normalizeProjectContextStatus(
+          toolArgs.status,
+          toolName === "project.context.suggest" ? "suggested" : "active",
+        );
+        const existingItems = ensureArray(await listProjectContextItems({
+          siteBaseURL,
+          projectID,
+          token,
+          timeoutSeconds,
+          actorUserID,
+        })).map((item) => normalizeProjectContextRecord(item));
+        const duplicate = findExactProjectContextDuplicate(existingItems, {
+          title,
+          body,
+        }, {
+          statuses: ["active", "suggested"],
+        });
+        if (duplicate) {
+          return jsonRpcResult(requestObj, {
+            content: [{ type: "text", text: buildProjectContextDuplicateText(projectID, duplicate, requestedStatus) }],
+            structuredContent: {
+              ok: true,
+              created: false,
+              duplicate: true,
+              reason: `duplicate_${String(duplicate.status || "").trim().toLowerCase() || "existing"}`,
+              item: normalizeProjectContextRecord(duplicate),
+            },
+          });
+        }
         const created = normalizeProjectContextRecord(await createProjectContextItem({
           siteBaseURL,
           token,
@@ -488,7 +536,7 @@ export async function handleLocalProjectToolDispatch(
           body,
           category: normalizeProjectContextCategory(toolArgs.category),
           importance: normalizeProjectContextImportance(toolArgs.importance),
-          status: normalizeProjectContextStatus(toolArgs.status, toolName === "project.context.suggest" ? "suggested" : "active"),
+          status: requestedStatus,
         }));
         return jsonRpcResult(requestObj, {
           content: [{ type: "text", text: buildProjectContextText(created) }],

package/lib/project-context-dedupe.mjs

@@ -0,0 +1,48 @@
+function safeObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return value;
+}
+
+function ensureArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+export function normalizeProjectContextComparableText(value) {
+  return String(value || "")
+    .trim()
+    .toLowerCase()
+    .replace(/\s+/g, " ");
+}
+
+export function normalizeProjectContextDuplicateRecord(rawItem) {
+  const item = safeObject(rawItem);
+  return {
+    id: String(item.id || item.context_id || "").trim(),
+    title: String(item.title || "").trim(),
+    body: String(item.body || "").trim(),
+    status: String(item.status || "").trim().toLowerCase(),
+  };
+}
+
+export function findExactProjectContextDuplicate(rawItems, rawCandidate, options = {}) {
+  const allowedStatuses = new Set(
+    ensureArray(options.statuses && options.statuses.length ? options.statuses : ["active", "suggested"])
+      .map((value) => String(value || "").trim().toLowerCase())
+      .filter(Boolean),
+  );
+  const candidate = normalizeProjectContextDuplicateRecord(rawCandidate);
+  if (!candidate.title || !candidate.body) {
+    return null;
+  }
+  const candidateTitle = normalizeProjectContextComparableText(candidate.title);
+  const candidateBody = normalizeProjectContextComparableText(candidate.body);
+  return ensureArray(rawItems)
+    .map((item) => normalizeProjectContextDuplicateRecord(item))
+    .find((item) => (
+      allowedStatuses.has(item.status)
+      && normalizeProjectContextComparableText(item.title) === candidateTitle
+      && normalizeProjectContextComparableText(item.body) === candidateBody
+    )) || null;
+}

package/lib/runner-delivery-archive-handoff.mjs

@@ -13,6 +13,14 @@ function intFromRawAllowZero(value, fallback = 0) {
   return Number.isFinite(parsed) ? parsed : fallback;
 }
 
+function buildReplyAnchorMismatchError(expectedReplyToMessageID, observedReplyToMessageID) {
+  return `reply anchor mismatch: expected ${String(expectedReplyToMessageID || 0)}, observed ${String(observedReplyToMessageID || 0)}`;
+}
+
+function buildMessageThreadMismatchError(expectedMessageThreadID, observedMessageThreadID) {
+  return `message thread mismatch: expected ${String(expectedMessageThreadID || 0)}, observed ${String(observedMessageThreadID || 0)}`;
+}
+
 function requireArchiveDependency(deps, key) {
   const candidate = deps?.[key];
   if (typeof candidate !== "function") {
@@ -83,11 +91,41 @@ export async function finalizeLocalBotDeliveryArchive({
       deliveredResult.message_id ?? deliveredBody.message_id ?? deliveredBody.ts,
       0,
     );
-    const deliveredMessageThreadID = intFromRawAllowZero(
+    const observedMessageThreadID = intFromRawAllowZero(
       deliveredResult.message_thread_id ?? deliveredBody.message_thread_id ?? delivery.effectiveMessageThreadID,
       intFromRawAllowZero(messageThreadID, 0),
     );
-    const archiveReplyToMessageID = intFromRawAllowZero(delivery.effectiveReplyToMessageID, replyToMessageID);
+    const expectedMessageThreadID = intFromRawAllowZero(messageThreadID, 0);
+    const expectedReplyToMessageID = intFromRawAllowZero(replyToMessageID, 0);
+    const observedReplyToMessageID = intFromRawAllowZero(delivery.effectiveReplyToMessageID, 0);
+    if (
+      (expectedReplyToMessageID > 0 || observedReplyToMessageID > 0)
+      && observedReplyToMessageID !== expectedReplyToMessageID
+    ) {
+      return {
+        ok: false,
+        error: buildReplyAnchorMismatchError(expectedReplyToMessageID, observedReplyToMessageID),
+        reply_anchor_mismatch: true,
+        expected_reply_to_message_id: expectedReplyToMessageID,
+        observed_reply_to_message_id: observedReplyToMessageID,
+        thread_id: thread.threadID,
+        work_item_id: thread.workItemID,
+      };
+    }
+    if (
+      (expectedMessageThreadID > 0 || observedMessageThreadID > 0)
+      && observedMessageThreadID !== expectedMessageThreadID
+    ) {
+      return {
+        ok: false,
+        error: buildMessageThreadMismatchError(expectedMessageThreadID, observedMessageThreadID),
+        message_thread_mismatch: true,
+        expected_message_thread_id: expectedMessageThreadID,
+        observed_message_thread_id: observedMessageThreadID,
+        thread_id: thread.threadID,
+        work_item_id: thread.workItemID,
+      };
+    }
     if (archiveDedupeOutbound && deliveredMessageID > 0) {
       const existingComments = await listThreadCommentsTail({
         siteBaseURL,
@@ -119,8 +157,8 @@ export async function finalizeLocalBotDeliveryArchive({
       destination,
       replyText: text,
       messageID: deliveredMessageID,
-      messageThreadID: deliveredMessageThreadID,
-      replyToMessageID: archiveReplyToMessageID,
+      messageThreadID: expectedMessageThreadID,
+      replyToMessageID: expectedReplyToMessageID,
       conversation: archiveConversation,
     });
     const createdComment = await createThreadComment({

package/lib/runner-helpers.mjs

@@ -275,13 +275,11 @@ export function buildTelegramMessageEnvelopeFromParsedArchive(parsedArchiveRaw,
       overrides.sender,
       parsedArchive.sender,
       parsedArchive.botName,
-      parsedArchive.replyToSender,
     ]),
     sender_username: firstNonEmptyString([
       overrides.sender_username,
       parsedArchive.botUsername,
       parsedArchive.username,
-      parsedArchive.replyToUsername,
     ]),
     sender_is_bot: overrides.sender_is_bot ?? parsedArchive.senderIsBot,
     body: firstNonEmptyString([overrides.body, parsedArchive.body]),
@@ -314,6 +312,27 @@ export function buildTelegramMessageEnvelopeFromParsedArchive(parsedArchiveRaw,
   });
 }
 
+export function resolveTelegramReplyAnchorMessageID({
+  replyToMessageID = 0,
+  sourceEnvelope: sourceEnvelopeRaw = {},
+  fallbackReplyToMessageID = 0,
+} = {}) {
+  const explicitReplyToMessageID = intFromRawAllowZero(replyToMessageID, 0);
+  if (explicitReplyToMessageID > 0) {
+    return explicitReplyToMessageID;
+  }
+  const sourceEnvelope = normalizeTelegramMessageEnvelope(sourceEnvelopeRaw);
+  const sourceMessageID = intFromRawAllowZero(sourceEnvelope.message_id, 0);
+  if (sourceMessageID > 0) {
+    return sourceMessageID;
+  }
+  const sourceReplyToMessageID = intFromRawAllowZero(sourceEnvelope.reply_to_message_id, 0);
+  if (sourceReplyToMessageID > 0) {
+    return sourceReplyToMessageID;
+  }
+  return intFromRawAllowZero(fallbackReplyToMessageID, 0);
+}
+
 export function buildTelegramBotReplyEnvelope({
   sourceEnvelope: sourceEnvelopeRaw = {},
   chatID = "",
@@ -499,7 +518,7 @@ function buildContextSpeakerLabel(parsed) {
   if (username) {
     return `@${String(username).replace(/^@+/, "")}`;
   }
-  return firstNonEmptyString([parsed.sender, parsed.botName, parsed.replyToSender]);
+  return firstNonEmptyString([parsed.sender, parsed.botName]);
 }
 
 function normalizeContextWindowOptions(rawOptions) {

package/lib/runner-orchestration-entrypoints.mjs

@@ -561,7 +561,9 @@ function summarizeStartupLoopFacts({
     execution_contract_targets: ensureArray(parsed.executionContractAssignments)
       .map((item) => normalizeMentionSelector(safeObject(item).targetBot))
       .filter(Boolean),
-    reply_to_bot_username: normalizeMentionSelector(parsed.replyToUsername),
+    reply_to_bot_username: parsed.replyToSenderIsBot === true
+      ? normalizeMentionSelector(parsed.replyToUsername)
+      : "",
     newer_human_message_count: newerHumanMessages.length,
     has_newer_human_message: newerHumanMessages.length > 0,
     bot_reply_count_since_last_human: botReplysSinceLastHuman.length + 1,

package/lib/runner-orchestration-selected-record-context.mjs

@@ -52,7 +52,7 @@ export async function prepareRunnerSelectedRecordContext({
     reduceContextWindowForHumanIntent,
     buildRunnerContextWindow,
     buildHumanIntentContextWindowOptions,
-    loadActiveProjectContextItems,
+    loadProjectContextItemsForPrompt,
     isInformationalHumanIntentType,
     resolveInformationalQueryExecutionPlan,
     buildRunnerInputPayload,
@@ -76,7 +76,7 @@ export async function prepareRunnerSelectedRecordContext({
     || typeof reduceContextWindowForHumanIntent !== "function"
     || typeof buildRunnerContextWindow !== "function"
     || typeof buildHumanIntentContextWindowOptions !== "function"
-    || typeof loadActiveProjectContextItems !== "function"
+    || typeof loadProjectContextItemsForPrompt !== "function"
     || typeof isInformationalHumanIntentType !== "function"
     || typeof resolveInformationalQueryExecutionPlan !== "function"
     || typeof buildRunnerInputPayload !== "function"
@@ -372,7 +372,7 @@ export async function prepareRunnerSelectedRecordContext({
     ),
     directHumanResponseContract.intentType,
   );
-  const projectContextItems = await loadActiveProjectContextItems({
+  const projectContextItems = await loadProjectContextItemsForPrompt({
     normalizedRoute,
     runtime,
     deps: executionDeps,

package/lib/runner-orchestration-selected-record-delivery-context.mjs

@@ -84,6 +84,11 @@ export async function prepareRunnerSelectedRecordDeliveryContext({
   const normalizedConversationMode = String(effectiveConversationContext?.mode || "").trim().toLowerCase();
   const normalizedConversationStage = String(effectiveConversationContext?.stage || "").trim().toLowerCase();
   const normalizedGuideVisibleReplyTarget = normalizeMentionSelector(safeObject(guidePacket).visible_reply_target);
+  const managedPeerSelectors = new Set(
+    Array.from(directHumanPeerMap instanceof Map ? directHumanPeerMap.keys() : [])
+      .map((item) => normalizeMentionSelector(item))
+      .filter(Boolean),
+  );
   const visibleDelegationTargets = uniqueOrdered(
     normalizedExecutionContractType === "delegation"
       ? [
@@ -122,6 +127,7 @@ export async function prepareRunnerSelectedRecordDeliveryContext({
     effectiveResponseContractValidation.ok
     && normalizedReplyTargetBotSelector
     && normalizedReplyTargetBotSelector !== currentBotSelector
+    && managedPeerSelectors.has(normalizedReplyTargetBotSelector)
     && normalizedGuideVisibleReplyTarget
     && normalizedGuideVisibleReplyTarget === normalizedReplyTargetBotSelector
   ) {

package/lib/runner-orchestration-selected-record-preparation.mjs

@@ -1,3 +1,7 @@
+import {
+  resolveTelegramReplyAnchorMessageID,
+} from "./runner-helpers.mjs";
+
 function safeObject(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return {};
@@ -154,9 +158,20 @@ export function prepareRunnerSelectedRecordIngress({
           currentBotSelector,
         });
   const replyMessageThreadID = intFromRawAllowZero(sourceMessageEnvelope.message_thread_id, 0);
-  const replyToMessageID = intFromRawAllowZero(sourceMessageEnvelope.message_id, 0);
+  const sourceMessageID = intFromRawAllowZero(sourceMessageEnvelope.message_id, 0);
+  const sourceReplyToMessageID = intFromRawAllowZero(sourceMessageEnvelope.reply_to_message_id, 0);
+  const replyToMessageID = resolveTelegramReplyAnchorMessageID({
+    replyToMessageID: sourceMessageID,
+    sourceEnvelope: sourceMessageEnvelope,
+  });
   const replyAnchorSource = String(sourceMessageEnvelope.source_origin || "").trim()
-    || (replyToMessageID > 0 ? "source_message_envelope" : "");
+    || (replyToMessageID > 0
+      ? sourceMessageID > 0
+        ? "source_message_envelope"
+        : sourceReplyToMessageID > 0
+          ? "source_message_envelope_reply_to"
+          : ""
+      : "");
 
   return {
     handledResult: null,