metheus-governance-mcp-cli 0.2.197 → 0.2.199

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,66 @@ function buildRunnerRequestKey({
   ].join("::");
 }
 
+function looksLikeRunnerClaimQuestion(rawText) {
+  return /[?？]/.test(String(rawText || ""));
+}
+
+function inferRunnerRequestClaimIntent(selectedRecord) {
+  const parsed = safeObject(selectedRecord?.parsedArchive);
+  const commentKind = String(parsed.kind || "").trim().toLowerCase();
+  if (!isInboundArchiveKind(commentKind)) {
+    return "";
+  }
+  const rawText = String(parsed.body || "").trim();
+  const normalizedText = rawText.toLowerCase();
+  const replyToMessageID = intFromRawAllowZero(parsed.replyToMessageID, 0);
+  if (!rawText) {
+    return "";
+  }
+  if (/^(hi|hello|hey|thanks|thank you|good morning|good afternoon|good evening)\b/.test(normalizedText)) {
+    return "small_talk";
+  }
+  if (/\b(bot role|your role|what do you do|who are you|which bot|who should respond)\b/.test(normalizedText)) {
+    return "bot_role_query";
+  }
+  if (/\b(workspace|working directory|workdir|project folder|local folder)\b/.test(normalizedText)) {
+    return "workspace_query";
+  }
+  if (
+    (/\b(where|path|locate|find)\b/.test(normalizedText) || /\.[a-z0-9]{1,8}\b/.test(normalizedText))
+    && /\b(file|folder|path|doc|guide|readme|workspace)\b/.test(normalizedText)
+  ) {
+    return "artifact_location_query";
+  }
+  if (/\b(why|explain|what is|what does|how does|describe)\b/.test(normalizedText) && looksLikeRunnerClaimQuestion(rawText)) {
+    return "explanation_query";
+  }
+  if (
+    /\b(status|progress|done|finished|complete|completed|working on|current work|did you|handled|handle it|what are you working|check status)\b/
+      .test(normalizedText)
+  ) {
+    return "status_query";
+  }
+  if (replyToMessageID > 0 && looksLikeRunnerClaimQuestion(rawText)) {
+    return "status_query";
+  }
+  if (looksLikeRunnerClaimQuestion(rawText) && normalizedText.split(/\s+/).filter(Boolean).length <= 8) {
+    return "status_query";
+  }
+  return "general_execution";
+}
+
+function resolveRunnerRequestClaimIntent({
+  normalizedIntent = "",
+  selectedRecord,
+}) {
+  const explicitIntent = String(normalizedIntent || "").trim().toLowerCase();
+  if (explicitIntent) {
+    return explicitIntent;
+  }
+  return inferRunnerRequestClaimIntent(selectedRecord);
+}
+
 function buildSyntheticReplyChainConversationID(normalizedRoute, chatID, anchorMessageID) {
   const provider = String(normalizedRoute?.provider || "").trim() || "unknown";
   const normalizedChatID = String(chatID || "").trim() || "-";
@@ -2409,6 +2492,67 @@ function findRunnerRequestsForMessageID(state, normalizedRoute, selectors = {})
     ));
 }
 
+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();
@@ -2451,6 +2595,74 @@ function resolveRunnerReplyChainConversationContext(state, normalizedRoute, sele
   };
 }
 
+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);
@@ -2490,104 +2702,699 @@ 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 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();
+  const resolvedNormalizedIntent = resolveRunnerRequestClaimIntent({
+    normalizedIntent,
+    selectedRecord,
+  });
+  const requestKey = buildRunnerRequestKey({
+    normalizedRoute,
+    selectedRecord,
+    selectedBotUsernames,
+    normalizedIntent: resolvedNormalizedIntent,
+  });
+  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: resolvedNormalizedIntent,
+    status: "claimed",
+    claimed_by_route: String(routeKey || "").trim(),
+    claimed_at: firstNonEmptyString([existing.claimed_at, nowISO]) || nowISO,
+    root_work_item_id: String(existing.root_work_item_id || referencedRequest.root_work_item_id || "").trim(),
+    root_work_item_title: String(existing.root_work_item_title || referencedRequest.root_work_item_title || "").trim(),
+    root_work_item_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 loadRunnerRequestByKey(requestKey) {
+  const key = String(requestKey || "").trim();
+  if (!key) {
+    return {};
+  }
+  return safeObject(normalizeBotRunnerRequests(loadBotRunnerState().requests)[key]);
+}
+
+function actionableRunnerRequestMissingRootWorkItem(requestRaw) {
+  const request = safeObject(requestRaw);
+  return (
+    isActionableRunnerRequestIntent(request.normalized_intent)
+    && !String(request.root_work_item_id || "").trim()
+  );
+}
+
+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,
+  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 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)) {
+  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(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,
-    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",
+  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: stateForClaim.routes,
-    sharedInboxes: stateForClaim.sharedInboxes || stateForClaim.shared_inboxes,
-    excludedComments: stateForClaim.excludedComments || stateForClaim.excluded_comments,
+    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,
   };
 }
 
@@ -2918,6 +3725,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);
@@ -2941,7 +3772,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);
@@ -3094,6 +3930,12 @@ async function syncRunnerRequestLedgerForProjectToServer({ normalizedRoute, runt
     const commentStates = buildProjectRunnerRequestCommentStatesForSync(state, normalizedRoute);
 
     for (const request of requests) {
+      if (
+        isActionableRunnerRequestIntent(request.normalized_intent)
+        && !String(request.root_work_item_id || "").trim()
+      ) {
+        continue;
+      }
       await upsertProjectRunnerRequest({
         siteBaseURL: runtime.baseURL,
         projectID,
@@ -4925,6 +5767,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());
 }
@@ -4933,6 +5779,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());
 }
@@ -5241,6 +6091,14 @@ function summarizeRunnerRequestForStatusLookup(entryRaw) {
     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,
   };
 }
 
@@ -5299,7 +6157,7 @@ function pickPreferredStatusLookupRequest(entries = []) {
   return candidates[0];
 }
 
-function buildRunnerStatusQueryLookup({ route, routeState, selectedRecord }) {
+function buildRunnerStatusQueryLookup({ route, routeState, selectedRecord, runnerStateOverride = null }) {
   const parsed = safeObject(selectedRecord?.parsedArchive);
   const currentMessageID = intFromRawAllowZero(parsed.messageID, 0);
   const currentChatID = String(parsed.chatID || parsed.chatId || "").trim();
@@ -5318,18 +6176,23 @@ function buildRunnerStatusQueryLookup({ route, routeState, selectedRecord }) {
     && activeSourceMessageID > 0
     && currentMessageID === activeSourceMessageID
   );
-  let runnerState = { requests: {} };
-  try {
-    runnerState = loadBotRunnerState();
-  } catch {}
+  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;
   let relatedRequest = null;
   const selectors = currentConversationID
@@ -5339,20 +6202,43 @@ function buildRunnerStatusQueryLookup({ route, routeState, selectedRecord }) {
   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);
-  relatedActiveRequest = eligibleScopedRequests
+  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(
-    eligibleScopedRequests.length
-      ? eligibleScopedRequests
-      : (replyChainContext.referencedRequest ? [replyChainContext.referencedRequest] : []).filter(requestMatchesCurrentRoute),
-  );
+  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
@@ -5376,6 +6262,21 @@ 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,
@@ -5442,6 +6343,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",
@@ -5451,6 +6359,7 @@ async function resolveInformationalQueryReply({
         route,
         routeState,
         selectedRecord,
+        runnerStateOverride: hydratedRunnerState,
       }),
     };
     const activeExecution = resolveRunnerActiveExecutionState(routeState);
@@ -5591,14 +6500,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]),
@@ -5606,6 +6519,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()}`,
   };
@@ -6085,7 +7001,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") {
@@ -6115,6 +7031,7 @@ async function processRunnerRouteOnce(route, runtime, mode, options = {}) {
         routeKey,
         selectedRecord,
         selectedBotUsernames: selectedResponderSelectors,
+        runtime,
       });
     };
     if (deferExecution) {
@@ -6201,7 +7118,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,
@@ -6226,9 +7143,75 @@ 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,
+        });
+        const claimedRequest = safeObject(
+          loadRunnerRequestByKey(requestClaim.requestKey)
+          || rootWorkItemClaim.request
+          || inheritedRootReference.request
+          || requestClaim.request,
+        );
+        const missingRequiredRootWorkItem = actionableRunnerRequestMissingRootWorkItem(claimedRequest);
+        if (!rootWorkItemClaim.ok || missingRequiredRootWorkItem) {
+          const rootWorkItemFailure = String(
+            rootWorkItemClaim.error
+            || rootWorkItemClaim.reason
+            || (missingRequiredRootWorkItem ? "root_work_item_missing" : "root_work_item_create_failed"),
+          ).trim() || "root_work_item_create_failed";
+          if (String(requestClaim.requestKey || "").trim()) {
+            markRunnerRequestLifecycle({
+              normalizedRoute,
+              requestKey: requestClaim.requestKey,
+              selectedRecord,
+              routeKey,
+              outcome: "closed",
+              closedReason: rootWorkItemFailure,
+            });
+            await syncRunnerRequestLedgerForProjectToServer({
+              normalizedRoute,
+              runtime,
+            });
+          }
+          saveRunnerRouteState(
+            routeKey,
+            buildRunnerRouteStateFromComment(selectedRecord, {
+              last_action: "request_skipped",
+              last_reason: rootWorkItemFailure,
+              last_trigger: "work_item_root",
+              last_request_key: String(requestClaim.requestKey || "").trim(),
+            }),
+          );
+          skippedRecords.push({
+            id: selectedRecord.id,
+            reason: rootWorkItemFailure,
+            messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
+            diagnosticType: "skip",
+            action: "skip_missing_root_work_item",
+            closedReason: rootWorkItemFailure,
+          });
+          continue;
+        }
         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,
@@ -6375,7 +7358,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,
@@ -6400,11 +7383,78 @@ 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,
+      });
+      const claimedRequest = safeObject(
+        loadRunnerRequestByKey(requestClaim.requestKey)
+        || rootWorkItemClaim.request
+        || inheritedRootReference.request
+        || requestClaim.request,
+      );
+      const missingRequiredRootWorkItem = actionableRunnerRequestMissingRootWorkItem(claimedRequest);
+      if (!rootWorkItemClaim.ok || missingRequiredRootWorkItem) {
+        const rootWorkItemFailure = String(
+          rootWorkItemClaim.error
+          || rootWorkItemClaim.reason
+          || (missingRequiredRootWorkItem ? "root_work_item_missing" : "root_work_item_create_failed"),
+        ).trim() || "root_work_item_create_failed";
+        if (String(requestClaim.requestKey || "").trim()) {
+          markRunnerRequestLifecycle({
+            normalizedRoute,
+            requestKey: requestClaim.requestKey,
+            selectedRecord,
+            routeKey,
+            outcome: "closed",
+            closedReason: rootWorkItemFailure,
+          });
+          await syncRunnerRequestLedgerForProjectToServer({
+            normalizedRoute,
+            runtime,
+          });
+        }
+        saveRunnerRouteState(
+          routeKey,
+          buildRunnerRouteStateFromComment(selectedRecord, {
+            last_action: "request_skipped",
+            last_reason: rootWorkItemFailure,
+            last_trigger: "work_item_root",
+            last_request_key: String(requestClaim.requestKey || "").trim(),
+          }),
+        );
+        skippedRecords.push({
+          id: selectedRecord.id,
+          reason: rootWorkItemFailure,
+          messageID: intFromRawAllowZero(selectedRecord?.parsedArchive?.messageID, 0),
+          diagnosticType: "skip",
+          action: "skip_missing_root_work_item",
+          closedReason: rootWorkItemFailure,
+        });
+        continue;
+      }
       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,
@@ -6412,6 +7462,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,
@@ -6422,7 +7488,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,
@@ -6457,6 +7527,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,
@@ -6466,6 +7549,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,
@@ -6479,8 +7563,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,
@@ -8172,7 +9276,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`);
   }
 }
@@ -8197,7 +9301,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,
@@ -8724,6 +9828,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,
@@ -8786,6 +9906,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,
@@ -8806,6 +9939,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,
@@ -8821,8 +9957,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,
@@ -8843,6 +9999,12 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                       last_error: errorText,
                     });
                     if (String(deferredExecution.requestKey || "").trim()) {
+                      const currentRequest = safeObject(loadRunnerRequestByKey(deferredExecution.requestKey));
+                      const resolvedIntentType = String(
+                        safeObject(loadBotRunnerState().routes[deferredExecution.routeKey]).last_intent_type
+                        || currentRequest.normalized_intent
+                        || "",
+                      ).trim();
                       markRunnerRequestLifecycle({
                         normalizedRoute: deferredExecution.normalizedRoute,
                         requestKey: deferredExecution.requestKey,
@@ -8850,7 +10012,28 @@ async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
                         routeKey: deferredExecution.routeKey,
                         outcome: "error",
                         closedReason: errorText || "execution_error",
+                        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,
@@ -13130,6 +14313,7 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     runnerRouteLogicalSignature,
     loadBotRunnerState,
     saveBotRunnerState,
+    mergeServerRunnerRequestLedgerIntoLocalState,
     buildRunnerStatusQueryLookup,
     tryJsonParse,
     safeObject,