metheus-governance-mcp-cli 0.2.196 → 0.2.198

package/cli.mjs

@@ -158,11 +158,13 @@ import {
   listProjectCtxpackFiles as listProjectCtxpackFilesImpl,
   listProjectRunnerRequestCommentStates as listProjectRunnerRequestCommentStatesImpl,
   listProjectRunnerRequests as listProjectRunnerRequestsImpl,
+  listWorkItemThreads as listWorkItemThreadsImpl,
   listThreadComments as listThreadCommentsImpl,
   listThreadCommentsTail as listThreadCommentsTailImpl,
   listUserBotsForRunner as listUserBotsForRunnerImpl,
   selectProjectChatDestination as selectProjectChatDestinationImpl,
   selectRunnerBot as selectRunnerBotImpl,
+  transitionProjectWorkItem as transitionProjectWorkItemImpl,
   upsertProjectRunnerRequest as upsertProjectRunnerRequestImpl,
   upsertProjectRunnerRequestCommentState as upsertProjectRunnerRequestCommentStateImpl,
   updateProjectContextItem as updateProjectContextItemImpl,
@@ -1914,9 +1916,17 @@ function mergeRunnerStateRecords(preferred, fallback) {
     active_comment_id: pickString(primary.active_comment_id, secondary.active_comment_id),
     active_comment_created_at: pickString(primary.active_comment_created_at, secondary.active_comment_created_at),
     active_source_message_id: pickNumber(primary.active_source_message_id, secondary.active_source_message_id) || undefined,
+    active_request_key: pickString(primary.active_request_key, secondary.active_request_key),
     active_started_at: pickString(primary.active_started_at, secondary.active_started_at),
+    active_root_work_item_id: pickString(primary.active_root_work_item_id, secondary.active_root_work_item_id),
+    active_root_work_item_title: pickString(primary.active_root_work_item_title, secondary.active_root_work_item_title),
+    active_root_work_item_status: pickString(primary.active_root_work_item_status, secondary.active_root_work_item_status),
     active_runner_pid: pickNumber(primary.active_runner_pid, secondary.active_runner_pid) || undefined,
     active_execution_token: pickString(primary.active_execution_token, secondary.active_execution_token),
+    last_request_key: pickString(primary.last_request_key, secondary.last_request_key),
+    last_root_work_item_id: pickString(primary.last_root_work_item_id, secondary.last_root_work_item_id),
+    last_root_work_item_title: pickString(primary.last_root_work_item_title, secondary.last_root_work_item_title),
+    last_root_work_item_status: pickString(primary.last_root_work_item_status, secondary.last_root_work_item_status),
     conversation_sessions: {
       ...safeObject(secondary.conversation_sessions),
       ...safeObject(primary.conversation_sessions),
@@ -2123,6 +2133,13 @@ function isActiveRunnerRequestStatus(rawStatus) {
   return status === "planned" || status === "claimed" || status === "running";
 }
 
+function normalizeRunnerWorkItemStatus(rawStatus) {
+  const status = String(rawStatus || "").trim().toLowerCase();
+  return ["backlog", "doing", "review", "done", "canceled"].includes(status)
+    ? status
+    : "";
+}
+
 function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
   const normalized = {};
   for (const [requestKeyRaw, entryRaw] of Object.entries(safeObject(rawRequests))) {
@@ -2158,6 +2175,12 @@ function normalizeBotRunnerRequests(rawRequests, nowMs = Date.now()) {
       completed_at: firstNonEmptyString([entry.completed_at, entry.completedAt]),
       closed_at: firstNonEmptyString([entry.closed_at, entry.closedAt]),
       closed_reason: String(entry.closed_reason || entry.closedReason || "").trim(),
+      root_work_item_id: String(entry.root_work_item_id || entry.rootWorkItemID || "").trim(),
+      root_work_item_title: String(entry.root_work_item_title || entry.rootWorkItemTitle || "").trim(),
+      root_work_item_status: normalizeRunnerWorkItemStatus(entry.root_work_item_status || entry.rootWorkItemStatus),
+      root_thread_id: String(entry.root_thread_id || entry.rootThreadID || "").trim(),
+      root_work_item_created_at: firstNonEmptyString([entry.root_work_item_created_at, entry.rootWorkItemCreatedAt]),
+      root_work_item_last_error: String(entry.root_work_item_last_error || entry.rootWorkItemLastError || "").trim(),
       last_comment_id: String(entry.last_comment_id || entry.lastCommentID || "").trim(),
       last_comment_kind: String(entry.last_comment_kind || entry.lastCommentKind || "").trim().toLowerCase(),
       last_source_message_id: intFromRawAllowZero(entry.last_source_message_id || entry.lastSourceMessageID, 0) || undefined,
@@ -2363,6 +2386,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 +2419,190 @@ 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 sortRunnerRequestEntriesNewestFirst(entries = []) {
+  return ensureArray(entries).slice().sort((leftRaw, rightRaw) => {
+    const left = safeObject(leftRaw);
+    const right = safeObject(rightRaw);
+    const leftTime = firstNonEmptyString([left.updated_at, left.completed_at, left.closed_at, left.claimed_at]);
+    const rightTime = firstNonEmptyString([right.updated_at, right.completed_at, right.closed_at, right.claimed_at]);
+    if (leftTime && rightTime && leftTime !== rightTime) {
+      return leftTime < rightTime ? 1 : -1;
+    }
+    return String(left.request_key || "").localeCompare(String(right.request_key || ""));
+  });
+}
+
+async function findServerRunnerRequestForMessageID({
+  normalizedRoute,
+  runtime,
+  chatID,
+  messageID,
+}) {
+  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 = sortRunnerRequestEntriesNewestFirst(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 safeObject(matched[0]);
+  } catch {
+    return null;
+  }
+}
+
+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,
+  };
+}
+
+async function resolveRunnerReplyChainConversationContextWithServerFallback({
+  state,
+  normalizedRoute,
+  selectedRecord,
+  runtime,
+}) {
+  const initialState = safeObject(state);
+  const initialContext = resolveRunnerReplyChainConversationContext(initialState, normalizedRoute, selectedRecord);
+  if (safeObject(initialContext.referencedRequest).request_key) {
+    return {
+      state: initialState,
+      replyChainContext: initialContext,
+      hydrated: false,
+    };
+  }
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const replyToMessageID = intFromRawAllowZero(
+    parsed.replyToMessageID || safeObject(initialContext).replyToMessageID,
+    0,
+  );
+  if (replyToMessageID <= 0 || !runtime?.baseURL || !runtime?.token) {
+    return {
+      state: initialState,
+      replyChainContext: initialContext,
+      hydrated: false,
+    };
+  }
+  const chatID = String(parsed.chatID || parsed.chatId || "").trim();
+  const serverReferencedRequest = await findServerRunnerRequestForMessageID({
+    normalizedRoute,
+    runtime,
+    chatID,
+    messageID: replyToMessageID,
+  });
+  if (serverReferencedRequest.request_key) {
+    const requestIndex = normalizeBotRunnerRequests(initialState.requests);
+    requestIndex[String(serverReferencedRequest.request_key || "").trim()] = serverReferencedRequest;
+    const anchorMessageID = intFromRawAllowZero(serverReferencedRequest.source_message_id, 0) || replyToMessageID;
+    return {
+      state: {
+        ...initialState,
+        requests: requestIndex,
+      },
+      replyChainContext: {
+        conversationID: String(serverReferencedRequest.conversation_id || "").trim()
+          || buildSyntheticReplyChainConversationID(normalizedRoute, chatID, anchorMessageID),
+        replyToMessageID,
+        anchorMessageID,
+        reason: String(serverReferencedRequest.conversation_id || "").trim()
+          ? "reply_request_conversation_server"
+          : "reply_request_synthetic_server",
+        referencedRequest: serverReferencedRequest,
+      },
+      hydrated: false,
+    };
+  }
+  const hydratedState = await hydrateRunnerRequestLedgerFromServer({
+    normalizedRoute,
+    runtime,
+  });
+  const hydratedContext = resolveRunnerReplyChainConversationContext(hydratedState, normalizedRoute, selectedRecord);
+  return {
+    state: hydratedState,
+    replyChainContext: hydratedContext,
+    hydrated: true,
+  };
+}
+
 function upsertRunnerRequest(state, requestKey, patch = {}) {
   const currentState = safeObject(state);
   const requests = normalizeBotRunnerRequests(currentState.requests);
@@ -2425,87 +2642,679 @@ function upsertRunnerConsumedComment(state, commentIDRaw, patch = {}) {
   };
 }
 
-function claimRunnerRequestForHumanComment({
+async function claimRunnerRequestForHumanComment({
+  normalizedRoute,
+  routeKey,
+  selectedRecord,
+  selectedBotUsernames = [],
+  normalizedIntent = "",
+  runtime = null,
+}) {
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const commentKind = String(parsed.kind || "").trim().toLowerCase();
+  if (!isInboundArchiveKind(commentKind)) {
+    return {
+      ok: false,
+      reason: "non_human_comment_cannot_create_request",
+    };
+  }
+  const requestKey = buildRunnerRequestKey({
+    normalizedRoute,
+    selectedRecord,
+    selectedBotUsernames,
+    normalizedIntent,
+  });
+  const currentState = loadBotRunnerState();
+  const replyChainResolution = await resolveRunnerReplyChainConversationContextWithServerFallback({
+    state: currentState,
+    normalizedRoute,
+    selectedRecord,
+    runtime,
+  });
+  const replyChainContext = safeObject(replyChainResolution.replyChainContext);
+  const referencedRequest = safeObject(replyChainContext.referencedRequest);
+  const conversationID = String(parsed.conversationID || replyChainContext.conversationID || "").trim();
+  let stateForClaim = safeObject(replyChainResolution.state);
+  if (
+    Object.keys(referencedRequest).length > 0
+    && conversationID
+    && !String(referencedRequest.conversation_id || "").trim()
+    && String(referencedRequest.request_key || "").trim()
+  ) {
+    const backfilled = upsertRunnerRequest(stateForClaim, 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 {
+      ok: false,
+      reason: "request_already_finalized",
+      requestKey,
+    };
+  }
+  if (
+    isActiveRunnerRequestStatus(existing.status)
+    && String(existing.claimed_by_route || "").trim()
+    && String(existing.claimed_by_route || "").trim() !== String(routeKey || "").trim()
+  ) {
+    return {
+      ok: false,
+      reason: "request_already_claimed",
+      requestKey,
+    };
+  }
+  const nowISO = new Date().toISOString();
+  const { 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: conversationID,
+    selected_bot_usernames: uniqueOrderedStrings(selectedBotUsernames, normalizeTelegramMentionUsername),
+    normalized_intent: String(normalizedIntent || "").trim().toLowerCase(),
+    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_status: normalizeRunnerWorkItemStatus(
+      existing.root_work_item_status || referencedRequest.root_work_item_status,
+    ),
+    root_thread_id: String(existing.root_thread_id || referencedRequest.root_thread_id || "").trim(),
+    root_work_item_created_at: firstNonEmptyString([
+      existing.root_work_item_created_at,
+      referencedRequest.root_work_item_created_at,
+    ]),
+    root_work_item_last_error: String(existing.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,
+  });
+  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: conversationID,
+    source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
+    comment_kind: commentKind,
+    request_status: "claimed",
+  });
+  saveBotRunnerState({
+    routes: stateForClaim.routes,
+    sharedInboxes: stateForClaim.sharedInboxes || stateForClaim.shared_inboxes,
+    excludedComments: stateForClaim.excludedComments || stateForClaim.excluded_comments,
+    requests: nextRequests,
+    consumedComments: nextConsumedComments,
+  });
+  return {
+    ok: true,
+    requestKey,
+    request,
+  };
+}
+
+function isActionableRunnerRequestIntent(rawIntent) {
+  const normalizedIntent = String(rawIntent || "").trim().toLowerCase();
+  return Boolean(normalizedIntent) && !isInformationalRunnerRequestIntent(normalizedIntent);
+}
+
+function truncateRunnerWorkItemTitleText(rawText, maxLength = 96) {
+  const text = String(rawText || "").replace(/\s+/g, " ").trim();
+  if (!text) {
+    return "";
+  }
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return `${text.slice(0, Math.max(1, maxLength - 3)).trim()}...`;
+}
+
+function buildRunnerRootWorkItemTitle({ selectedRecord, request }) {
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const intent = String(safeObject(request).normalized_intent || "").trim().toLowerCase();
+  const requestBody = truncateRunnerWorkItemTitleText(parsed.body || "", 84);
+  const prefix = intent === "ctxpack_mutation"
+    ? "Ctxpack request"
+    : intent === "workitem_mutation"
+      ? "Work item request"
+      : "Runner request";
+  if (requestBody) {
+    return `${prefix}: ${requestBody}`;
+  }
+  const messageID = intFromRawAllowZero(parsed.messageID, 0);
+  return messageID > 0 ? `${prefix} #${messageID}` : prefix;
+}
+
+function buildRunnerRootWorkItemDescription({
+  normalizedRoute,
+  routeKey,
+  selectedRecord,
+  request,
+}) {
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const lines = [
+    `Source request: ${String(parsed.body || "").trim() || "(empty)"}`,
+    `Intent: ${String(safeObject(request).normalized_intent || "").trim() || "unknown"}`,
+    `Route: ${String(normalizedRoute?.name || routeKey || "").trim() || "-"}`,
+    `Provider: ${String(normalizedRoute?.provider || "").trim() || "-"}`,
+    `Chat ID: ${String(parsed.chatID || parsed.chatId || "").trim() || "-"}`,
+    `Message ID: ${intFromRawAllowZero(parsed.messageID, 0) || "-"}`,
+    `Request key: ${String(safeObject(request).request_key || "").trim() || "-"}`,
+  ];
+  const conversationID = String(safeObject(request).conversation_id || parsed.conversationID || "").trim();
+  if (conversationID) {
+    lines.push(`Conversation ID: ${conversationID}`);
+  }
+  const selectedBots = ensureArray(safeObject(request).selected_bot_usernames)
+    .map((item) => normalizeTelegramMentionUsername(item))
+    .filter(Boolean);
+  if (selectedBots.length > 0) {
+    lines.push(`Selected bots: ${selectedBots.join(", ")}`);
+  }
+  return lines.join("\n").trim();
+}
+
+function buildRunnerRootWorkItemThreadTitle({ selectedRecord }) {
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const requestBody = truncateRunnerWorkItemTitleText(parsed.body || "", 72);
+  if (requestBody) {
+    return `Request Context: ${requestBody}`;
+  }
+  const messageID = intFromRawAllowZero(parsed.messageID, 0);
+  return messageID > 0 ? `Request Context #${messageID}` : "Request Context";
+}
+
+function buildRunnerRootWorkItemThreadBody({
+  normalizedRoute,
+  routeKey,
+  selectedRecord,
+  request,
+}) {
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const lines = [
+    "Runner root request context thread.",
+    buildRunnerRootWorkItemDescription({
+      normalizedRoute,
+      routeKey,
+      selectedRecord,
+      request,
+    }),
+  ];
+  if (String(selectedRecord?.id || "").trim()) {
+    lines.push(`Archive comment ID: ${String(selectedRecord.id || "").trim()}`);
+  }
+  const occurredAt = String(parsed.occurredAt || parsed.occurred_at || "").trim();
+  if (occurredAt) {
+    lines.push(`Occurred at: ${occurredAt}`);
+  }
+  return lines.filter(Boolean).join("\n").trim();
+}
+
+async function ensureRunnerRootThreadForRequest({
+  normalizedRoute,
+  routeKey,
+  selectedRecord,
+  runtime,
+  requestKey,
+}) {
+  const key = String(requestKey || "").trim();
+  if (!key) {
+    return {
+      ok: false,
+      reason: "request_key_missing",
+    };
+  }
+  const currentState = loadBotRunnerState();
+  const request = safeObject(normalizeBotRunnerRequests(currentState.requests)[key]);
+  const rootWorkItemID = String(request.root_work_item_id || "").trim();
+  if (!Object.keys(request).length) {
+    return {
+      ok: false,
+      reason: "request_not_found",
+      requestKey: key,
+    };
+  }
+  if (!rootWorkItemID) {
+    return {
+      ok: true,
+      requestKey: key,
+      request,
+      skipped: true,
+      reason: "root_work_item_missing",
+    };
+  }
+  if (String(request.root_thread_id || "").trim()) {
+    return {
+      ok: true,
+      requestKey: key,
+      request,
+      reused: true,
+    };
+  }
+  if (!runtime?.baseURL || !runtime?.token || !runtime?.actor?.user_id) {
+    return {
+      ok: false,
+      reason: "governance_runtime_unavailable",
+      requestKey: key,
+      request,
+    };
+  }
+  try {
+    let rootThreadID = "";
+    const existingThreads = ensureArray(await listWorkItemThreads({
+      siteBaseURL: runtime.baseURL,
+      token: runtime.token,
+      timeoutSeconds: runtime.timeoutSeconds,
+      workItemID: rootWorkItemID,
+      status: "",
+    }));
+    rootThreadID = String(
+      safeObject(existingThreads[0]).id
+      || safeObject(existingThreads[0]).thread_id
+      || safeObject(existingThreads[0]).threadID
+      || "",
+    ).trim();
+    if (!rootThreadID) {
+      const createdThread = safeObject(await createWorkItemThread({
+        siteBaseURL: runtime.baseURL,
+        token: runtime.token,
+        timeoutSeconds: runtime.timeoutSeconds,
+        actorUserID: runtime.actor.user_id,
+        workItemID: rootWorkItemID,
+        title: buildRunnerRootWorkItemThreadTitle({
+          selectedRecord,
+        }),
+        body: buildRunnerRootWorkItemThreadBody({
+          normalizedRoute,
+          routeKey,
+          selectedRecord,
+          request,
+        }),
+      }));
+      rootThreadID = String(createdThread.thread_id || createdThread.threadID || createdThread.id || "").trim();
+    }
+    if (!rootThreadID) {
+      throw new Error("root thread creation returned no id");
+    }
+    const { requests: nextRequests, request: nextRequest } = upsertRunnerRequest(currentState, key, {
+      root_thread_id: rootThreadID,
+    });
+    saveBotRunnerState({
+      routes: currentState.routes,
+      sharedInboxes: currentState.sharedInboxes || currentState.shared_inboxes,
+      excludedComments: currentState.excludedComments || currentState.excluded_comments,
+      requests: nextRequests,
+      consumedComments: currentState.consumedComments || currentState.consumed_comments,
+    });
+    return {
+      ok: true,
+      requestKey: key,
+      request: nextRequest,
+      created: true,
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      reason: "root_thread_create_failed",
+      requestKey: key,
+      request,
+      error: String(err?.message || err).trim() || "failed to create root thread",
+    };
+  }
+}
+
+async function inheritRunnerReferenceRootWorkItemForRequest({
+  normalizedRoute,
+  selectedRecord,
+  runtime,
+  requestKey,
+}) {
+  const key = String(requestKey || "").trim();
+  if (!key) {
+    return {
+      ok: false,
+      reason: "request_key_missing",
+    };
+  }
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const chatID = String(parsed.chatID || parsed.chatId || "").trim();
+  const replyToMessageID = intFromRawAllowZero(parsed.replyToMessageID, 0);
+  if (!chatID || replyToMessageID <= 0) {
+    return {
+      ok: true,
+      requestKey: key,
+      skipped: true,
+      reason: "reply_reference_missing",
+    };
+  }
+  const currentState = loadBotRunnerState();
+  const currentRequest = safeObject(normalizeBotRunnerRequests(currentState.requests)[key]);
+  if (!Object.keys(currentRequest).length) {
+    return {
+      ok: false,
+      requestKey: key,
+      reason: "request_not_found",
+    };
+  }
+  if (String(currentRequest.root_work_item_id || "").trim()) {
+    return {
+      ok: true,
+      requestKey: key,
+      request: currentRequest,
+      reused: true,
+    };
+  }
+  const serverReferencedRequest = await findServerRunnerRequestForMessageID({
+    normalizedRoute,
+    runtime,
+    chatID,
+    messageID: replyToMessageID,
+  });
+  if (!String(serverReferencedRequest.root_work_item_id || "").trim()) {
+    return {
+      ok: true,
+      requestKey: key,
+      request: currentRequest,
+      skipped: true,
+      reason: "referenced_root_work_item_missing",
+    };
+  }
+  const { requests: nextRequests, request } = upsertRunnerRequest(currentState, key, {
+    root_work_item_id: String(serverReferencedRequest.root_work_item_id || "").trim(),
+    root_work_item_title: String(serverReferencedRequest.root_work_item_title || "").trim(),
+    root_work_item_status: normalizeRunnerWorkItemStatus(serverReferencedRequest.root_work_item_status),
+    root_thread_id: String(serverReferencedRequest.root_thread_id || "").trim(),
+    root_work_item_created_at: firstNonEmptyString([serverReferencedRequest.root_work_item_created_at]),
+    root_work_item_last_error: String(serverReferencedRequest.root_work_item_last_error || "").trim(),
+  });
+  saveBotRunnerState({
+    routes: currentState.routes,
+    sharedInboxes: currentState.sharedInboxes || currentState.shared_inboxes,
+    excludedComments: currentState.excludedComments || currentState.excluded_comments,
+    requests: nextRequests,
+    consumedComments: currentState.consumedComments || currentState.consumed_comments,
+  });
+  return {
+    ok: true,
+    requestKey: key,
+    request,
+    inherited: true,
+  };
+}
+
+async function ensureRunnerRootWorkItemForRequest({
+  normalizedRoute,
+  routeKey,
+  selectedRecord,
+  runtime,
+  requestKey,
+}) {
+  const key = String(requestKey || "").trim();
+  if (!key) {
+    return {
+      ok: false,
+      reason: "request_key_missing",
+    };
+  }
+  const currentState = loadBotRunnerState();
+  const existing = safeObject(normalizeBotRunnerRequests(currentState.requests)[key]);
+  if (!Object.keys(existing).length) {
+    return {
+      ok: false,
+      reason: "request_not_found",
+      requestKey: key,
+    };
+  }
+  if (!isActionableRunnerRequestIntent(existing.normalized_intent)) {
+    return {
+      ok: true,
+      requestKey: key,
+      request: existing,
+      skipped: true,
+      reason: "informational_request",
+    };
+  }
+  if (String(existing.root_work_item_id || "").trim()) {
+    const rootThreadClaim = await ensureRunnerRootThreadForRequest({
+      normalizedRoute,
+      routeKey,
+      selectedRecord,
+      runtime,
+      requestKey: key,
+    });
+    return {
+      ok: true,
+      requestKey: key,
+      request: safeObject(rootThreadClaim.request || existing),
+      reused: true,
+      root_thread_created: rootThreadClaim.created === true,
+      root_thread_error: String(rootThreadClaim.error || "").trim(),
+    };
+  }
+  if (!runtime?.baseURL || !runtime?.token || !runtime?.actor?.user_id) {
+    return {
+      ok: false,
+      reason: "governance_runtime_unavailable",
+      requestKey: key,
+    };
+  }
+  try {
+    const actorBotID = firstNonEmptyString([
+      normalizedRoute?.botID,
+      normalizedRoute?.botId,
+      normalizedRoute?.serverBotID,
+      normalizedRoute?.server_bot_id,
+    ]);
+    const actorBotName = firstNonEmptyString([
+      normalizedRoute?.botName,
+      normalizedRoute?.bot_name,
+      normalizedRoute?.serverBotName,
+      normalizedRoute?.server_bot_name,
+    ]);
+    const title = buildRunnerRootWorkItemTitle({
+      selectedRecord,
+      request: existing,
+    });
+    const description = buildRunnerRootWorkItemDescription({
+      normalizedRoute,
+      routeKey,
+      selectedRecord,
+      request: existing,
+    });
+    const created = safeObject(await createProjectWorkItem({
+      siteBaseURL: runtime.baseURL,
+      token: runtime.token,
+      timeoutSeconds: runtime.timeoutSeconds,
+      actorUserID: runtime.actor.user_id,
+      actorBotID: String(actorBotID || "").trim(),
+      actorBotName: String(actorBotName || "").trim(),
+      projectID: String(normalizedRoute?.projectID || "").trim(),
+      title,
+      description,
+    }));
+    const rootWorkItemID = String(created.id || created.work_item_id || created.workItemID || "").trim();
+    if (!rootWorkItemID) {
+      throw new Error("work item creation returned no id");
+    }
+    const rootWorkItemStatus = normalizeRunnerWorkItemStatus(created.status || "backlog") || "backlog";
+    const { requests: nextRequests, request } = upsertRunnerRequest(currentState, key, {
+      root_work_item_id: rootWorkItemID,
+      root_work_item_title: String(created.title || title).trim() || title,
+      root_work_item_status: rootWorkItemStatus,
+      root_work_item_created_at: new Date().toISOString(),
+      root_work_item_last_error: "",
+    });
+    saveBotRunnerState({
+      routes: currentState.routes,
+      sharedInboxes: currentState.sharedInboxes || currentState.shared_inboxes,
+      excludedComments: currentState.excludedComments || currentState.excluded_comments,
+      requests: nextRequests,
+      consumedComments: currentState.consumedComments || currentState.consumed_comments,
+    });
+    const rootThreadClaim = await ensureRunnerRootThreadForRequest({
+      normalizedRoute,
+      routeKey,
+      selectedRecord,
+      runtime,
+      requestKey: key,
+    });
+    return {
+      ok: true,
+      requestKey: key,
+      request: safeObject(rootThreadClaim.request || request),
+      created: true,
+      root_thread_created: rootThreadClaim.created === true,
+      root_thread_error: String(rootThreadClaim.error || "").trim(),
+    };
+  } catch (err) {
+    const errorText = String(err?.message || err).trim() || "failed to create root work item";
+    const { requests: nextRequests, request } = upsertRunnerRequest(currentState, key, {
+      root_work_item_last_error: errorText,
+    });
+    saveBotRunnerState({
+      routes: currentState.routes,
+      sharedInboxes: currentState.sharedInboxes || currentState.shared_inboxes,
+      excludedComments: currentState.excludedComments || currentState.excluded_comments,
+      requests: nextRequests,
+      consumedComments: currentState.consumedComments || currentState.consumed_comments,
+    });
+    return {
+      ok: false,
+      reason: "root_work_item_create_failed",
+      requestKey: key,
+      request,
+      error: errorText,
+    };
+  }
+}
+
+function deriveRunnerRootWorkItemTargetStatus(rawRequestStatus) {
+  const status = normalizeRunnerRequestStatus(rawRequestStatus);
+  if (status === "running") {
+    return "doing";
+  }
+  if (status === "completed" || status === "loop_closed") {
+    return "done";
+  }
+  if (status === "closed" || status === "expired") {
+    return "canceled";
+  }
+  return "";
+}
+
+function buildRunnerRootWorkItemTransitionPath(currentStatusRaw, targetStatusRaw) {
+  const currentStatus = normalizeRunnerWorkItemStatus(currentStatusRaw) || "backlog";
+  const targetStatus = normalizeRunnerWorkItemStatus(targetStatusRaw);
+  if (!targetStatus || currentStatus === targetStatus) {
+    return [];
+  }
+  if (targetStatus === "doing") {
+    return currentStatus === "backlog" ? ["doing"] : [];
+  }
+  if (targetStatus === "done") {
+    if (currentStatus === "backlog") return ["doing", "review", "done"];
+    if (currentStatus === "doing") return ["review", "done"];
+    if (currentStatus === "review") return ["done"];
+    return [];
+  }
+  if (targetStatus === "canceled") {
+    if (currentStatus === "backlog" || currentStatus === "doing" || currentStatus === "review") {
+      return ["canceled"];
+    }
+  }
+  return [];
+}
+
+async function syncRunnerRequestRootWorkItemForOutcome({
   normalizedRoute,
-  routeKey,
-  selectedRecord,
-  selectedBotUsernames = [],
-  normalizedIntent = "",
+  runtime,
+  requestKey,
 }) {
-  const parsed = safeObject(selectedRecord?.parsedArchive);
-  const commentKind = String(parsed.kind || "").trim().toLowerCase();
-  if (!isInboundArchiveKind(commentKind)) {
+  const key = String(requestKey || "").trim();
+  if (!key) {
     return {
       ok: false,
-      reason: "non_human_comment_cannot_create_request",
+      reason: "request_key_missing",
     };
   }
-  const requestKey = buildRunnerRequestKey({
-    normalizedRoute,
-    selectedRecord,
-    selectedBotUsernames,
-    normalizedIntent,
-  });
   const currentState = loadBotRunnerState();
-  const requests = normalizeBotRunnerRequests(currentState.requests);
-  const existing = safeObject(requests[requestKey]);
-  if (isFinalRunnerRequestStatus(existing.status)) {
+  const request = safeObject(normalizeBotRunnerRequests(currentState.requests)[key]);
+  const rootWorkItemID = String(request.root_work_item_id || "").trim();
+  if (!rootWorkItemID) {
     return {
-      ok: false,
-      reason: "request_already_finalized",
-      requestKey,
+      ok: true,
+      skipped: true,
+      reason: "root_work_item_missing",
+      request,
     };
   }
-  if (
-    isActiveRunnerRequestStatus(existing.status)
-    && String(existing.claimed_by_route || "").trim()
-    && String(existing.claimed_by_route || "").trim() !== String(routeKey || "").trim()
-  ) {
+  const targetStatus = deriveRunnerRootWorkItemTargetStatus(request.status);
+  if (!targetStatus || !runtime?.baseURL || !runtime?.token || !runtime?.actor?.user_id) {
     return {
-      ok: false,
-      reason: "request_already_claimed",
-      requestKey,
+      ok: true,
+      skipped: true,
+      reason: !targetStatus ? "no_target_status" : "governance_runtime_unavailable",
+      request,
     };
   }
-  const nowISO = new Date().toISOString();
-  const { requests: nextRequests, request } = upsertRunnerRequest(currentState, 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(),
-    selected_bot_usernames: uniqueOrderedStrings(selectedBotUsernames, normalizeTelegramMentionUsername),
-    normalized_intent: String(normalizedIntent || "").trim().toLowerCase(),
-    status: "claimed",
-    claimed_by_route: String(routeKey || "").trim(),
-    claimed_at: firstNonEmptyString([existing.claimed_at, nowISO]) || nowISO,
-    last_comment_id: String(selectedRecord?.id || "").trim(),
-    last_comment_kind: commentKind,
-    last_source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
-  });
-  const { consumedComments: nextConsumedComments } = upsertRunnerConsumedComment(currentState, 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(),
-    source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
-    comment_kind: commentKind,
-    request_status: "claimed",
+  let currentStatus = normalizeRunnerWorkItemStatus(request.root_work_item_status) || "backlog";
+  const transitions = buildRunnerRootWorkItemTransitionPath(currentStatus, targetStatus);
+  let lastError = "";
+  const actorBotID = firstNonEmptyString([
+    normalizedRoute?.botID,
+    normalizedRoute?.botId,
+    normalizedRoute?.serverBotID,
+    normalizedRoute?.server_bot_id,
+  ]);
+  const actorBotName = firstNonEmptyString([
+    normalizedRoute?.botName,
+    normalizedRoute?.bot_name,
+    normalizedRoute?.serverBotName,
+    normalizedRoute?.server_bot_name,
+  ]);
+  for (const nextStatus of transitions) {
+    try {
+      await transitionProjectWorkItem({
+        siteBaseURL: runtime.baseURL,
+        token: runtime.token,
+        timeoutSeconds: runtime.timeoutSeconds,
+        actorUserID: runtime.actor.user_id,
+        actorBotID: String(actorBotID || "").trim(),
+        actorBotName: String(actorBotName || "").trim(),
+        workItemID: rootWorkItemID,
+        status: nextStatus,
+      });
+      currentStatus = nextStatus;
+    } catch (err) {
+      lastError = String(err?.message || err).trim() || `failed to transition work item to ${nextStatus}`;
+      break;
+    }
+  }
+  const { requests: nextRequests, request: nextRequest } = upsertRunnerRequest(currentState, key, {
+    root_work_item_status: currentStatus,
+    root_work_item_last_error: lastError,
   });
   saveBotRunnerState({
     routes: currentState.routes,
     sharedInboxes: currentState.sharedInboxes || currentState.shared_inboxes,
     excludedComments: currentState.excludedComments || currentState.excluded_comments,
     requests: nextRequests,
-    consumedComments: nextConsumedComments,
+    consumedComments: currentState.consumedComments || currentState.consumed_comments,
   });
   return {
-    ok: true,
-    requestKey,
-    request,
+    ok: lastError === "",
+    request: nextRequest,
+    transitioned: transitions.length > 0 && lastError === "",
+    error: lastError,
   };
 }
 
@@ -2836,6 +3645,30 @@ function runnerLedgerEntryMatchesProject(entryRaw, normalizedRoute, requestIndex
   );
 }
 
+function mergeRunnerRequestForServerHydration(localEntryRaw, serverEntryRaw) {
+  const localEntry = safeObject(localEntryRaw);
+  const serverEntry = safeObject(serverEntryRaw);
+  const merged = {
+    ...localEntry,
+    ...serverEntry,
+  };
+  const preserveLocalStringWhenServerBlank = (fieldName) => {
+    const serverValue = String(serverEntry[fieldName] || "").trim();
+    const localValue = String(localEntry[fieldName] || "").trim();
+    if (!serverValue && localValue) {
+      merged[fieldName] = localValue;
+    }
+  };
+  preserveLocalStringWhenServerBlank("conversation_id");
+  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");
+  return merged;
+}
+
 function mergeServerRunnerRequestLedgerIntoLocalState(currentState, normalizedRoute, serverRequests = [], serverCommentStates = []) {
   const state = safeObject(currentState);
   const normalizedRequests = normalizeBotRunnerRequests(state.requests);
@@ -2859,7 +3692,12 @@ function mergeServerRunnerRequestLedgerIntoLocalState(currentState, normalizedRo
     const request = safeObject(requestRaw);
     const requestKey = String(request.request_key || request.requestKey || "").trim();
     if (!requestKey) continue;
-    nextRequests[requestKey] = normalizeBotRunnerRequests({ [requestKey]: request })[requestKey];
+    const localRequest = safeObject(normalizedRequests[requestKey]);
+    nextRequests[requestKey] = normalizeBotRunnerRequests({
+      [requestKey]: {
+        ...mergeRunnerRequestForServerHydration(localRequest, request),
+      },
+    })[requestKey];
   }
 
   const requestIndex = normalizeBotRunnerRequests(nextRequests);
@@ -4843,6 +5681,10 @@ async function createProjectWorkItem(params) {
   return createProjectWorkItemImpl(params, buildRunnerDataDeps());
 }
 
+async function transitionProjectWorkItem(params) {
+  return transitionProjectWorkItemImpl(params, buildRunnerDataDeps());
+}
+
 async function createProjectEvidence(params) {
   return createProjectEvidenceImpl(params, buildRunnerDataDeps());
 }
@@ -4851,6 +5693,10 @@ async function createWorkItemThread(params) {
   return createWorkItemThreadImpl(params, buildRunnerDataDeps());
 }
 
+async function listWorkItemThreads(params) {
+  return listWorkItemThreadsImpl(params, buildRunnerDataDeps());
+}
+
 async function linkWorkItemEvidence(params) {
   return linkWorkItemEvidenceImpl(params, buildRunnerDataDeps());
 }
@@ -5149,20 +5995,85 @@ function summarizeRunnerRequestForStatusLookup(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),
+    root_work_item: String(entry.root_work_item_id || "").trim()
+      ? {
+          id: String(entry.root_work_item_id || "").trim(),
+          title: String(entry.root_work_item_title || "").trim(),
+          status: normalizeRunnerWorkItemStatus(entry.root_work_item_status),
+          thread_id: String(entry.root_thread_id || "").trim(),
+        }
+      : null,
   };
 }
 
-function buildRunnerStatusQueryLookup({ route, routeState, selectedRecord }) {
+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, runnerStateOverride = null }) {
   const parsed = safeObject(selectedRecord?.parsedArchive);
   const currentMessageID = intFromRawAllowZero(parsed.messageID, 0);
-  const currentConversationID = String(parsed.conversationID || "").trim();
   const currentChatID = String(parsed.chatID || parsed.chatId || "").trim();
   const routeKey = runnerRouteKey(route);
   const selfBotUsername = normalizeTelegramMentionUsername(firstNonEmptyString([
@@ -5179,34 +6090,80 @@ function buildRunnerStatusQueryLookup({ route, routeState, selectedRecord }) {
     && activeSourceMessageID > 0
     && currentMessageID === activeSourceMessageID
   );
+  let runnerState = safeObject(runnerStateOverride);
+  if (!Object.keys(runnerState).length) {
+    runnerState = { requests: {} };
+    try {
+      runnerState = loadBotRunnerState();
+    } catch {}
+  }
+  const replyChainContext = resolveRunnerReplyChainConversationContext(runnerState, route, selectedRecord);
+  const currentConversationID = String(parsed.conversationID || replyChainContext.conversationID || "").trim();
+  const activeRequestKey = String(safeObject(routeState).active_request_key || "").trim();
+  const requestMatchesCurrentRoute = (entry) => requestEligibleForStatusLookup(
+    entry,
+    routeKey,
+    selfBotUsername,
+    currentMessageID,
+  );
+  const referencedRequestCandidate = safeObject(replyChainContext.referencedRequest);
   let relatedActiveRequest = null;
-  try {
-    const runnerState = loadBotRunnerState();
-    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 });
-    }
-    relatedActiveRequest = scopedRequests
-      .filter((entry) => isActiveRunnerRequestStatus(entry.status))
-      .filter((entry) => intFromRawAllowZero(entry.source_message_id, 0) !== currentMessageID)
-      .filter((entry) => {
-        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);
-      })[0] || null;
-  } catch {}
+  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 });
+  }
+  if (!scopedRequests.length && activeRequestKey) {
+    scopedRequests = findRunnerRequestsForScope(runnerState, route, { requestKey: activeRequestKey });
+  }
+  const eligibleScopedRequests = scopedRequests.filter(requestMatchesCurrentRoute);
+  const statusLookupCandidates = [...eligibleScopedRequests];
+  if (
+    Object.keys(referencedRequestCandidate).length > 0
+    && requestMatchesCurrentRoute(referencedRequestCandidate)
+    && !statusLookupCandidates.some(
+      (entry) => String(safeObject(entry).request_key || "").trim() === String(referencedRequestCandidate.request_key || "").trim(),
+    )
+  ) {
+    statusLookupCandidates.push(referencedRequestCandidate);
+  }
+  relatedActiveRequest = statusLookupCandidates
+    .filter((entry) => isActiveRunnerRequestStatus(entry.status))[0] || null;
+  relatedRequest = pickPreferredStatusLookupRequest(statusLookupCandidates);
   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 activeRootWorkItemID = String(safeObject(routeState).active_root_work_item_id || "").trim();
+  const activeRootWorkItemTitle = String(safeObject(routeState).active_root_work_item_title || "").trim();
+  const activeRootWorkItemStatus = normalizeRunnerWorkItemStatus(safeObject(routeState).active_root_work_item_status);
+  const routeRootWorkItemID = String(safeObject(routeState).last_root_work_item_id || "").trim();
+  const routeRootWorkItemTitle = String(safeObject(routeState).last_root_work_item_title || "").trim();
+  const routeRootWorkItemStatus = normalizeRunnerWorkItemStatus(safeObject(routeState).last_root_work_item_status);
+  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);
+  const requestRootWorkItem = String(safeObject(relatedRequest).root_work_item_id || "").trim()
+    ? {
+        id: String(safeObject(relatedRequest).root_work_item_id || "").trim(),
+        title: String(safeObject(relatedRequest).root_work_item_title || "").trim(),
+        status: normalizeRunnerWorkItemStatus(safeObject(relatedRequest).root_work_item_status),
+        thread_id: String(safeObject(relatedRequest).root_thread_id || "").trim(),
+      }
+    : null;
   return {
     kind: "runner_status",
-    status: (!selfBusyFiltered && activeExecution.active) || relatedActiveRequest ? "running" : "idle",
+    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
       ? {
@@ -5218,6 +6175,28 @@ function buildRunnerStatusQueryLookup({ route, routeState, selectedRecord }) {
         }
       : null,
     related_active_request: relatedActiveRequest ? summarizeRunnerRequestForStatusLookup(relatedActiveRequest) : null,
+    related_request: relatedRequest ? summarizeRunnerRequestForStatusLookup(relatedRequest) : null,
+    root_work_item: String(safeObject(requestRootWorkItem).id || "").trim()
+      ? requestRootWorkItem
+      : activeRootWorkItemID
+        ? {
+            id: activeRootWorkItemID,
+            title: activeRootWorkItemTitle,
+            status: activeRootWorkItemStatus,
+          }
+        : currentConversationID && routeConversationID === currentConversationID && routeRootWorkItemID
+          ? {
+              id: routeRootWorkItemID,
+              title: routeRootWorkItemTitle,
+              status: routeRootWorkItemStatus,
+            }
+          : 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,
@@ -5278,6 +6257,13 @@ async function resolveInformationalQueryReply({
     };
   }
   if (normalizedIntentType === "status_query") {
+    let hydratedRunnerState = null;
+    try {
+      hydratedRunnerState = await hydrateRunnerRequestLedgerFromServer({
+        normalizedRoute: route,
+        runtime,
+      });
+    } catch {}
     return {
       handled: true,
       source: "runner.status",
@@ -5287,6 +6273,7 @@ async function resolveInformationalQueryReply({
         route,
         routeState,
         selectedRecord,
+        runnerStateOverride: hydratedRunnerState,
       }),
     };
     const activeExecution = resolveRunnerActiveExecutionState(routeState);
@@ -5427,14 +6414,18 @@ function emptyRunnerActiveExecutionPatch() {
     active_request_key: "",
     active_started_at: "",
     active_heartbeat_at: "",
+    active_root_work_item_id: "",
+    active_root_work_item_title: "",
+    active_root_work_item_status: "",
     active_runner_pid: undefined,
     active_execution_token: "",
   };
 }
 
-function buildRunnerActiveExecutionPatch(selectedRecord, requestKey = "") {
+function buildRunnerActiveExecutionPatch(selectedRecord, requestKey = "", rootWorkItem = {}) {
   const nowISO = new Date().toISOString();
   const parsed = safeObject(selectedRecord?.parsedArchive);
+  const root = safeObject(rootWorkItem);
   return {
     active_comment_id: String(selectedRecord?.id || "").trim(),
     active_comment_created_at: firstNonEmptyString([selectedRecord?.createdAt, selectedRecord?.updatedAt]),
@@ -5442,6 +6433,9 @@ function buildRunnerActiveExecutionPatch(selectedRecord, requestKey = "") {
     active_request_key: String(requestKey || "").trim(),
     active_started_at: nowISO,
     active_heartbeat_at: nowISO,
+    active_root_work_item_id: String(root.id || root.root_work_item_id || "").trim(),
+    active_root_work_item_title: String(root.title || root.root_work_item_title || "").trim(),
+    active_root_work_item_status: normalizeRunnerWorkItemStatus(root.status || root.root_work_item_status),
     active_runner_pid: process.pid,
     active_execution_token: `${Date.now()}-${process.pid}-${String(selectedRecord?.id || "").trim()}`,
   };
@@ -5921,7 +6915,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
       }
       return null;
     };
-    const prepareRunnerRequestClaim = (selectedRecord, selectedResponderSelectors = []) => {
+    const prepareRunnerRequestClaim = async (selectedRecord, selectedResponderSelectors = []) => {
       const parsed = safeObject(selectedRecord?.parsedArchive);
       const kind = String(parsed.kind || "").trim().toLowerCase();
       if (kind === "bot_reply") {
@@ -5951,6 +6945,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         routeKey,
         selectedRecord,
         selectedBotUsernames: selectedResponderSelectors,
+        runtime,
       });
     };
     if (deferExecution) {
@@ -6037,7 +7032,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           });
           continue;
         }
-        const requestClaim = prepareRunnerRequestClaim(selectedRecord, adjudication.selected_bot_usernames);
+        const requestClaim = await prepareRunnerRequestClaim(selectedRecord, adjudication.selected_bot_usernames);
         if (!requestClaim.ok) {
           await syncRunnerRequestLedgerForProjectToServer({
             normalizedRoute,
@@ -6062,9 +7057,64 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           });
           continue;
         }
+        const inheritedRootReference = await inheritRunnerReferenceRootWorkItemForRequest({
+          normalizedRoute,
+          selectedRecord,
+          runtime,
+          requestKey: requestClaim.requestKey,
+        });
+        const rootWorkItemClaim = await ensureRunnerRootWorkItemForRequest({
+          normalizedRoute,
+          routeKey,
+          selectedRecord,
+          runtime,
+          requestKey: requestClaim.requestKey,
+        });
+        if (!rootWorkItemClaim.ok) {
+          if (String(requestClaim.requestKey || "").trim()) {
+            markRunnerRequestLifecycle({
+              normalizedRoute,
+              requestKey: requestClaim.requestKey,
+              selectedRecord,
+              routeKey,
+              outcome: "closed",
+              closedReason: String(rootWorkItemClaim.error || rootWorkItemClaim.reason || "root_work_item_create_failed").trim(),
+            });
+            await syncRunnerRequestLedgerForProjectToServer({
+              normalizedRoute,
+              runtime,
+            });
+          }
+          saveRunnerRouteState(
+            routeKey,
+            buildRunnerRouteStateFromComment(selectedRecord, {
+              last_action: "request_skipped",
+              last_reason: String(rootWorkItemClaim.error || rootWorkItemClaim.reason || "root_work_item_create_failed").trim() || "root_work_item_create_failed",
+              last_trigger: "work_item_root",
+              last_request_key: String(requestClaim.requestKey || "").trim(),
+            }),
+          );
+          skippedRecords.push({
+            id: selectedRecord.id,
+            reason: String(rootWorkItemClaim.error || rootWorkItemClaim.reason || "root_work_item_create_failed").trim() || "root_work_item_create_failed",
+            messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
+            diagnosticType: "skip",
+            action: "skip_missing_root_work_item",
+            closedReason: String(rootWorkItemClaim.reason || "").trim(),
+          });
+          continue;
+        }
+        const claimedRequest = safeObject(rootWorkItemClaim.request || inheritedRootReference.request || requestClaim.request);
         saveRunnerRouteState(routeKey, {
-          ...buildRunnerActiveExecutionPatch(selectedRecord, requestClaim.requestKey),
+          ...buildRunnerActiveExecutionPatch(selectedRecord, requestClaim.requestKey, {
+            id: String(claimedRequest.root_work_item_id || "").trim(),
+            title: String(claimedRequest.root_work_item_title || "").trim(),
+            status: String(claimedRequest.root_work_item_status || "").trim(),
+          }),
           last_request_key: String(requestClaim.requestKey || "").trim(),
+          last_root_work_item_id: String(claimedRequest.root_work_item_id || "").trim(),
+          last_root_work_item_title: String(claimedRequest.root_work_item_title || "").trim(),
+          last_root_work_item_status: String(claimedRequest.root_work_item_status || "").trim(),
         });
         await syncRunnerRequestLedgerForProjectToServer({
           normalizedRoute,
@@ -6211,7 +7261,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         continue;
       }
       const currentRouteState = safeObject(loadBotRunnerState().routes[routeKey]);
-      const requestClaim = prepareRunnerRequestClaim(selectedRecord, inlineAdjudication.selected_bot_usernames);
+      const requestClaim = await prepareRunnerRequestClaim(selectedRecord, inlineAdjudication.selected_bot_usernames);
       if (!requestClaim.ok) {
         await syncRunnerRequestLedgerForProjectToServer({
           normalizedRoute,
@@ -6236,11 +7286,67 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         });
         continue;
       }
+      const inheritedRootReference = await inheritRunnerReferenceRootWorkItemForRequest({
+        normalizedRoute,
+        selectedRecord,
+        runtime,
+        requestKey: requestClaim.requestKey,
+      });
+      const rootWorkItemClaim = await ensureRunnerRootWorkItemForRequest({
+        normalizedRoute,
+        routeKey,
+        selectedRecord,
+        runtime,
+        requestKey: requestClaim.requestKey,
+      });
+      if (!rootWorkItemClaim.ok) {
+        if (String(requestClaim.requestKey || "").trim()) {
+          markRunnerRequestLifecycle({
+            normalizedRoute,
+            requestKey: requestClaim.requestKey,
+            selectedRecord,
+            routeKey,
+            outcome: "closed",
+            closedReason: String(rootWorkItemClaim.error || rootWorkItemClaim.reason || "root_work_item_create_failed").trim(),
+          });
+          await syncRunnerRequestLedgerForProjectToServer({
+            normalizedRoute,
+            runtime,
+          });
+        }
+        saveRunnerRouteState(
+          routeKey,
+          buildRunnerRouteStateFromComment(selectedRecord, {
+            last_action: "request_skipped",
+            last_reason: String(rootWorkItemClaim.error || rootWorkItemClaim.reason || "root_work_item_create_failed").trim() || "root_work_item_create_failed",
+            last_trigger: "work_item_root",
+            last_request_key: String(requestClaim.requestKey || "").trim(),
+          }),
+        );
+        skippedRecords.push({
+          id: selectedRecord.id,
+          reason: String(rootWorkItemClaim.error || rootWorkItemClaim.reason || "root_work_item_create_failed").trim() || "root_work_item_create_failed",
+          messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
+          diagnosticType: "skip",
+          action: "skip_missing_root_work_item",
+          closedReason: String(rootWorkItemClaim.reason || "").trim(),
+        });
+        continue;
+      }
+      const claimedRequest = safeObject(rootWorkItemClaim.request || inheritedRootReference.request || requestClaim.request);
       saveRunnerRouteState(routeKey, {
-        active_request_key: String(requestClaim.requestKey || "").trim(),
+        ...buildRunnerActiveExecutionPatch(selectedRecord, requestClaim.requestKey, {
+          id: String(claimedRequest.root_work_item_id || "").trim(),
+          title: String(claimedRequest.root_work_item_title || "").trim(),
+          status: String(claimedRequest.root_work_item_status || "").trim(),
+        }),
         last_request_key: String(requestClaim.requestKey || "").trim(),
+        last_root_work_item_id: String(claimedRequest.root_work_item_id || "").trim(),
+        last_root_work_item_title: String(claimedRequest.root_work_item_title || "").trim(),
+        last_root_work_item_status: String(claimedRequest.root_work_item_status || "").trim(),
       });
       if (String(requestClaim.requestKey || "").trim()) {
+        const resolvedIntentType = String(safeObject(loadBotRunnerState().routes[routeKey]).last_intent_type || "").trim();
         markRunnerRequestLifecycle({
           normalizedRoute,
           requestKey: requestClaim.requestKey,
@@ -6248,6 +7354,22 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           routeKey,
           outcome: "running",
         });
+        const rootWorkItemSync = await syncRunnerRequestRootWorkItemForOutcome({
+          normalizedRoute,
+          runtime,
+          requestKey: requestClaim.requestKey,
+        });
+        const syncedRequest = safeObject(rootWorkItemSync.request);
+        if (String(syncedRequest.root_work_item_id || "").trim()) {
+          saveRunnerRouteState(routeKey, {
+            active_root_work_item_id: String(syncedRequest.root_work_item_id || "").trim(),
+            active_root_work_item_title: String(syncedRequest.root_work_item_title || "").trim(),
+            active_root_work_item_status: String(syncedRequest.root_work_item_status || "").trim(),
+            last_root_work_item_id: String(syncedRequest.root_work_item_id || "").trim(),
+            last_root_work_item_title: String(syncedRequest.root_work_item_title || "").trim(),
+            last_root_work_item_status: String(syncedRequest.root_work_item_status || "").trim(),
+          });
+        }
         await syncRunnerRequestLedgerForProjectToServer({
           normalizedRoute,
           runtime,
@@ -6258,7 +7380,11 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         normalizedRoute,
         routeState: {
           ...currentRouteState,
-          active_request_key: String(requestClaim.requestKey || "").trim(),
+          ...buildRunnerActiveExecutionPatch(selectedRecord, requestClaim.requestKey, {
+            id: String(claimedRequest.root_work_item_id || "").trim(),
+            title: String(claimedRequest.root_work_item_title || "").trim(),
+            status: String(claimedRequest.root_work_item_status || "").trim(),
+          }),
         },
         selectedRecord,
         pendingOrdered: pending.ordered,
@@ -6293,6 +7419,19 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
             outcome: "skipped",
             closedReason: String(processed.skippedRecord?.reason || "skipped").trim() || "skipped",
           });
+          const rootWorkItemSync = await syncRunnerRequestRootWorkItemForOutcome({
+            normalizedRoute,
+            runtime,
+            requestKey: requestClaim.requestKey,
+          });
+          const syncedRequest = safeObject(rootWorkItemSync.request);
+          if (String(syncedRequest.root_work_item_id || "").trim()) {
+            saveRunnerRouteState(routeKey, {
+              last_root_work_item_id: String(syncedRequest.root_work_item_id || "").trim(),
+              last_root_work_item_title: String(syncedRequest.root_work_item_title || "").trim(),
+              last_root_work_item_status: String(syncedRequest.root_work_item_status || "").trim(),
+            });
+          }
           await syncRunnerRequestLedgerForProjectToServer({
             normalizedRoute,
             runtime,
@@ -6302,6 +7441,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         continue;
       }
       if (String(requestClaim.requestKey || "").trim()) {
+        const resolvedIntentType = String(safeObject(loadBotRunnerState().routes[routeKey]).last_intent_type || "").trim();
         markRunnerRequestLifecycle({
           normalizedRoute,
           requestKey: requestClaim.requestKey,
@@ -6315,8 +7455,28 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
           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(),
+          normalizedIntent: resolvedIntentType,
+        });
+        await ensureRunnerRootWorkItemForRequest({
+          normalizedRoute,
+          routeKey,
+          selectedRecord,
+          runtime,
+          requestKey: requestClaim.requestKey,
+        });
+        const rootWorkItemSync = await syncRunnerRequestRootWorkItemForOutcome({
+          normalizedRoute,
+          runtime,
+          requestKey: requestClaim.requestKey,
         });
+        const syncedRequest = safeObject(rootWorkItemSync.request);
+        if (String(syncedRequest.root_work_item_id || "").trim()) {
+          saveRunnerRouteState(routeKey, {
+            last_root_work_item_id: String(syncedRequest.root_work_item_id || "").trim(),
+            last_root_work_item_title: String(syncedRequest.root_work_item_title || "").trim(),
+            last_root_work_item_status: String(syncedRequest.root_work_item_status || "").trim(),
+          });
+        }
         await syncRunnerRequestLedgerForProjectToServer({
           normalizedRoute,
           runtime,
@@ -8008,7 +9168,7 @@ async function runRunnerStop(flags) {
   }
   process.stdout.write("Detached runner stop: OK\n");
   process.stdout.write(`registry_file: ${payload.registry_file}\n`);
-  for (const entry of stopped) {
+  for (const entry of ensureArray(payload.stopped)) {
     process.stdout.write(`stopped: ${entry.launch_id} pid=${entry.pid} routes=${entry.route_names.join(", ") || "-"}\n`);
   }
 }
@@ -8033,7 +9193,7 @@ async function runRunnerStartDetachedResolvedRoutes(routes, flags, sourceCommand
   process.stdout.write(`Detached runner already running: launch_id=${existing.launch_id} pid=${existing.pid}${existing.log_file ? ` log_file=${existing.log_file}` : ""}\n`);
   return payload;
   }
-  const launch = launchDetachedRunnerProcess(flags, routes, sourceCommand);
+  const launch = await launchDetachedRunnerProcess(flags, routes, sourceCommand);
   const nextLaunches = {
     ...safeObject(registry).launches,
     [launch.launch_id]: launch,
@@ -8560,6 +9720,22 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                     routeKey: deferredExecution.routeKey,
                     outcome: "running",
                   });
+                  const rootWorkItemSync = await syncRunnerRequestRootWorkItemForOutcome({
+                    normalizedRoute: deferredExecution.normalizedRoute,
+                    runtime: deferredExecution.runtime,
+                    requestKey: deferredExecution.requestKey,
+                  });
+                  const syncedRequest = safeObject(rootWorkItemSync.request);
+                  if (String(syncedRequest.root_work_item_id || "").trim()) {
+                    saveRunnerRouteState(deferredExecution.routeKey, {
+                      active_root_work_item_id: String(syncedRequest.root_work_item_id || "").trim(),
+                      active_root_work_item_title: String(syncedRequest.root_work_item_title || "").trim(),
+                      active_root_work_item_status: String(syncedRequest.root_work_item_status || "").trim(),
+                      last_root_work_item_id: String(syncedRequest.root_work_item_id || "").trim(),
+                      last_root_work_item_title: String(syncedRequest.root_work_item_title || "").trim(),
+                      last_root_work_item_status: String(syncedRequest.root_work_item_status || "").trim(),
+                    });
+                  }
                   await syncRunnerRequestLedgerForProjectToServer({
                     normalizedRoute: deferredExecution.normalizedRoute,
                     runtime: deferredExecution.runtime,
@@ -8622,6 +9798,19 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                           outcome: "skipped",
                           closedReason: String(processed.skippedRecord?.reason || "skipped").trim() || "skipped",
                         });
+                        const rootWorkItemSync = await syncRunnerRequestRootWorkItemForOutcome({
+                          normalizedRoute: deferredExecution.normalizedRoute,
+                          runtime: deferredExecution.runtime,
+                          requestKey: deferredExecution.requestKey,
+                        });
+                        const syncedRequest = safeObject(rootWorkItemSync.request);
+                        if (String(syncedRequest.root_work_item_id || "").trim()) {
+                          saveRunnerRouteState(deferredExecution.routeKey, {
+                            last_root_work_item_id: String(syncedRequest.root_work_item_id || "").trim(),
+                            last_root_work_item_title: String(syncedRequest.root_work_item_title || "").trim(),
+                            last_root_work_item_status: String(syncedRequest.root_work_item_status || "").trim(),
+                          });
+                        }
                         await syncRunnerRequestLedgerForProjectToServer({
                           normalizedRoute: deferredExecution.normalizedRoute,
                           runtime: deferredExecution.runtime,
@@ -8642,6 +9831,9 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                       };
                     }
                     if (String(deferredExecution.requestKey || "").trim()) {
+                      const resolvedIntentType = String(
+                        safeObject(loadBotRunnerState().routes[deferredExecution.routeKey]).last_intent_type || "",
+                      ).trim();
                       markRunnerRequestLifecycle({
                         normalizedRoute: deferredExecution.normalizedRoute,
                         requestKey: deferredExecution.requestKey,
@@ -8657,8 +9849,28 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                           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(),
+                        normalizedIntent: resolvedIntentType,
+                      });
+                      await ensureRunnerRootWorkItemForRequest({
+                        normalizedRoute: deferredExecution.normalizedRoute,
+                        routeKey: deferredExecution.routeKey,
+                        selectedRecord: deferredExecution.selectedRecord,
+                        runtime: deferredExecution.runtime,
+                        requestKey: deferredExecution.requestKey,
+                      });
+                      const rootWorkItemSync = await syncRunnerRequestRootWorkItemForOutcome({
+                        normalizedRoute: deferredExecution.normalizedRoute,
+                        runtime: deferredExecution.runtime,
+                        requestKey: deferredExecution.requestKey,
                       });
+                      const syncedRequest = safeObject(rootWorkItemSync.request);
+                      if (String(syncedRequest.root_work_item_id || "").trim()) {
+                        saveRunnerRouteState(deferredExecution.routeKey, {
+                          last_root_work_item_id: String(syncedRequest.root_work_item_id || "").trim(),
+                          last_root_work_item_title: String(syncedRequest.root_work_item_title || "").trim(),
+                          last_root_work_item_status: String(syncedRequest.root_work_item_status || "").trim(),
+                        });
+                      }
                       await syncRunnerRequestLedgerForProjectToServer({
                         normalizedRoute: deferredExecution.normalizedRoute,
                         runtime: deferredExecution.runtime,
@@ -8687,6 +9899,19 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                         outcome: "error",
                         closedReason: errorText || "execution_error",
                       });
+                      const rootWorkItemSync = await syncRunnerRequestRootWorkItemForOutcome({
+                        normalizedRoute: deferredExecution.normalizedRoute,
+                        runtime: deferredExecution.runtime,
+                        requestKey: deferredExecution.requestKey,
+                      });
+                      const syncedRequest = safeObject(rootWorkItemSync.request);
+                      if (String(syncedRequest.root_work_item_id || "").trim()) {
+                        saveRunnerRouteState(deferredExecution.routeKey, {
+                          last_root_work_item_id: String(syncedRequest.root_work_item_id || "").trim(),
+                          last_root_work_item_title: String(syncedRequest.root_work_item_title || "").trim(),
+                          last_root_work_item_status: String(syncedRequest.root_work_item_status || "").trim(),
+                        });
+                      }
                       await syncRunnerRequestLedgerForProjectToServer({
                         normalizedRoute: deferredExecution.normalizedRoute,
                         runtime: deferredExecution.runtime,
@@ -12966,6 +14191,8 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     runnerRouteLogicalSignature,
     loadBotRunnerState,
     saveBotRunnerState,
+    mergeServerRunnerRequestLedgerIntoLocalState,
+    buildRunnerStatusQueryLookup,
     tryJsonParse,
     safeObject,
     normalizeRunnerTriggerPolicy,