metheus-governance-mcp-cli 0.2.284 → 0.2.286

package/cli.mjs

@@ -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);
@@ -3564,7 +3562,9 @@ function buildRunnerRequestKey({
   const intent = canonicalHumanKey
     ? "-"
     : String(normalizedIntent || "").trim().toLowerCase() || "-";
-  const resolvedConversationID = String(conversationID || parsed.conversationID || "").trim() || "-";
+  const resolvedConversationID = canonicalHumanKey
+    ? "-"
+    : String(conversationID || parsed.conversationID || "").trim() || "-";
   return [
     String(normalizedRoute?.projectID || "").trim() || "-",
     String(normalizedRoute?.provider || "").trim() || "-",
@@ -3996,10 +3996,10 @@ function runnerRequestPreferredNextExpectedResponders(entryRaw) {
   );
 }
 
-function runnerRequestPreferredAuthoritySelectedBotUsernames(entryRaw) {
-  const entry = safeObject(entryRaw);
-  const normalizedSummaryBot = normalizeTelegramMentionUsername(entry.conversation_summary_bot);
-  return uniqueOrderedStrings(
+function runnerRequestPreferredAuthoritySelectedBotUsernames(entryRaw) {
+  const entry = safeObject(entryRaw);
+  const normalizedSummaryBot = normalizeTelegramMentionUsername(entry.conversation_summary_bot);
+  return uniqueOrderedStrings(
     runnerRequestPreferredNextExpectedResponders(entry).length
       ? runnerRequestPreferredNextExpectedResponders(entry)
       : runnerRequestPreferredExecutionContractTargets(entry).length
@@ -4015,17 +4015,47 @@ 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 runnerRequestAllowsSharedHumanClaimTakeover({
+  entryRaw,
+  currentBotUsername = "",
+  canonicalHumanMessageKey = "",
+}) {
+  const entry = safeObject(entryRaw);
+  const normalizedCurrentBotUsername = normalizeTelegramMentionUsername(currentBotUsername);
+  const normalizedCanonicalHumanMessageKey = String(canonicalHumanMessageKey || "").trim();
+  if (!normalizedCurrentBotUsername || !normalizedCanonicalHumanMessageKey) {
+    return false;
+  }
+  if (String(entry.canonical_human_message_key || "").trim() !== normalizedCanonicalHumanMessageKey) {
+    return false;
+  }
+  const pendingResponders = runnerRequestPreferredNextExpectedResponders(entry);
+  if (pendingResponders.length > 0) {
+    return pendingResponders.includes(normalizedCurrentBotUsername);
+  }
+  const directHumanResponders = uniqueOrderedStrings(
+    [
+      ...ensureArray(entry.selected_bot_usernames),
+      ...ensureArray(entry.conversation_initial_responders),
+      ...ensureArray(entry.conversation_allowed_responders),
+    ],
+    normalizeTelegramMentionUsername,
+  );
+  return directHumanResponders.includes(normalizedCurrentBotUsername);
+}
 
 function runnerRequestPreferredAIReplyPreview(entryRaw) {
   const entry = safeObject(entryRaw);
@@ -5068,8 +5098,8 @@ async function claimRunnerRequestForHumanComment({
       reason: "non_human_comment_cannot_create_request",
     };
   }
-  const currentState = loadBotRunnerState();
-  const currentRouteState = safeObject(safeObject(currentState.routes)[String(routeKey || "").trim()]);
+  const currentState = loadBotRunnerState();
+  const currentRouteState = safeObject(safeObject(currentState.routes)[String(routeKey || "").trim()]);
   const replyChainResolution = await resolveRunnerReplyChainConversationContextWithServerFallback({
     state: currentState,
     normalizedRoute,
@@ -5169,6 +5199,16 @@ async function claimRunnerRequestForHumanComment({
   const authoritativeDecisionBundle = decisionBundleValidation.ok === true
     ? safeObject(decisionBundleValidation.bundle)
     : {};
+  const normalizedAuthoritativeSourceMessageEnvelope = normalizeRunnerTelegramMessageEnvelope(
+    authoritativeSourceMessageEnvelope,
+  );
+  const currentClaimBotUsername = normalizeTelegramMentionUsername(
+    normalizedAuthoritativeSourceMessageEnvelope.source_bot_username
+      || normalizedAuthoritativeSourceMessageEnvelope.sender_username
+      || currentRouteState.last_source_bot_username
+      || currentRouteState.source_message_bot_username
+      || currentRouteState.last_speaker_bot_username,
+  );
   const authorityReplyChainContext = await buildRunnerAuthorityReplyChainContext({
     selectedRecord,
     replyChainContext,
@@ -5201,24 +5241,35 @@ async function claimRunnerRequestForHumanComment({
       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 normalizedAuthoritativeSourceMessageEnvelope = normalizeRunnerTelegramMessageEnvelope(
-    authoritativeSourceMessageEnvelope,
+  if (
+    isActiveRunnerRequestStatus(existing.status)
+    && String(existing.claimed_by_route || "").trim()
+    && String(existing.claimed_by_route || "").trim() !== String(routeKey || "").trim()
+    && !runnerRequestAllowsSharedHumanClaimTakeover({
+      entryRaw: existing,
+      currentBotUsername: currentClaimBotUsername,
+      canonicalHumanMessageKey,
+    })
+  ) {
+    return {
+      ok: false,
+      reason: "request_already_claimed",
+      requestKey,
+    };
+  }
+  const nowISO = new Date().toISOString();
+  const existingSourceMessageEnvelope = normalizeRunnerTelegramMessageEnvelope(existing.source_message_envelope);
+  const preserveExistingCanonicalSourceEnvelope = Boolean(
+    canonicalHumanMessageKey
+    && String(existing.canonical_human_message_key || "").trim() === canonicalHumanMessageKey
+    && intFromRawAllowZero(existing.source_message_id, 0) === currentMessageID
+    && Object.keys(existingSourceMessageEnvelope).length > 0
   );
-  const sourceMessageEnvelope = Object.keys(normalizedAuthoritativeSourceMessageEnvelope).length
-    ? normalizedAuthoritativeSourceMessageEnvelope
-    : normalizeRunnerTelegramMessageEnvelope(existing.source_message_envelope);
+  const sourceMessageEnvelope = preserveExistingCanonicalSourceEnvelope
+    ? existingSourceMessageEnvelope
+    : Object.keys(normalizedAuthoritativeSourceMessageEnvelope).length
+      ? normalizedAuthoritativeSourceMessageEnvelope
+      : existingSourceMessageEnvelope;
   const decisionConversationParticipants = uniqueOrderedStrings(
     ensureArray(authoritativeDecisionBundle.participants),
     normalizeTelegramMentionUsername,
@@ -18685,13 +18736,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,
@@ -18715,11 +18767,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-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]),
@@ -520,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
   ) {