metheus-governance-mcp-cli 0.2.201 → 0.2.203

package/cli.mjs

@@ -2167,6 +2167,33 @@ function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
       conversation_allowed_responders: ensureArray(entry.conversation_allowed_responders || entry.conversationAllowedResponders)
         .map((value) => normalizeTelegramMentionUsername(value))
         .filter(Boolean),
+      conversation_intent_mode: String(entry.conversation_intent_mode || entry.conversationIntentMode || "").trim().toLowerCase(),
+      conversation_lead_bot: normalizeTelegramMentionUsername(entry.conversation_lead_bot || entry.conversationLeadBot),
+      conversation_summary_bot: normalizeTelegramMentionUsername(entry.conversation_summary_bot || entry.conversationSummaryBot),
+      conversation_participants: ensureArray(entry.conversation_participants || entry.conversationParticipants)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
+      conversation_initial_responders: ensureArray(entry.conversation_initial_responders || entry.conversationInitialResponders)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
+      conversation_allow_bot_to_bot: boolFromRaw(
+        entry.conversation_allow_bot_to_bot ?? entry.conversationAllowBotToBot,
+        false,
+      ),
+      conversation_reply_expectation: String(
+        entry.conversation_reply_expectation || entry.conversationReplyExpectation || "",
+      ).trim().toLowerCase(),
+      execution_contract_type: String(entry.execution_contract_type || entry.executionContractType || "").trim().toLowerCase(),
+      execution_contract_actionable: boolFromRaw(
+        entry.execution_contract_actionable ?? entry.executionContractActionable,
+        false,
+      ),
+      execution_contract_targets: ensureArray(entry.execution_contract_targets || entry.executionContractTargets)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
+      next_expected_responders: ensureArray(entry.next_expected_responders || entry.nextExpectedResponders)
+        .map((value) => normalizeTelegramMentionUsername(value))
+        .filter(Boolean),
       normalized_intent: String(entry.normalized_intent || entry.normalizedIntent || "").trim().toLowerCase(),
       status,
       claimed_by_route: String(entry.claimed_by_route || entry.claimedByRoute || "").trim(),
@@ -2553,6 +2580,86 @@ async function findServerRunnerRequestForMessageID({
   }
 }
 
+function runnerRequestHasConversationContractData(entryRaw) {
+  const entry = safeObject(entryRaw);
+  return Boolean(
+    String(entry.conversation_intent_mode || "").trim()
+    || String(entry.conversation_lead_bot || "").trim()
+    || String(entry.conversation_summary_bot || "").trim()
+    || ensureArray(entry.conversation_participants).length
+    || ensureArray(entry.conversation_initial_responders).length
+    || ensureArray(entry.conversation_allowed_responders).length
+    || entry.conversation_allow_bot_to_bot === true
+    || String(entry.conversation_reply_expectation || "").trim()
+    || String(entry.execution_contract_type || "").trim()
+    || entry.execution_contract_actionable === true
+    || ensureArray(entry.execution_contract_targets).length
+    || ensureArray(entry.next_expected_responders).length
+  );
+}
+
+function pickRunnerSharedConversationSourceRequest(entries = [], excludeRequestKey = "") {
+  const excludedKey = String(excludeRequestKey || "").trim();
+  const matched = sortRunnerRequestEntriesNewestFirst(ensureArray(entries))
+    .filter((entryRaw) => String(safeObject(entryRaw).request_key || "").trim() !== excludedKey)
+    .filter((entryRaw) => {
+      const entry = safeObject(entryRaw);
+      return runnerRequestHasConversationContractData(entry)
+        || String(entry.root_work_item_id || "").trim()
+        || String(entry.root_thread_id || "").trim();
+    });
+  return safeObject(matched[0]);
+}
+
+async function findServerRunnerConversationSourceRequestForMessageID({
+  normalizedRoute,
+  runtime,
+  chatID,
+  messageID,
+  excludeRequestKey = "",
+}) {
+  const projectID = String(normalizedRoute?.projectID || "").trim();
+  const provider = String(normalizedRoute?.provider || "").trim();
+  const normalizedChatID = String(chatID || "").trim();
+  const normalizedMessageID = intFromRawAllowZero(messageID, 0);
+  if (
+    !projectID
+    || !provider
+    || !normalizedChatID
+    || normalizedMessageID <= 0
+    || !runtime?.baseURL
+    || !runtime?.token
+  ) {
+    return null;
+  }
+  try {
+    const serverRequests = await listProjectRunnerRequests({
+      siteBaseURL: runtime.baseURL,
+      projectID,
+      token: runtime.token,
+      timeoutSeconds: runtime.timeoutSeconds,
+      actorUserID: runtime.actor?.user_id,
+      limit: 500,
+      offset: 0,
+    });
+    const matched = serverRequests.filter((entryRaw) => {
+      const entry = safeObject(entryRaw);
+      return (
+        String(entry.project_id || "").trim() === projectID
+        && String(entry.provider || "").trim() === provider
+        && String(entry.chat_id || "").trim() === normalizedChatID
+        && (
+          intFromRawAllowZero(entry.source_message_id, 0) === normalizedMessageID
+          || intFromRawAllowZero(entry.last_source_message_id, 0) === normalizedMessageID
+        )
+      );
+    });
+    return pickRunnerSharedConversationSourceRequest(matched, excludeRequestKey);
+  } catch {
+    return null;
+  }
+}
+
 async function loadRunnerArchiveThreadMessageIndex({
   runtime,
   threadID,
@@ -2900,7 +3007,6 @@ async function claimRunnerRequestForHumanComment({
   });
   const replyChainContext = safeObject(replyChainResolution.replyChainContext);
   const referencedRequest = safeObject(replyChainContext.referencedRequest);
-  const conversationID = String(parsed.conversationID || replyChainContext.conversationID || "").trim();
   const resolvedNormalizedIntent = resolveRunnerRequestClaimIntent({
     normalizedIntent,
     selectedRecord,
@@ -2912,14 +3018,19 @@ async function claimRunnerRequestForHumanComment({
     normalizedIntent: resolvedNormalizedIntent,
   });
   let stateForClaim = safeObject(replyChainResolution.state);
+  const baseConversationID = String(
+    parsed.conversationID
+    || replyChainContext.conversationID
+    || "",
+  ).trim();
   if (
     Object.keys(referencedRequest).length > 0
-    && conversationID
+    && baseConversationID
     && !String(referencedRequest.conversation_id || "").trim()
     && String(referencedRequest.request_key || "").trim()
   ) {
     const backfilled = upsertRunnerRequest(stateForClaim, referencedRequest.request_key, {
-      conversation_id: conversationID,
+      conversation_id: baseConversationID,
     });
     stateForClaim = {
       ...stateForClaim,
@@ -2928,6 +3039,35 @@ async function claimRunnerRequestForHumanComment({
   }
   const requests = normalizeBotRunnerRequests(stateForClaim.requests);
   const existing = safeObject(requests[requestKey]);
+  const currentMessageID = intFromRawAllowZero(parsed.messageID, 0);
+  let sharedConversationSource = currentMessageID > 0
+    ? pickRunnerSharedConversationSourceRequest(
+      findRunnerRequestsForMessageID(stateForClaim, normalizedRoute, {
+        chatID: String(parsed.chatID || parsed.chatId || "").trim(),
+        messageID: currentMessageID,
+      }),
+      requestKey,
+    )
+    : {};
+  if (
+    !Object.keys(sharedConversationSource).length
+    && currentMessageID > 0
+    && runtime?.baseURL
+    && runtime?.token
+  ) {
+    sharedConversationSource = safeObject(await findServerRunnerConversationSourceRequestForMessageID({
+      normalizedRoute,
+      runtime,
+      chatID: String(parsed.chatID || parsed.chatId || "").trim(),
+      messageID: currentMessageID,
+      excludeRequestKey: requestKey,
+    }));
+  }
+  const resolvedConversationID = String(
+    baseConversationID
+    || sharedConversationSource.conversation_id
+    || "",
+  ).trim();
   if (isFinalRunnerRequestStatus(existing.status)) {
     return {
       ok: false,
@@ -2954,23 +3094,87 @@ async function claimRunnerRequestForHumanComment({
     source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
     root_comment_id: String(selectedRecord?.id || "").trim(),
     root_comment_kind: commentKind,
-    conversation_id: conversationID,
+    conversation_id: resolvedConversationID,
     selected_bot_usernames: uniqueOrderedStrings(selectedBotUsernames, normalizeTelegramMentionUsername),
+    conversation_intent_mode: String(
+      existing.conversation_intent_mode || sharedConversationSource.conversation_intent_mode || referencedRequest.conversation_intent_mode || "",
+    ).trim().toLowerCase(),
+    conversation_lead_bot: normalizeTelegramMentionUsername(
+      existing.conversation_lead_bot || sharedConversationSource.conversation_lead_bot || referencedRequest.conversation_lead_bot,
+    ),
+    conversation_summary_bot: normalizeTelegramMentionUsername(
+      existing.conversation_summary_bot || sharedConversationSource.conversation_summary_bot || referencedRequest.conversation_summary_bot,
+    ),
+    conversation_participants: uniqueOrderedStrings(
+      ensureArray(existing.conversation_participants).length
+        ? existing.conversation_participants
+        : ensureArray(sharedConversationSource.conversation_participants).length
+          ? sharedConversationSource.conversation_participants
+          : referencedRequest.conversation_participants,
+      normalizeTelegramMentionUsername,
+    ),
+    conversation_initial_responders: uniqueOrderedStrings(
+      ensureArray(existing.conversation_initial_responders).length
+        ? existing.conversation_initial_responders
+        : ensureArray(sharedConversationSource.conversation_initial_responders).length
+          ? sharedConversationSource.conversation_initial_responders
+          : referencedRequest.conversation_initial_responders,
+      normalizeTelegramMentionUsername,
+    ),
+    conversation_allowed_responders: uniqueOrderedStrings(
+      ensureArray(existing.conversation_allowed_responders).length
+        ? existing.conversation_allowed_responders
+        : ensureArray(sharedConversationSource.conversation_allowed_responders).length
+          ? sharedConversationSource.conversation_allowed_responders
+          : referencedRequest.conversation_allowed_responders,
+      normalizeTelegramMentionUsername,
+    ),
+    conversation_allow_bot_to_bot: existing.conversation_allow_bot_to_bot === true
+      || sharedConversationSource.conversation_allow_bot_to_bot === true
+      || referencedRequest.conversation_allow_bot_to_bot === true,
+    conversation_reply_expectation: String(
+      existing.conversation_reply_expectation || sharedConversationSource.conversation_reply_expectation || referencedRequest.conversation_reply_expectation || "",
+    ).trim().toLowerCase(),
+    execution_contract_type: String(
+      existing.execution_contract_type || sharedConversationSource.execution_contract_type || referencedRequest.execution_contract_type || "",
+    ).trim().toLowerCase(),
+    execution_contract_actionable: existing.execution_contract_actionable === true
+      || sharedConversationSource.execution_contract_actionable === true
+      || referencedRequest.execution_contract_actionable === true,
+    execution_contract_targets: uniqueOrderedStrings(
+      ensureArray(existing.execution_contract_targets).length
+        ? existing.execution_contract_targets
+        : ensureArray(sharedConversationSource.execution_contract_targets).length
+          ? sharedConversationSource.execution_contract_targets
+          : referencedRequest.execution_contract_targets,
+      normalizeTelegramMentionUsername,
+    ),
+    next_expected_responders: uniqueOrderedStrings(
+      ensureArray(existing.next_expected_responders).length
+        ? existing.next_expected_responders
+        : ensureArray(sharedConversationSource.next_expected_responders).length
+          ? sharedConversationSource.next_expected_responders
+          : referencedRequest.next_expected_responders,
+      normalizeTelegramMentionUsername,
+    ),
     normalized_intent: resolvedNormalizedIntent,
     status: "claimed",
     claimed_by_route: String(routeKey || "").trim(),
     claimed_at: firstNonEmptyString([existing.claimed_at, nowISO]) || nowISO,
-    root_work_item_id: String(existing.root_work_item_id || referencedRequest.root_work_item_id || "").trim(),
-    root_work_item_title: String(existing.root_work_item_title || referencedRequest.root_work_item_title || "").trim(),
+    root_work_item_id: String(existing.root_work_item_id || sharedConversationSource.root_work_item_id || referencedRequest.root_work_item_id || "").trim(),
+    root_work_item_title: String(existing.root_work_item_title || sharedConversationSource.root_work_item_title || referencedRequest.root_work_item_title || "").trim(),
     root_work_item_status: normalizeRunnerWorkItemStatus(
-      existing.root_work_item_status || referencedRequest.root_work_item_status,
+      existing.root_work_item_status || sharedConversationSource.root_work_item_status || referencedRequest.root_work_item_status,
     ),
-    root_thread_id: String(existing.root_thread_id || referencedRequest.root_thread_id || "").trim(),
+    root_thread_id: String(existing.root_thread_id || sharedConversationSource.root_thread_id || referencedRequest.root_thread_id || "").trim(),
     root_work_item_created_at: firstNonEmptyString([
       existing.root_work_item_created_at,
+      sharedConversationSource.root_work_item_created_at,
       referencedRequest.root_work_item_created_at,
     ]),
-    root_work_item_last_error: String(existing.root_work_item_last_error || "").trim(),
+    root_work_item_last_error: String(
+      existing.root_work_item_last_error || sharedConversationSource.root_work_item_last_error || "",
+    ).trim(),
     last_comment_id: String(selectedRecord?.id || "").trim(),
     last_comment_kind: commentKind,
     last_source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
@@ -2980,7 +3184,7 @@ async function claimRunnerRequestForHumanComment({
     provider: String(normalizedRoute?.provider || "").trim(),
     request_key: requestKey,
     route_key: String(routeKey || "").trim(),
-    conversation_id: conversationID,
+    conversation_id: resolvedConversationID,
     source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
     comment_kind: commentKind,
     request_status: "claimed",
@@ -3728,11 +3932,18 @@ function markRunnerRequestLifecycle({
   outcome,
   conversationIDRaw = "",
   allowedResponders = [],
+  conversationParticipants = [],
+  conversationInitialResponders = [],
   executionContractType = "",
+  executionContractActionable = false,
   executionContractTargets = [],
   nextExpectedResponders = [],
   currentBotSelector = "",
   conversationIntentMode = "",
+  conversationLeadBot = "",
+  conversationSummaryBot = "",
+  conversationAllowBotToBot = false,
+  conversationReplyExpectation = "",
   normalizedIntent = "",
   closedReason = "",
 }) {
@@ -3777,6 +3988,16 @@ function markRunnerRequestLifecycle({
   const nowISO = new Date().toISOString();
   const patch = {
     conversation_id: conversationID,
+    conversation_participants: uniqueOrderedStrings(
+      ensureArray(conversationParticipants).length ? conversationParticipants : existing.conversation_participants,
+      normalizeTelegramMentionUsername,
+    ),
+    conversation_initial_responders: uniqueOrderedStrings(
+      ensureArray(conversationInitialResponders).length
+        ? conversationInitialResponders
+        : existing.conversation_initial_responders,
+      normalizeTelegramMentionUsername,
+    ),
     conversation_allowed_responders: uniqueOrderedStrings(
       ensureArray(allowedResponders).length ? allowedResponders : existing.conversation_allowed_responders,
       normalizeTelegramMentionUsername,
@@ -3786,11 +4007,30 @@ function markRunnerRequestLifecycle({
       || existing.conversation_intent_mode
       || "",
     ).trim().toLowerCase(),
+    conversation_lead_bot: normalizeTelegramMentionUsername(
+      conversationLeadBot
+      || existing.conversation_lead_bot
+      || "",
+    ),
+    conversation_summary_bot: normalizeTelegramMentionUsername(
+      conversationSummaryBot
+      || existing.conversation_summary_bot
+      || "",
+    ),
+    conversation_allow_bot_to_bot: conversationAllowBotToBot === true
+      || existing.conversation_allow_bot_to_bot === true,
+    conversation_reply_expectation: String(
+      conversationReplyExpectation
+      || existing.conversation_reply_expectation
+      || "",
+    ).trim().toLowerCase(),
     execution_contract_type: String(
       executionContractType
       || existing.execution_contract_type
       || "",
     ).trim().toLowerCase(),
+    execution_contract_actionable: executionContractActionable === true
+      || existing.execution_contract_actionable === true,
     execution_contract_targets: uniqueOrderedStrings(
       ensureArray(executionContractTargets).length ? executionContractTargets : existing.execution_contract_targets,
       normalizeTelegramMentionUsername,
@@ -3999,13 +4239,36 @@ function mergeRunnerRequestForServerHydration(localEntryRaw, serverEntryRaw) {
       merged[fieldName] = localValue;
     }
   };
+  const preserveLocalArrayWhenServerEmpty = (fieldName) => {
+    const serverValues = ensureArray(serverEntry[fieldName]).filter(Boolean);
+    const localValues = ensureArray(localEntry[fieldName]).filter(Boolean);
+    if (serverValues.length === 0 && localValues.length > 0) {
+      merged[fieldName] = localValues;
+    }
+  };
   preserveLocalStringWhenServerBlank("conversation_id");
+  preserveLocalStringWhenServerBlank("conversation_intent_mode");
+  preserveLocalStringWhenServerBlank("conversation_lead_bot");
+  preserveLocalStringWhenServerBlank("conversation_summary_bot");
+  preserveLocalStringWhenServerBlank("conversation_reply_expectation");
+  preserveLocalStringWhenServerBlank("execution_contract_type");
   preserveLocalStringWhenServerBlank("root_work_item_id");
   preserveLocalStringWhenServerBlank("root_work_item_title");
   preserveLocalStringWhenServerBlank("root_work_item_status");
   preserveLocalStringWhenServerBlank("root_thread_id");
   preserveLocalStringWhenServerBlank("root_work_item_created_at");
   preserveLocalStringWhenServerBlank("root_work_item_last_error");
+  preserveLocalArrayWhenServerEmpty("conversation_participants");
+  preserveLocalArrayWhenServerEmpty("conversation_initial_responders");
+  preserveLocalArrayWhenServerEmpty("conversation_allowed_responders");
+  preserveLocalArrayWhenServerEmpty("execution_contract_targets");
+  preserveLocalArrayWhenServerEmpty("next_expected_responders");
+  if (serverEntry.conversation_allow_bot_to_bot !== true && localEntry.conversation_allow_bot_to_bot === true) {
+    merged.conversation_allow_bot_to_bot = true;
+  }
+  if (serverEntry.execution_contract_actionable !== true && localEntry.execution_contract_actionable === true) {
+    merged.execution_contract_actionable = true;
+  }
   const localStatus = normalizeRunnerRequestStatus(localEntry.status);
   const serverStatus = normalizeRunnerRequestStatus(serverEntry.status);
   if (isFinalRunnerRequestStatus(localStatus) && !isFinalRunnerRequestStatus(serverStatus)) {
@@ -6319,6 +6582,7 @@ function stableTextModulo(rawValue, modulo = 1) {
   return hash % normalizedModulo;
 }
 
+/* Dead small_talk helper kept only as commented legacy code after lookup-only migration.
 function buildRunnerSmallTalkReply({ route, executionPlan } = {}) {
   const normalizedRoute = safeObject(route);
   const roleProfileName = normalizeRunnerRoleProfileName(
@@ -6355,6 +6619,7 @@ function buildRunnerSmallTalkReply({ route, executionPlan } = {}) {
   const templatePool = roleSpecificReplies[roleProfileName] || roleSpecificReplies.monitor;
   return templatePool[stableTextModulo(`${displayName}:${roleProfileName}`, templatePool.length)];
 }
+*/
 
 function buildInformationalMiniExecutionOverride({ route, executionPlan } = {}) {
   const safeRoute = safeObject(route);
@@ -6363,8 +6628,8 @@ function buildInformationalMiniExecutionOverride({ route, executionPlan } = {})
     safeExecutionPlan.roleProfileName || safeRoute.roleProfile || safeRoute.role || "monitor",
   ) || "monitor";
   const lightweightModel = String(
-    resolveResponderAdjudicatorModelDisplayName({ client: "gpt", env: process.env }) || "gpt-5.3-codex-spark",
-  ).trim() || "gpt-5.3-codex-spark";
+    resolveResponderAdjudicatorModelDisplayName({ client: "gpt", env: process.env }) || "gpt-5.4-mini",
+  ).trim() || "gpt-5.4-mini";
   return {
     mode: "role_profile",
     role_profile_name: roleProfileName,
@@ -6616,11 +6881,11 @@ async function resolveInformationalQueryReply({
         user_message: messageText,
         bot_name: firstNonEmptyString([route?.botName, route?.serverBotName, route?.server_bot_name, route?.name]),
         bot_role: String(route?.role || route?.roleProfile || "").trim(),
-        proposed_summary: buildRunnerSmallTalkReply({ route, executionPlan }),
       },
       execution_override: executionOverride,
     };
   }
+  /* Dead legacy direct small_talk branch kept commented for reference.
   if (false && normalizedIntentType === "small_talk") {
     return {
       handled: true,
@@ -6628,6 +6893,7 @@ async function resolveInformationalQueryReply({
       source: "small_talk",
     };
   }
+  */
   if (normalizedIntentType === "workspace_query") {
     const workspace = resolveProjectWorkspaceBindingSummary(route?.projectID, executionPlan?.workspaceDir || route?.workspaceDir || "");
     const workspaceDir = String(workspace.workspace_dir || "").trim();
@@ -6641,7 +6907,6 @@ async function resolveInformationalQueryReply({
       source: "project.workspace",
       lookup: {
         ...workspace,
-        proposed_summary: reply,
       },
       execution_override: executionOverride,
     };
@@ -6660,7 +6925,6 @@ async function resolveInformationalQueryReply({
       source: "project.bot_roles",
       lookup: {
         ...payload,
-        proposed_summary: buildProjectBotRolesText(payload),
       },
       execution_override: executionOverride,
     };
@@ -6730,7 +6994,6 @@ async function resolveInformationalQueryReply({
       source: "project.file.locate",
       lookup: {
         ...payload,
-        proposed_summary: buildProjectFileLocateText(payload),
       },
       execution_override: executionOverride,
     };
@@ -7832,6 +8095,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         runtime,
         triggerDecision,
         responderAdjudication: inlineAdjudication,
+        persistedHumanIntentRequest: claimedRequest,
         deps: {
           saveRunnerRouteState,
           startRunnerTypingHeartbeat,
@@ -7886,8 +8150,15 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           routeKey,
           outcome: String(processed.result?.outcome || "replied").trim().toLowerCase(),
           conversationIDRaw: String(processed.result?.conversation_id || "").trim(),
+          conversationParticipants: ensureArray(processed.result?.conversation_participants),
+          conversationInitialResponders: ensureArray(processed.result?.conversation_initial_responders),
           allowedResponders: ensureArray(processed.result?.conversation_allowed_responders),
+          conversationLeadBot: String(processed.result?.conversation_lead_bot || "").trim(),
+          conversationSummaryBot: String(processed.result?.conversation_summary_bot || "").trim(),
+          conversationAllowBotToBot: processed.result?.conversation_allow_bot_to_bot === true,
+          conversationReplyExpectation: String(processed.result?.conversation_reply_expectation || "").trim(),
           executionContractType: String(processed.result?.execution_contract_type || "").trim(),
+          executionContractActionable: processed.result?.execution_contract_actionable === true,
           executionContractTargets: ensureArray(processed.result?.execution_contract_targets),
           nextExpectedResponders: ensureArray(processed.result?.next_expected_responders),
           currentBotSelector,
@@ -10193,6 +10464,7 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                       runtime: deferredExecution.runtime,
                       triggerDecision: deferredExecution.triggerDecision,
                       responderAdjudication: deferredExecution.responderAdjudication,
+                      persistedHumanIntentRequest: loadRunnerRequestByKey(deferredExecution.requestKey),
                       deps: {
                         saveRunnerRouteState,
                         startRunnerTypingHeartbeat,
@@ -10278,8 +10550,15 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                         routeKey: deferredExecution.routeKey,
                         outcome: String(processed.result?.outcome || "replied").trim().toLowerCase(),
                         conversationIDRaw: String(processed.result?.conversation_id || "").trim(),
+                        conversationParticipants: ensureArray(processed.result?.conversation_participants),
+                        conversationInitialResponders: ensureArray(processed.result?.conversation_initial_responders),
                         allowedResponders: ensureArray(processed.result?.conversation_allowed_responders),
+                        conversationLeadBot: String(processed.result?.conversation_lead_bot || "").trim(),
+                        conversationSummaryBot: String(processed.result?.conversation_summary_bot || "").trim(),
+                        conversationAllowBotToBot: processed.result?.conversation_allow_bot_to_bot === true,
+                        conversationReplyExpectation: String(processed.result?.conversation_reply_expectation || "").trim(),
                         executionContractType: String(processed.result?.execution_contract_type || "").trim(),
+                        executionContractActionable: processed.result?.execution_contract_actionable === true,
                         executionContractTargets: ensureArray(processed.result?.execution_contract_targets),
                         nextExpectedResponders: ensureArray(processed.result?.next_expected_responders),
                         currentBotSelector: normalizeTelegramMentionUsername(
@@ -14394,21 +14673,6 @@ async function runSelftest(flags = {}) {
     String(parsedEnv.SLACK_BOT_TOKEN || "") === "xoxb-test",
     `token=${String(parsedEnv.SLACK_BOT_TOKEN || "(missing)")}`,
   );
-  const monitorGreeting = buildRunnerSmallTalkReply({
-    route: { botName: "RyoAI_bot", roleProfile: "monitor" },
-    executionPlan: { roleProfileName: "monitor" },
-  });
-  const reviewGreeting = buildRunnerSmallTalkReply({
-    route: { botName: "RyoAI2_bot", roleProfile: "review" },
-    executionPlan: { roleProfileName: "review" },
-  });
-  push(
-    "small_talk_reply_varies_by_bot_and_role",
-    monitorGreeting.includes("RyoAI_bot")
-      && reviewGreeting.includes("RyoAI2_bot")
-      && monitorGreeting !== reviewGreeting,
-    `monitor=${monitorGreeting} review=${reviewGreeting}`,
-  );
   const informationalMiniReply = await resolveInformationalQueryReply({
     intentType: "small_talk",
     route: { botName: "RyoAI_bot", role: "monitor", roleProfile: "monitor" },
@@ -14441,6 +14705,7 @@ async function runSelftest(flags = {}) {
     safeObject(informationalMiniReply).handled === true
       && String(safeObject(informationalMiniReply).response_mode || "") === "lookup_only"
       && String(safeObject(informationalMiniReply).reply || "") === ""
+      && !Object.prototype.hasOwnProperty.call(safeObject(safeObject(informationalMiniReply).lookup), "proposed_summary")
       && String(safeObject(safeObject(informationalMiniReply).execution_override).role_profile?.client || "") === "gpt"
       && String(safeObject(safeObject(informationalMiniReply).execution_override).role_profile?.model || "") === String(expectedInformationalModel || "")
       && String(safeObject(safeObject(informationalMiniReply).execution_override).role_profile?.permissionMode || "") === "read_only"
@@ -14564,28 +14829,28 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     summarizeProviderSupport("kakaotalk"),
   );
   push(
-    "intent_parser_default_model_uses_codex_spark_without_openai_api_key",
-    resolveIntentParserModelDisplayName({ client: "gpt", env: {} }) === "gpt-5.3-codex-spark",
+    "intent_parser_default_model_uses_gpt_5_4_mini_without_openai_api_key",
+    resolveIntentParserModelDisplayName({ client: "gpt", env: {} }) === "gpt-5.4-mini",
     resolveIntentParserModelDisplayName({ client: "gpt", env: {} }),
   );
   push(
-    "intent_parser_prefers_gpt_5_mini_when_openai_api_key_present",
-    resolveIntentParserModelDisplayName({ client: "gpt", env: { OPENAI_API_KEY: "sk-selftest" } }) === "gpt-5-mini",
+    "intent_parser_defaults_to_gpt_5_4_mini_when_openai_api_key_present",
+    resolveIntentParserModelDisplayName({ client: "gpt", env: { OPENAI_API_KEY: "sk-selftest" } }) === "gpt-5.4-mini",
     resolveIntentParserModelDisplayName({ client: "gpt", env: { OPENAI_API_KEY: "sk-selftest" } }),
   );
   push(
-    "responder_adjudicator_default_model_uses_codex_spark_without_openai_api_key",
-    resolveResponderAdjudicatorModelDisplayName({ client: "gpt", env: {} }) === "gpt-5.3-codex-spark",
+    "responder_adjudicator_default_model_uses_gpt_5_4_mini_without_openai_api_key",
+    resolveResponderAdjudicatorModelDisplayName({ client: "gpt", env: {} }) === "gpt-5.4-mini",
     resolveResponderAdjudicatorModelDisplayName({ client: "gpt", env: {} }),
   );
   push(
-    "responder_adjudicator_prefers_gpt_5_mini_when_openai_api_key_present",
-    resolveResponderAdjudicatorModelDisplayName({ client: "gpt", env: { OPENAI_API_KEY: "sk-selftest" } }) === "gpt-5-mini",
+    "responder_adjudicator_defaults_to_gpt_5_4_mini_when_openai_api_key_present",
+    resolveResponderAdjudicatorModelDisplayName({ client: "gpt", env: { OPENAI_API_KEY: "sk-selftest" } }) === "gpt-5.4-mini",
     resolveResponderAdjudicatorModelDisplayName({ client: "gpt", env: { OPENAI_API_KEY: "sk-selftest" } }),
   );
   push(
-    "role_planner_default_model_uses_gpt_5_mini",
-    resolveRolePlannerModelDisplayName({ client: "gpt", env: {} }) === "gpt-5-mini",
+    "role_planner_default_model_uses_gpt_5_4_mini",
+    resolveRolePlannerModelDisplayName({ client: "gpt", env: {} }) === "gpt-5.4-mini",
     resolveRolePlannerModelDisplayName({ client: "gpt", env: {} }),
   );
   push(
@@ -15945,7 +16210,7 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
           client: "gpt",
           model: "gpt-5.4",
           planner_client: "gpt",
-          planner_model: "gpt-5-mini",
+          planner_model: "gpt-5.4-mini",
           intent_type: "status_query",
           source_message_id: 128,
           next_run_at: Date.now() + 5000,
@@ -15975,7 +16240,7 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
         && frame.includes("telegram-monitor-self...")
         && frame.includes("AI_RUNNING")
         && frame.includes("gpt/gpt-5.4")
-        && frame.includes("planner=gpt/gpt-5-mini")
+        && frame.includes("planner=gpt/gpt-5.4-mini")
         && frame.includes("status_query")
         && frame.includes("warning=active execution is taking longer than expected"),
       frame.replace(/\r?\n/g, " | "),

package/lib/local-ai-adapters.mjs

@@ -25,6 +25,11 @@ const LOCAL_AI_MODEL_MAPPINGS = {
       execution: "gpt-5.4",
       aliases: ["gpt-5.4", "gpt 5.4", "GPT-5.4"],
     },
+    {
+      display: "gpt-5.4-mini",
+      execution: "gpt-5.4-mini",
+      aliases: ["gpt-5.4-mini", "gpt 5.4 mini", "GPT-5.4-mini", "gpt5.4-mini", "gpt54-mini"],
+    },
     {
       display: "gpt-5-mini",
       execution: "gpt-5-mini",
@@ -1068,12 +1073,11 @@ function truthyEnvFlag(value) {
 function defaultAdjudicationModelForClient(clientName, env = process.env) {
   const normalizedClient = normalizeLocalAIClientName(clientName, "");
   if (normalizedClient === "gpt") {
-    const hasOpenAIAPIKey = String(env?.OPENAI_API_KEY || "").trim().length > 0;
     const prefersMini = truthyEnvFlag(env?.METHEUS_PREFER_GPT_5_MINI_ADJUDICATOR);
-    if (hasOpenAIAPIKey || prefersMini) {
+    if (prefersMini) {
       return "gpt-5-mini";
     }
-    return "gpt-5.3-codex-spark";
+    return "gpt-5.4-mini";
   }
   return suggestLocalAIModelDisplayName(normalizedClient, "");
 }
@@ -1081,7 +1085,7 @@ function defaultAdjudicationModelForClient(clientName, env = process.env) {
 function defaultRolePlannerModelForClient(clientName) {
   const normalizedClient = normalizeLocalAIClientName(clientName, "");
   if (normalizedClient === "gpt") {
-    return "gpt-5-mini";
+    return "gpt-5.4-mini";
   }
   return suggestLocalAIModelDisplayName(normalizedClient, "");
 }
@@ -1786,9 +1790,6 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
     if (queryLookupResponseMode) {
       lines.push(`- Response mode: ${queryLookupResponseMode}`);
     }
-    if (String(queryLookup.proposed_reply || "").trim()) {
-      lines.push(`- Proposed factual reply: ${String(queryLookup.proposed_reply || "").trim()}`);
-    }
     if (queryLookupFacts != null) {
       lines.push("Structured lookup facts:");
       lines.push(JSON.stringify(queryLookupFacts, null, 2));
@@ -1994,7 +1995,7 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
         String(conversation.intent_mode || "").trim() === "delegated_single_lead"
           ? (selfIsLeadBot
             ? "This bot is the lead bot for a delegated public collaboration. It may assign work publicly only to allowed responders, and it may not expand the participant set."
-            : "This bot is not the lead bot. Respond only when the lead bot or the human explicitly addresses this bot, and do not start peer-to-peer chains.")
+            : "This bot is not the lead bot. Prefer replying when the human, the lead bot, or another managed bot explicitly addresses this bot in the live room context. Do not expand the participant set beyond the allowed responders.")
           : "Use the human conversation contract as the source of truth for who may reply.",
         conversation.allow_bot_to_bot === true
           ? "If another bot explicitly mentioned you and you are in the allowed responders list, you may answer that bot publicly in the room."
@@ -2663,7 +2664,7 @@ export function adjudicateRunnerStartupLoopWithAI({
     || env?.METHEUS_STARTUP_LOOP_ADJUDICATOR_MODEL
     || env?.METHEUS_RESPONDER_ADJUDICATOR_MODEL
     || env?.METHEUS_INTENT_PARSER_MODEL
-    || (adjudicatorClient === "gpt" ? "gpt-5.3-codex-spark" : suggestLocalAIModelDisplayName(adjudicatorClient, ""))
+    || (adjudicatorClient === "gpt" ? "gpt-5.4-mini" : suggestLocalAIModelDisplayName(adjudicatorClient, ""))
     || "",
   ).trim();
   const rawText = runLocalAIPromptRawText({