metheus-governance-mcp-cli 0.2.284 → 0.2.285

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);
@@ -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);
@@ -18685,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,
@@ -18715,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-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
   ) {

package/lib/runner-orchestration.mjs

@@ -107,6 +107,9 @@ import {
 import {
   isInternalRuntimeArtifactPath,
 } from "./local-ai-adapters.mjs";
+import {
+  findExactProjectContextDuplicate,
+} from "./project-context-dedupe.mjs";
 
 function safeObject(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -266,11 +269,14 @@ export function buildRunnerInputPayload({
       .map((value) => String(value || "").trim().toLowerCase())
       .filter(Boolean),
   );
+  const parsedReplyTargetBot = parsed.replyToSenderIsBot === true
+    ? parsed.replyToUsername
+    : "";
   const normalizedReplyTargetBot = normalizeMentionSelector(
     directHumanIntent.replyTargetBotSelector
     || directHumanIntent.reply_target_bot
     || directHumanIntent.reply_to_bot_username
-    || parsed.replyToUsername,
+    || parsedReplyTargetBot,
   );
   const normalizedIntentMode = String(
     directHumanIntent.intentMode || directHumanIntent.intent_mode || directHumanIntent.mode || "",
@@ -626,6 +632,11 @@ function projectContextImportanceRank(value) {
 function compareProjectContextItems(leftRaw, rightRaw) {
   const left = normalizeProjectContextItem(leftRaw);
   const right = normalizeProjectContextItem(rightRaw);
+  const leftStatus = String(left.status || "").trim().toLowerCase();
+  const rightStatus = String(right.status || "").trim().toLowerCase();
+  const leftStatusRank = leftStatus === "active" ? 0 : leftStatus === "suggested" ? 1 : 2;
+  const rightStatusRank = rightStatus === "active" ? 0 : rightStatus === "suggested" ? 1 : 2;
+  if (leftStatusRank !== rightStatusRank) return leftStatusRank - rightStatusRank;
   const importanceDelta = projectContextImportanceRank(right.importance) - projectContextImportanceRank(left.importance);
   if (importanceDelta !== 0) return importanceDelta;
   const leftUpdated = Date.parse(String(left.updated_at || left.created_at || "").trim());
@@ -660,13 +671,6 @@ function normalizeProjectContextImportance(value) {
   return "normal";
 }
 
-function normalizeProjectContextComparableText(value) {
-  return String(value || "")
-    .trim()
-    .toLowerCase()
-    .replace(/\s+/g, " ");
-}
-
 function looksLikeInterrogativeMessage(text) {
   const normalizedText = String(text || "").trim();
   if (!normalizedText) {
@@ -770,13 +774,9 @@ async function maybeCreateSuggestedProjectContext({
         actorUserID,
       }))
       : [];
-    const duplicate = existingItems
-      .map((item) => normalizeProjectContextItem(item))
-      .find((item) => (
-        ["active", "suggested"].includes(String(item.status || "").trim().toLowerCase())
-        && normalizeProjectContextComparableText(item.title) === normalizeProjectContextComparableText(candidate.title)
-        && normalizeProjectContextComparableText(item.body) === normalizeProjectContextComparableText(candidate.body)
-      ));
+    const duplicate = findExactProjectContextDuplicate(existingItems, candidate, {
+      statuses: ["active", "suggested"],
+    });
     if (duplicate) {
       return {
         skipped: true,
@@ -817,7 +817,7 @@ async function maybeCreateSuggestedProjectContext({
   }
 }
 
-async function loadActiveProjectContextItems({ normalizedRoute, runtime, deps }) {
+async function loadProjectContextItemsForPrompt({ normalizedRoute, runtime, deps }) {
   const listProjectContextItems = typeof deps?.listProjectContextItems === "function"
     ? deps.listProjectContextItems
     : null;
@@ -839,7 +839,7 @@ async function loadActiveProjectContextItems({ normalizedRoute, runtime, deps })
       actorUserID: safeObject(runtime.actor).user_id,
     }))
       .map((item) => normalizeProjectContextItem(item))
-      .filter((item) => item.id && item.status.toLowerCase() === "active")
+      .filter((item) => item.id && ["active", "suggested"].includes(item.status.toLowerCase()))
       .sort(compareProjectContextItems)
       .slice(0, 8);
   } catch {
@@ -3308,7 +3308,7 @@ export async function processRunnerSelectedRecord({
       reduceContextWindowForHumanIntent,
       buildRunnerContextWindow,
       buildHumanIntentContextWindowOptions,
-      loadActiveProjectContextItems,
+      loadProjectContextItemsForPrompt,
       isInformationalHumanIntentType,
       resolveInformationalQueryExecutionPlan,
       buildRunnerInputPayload,

package/lib/selftest-runner-scenarios.mjs

@@ -89,6 +89,7 @@ import {
   resolveCodexRawTextProcessResult,
 } from "./local-ai-adapters.mjs";
 import {
+  buildTelegramMessageEnvelopeFromParsedArchive,
   buildRunnerRouteDuplicateStateFromComment,
   buildRunnerRouteStateFromComment,
 } from "./runner-helpers.mjs";
@@ -115,6 +116,9 @@ import {
 import {
   resolveRunnerAuthoritativeTriggerDecision,
 } from "./runner-trigger.mjs";
+import {
+  findExactProjectContextDuplicate,
+} from "./project-context-dedupe.mjs";
 
 function requireDependency(deps, key) {
   const candidate = deps?.[key];
@@ -7477,6 +7481,175 @@ export async function runSelftestRunnerScenarios(push, deps) {
     push("single_bot_direct_reply_target_prefixes_visible_target_when_ai_omits_mention", false, String(err?.message || err));
   }
 
+  try {
+    let aiCalls = 0;
+    let plannerCalls = 0;
+    let deliveryCalls = 0;
+    let deliveredText = "";
+    const processed = await processRunnerSelectedRecord({
+      routeKey: "single-bot-human-direct-reply-with-human-reply-target-key",
+      normalizedRoute: normalizeRunnerRoute({
+        name: "telegram-monitor-single-bot-human-direct-reply-with-human-reply-target",
+        project_id: selftestProjectID,
+        provider: "telegram",
+        role: "monitor",
+        role_profile: "monitor",
+        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: true,
+      }),
+      selectedRecord: {
+        id: "comment-single-bot-human-direct-reply-with-human-reply-target",
+        createdAt: "2026-04-02T05:48:25.000Z",
+        parsedArchive: {
+          kind: "telegram_message",
+          chatID: "-100123",
+          chatType: "supergroup",
+          senderIsBot: false,
+          sender: "Human",
+          username: "sopia19910",
+          body: "@RyoAI2_bot 너 대답 안하지?",
+          mentionUsernames: ["RyoAI2_bot"],
+          messageID: 376,
+          replyToMessageID: 375,
+          replyToUsername: "sopia19910",
+          replyToSenderIsBot: false,
+        },
+      },
+      pendingOrdered: [],
+      bot: {
+        id: "bot-peer-1",
+        name: "RyoAI2_bot",
+        username: "RyoAI2_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: path.join(os.tmpdir(), "metheus-runner-selftest-single-bot-human-direct-reply-with-human-reply-target"),
+        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 () => {
+          aiCalls += 1;
+          return {
+            skip: false,
+            reply: "대답합니다.",
+            replyToMessageID: 0,
+          };
+        },
+        performLocalBotDelivery: async ({ text }) => {
+          deliveryCalls += 1;
+          deliveredText = String(text || "").trim();
+          return {
+            delivery: { dryRun: true, body: {} },
+            archive: {},
+          };
+        },
+        serializeRunnerTriggerPolicy: (value) => value,
+        serializeRunnerArchivePolicy: (value) => value,
+        buildRunnerExecutionDeps: () => ({
+          analyzeHumanConversationIntentWithAI: async () => ({
+            mode: "single_bot",
+            lead_bot: "ryoai2_bot",
+            participants: ["ryoai2_bot"],
+            initial_responders: ["ryoai2_bot"],
+            allowed_responders: ["ryoai2_bot"],
+            summary_bot: "",
+            allow_bot_to_bot: false,
+            reply_expectation: "informational",
+            intent_type: "small_talk",
+          }),
+          planRoleExecutionWithAI: async () => {
+            plannerCalls += 1;
+            return {
+              requiresExecution: true,
+              summaryRole: "worker",
+              steps: [{ role: "worker", goal: "unexpected", artifactsRequired: true }],
+            };
+          },
+        }),
+        buildRunnerDeliveryDeps: () => ({}),
+        buildRunnerRuntimeDeps: () => ({}),
+        resolveConversationPeerBots: () => [
+          { id: "bot-peer-1", name: "RyoAI2_bot" },
+          { id: "bot-peer-2", name: "RyoAI3_bot" },
+        ],
+      },
+    });
+    push(
+      "single_bot_human_direct_reply_does_not_require_visible_human_target",
+      processed.kind === "replied"
+        && aiCalls === 1
+        && plannerCalls === 0
+        && deliveryCalls === 1
+        && String(processed.result?.response_contract_validation_status || "") !== "reply_target_not_visible_in_reply"
+        && deliveredText === "대답합니다.",
+      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} planner_calls=${plannerCalls} delivery_calls=${deliveryCalls} validation=${String(processed.result?.response_contract_validation_status || "(none)")} delivered=${String(deliveredText || "(none)")}`,
+    );
+  } catch (err) {
+    push("single_bot_human_direct_reply_does_not_require_visible_human_target", false, String(err?.message || err));
+  }
+
+  try {
+    const envelope = buildTelegramMessageEnvelopeFromParsedArchive({
+      kind: "telegram_message",
+      chatID: "-100123",
+      messageID: 377,
+      sender: "",
+      username: "",
+      senderIsBot: false,
+      replyToSender: "Human Target",
+      replyToUsername: "sopia19910",
+      replyToSenderIsBot: false,
+      body: "본문",
+      occurredAt: "2026-04-02T05:48:35.000Z",
+    });
+    push(
+      "telegram_message_envelope_does_not_promote_human_reply_target_to_sender_identity",
+      String(envelope.sender_username || "") === ""
+        && String(envelope.sender || "") === "",
+      `sender=${String(envelope.sender || "(none)")} sender_username=${String(envelope.sender_username || "(none)")}`,
+    );
+  } catch (err) {
+    push("telegram_message_envelope_does_not_promote_human_reply_target_to_sender_identity", false, String(err?.message || err));
+  }
+
   try {
     let aiCalls = 0;
     let deliveryCalls = 0;
@@ -12789,17 +12962,26 @@ export async function runSelftestRunnerScenarios(push, deps) {
               status: "archived",
               updated_at: "2026-03-17T00:00:00.000Z",
             },
-            {
-              id: "ctx-3",
-              title: "Workspace Binding",
-              body: "Workspace is C:/LUSH KOREA CLI.",
-              category: "workspace",
-              importance: "high",
-              status: "active",
-              updated_at: "2026-03-18T00:08:00.000Z",
-            },
-          ]),
-        }),
+            {
+              id: "ctx-3",
+              title: "Workspace Binding",
+              body: "Workspace is C:/LUSH KOREA CLI.",
+              category: "workspace",
+              importance: "high",
+              status: "active",
+              updated_at: "2026-03-18T00:08:00.000Z",
+            },
+            {
+              id: "ctx-4",
+              title: "Pending Risk",
+              body: "BOT3 capacity failures should be tracked before closing a delegation turn.",
+              category: "risk",
+              importance: "normal",
+              status: "suggested",
+              updated_at: "2026-03-18T00:07:00.000Z",
+            },
+          ]),
+        }),
         buildRunnerDeliveryDeps: () => ({}),
         buildRunnerRuntimeDeps: () => ({}),
       },
@@ -12807,26 +12989,63 @@ export async function runSelftestRunnerScenarios(push, deps) {
     const prompt = buildLocalBotPrompt(capturedInputPayload, { terse: true });
     const projectContexts = ensureArray(capturedInputPayload?.project_context_items);
     push(
-      "active_project_context_is_injected_into_runner_prompt",
-      processed.kind === "replied"
-        && aiCalls === 1
-        && projectContexts.length === 2
-        && String(projectContexts[0]?.title || "") === "Operating Rule"
-        && String(projectContexts[1]?.title || "") === "Workspace Binding"
-        && prompt.includes("Active project context")
-        && prompt.includes("Operating Rule")
-        && prompt.includes("Workspace Binding")
-        && !prompt.includes("Archived Note"),
-      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} contexts=${projectContexts.map((item) => item.title).join(",") || "(none)"} prompt_has_active_context=${String(prompt.includes("Active project context"))}`,
-    );
-  } catch (err) {
-    push("active_project_context_is_injected_into_runner_prompt", false, String(err?.message || err));
-  }
-
-  try {
-    const prompt = buildLocalBotPrompt({
-      bot: {
-        name: "RyoAI_bot",
+      "existing_project_context_is_injected_into_runner_prompt",
+      processed.kind === "replied"
+        && aiCalls === 1
+        && projectContexts.length === 3
+        && String(projectContexts[0]?.title || "") === "Operating Rule"
+        && String(projectContexts[1]?.title || "") === "Workspace Binding"
+        && String(projectContexts[2]?.title || "") === "Pending Risk"
+        && prompt.includes("Existing project context memory")
+        && prompt.includes("Operating Rule")
+        && prompt.includes("Workspace Binding")
+        && prompt.includes("Pending Risk")
+        && !prompt.includes("Archived Note"),
+      `kind=${String(processed.kind || "(none)")} ai_calls=${aiCalls} contexts=${projectContexts.map((item) => `${item.status}:${item.title}`).join(",") || "(none)"} prompt_has_context_memory=${String(prompt.includes("Existing project context memory"))}`,
+    );
+  } catch (err) {
+    push("existing_project_context_is_injected_into_runner_prompt", false, String(err?.message || err));
+  }
+
+  try {
+    const duplicate = findExactProjectContextDuplicate([
+      {
+        id: "ctx-active-1",
+        title: "Operating Rule",
+        body: "Always answer with current project settings first.",
+        status: "active",
+      },
+      {
+        id: "ctx-suggested-1",
+        title: " Pending Risk ",
+        body: "BOT3 capacity failures should be tracked before closing a delegation turn.",
+        status: "suggested",
+      },
+      {
+        id: "ctx-archived-1",
+        title: "Old Note",
+        body: "old note",
+        status: "archived",
+      },
+    ], {
+      title: "pending risk",
+      body: "BOT3   capacity failures should be tracked before closing a delegation turn.",
+    }, {
+      statuses: ["active", "suggested"],
+    });
+    push(
+      "project_context_exact_duplicate_helper_matches_active_and_suggested_only",
+      String(duplicate?.id || "") === "ctx-suggested-1",
+      `duplicate_id=${String(duplicate?.id || "(none)")} duplicate_status=${String(duplicate?.status || "(none)")}`,
+    );
+  } catch (err) {
+    push("project_context_exact_duplicate_helper_matches_active_and_suggested_only", false, String(err?.message || err));
+  }
+
+  try {
+    const prompt = buildLocalBotPrompt({
+      bot: {
+        name: "RyoAI_bot",
         username: "RyoAI_bot",
         role: "monitor",
       },
@@ -13096,14 +13315,148 @@ export async function runSelftestRunnerScenarios(push, deps) {
         && String(safeObject(lastSavedState).last_context_suggestion_id || "") === "ctx-suggest-1",
       `kind=${String(processed.kind || "(none)")} create_calls=${createCalls.length} status=${String(processed?.result?.context_suggestion_status || "(none)")} state_id=${String(safeObject(lastSavedState).last_context_suggestion_id || "(none)")}`,
     );
-  } catch (err) {
-    push("human_role_rule_creates_suggested_project_context", false, String(err?.message || err));
-  }
-
-  try {
-    const createCalls = [];
-    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-selftest-context-suggest-question-"));
-    const processed = await processRunnerSelectedRecord({
+  } catch (err) {
+    push("human_role_rule_creates_suggested_project_context", false, String(err?.message || err));
+  }
+
+  try {
+    const createCalls = [];
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-selftest-context-suggest-duplicate-"));
+    const processed = await processRunnerSelectedRecord({
+      routeKey: "context-suggest-duplicate-key",
+      normalizedRoute: normalizeRunnerRoute({
+        name: "telegram-monitor-context-suggest-duplicate",
+        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-context-suggest-duplicate",
+        createdAt: "2026-03-19T01:04:00.000Z",
+        parsedArchive: {
+          kind: "telegram_message",
+          chatID: "-100123",
+          chatType: "supergroup",
+          body: "@RyoAI_bot Room rule: RyoAI_bot handles coordination and RyoAI2_bot handles review in this room.",
+          messageID: 301,
+          sender: "human",
+          senderIsBot: false,
+          mentionUsernames: ["ryoai_bot", "ryoai2_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: "역할 규칙으로 기억하겠습니다.",
+          replyToMessageID: 301,
+          raw: {
+            context_suggestion: {
+              should_store: true,
+              title: "Bot collaboration roles",
+              body: "RyoAI_bot handles coordination and RyoAI2_bot handles review in this room.",
+              category: "bot_role",
+              importance: "high",
+            },
+          },
+        }),
+        performLocalBotDelivery: async () => ({
+          delivery: { dryRun: false, body: { result: { message_id: 9003 } } },
+          archive: { ok: true },
+        }),
+        serializeRunnerTriggerPolicy: (value) => value,
+        serializeRunnerArchivePolicy: (value) => value,
+        buildRunnerExecutionDeps: () => ({
+          listProjectContextItems: async () => ([
+            {
+              id: "ctx-suggest-existing",
+              project_id: selftestProjectID,
+              title: "Bot collaboration roles",
+              body: "RyoAI_bot handles coordination and RyoAI2_bot handles review in this room.",
+              category: "bot_role",
+              importance: "high",
+              status: "suggested",
+            },
+          ]),
+          createProjectContextItem: async (input) => {
+            createCalls.push(input);
+            return { id: "ctx-should-not-create" };
+          },
+        }),
+        buildRunnerDeliveryDeps: () => ({}),
+        buildRunnerRuntimeDeps: () => ({}),
+      },
+    });
+    push(
+      "duplicate_suggested_project_context_is_not_created",
+      processed.kind === "replied"
+        && createCalls.length === 0
+        && String(processed?.result?.context_suggestion_status || "") === "skipped:duplicate_suggested",
+      `kind=${String(processed.kind || "(none)")} create_calls=${createCalls.length} status=${String(processed?.result?.context_suggestion_status || "(none)")}`,
+    );
+  } catch (err) {
+    push("duplicate_suggested_project_context_is_not_created", false, String(err?.message || err));
+  }
+
+  try {
+    const createCalls = [];
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-selftest-context-suggest-question-"));
+    const processed = await processRunnerSelectedRecord({
       routeKey: "context-suggest-question-key",
       normalizedRoute: normalizeRunnerRoute({
         name: "telegram-monitor-context-suggest-question",
@@ -19962,7 +20315,7 @@ export async function runSelftestRunnerScenarios(push, deps) {
         reduceContextWindowForHumanIntent: (items) => items,
         buildRunnerContextWindow: () => [{ id: "ctx-1" }],
         buildHumanIntentContextWindowOptions: () => ({}),
-        loadActiveProjectContextItems: async () => [{ id: "pc-1" }],
+        loadProjectContextItemsForPrompt: async () => [{ id: "pc-1" }],
         isInformationalHumanIntentType: (value) => String(value || "").trim().toLowerCase() === "status_query",
         resolveInformationalQueryExecutionPlan: (plan) => ({ ...plan, mode: "lookup_only" }),
         buildRunnerInputPayload: (payload) => ({

package/package.json

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