metheus-governance-mcp-cli 0.2.195 → 0.2.197

package/README.md

@@ -664,6 +664,11 @@ Runner command contract:
 Notes:
 - `runner once` processes the most recent pending archived inbound message
 - `runner start` keeps polling and stores per-route cursor state in `~/.metheus/bot-runner-state.json`
+- request execution is request-ledger first: one human root message becomes one `request_key`, and request status is the real execution gate
+- `conversation_session` is advisory metadata only; participants, last speaker, and next expected responders stay there, but session `open` alone must not revive old work
+- bot replies and public bot-to-bot delegation replies do not create a fresh request on their own; they continue only when an active request already exists for that conversation
+- consumed archived comments are recorded in the runner request comment ledger so the same bot reply does not get re-queued later as new work
+- startup cleanup closes stale open sessions without an active request and excludes their archived bot replies before pending selection runs
 - first start primes the cursor to the latest inbound message and does not reply to old backlog
 - when inline filters match a configured route in `~/.metheus/bot-runner.json`, the runner reuses that route's canonical name/destination and state cursor instead of creating a new anonymous route key
 - stale anonymous route keys in `~/.metheus/bot-runner-state.json` are auto-migrated to the matching configured route when possible; `doctor` warns if ambiguous legacy keys still remain

package/cli.mjs

@@ -2363,6 +2363,16 @@ function buildRunnerRequestKey({
   ].join("::");
 }
 
+function buildSyntheticReplyChainConversationID(normalizedRoute, chatID, anchorMessageID) {
+  const provider = String(normalizedRoute?.provider || "").trim() || "unknown";
+  const normalizedChatID = String(chatID || "").trim() || "-";
+  const normalizedAnchorMessageID = intFromRawAllowZero(anchorMessageID, 0);
+  if (normalizedAnchorMessageID <= 0) {
+    return "";
+  }
+  return `reply_chain:${provider}:${normalizedChatID}:${normalizedAnchorMessageID}`;
+}
+
 function findRunnerRequestsForScope(state, normalizedRoute, selectors = {}) {
   const requests = normalizeBotRunnerRequests(state?.requests);
   const projectID = String(normalizedRoute?.projectID || "").trim();
@@ -2386,6 +2396,61 @@ function findRunnerRequestsForScope(state, normalizedRoute, selectors = {}) {
     });
 }
 
+function findRunnerRequestsForMessageID(state, normalizedRoute, selectors = {}) {
+  const chatID = String(selectors.chatID || "").trim();
+  const messageID = intFromRawAllowZero(selectors.messageID, 0);
+  if (!chatID || messageID <= 0) {
+    return [];
+  }
+  return findRunnerRequestsForScope(state, normalizedRoute, { chatID })
+    .filter((entry) => (
+      intFromRawAllowZero(entry.source_message_id, 0) === messageID
+      || intFromRawAllowZero(entry.last_source_message_id, 0) === messageID
+    ));
+}
+
+function resolveRunnerReplyChainConversationContext(state, normalizedRoute, selectedRecord) {
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const explicitConversationID = String(parsed.conversationID || "").trim();
+  if (explicitConversationID) {
+    return {
+      conversationID: explicitConversationID,
+      replyToMessageID: intFromRawAllowZero(parsed.replyToMessageID, 0),
+      anchorMessageID: 0,
+      reason: "archive_conversation",
+      referencedRequest: null,
+    };
+  }
+  const chatID = String(parsed.chatID || parsed.chatId || "").trim();
+  const replyToMessageID = intFromRawAllowZero(parsed.replyToMessageID, 0);
+  if (!chatID || replyToMessageID <= 0) {
+    return {
+      conversationID: "",
+      replyToMessageID,
+      anchorMessageID: 0,
+      reason: "",
+      referencedRequest: null,
+    };
+  }
+  const referencedRequest = safeObject(findRunnerRequestsForMessageID(state, normalizedRoute, {
+    chatID,
+    messageID: replyToMessageID,
+  })[0]);
+  const referencedConversationID = String(referencedRequest.conversation_id || "").trim();
+  const anchorMessageID = intFromRawAllowZero(referencedRequest.source_message_id, 0) || replyToMessageID;
+  return {
+    conversationID: referencedConversationID || buildSyntheticReplyChainConversationID(normalizedRoute, chatID, anchorMessageID),
+    replyToMessageID,
+    anchorMessageID,
+    reason: referencedConversationID
+      ? "reply_request_conversation"
+      : Object.keys(referencedRequest).length > 0
+        ? "reply_request_synthetic"
+        : "reply_message_synthetic",
+    referencedRequest: Object.keys(referencedRequest).length > 0 ? referencedRequest : null,
+  };
+}
+
 function upsertRunnerRequest(state, requestKey, patch = {}) {
   const currentState = safeObject(state);
   const requests = normalizeBotRunnerRequests(currentState.requests);
@@ -2447,7 +2512,24 @@ function claimRunnerRequestForHumanComment({
     normalizedIntent,
   });
   const currentState = loadBotRunnerState();
-  const requests = normalizeBotRunnerRequests(currentState.requests);
+  const replyChainContext = resolveRunnerReplyChainConversationContext(currentState, normalizedRoute, selectedRecord);
+  const conversationID = String(parsed.conversationID || replyChainContext.conversationID || "").trim();
+  let stateForClaim = currentState;
+  if (
+    replyChainContext.referencedRequest
+    && conversationID
+    && !String(replyChainContext.referencedRequest.conversation_id || "").trim()
+    && String(replyChainContext.referencedRequest.request_key || "").trim()
+  ) {
+    const backfilled = upsertRunnerRequest(stateForClaim, replyChainContext.referencedRequest.request_key, {
+      conversation_id: conversationID,
+    });
+    stateForClaim = {
+      ...stateForClaim,
+      requests: backfilled.requests,
+    };
+  }
+  const requests = normalizeBotRunnerRequests(stateForClaim.requests);
   const existing = safeObject(requests[requestKey]);
   if (isFinalRunnerRequestStatus(existing.status)) {
     return {
@@ -2468,14 +2550,14 @@ function claimRunnerRequestForHumanComment({
     };
   }
   const nowISO = new Date().toISOString();
-  const { requests: nextRequests, request } = upsertRunnerRequest(currentState, requestKey, {
+  const { requests: nextRequests, request } = upsertRunnerRequest(stateForClaim, requestKey, {
     project_id: String(normalizedRoute?.projectID || "").trim(),
     provider: String(normalizedRoute?.provider || "").trim(),
     chat_id: String(parsed.chatID || parsed.chatId || "").trim(),
     source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
     root_comment_id: String(selectedRecord?.id || "").trim(),
     root_comment_kind: commentKind,
-    conversation_id: String(parsed.conversationID || "").trim(),
+    conversation_id: conversationID,
     selected_bot_usernames: uniqueOrderedStrings(selectedBotUsernames, normalizeTelegramMentionUsername),
     normalized_intent: String(normalizedIntent || "").trim().toLowerCase(),
     status: "claimed",
@@ -2485,20 +2567,20 @@ function claimRunnerRequestForHumanComment({
     last_comment_kind: commentKind,
     last_source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
   });
-  const { consumedComments: nextConsumedComments } = upsertRunnerConsumedComment(currentState, selectedRecord?.id, {
+  const { consumedComments: nextConsumedComments } = upsertRunnerConsumedComment(stateForClaim, selectedRecord?.id, {
     project_id: String(normalizedRoute?.projectID || "").trim(),
     provider: String(normalizedRoute?.provider || "").trim(),
     request_key: requestKey,
     route_key: String(routeKey || "").trim(),
-    conversation_id: String(parsed.conversationID || "").trim(),
+    conversation_id: conversationID,
     source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
     comment_kind: commentKind,
     request_status: "claimed",
   });
   saveBotRunnerState({
-    routes: currentState.routes,
-    sharedInboxes: currentState.sharedInboxes || currentState.shared_inboxes,
-    excludedComments: currentState.excludedComments || currentState.excluded_comments,
+    routes: stateForClaim.routes,
+    sharedInboxes: stateForClaim.sharedInboxes || stateForClaim.shared_inboxes,
+    excludedComments: stateForClaim.excludedComments || stateForClaim.excluded_comments,
     requests: nextRequests,
     consumedComments: nextConsumedComments,
   });
@@ -2579,6 +2661,11 @@ function markRunnerRequestLifecycle({
   outcome,
   conversationIDRaw = "",
   allowedResponders = [],
+  executionContractType = "",
+  executionContractTargets = [],
+  nextExpectedResponders = [],
+  currentBotSelector = "",
+  conversationIntentMode = "",
   normalizedIntent = "",
   closedReason = "",
 }) {
@@ -2589,20 +2676,34 @@ function markRunnerRequestLifecycle({
   if (!Object.keys(existing).length) return null;
   const parsed = safeObject(selectedRecord?.parsedArchive);
   const conversationID = String(conversationIDRaw || existing.conversation_id || parsed.conversationID || "").trim();
-  const conversationFacts = conversationID
-    ? collectBotRunnerConversationSessionFacts(normalizedRoute, conversationID)
-    : {};
+  const normalizedCurrentBotSelector = normalizeTelegramMentionUsername(
+    currentBotSelector
+      || safeObject(currentState.routes)[String(routeKey || "").trim()]?.last_speaker_bot_username
+      || "",
+  );
+  const continuationSelectors = uniqueOrderedStrings(
+    [
+      ...ensureArray(executionContractTargets).length
+        ? ensureArray(executionContractTargets)
+        : ensureArray(existing.execution_contract_targets),
+      ...ensureArray(nextExpectedResponders).length
+        ? ensureArray(nextExpectedResponders)
+        : ensureArray(existing.next_expected_responders),
+    ],
+    normalizeTelegramMentionUsername,
+  ).filter((selector) => selector && selector !== normalizedCurrentBotSelector);
+  const shouldRemainRunningAfterReply = continuationSelectors.length > 0;
   const normalizedOutcome = String(outcome || "").trim().toLowerCase();
   const nextStatus = (() => {
     if (normalizedOutcome === "claimed") return "claimed";
     if (normalizedOutcome === "running") return "running";
     if (normalizedOutcome === "replied") {
-      return conversationFacts.any_open ? "running" : "completed";
+      return shouldRemainRunningAfterReply ? "running" : "completed";
     }
     if (normalizedOutcome === "loop_closed") return "loop_closed";
     if (normalizedOutcome === "expired") return "expired";
     if (normalizedOutcome === "error" || normalizedOutcome === "skipped" || normalizedOutcome === "closed") {
-      return conversationFacts.any_open ? "running" : "closed";
+      return "closed";
     }
     return normalizeRunnerRequestStatus(existing.status);
   })();
@@ -2613,6 +2714,24 @@ function markRunnerRequestLifecycle({
       ensureArray(allowedResponders).length ? allowedResponders : existing.conversation_allowed_responders,
       normalizeTelegramMentionUsername,
     ),
+    conversation_intent_mode: String(
+      conversationIntentMode
+      || existing.conversation_intent_mode
+      || "",
+    ).trim().toLowerCase(),
+    execution_contract_type: String(
+      executionContractType
+      || existing.execution_contract_type
+      || "",
+    ).trim().toLowerCase(),
+    execution_contract_targets: uniqueOrderedStrings(
+      ensureArray(executionContractTargets).length ? executionContractTargets : existing.execution_contract_targets,
+      normalizeTelegramMentionUsername,
+    ),
+    next_expected_responders: uniqueOrderedStrings(
+      ensureArray(nextExpectedResponders).length ? nextExpectedResponders : existing.next_expected_responders,
+      normalizeTelegramMentionUsername,
+    ),
     normalized_intent: String(normalizedIntent || existing.normalized_intent || "").trim().toLowerCase(),
     status: nextStatus,
     started_at: firstNonEmptyString([existing.started_at, nowISO]),
@@ -5107,6 +5226,170 @@ function buildRunnerSmallTalkReply({ route, executionPlan } = {}) {
   return templatePool[stableTextModulo(`${displayName}:${roleProfileName}`, templatePool.length)];
 }
 
+function summarizeRunnerRequestForStatusLookup(entryRaw) {
+  const entry = safeObject(entryRaw);
+  return {
+    status: String(entry.status || "").trim(),
+    normalized_intent: String(entry.normalized_intent || "").trim(),
+    conversation_id: String(entry.conversation_id || "").trim(),
+    closed_reason: String(entry.closed_reason || "").trim(),
+    claimed_at: firstNonEmptyString([entry.claimed_at, entry.started_at]),
+    started_at: firstNonEmptyString([entry.started_at, entry.claimed_at]),
+    updated_at: String(entry.updated_at || "").trim(),
+    source_message_id: intFromRawAllowZero(entry.source_message_id, 0) || undefined,
+    last_source_message_id: intFromRawAllowZero(entry.last_source_message_id, 0) || undefined,
+    selected_bot_usernames: ensureArray(entry.selected_bot_usernames)
+      .map((value) => normalizeTelegramMentionUsername(value))
+      .filter(Boolean),
+  };
+}
+
+function isInformationalRunnerRequestIntent(intentType) {
+  return new Set([
+    "status_query",
+    "bot_role_query",
+    "workspace_query",
+    "explanation_query",
+    "small_talk",
+  ]).has(String(intentType || "").trim().toLowerCase());
+}
+
+function requestEligibleForStatusLookup(entryRaw, routeKey, selfBotUsername, currentMessageID) {
+  const entry = safeObject(entryRaw);
+  const sourceMessageID = intFromRawAllowZero(entry.source_message_id, 0);
+  const lastSourceMessageID = intFromRawAllowZero(entry.last_source_message_id, 0);
+  if (
+    (currentMessageID > 0 && sourceMessageID === currentMessageID)
+    || (currentMessageID > 0 && lastSourceMessageID === currentMessageID)
+  ) {
+    return false;
+  }
+  if (String(entry.claimed_by_route || "").trim() === routeKey) {
+    return true;
+  }
+  if (!selfBotUsername) {
+    return true;
+  }
+  return ensureArray(entry.selected_bot_usernames)
+    .map((value) => normalizeTelegramMentionUsername(value))
+    .filter(Boolean)
+    .includes(selfBotUsername);
+}
+
+function pickPreferredStatusLookupRequest(entries = []) {
+  const candidates = ensureArray(entries).map((entry) => safeObject(entry)).filter((entry) => Object.keys(entry).length > 0);
+  if (!candidates.length) {
+    return null;
+  }
+  const activeNonInformational = candidates.filter((entry) => (
+    isActiveRunnerRequestStatus(entry.status)
+    && !isInformationalRunnerRequestIntent(entry.normalized_intent)
+  ));
+  if (activeNonInformational.length) {
+    return activeNonInformational[0];
+  }
+  const nonInformational = candidates.filter((entry) => !isInformationalRunnerRequestIntent(entry.normalized_intent));
+  if (nonInformational.length) {
+    return nonInformational[0];
+  }
+  const activeAny = candidates.filter((entry) => isActiveRunnerRequestStatus(entry.status));
+  if (activeAny.length) {
+    return activeAny[0];
+  }
+  return candidates[0];
+}
+
+function buildRunnerStatusQueryLookup({ route, routeState, selectedRecord }) {
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const currentMessageID = intFromRawAllowZero(parsed.messageID, 0);
+  const currentChatID = String(parsed.chatID || parsed.chatId || "").trim();
+  const routeKey = runnerRouteKey(route);
+  const selfBotUsername = normalizeTelegramMentionUsername(firstNonEmptyString([
+    route?.server_bot_name,
+    route?.serverBotName,
+    route?.botName,
+    route?.name,
+  ]));
+  const activeExecution = resolveRunnerActiveExecutionState(routeState);
+  const activeSourceMessageID = intFromRawAllowZero(activeExecution.sourceMessageID, 0);
+  const selfBusyFiltered = Boolean(
+    activeExecution.active
+    && currentMessageID > 0
+    && activeSourceMessageID > 0
+    && currentMessageID === activeSourceMessageID
+  );
+  let runnerState = { requests: {} };
+  try {
+    runnerState = loadBotRunnerState();
+  } catch {}
+  const replyChainContext = resolveRunnerReplyChainConversationContext(runnerState, route, selectedRecord);
+  const currentConversationID = String(parsed.conversationID || replyChainContext.conversationID || "").trim();
+  const requestMatchesCurrentRoute = (entry) => requestEligibleForStatusLookup(
+    entry,
+    routeKey,
+    selfBotUsername,
+    currentMessageID,
+  );
+  let relatedActiveRequest = null;
+  let relatedRequest = null;
+  const selectors = currentConversationID
+    ? { conversationID: currentConversationID, chatID: currentChatID }
+    : { chatID: currentChatID };
+  let scopedRequests = findRunnerRequestsForScope(runnerState, route, selectors);
+  if (!scopedRequests.length && currentConversationID) {
+    scopedRequests = findRunnerRequestsForScope(runnerState, route, { chatID: currentChatID });
+  }
+  const eligibleScopedRequests = scopedRequests.filter(requestMatchesCurrentRoute);
+  relatedActiveRequest = eligibleScopedRequests
+    .filter((entry) => isActiveRunnerRequestStatus(entry.status))[0] || null;
+  relatedRequest = pickPreferredStatusLookupRequest(
+    eligibleScopedRequests.length
+      ? eligibleScopedRequests
+      : (replyChainContext.referencedRequest ? [replyChainContext.referencedRequest] : []).filter(requestMatchesCurrentRoute),
+  );
+  const lastAction = String(safeObject(routeState).last_action || "").trim();
+  const lastReason = String(safeObject(routeState).last_reason || "").trim();
+  const lastIntentType = String(safeObject(routeState).last_intent_type || "").trim();
+  const routeConversationID = String(safeObject(routeState).last_conversation_id || "").trim();
+  const routeWorkItemIDs = ensureArray(safeObject(routeState).last_work_item_ids).map((item) => String(item || "").trim()).filter(Boolean);
+  const routeWorkItemTitles = ensureArray(safeObject(routeState).last_work_item_titles).map((item) => String(item || "").trim()).filter(Boolean);
+  return {
+    kind: "runner_status",
+    status: (!selfBusyFiltered && activeExecution.active) || relatedActiveRequest
+      ? "running"
+      : String(safeObject(relatedRequest).status || "").trim() || "idle",
+    resolved_conversation_id: currentConversationID,
+    reply_chain_resolution: {
+      reason: String(replyChainContext.reason || "").trim(),
+      reply_to_message_id: intFromRawAllowZero(replyChainContext.replyToMessageID, 0) || undefined,
+      anchor_message_id: intFromRawAllowZero(replyChainContext.anchorMessageID, 0) || undefined,
+    },
+    self_busy_filtered: selfBusyFiltered,
+    active_execution: activeExecution.active && !selfBusyFiltered
+      ? {
+          started_at: String(activeExecution.startedAt || "").trim(),
+          age_seconds: intFromRawAllowZero(activeExecution.ageSeconds, 0),
+          stale: activeExecution.stale === true,
+          stuck: activeExecution.stuck === true,
+          warning: String(activeExecution.warning || "").trim(),
+        }
+      : null,
+    related_active_request: relatedActiveRequest ? summarizeRunnerRequestForStatusLookup(relatedActiveRequest) : null,
+    related_request: relatedRequest ? summarizeRunnerRequestForStatusLookup(relatedRequest) : null,
+    route_work_items: currentConversationID && routeConversationID === currentConversationID && (routeWorkItemIDs.length > 0 || routeWorkItemTitles.length > 0)
+      ? {
+          ids: routeWorkItemIDs,
+          titles: routeWorkItemTitles,
+        }
+      : null,
+    last_route_result: {
+      action: lastAction,
+      reason: lastReason,
+      intent_type: lastIntentType,
+    },
+  };
+}
+
 async function resolveInformationalQueryReply({
   intentType,
   route,
@@ -5159,6 +5442,17 @@ async function resolveInformationalQueryReply({
     };
   }
   if (normalizedIntentType === "status_query") {
+    return {
+      handled: true,
+      source: "runner.status",
+      response_mode: "lookup_only",
+      reply: "",
+      lookup: buildRunnerStatusQueryLookup({
+        route,
+        routeState,
+        selectedRecord,
+      }),
+    };
     const activeExecution = resolveRunnerActiveExecutionState(routeState);
     if (activeExecution.active) {
       const startedAt = String(activeExecution.startedAt || "").trim();
@@ -5839,6 +6133,24 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           skippedRecords.push(duplicateArchivedSkip);
           continue;
         }
+        const triggerDecision = evaluateTelegramRunnerTrigger(selectedRecord, normalizedRoute, bot);
+        if (triggerDecision.shouldRespond !== true) {
+          saveRunnerRouteState(
+            routeKey,
+            buildRunnerRouteStateFromComment(selectedRecord, {
+              last_action: "trigger_skipped",
+              last_reason: String(triggerDecision.reason || "trigger policy skipped message").trim() || "trigger policy skipped message",
+              last_trigger: String(triggerDecision.trigger || "").trim() || "trigger_policy",
+            }),
+          );
+          skippedRecords.push({
+            id: selectedRecord.id,
+            reason: String(triggerDecision.reason || "trigger policy skipped message").trim() || "trigger policy skipped message",
+            messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
+            suppressDiagnostic: true,
+          });
+          continue;
+        }
         const startupLoopSkipped = await maybeHandleRunnerStartupLoopCandidate({
           routeKey,
           normalizedRoute,
@@ -5947,6 +6259,8 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
             runtime,
             managedConversationBots,
             requestKey: String(requestClaim.requestKey || "").trim(),
+            triggerDecision,
+            responderAdjudication: adjudication,
           },
         };
       }
@@ -5992,6 +6306,24 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         skippedRecords.push(duplicateArchivedSkip);
         continue;
       }
+      const triggerDecision = evaluateTelegramRunnerTrigger(selectedRecord, normalizedRoute, bot);
+      if (triggerDecision.shouldRespond !== true) {
+        saveRunnerRouteState(
+          routeKey,
+          buildRunnerRouteStateFromComment(selectedRecord, {
+            last_action: "trigger_skipped",
+            last_reason: String(triggerDecision.reason || "trigger policy skipped message").trim() || "trigger policy skipped message",
+            last_trigger: String(triggerDecision.trigger || "").trim() || "trigger_policy",
+          }),
+        );
+        skippedRecords.push({
+          id: selectedRecord.id,
+          reason: String(triggerDecision.reason || "trigger policy skipped message").trim() || "trigger policy skipped message",
+          messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
+          suppressDiagnostic: true,
+        });
+        continue;
+      }
       const startupLoopSkipped = await maybeHandleRunnerStartupLoopCandidate({
         routeKey,
         normalizedRoute,
@@ -6099,6 +6431,8 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         archiveThread,
         executionPlan,
         runtime,
+        triggerDecision,
+        responderAdjudication: inlineAdjudication,
         deps: {
           saveRunnerRouteState,
           startRunnerTypingHeartbeat,
@@ -6140,6 +6474,11 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           outcome: String(processed.result?.outcome || "replied").trim().toLowerCase(),
           conversationIDRaw: String(processed.result?.conversation_id || "").trim(),
           allowedResponders: ensureArray(processed.result?.conversation_allowed_responders),
+          executionContractType: String(processed.result?.execution_contract_type || "").trim(),
+          executionContractTargets: ensureArray(processed.result?.execution_contract_targets),
+          nextExpectedResponders: ensureArray(processed.result?.next_expected_responders),
+          currentBotSelector,
+          conversationIntentMode: String(processed.result?.conversation_intent_mode || "").trim(),
           normalizedIntent: String(safeObject(loadBotRunnerState().routes[routeKey]).last_intent_type || "").trim(),
         });
         await syncRunnerRequestLedgerForProjectToServer({
@@ -8403,6 +8742,8 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                       archiveThread: deferredExecution.archiveThread,
                       executionPlan: deferredExecution.executionPlan,
                       runtime: deferredExecution.runtime,
+                      triggerDecision: deferredExecution.triggerDecision,
+                      responderAdjudication: deferredExecution.responderAdjudication,
                       deps: {
                         saveRunnerRouteState,
                         startRunnerTypingHeartbeat,
@@ -8473,6 +8814,13 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                         outcome: String(processed.result?.outcome || "replied").trim().toLowerCase(),
                         conversationIDRaw: String(processed.result?.conversation_id || "").trim(),
                         allowedResponders: ensureArray(processed.result?.conversation_allowed_responders),
+                        executionContractType: String(processed.result?.execution_contract_type || "").trim(),
+                        executionContractTargets: ensureArray(processed.result?.execution_contract_targets),
+                        nextExpectedResponders: ensureArray(processed.result?.next_expected_responders),
+                        currentBotSelector: normalizeTelegramMentionUsername(
+                          deferredExecution.bot?.username || deferredExecution.bot?.name,
+                        ),
+                        conversationIntentMode: String(processed.result?.conversation_intent_mode || "").trim(),
                         normalizedIntent: String(safeObject(loadBotRunnerState().routes[deferredExecution.routeKey]).last_intent_type || "").trim(),
                       });
                       await syncRunnerRequestLedgerForProjectToServer({
@@ -12782,6 +13130,7 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     runnerRouteLogicalSignature,
     loadBotRunnerState,
     saveBotRunnerState,
+    buildRunnerStatusQueryLookup,
     tryJsonParse,
     safeObject,
     normalizeRunnerTriggerPolicy,
@@ -12791,6 +13140,7 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     processRunnerSelectedRecord,
     resolveRunnerStartupLoopAdjudication,
     claimRunnerRequestForHumanComment,
+    markRunnerRequestLifecycle,
     resolveRunnerContinuationRequestForBotReply,
     cleanupBotRunnerRequestState,
     runRunnerAIExecution,

package/lib/local-ai-adapters.mjs

@@ -1703,6 +1703,10 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
   const queryLookup = safePayload.query_lookup && typeof safePayload.query_lookup === "object"
     ? safePayload.query_lookup
     : null;
+  const queryLookupFacts = queryLookup && Object.prototype.hasOwnProperty.call(queryLookup, "facts")
+    ? queryLookup.facts
+    : null;
+  const queryLookupResponseMode = String(queryLookup?.response_mode || "").trim().toLowerCase();
   const currentTurnPurpose = inferCurrentTurnPurpose({
     trigger,
     conversation,
@@ -1777,13 +1781,25 @@ export function buildLocalBotPrompt(payload, { terse = true } = {}) {
     "",
   ];
   if (queryLookup?.handled === true) {
-    lines.push(
-      "Tool-assisted factual lookup for this turn:",
-      `- Source: ${String(queryLookup.source || "").trim() || "-"}`,
-      `- Proposed factual reply: ${String(queryLookup.proposed_reply || "").trim() || "-"}`,
-      "If you decide this bot should answer, prefer this factual reply and refine it only as needed.",
-      "",
-    );
+    lines.push("Tool-assisted factual lookup for this turn:");
+    lines.push(`- Source: ${String(queryLookup.source || "").trim() || "-"}`);
+    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));
+    }
+    if (queryLookupResponseMode === "lookup_only") {
+      lines.push("Use these facts to answer naturally in the user's language.");
+      lines.push("Do not expose raw internal ids, request keys, or exact ISO timestamps unless the user explicitly asks for debug details.");
+    } else {
+      lines.push("If you decide this bot should answer, prefer this factual reply and refine it only as needed.");
+    }
+    lines.push("");
   }
   if (isInternalExecutionStep) {
     const stepIndex = intFromRawAllowZero(executionStep.index, 0);