metheus-governance-mcp-cli 0.2.202 → 0.2.204

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)) {
@@ -6365,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,
@@ -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(
@@ -14550,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(
@@ -15931,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,
@@ -15961,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, "");
 }
@@ -2660,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({

package/lib/runner-data.mjs

@@ -339,8 +339,19 @@ export async function listProjectRunnerRequests(
       root_comment_kind: String(row.root_comment_kind || row.rootCommentKind || row.RootCommentKind || "").trim(),
       conversation_id: String(row.conversation_id || row.conversationID || row.ConversationID || "").trim(),
       selected_bot_usernames: ensureArray(row.selected_bot_usernames || row.selectedBotUsernames || row.SelectedBotUsernames).map((value) => String(value || "").trim()).filter(Boolean),
+      conversation_intent_mode: String(row.conversation_intent_mode || row.conversationIntentMode || row.ConversationIntentMode || "").trim(),
+      conversation_lead_bot: String(row.conversation_lead_bot || row.conversationLeadBot || row.ConversationLeadBot || "").trim(),
+      conversation_summary_bot: String(row.conversation_summary_bot || row.conversationSummaryBot || row.ConversationSummaryBot || "").trim(),
+      conversation_participants: ensureArray(row.conversation_participants || row.conversationParticipants || row.ConversationParticipants).map((value) => String(value || "").trim()).filter(Boolean),
+      conversation_initial_responders: ensureArray(row.conversation_initial_responders || row.conversationInitialResponders || row.ConversationInitialResponders).map((value) => String(value || "").trim()).filter(Boolean),
       conversation_allowed_responders: ensureArray(row.conversation_allowed_responders || row.conversationAllowedResponders || row.ConversationAllowedResponders).map((value) => String(value || "").trim()).filter(Boolean),
+      conversation_allow_bot_to_bot: row.conversation_allow_bot_to_bot === true || row.conversationAllowBotToBot === true || row.ConversationAllowBotToBot === true,
+      conversation_reply_expectation: String(row.conversation_reply_expectation || row.conversationReplyExpectation || row.ConversationReplyExpectation || "").trim(),
       normalized_intent: String(row.normalized_intent || row.normalizedIntent || row.NormalizedIntent || "").trim(),
+      execution_contract_type: String(row.execution_contract_type || row.executionContractType || row.ExecutionContractType || "").trim(),
+      execution_contract_actionable: row.execution_contract_actionable === true || row.executionContractActionable === true || row.ExecutionContractActionable === true,
+      execution_contract_targets: ensureArray(row.execution_contract_targets || row.executionContractTargets || row.ExecutionContractTargets).map((value) => String(value || "").trim()).filter(Boolean),
+      next_expected_responders: ensureArray(row.next_expected_responders || row.nextExpectedResponders || row.NextExpectedResponders).map((value) => String(value || "").trim()).filter(Boolean),
       status: String(row.status || row.Status || "").trim(),
       claimed_by_route: String(row.claimed_by_route || row.claimedByRoute || row.ClaimedByRoute || "").trim(),
       claimed_at: String(row.claimed_at || row.claimedAt || row.ClaimedAt || "").trim(),
@@ -390,8 +401,19 @@ export async function upsertProjectRunnerRequest(
     root_comment_kind: String(raw.root_comment_kind || "").trim(),
     conversation_id: String(raw.conversation_id || "").trim(),
     selected_bot_usernames: ensureArray(raw.selected_bot_usernames).map((value) => String(value || "").trim()).filter(Boolean),
+    conversation_intent_mode: String(raw.conversation_intent_mode || "").trim(),
+    conversation_lead_bot: String(raw.conversation_lead_bot || "").trim(),
+    conversation_summary_bot: String(raw.conversation_summary_bot || "").trim(),
+    conversation_participants: ensureArray(raw.conversation_participants).map((value) => String(value || "").trim()).filter(Boolean),
+    conversation_initial_responders: ensureArray(raw.conversation_initial_responders).map((value) => String(value || "").trim()).filter(Boolean),
     conversation_allowed_responders: ensureArray(raw.conversation_allowed_responders).map((value) => String(value || "").trim()).filter(Boolean),
+    conversation_allow_bot_to_bot: raw.conversation_allow_bot_to_bot === true,
+    conversation_reply_expectation: String(raw.conversation_reply_expectation || "").trim(),
     normalized_intent: String(raw.normalized_intent || "").trim(),
+    execution_contract_type: String(raw.execution_contract_type || "").trim(),
+    execution_contract_actionable: raw.execution_contract_actionable === true,
+    execution_contract_targets: ensureArray(raw.execution_contract_targets).map((value) => String(value || "").trim()).filter(Boolean),
+    next_expected_responders: ensureArray(raw.next_expected_responders).map((value) => String(value || "").trim()).filter(Boolean),
     status: String(raw.status || "").trim(),
     claimed_by_route: String(raw.claimed_by_route || "").trim(),
     claimed_at: String(raw.claimed_at || "").trim() || undefined,