metheus-governance-mcp-cli 0.2.170 → 0.2.172

package/cli.mjs

@@ -80,6 +80,7 @@ import {
   appendWorkitemListHints as appendWorkitemListHintsImpl,
   injectCtxpackPreflightToken as injectCtxpackPreflightTokenImpl,
   injectCtxpackUpdateDefaults as injectCtxpackUpdateDefaultsImpl,
+  injectWorkitemBotActorDefaults as injectWorkitemBotActorDefaultsImpl,
   maybeAutoSyncCtxpackForCall as maybeAutoSyncCtxpackForCallImpl,
   maybeAutoSyncCtxpackForSessionRequest as maybeAutoSyncCtxpackForSessionRequestImpl,
   stripLocalOnlyToolArgs as stripLocalOnlyToolArgsImpl,
@@ -142,6 +143,7 @@ import {
   linkWorkItemEvidence as linkWorkItemEvidenceImpl,
   listProjectChatDestinations as listProjectChatDestinationsImpl,
   listProjectContextItems as listProjectContextItemsImpl,
+  listProjectCtxpackFiles as listProjectCtxpackFilesImpl,
   listThreadComments as listThreadCommentsImpl,
   listUserBotsForRunner as listUserBotsForRunnerImpl,
   selectProjectChatDestination as selectProjectChatDestinationImpl,
@@ -187,9 +189,13 @@ const BOT_RUNNER_CONFIG_RELATIVE_PATH = path.join(".metheus", "bot-runner.json")
 const BOT_RUNNER_WORKSPACE_REGISTRY_RELATIVE_PATH = path.join(".metheus", "project-workspaces.json");
 const BOT_RUNNER_STATE_RELATIVE_PATH = path.join(".metheus", "bot-runner-state.json");
 const BOT_RUNNER_PROCESSES_RELATIVE_PATH = path.join(".metheus", "bot-runner-processes.json");
+const BOT_RUNNER_LOGS_RELATIVE_DIR = path.join(".metheus", "runner-logs");
 const BOT_RUNNER_LOCKS_RELATIVE_DIR = path.join(".metheus", "bot-runner-locks");
 const BOT_RUNNER_CONFIG_VERSION = 2;
 const BOT_RUNNER_ROUTE_LOCK_STALE_MS = 30 * 60 * 1000;
+const BOT_RUNNER_ACTIVE_EXECUTION_STUCK_WARNING_MS = 20 * 60 * 1000;
+const BOT_RUNNER_ACTIVE_EXECUTION_HEARTBEAT_INTERVAL_MS = 5000;
+const BOT_RUNNER_ACTIVE_EXECUTION_HEARTBEAT_STALE_MS = 60 * 1000;
 const BOT_RUNNER_DEFAULT_CONCURRENCY = 2;
 const BOT_RUNNER_MAX_CONCURRENCY = 8;
 const TELEGRAM_ROOT_LEGACY_ENV_RELATIVE_PATH = path.join(".metheus", "telegram.env");
@@ -220,6 +226,7 @@ const SELF_UPDATE_STATE_RELATIVE_PATH = path.join(".metheus", "governance-mcp-cl
 const CTXPACK_CACHE_RELATIVE_DIR = path.join(".metheus", "ctxpack-cache");
 const CTXPACK_META_FILENAME = ".metheus_ctxpack_sync.json";
 const CTXPACK_UPDATE_TOOL_NAMES = ["ctxpack.update"];
+const WORKITEM_MUTATION_TOOL_NAMES = ["workitem.push", "workitem.update", "workitem.transition"];
 const CLI_META = loadCLIMeta();
 const CLI_NAME = CLI_META.name || "metheus-governance-mcp-cli";
 const CLI_VERSION = CLI_META.version || "0.0.0";
@@ -295,14 +302,14 @@ function printUsage() {
       `  ${cmd} runner list [--json <true|false>]`,
       `  ${cmd} runner route list [--json <true|false>]`,
       `  ${cmd} runner route add [--project-id <uuid>] [--provider <telegram|slack|kakaotalk>] [--role <monitor|review|worker|approval>] [--bot-name <server_name> | --bot-id <uuid>] [--destination-label <label> | --destination-id <uuid>] [--poll-interval-ms <n>] [--enabled <true|false>]`,
-      `  ${cmd} runner project up [--project-id <uuid>] [--provider <telegram>] [--destination-label <label> | --destination-id <uuid>] [--bot-name <server_name> | --bot-id <uuid>] [--role <monitor|review|worker|approval> | --roles <csv>] [--apply <true|false>] [--start <true|false>] [--start-detached <true|false>] [--dry-run-delivery <true|false>] [--concurrency <n>] [--json <true|false>]`,
+      `  ${cmd} runner project up [--project-id <uuid>] [--provider <telegram>] [--destination-label <label> | --destination-id <uuid>] [--bot-name <server_name> | --bot-id <uuid>] [--role <monitor|review|worker|approval> | --roles <csv>] [--apply <true|false>] [--start <true|false>] [--start-detached <true|false>] [--tui <true|false>] [--log-file <path>] [--dry-run-delivery <true|false>] [--concurrency <n>] [--json <true|false>]`,
       `  ${cmd} runner artifact scan [--workspace-dir <path>] [--file-limit <n>] [--json <true|false>]`,
       `  ${cmd} runner route edit [--route-name <name> | --bot-name <server_name> | --bot-id <uuid>]`,
       `  ${cmd} runner route remove [--route-name <name> | --bot-name <server_name> | --bot-id <uuid>]`,
       `  ${cmd} runner show [--route-name <name> | --bot-name <server_name> | --bot-id <uuid>] [--json <true|false>]`,
       `  ${cmd} runner once [--route-name <name> | --bot-name <server_name when one enabled route matches> | --bot-id <uuid when one enabled route matches>] [--project-id <uuid>] [--provider <telegram|slack|kakaotalk>] [--role <monitor|review|worker|approval>] [--role-profile <name>] [--mentions-only <true|false>] [--reply-to-bot-messages <true|false>] [--direct-messages <true|false>] [--ignore-edited-messages <true|false>] [--dry-run-delivery <true|false>] [--context-comments <n>] [--archive-replies <true|false>]`,
-      `  ${cmd} runner start [--route-name <name> | --bot-name <server_name when one enabled route matches> | --bot-id <uuid when one enabled route matches>] [--project-id <uuid>] [--provider <telegram|slack|kakaotalk>] [--role <monitor|review|worker|approval>] [--role-profile <name>] [--mentions-only <true|false>] [--reply-to-bot-messages <true|false>] [--direct-messages <true|false>] [--ignore-edited-messages <true|false>] [--dry-run-delivery <true|false>] [--poll-interval-ms <n>] [--concurrency <n>] [--context-comments <n>] [--archive-replies <true|false>]`,
-      `  ${cmd} runner start-detached [--route-name <name> | --bot-name <server_name when one enabled route matches> | --bot-id <uuid when one enabled route matches>] [--project-id <uuid>] [--provider <telegram|slack|kakaotalk>] [--role <monitor|review|worker|approval>] [--role-profile <name>] [--mentions-only <true|false>] [--reply-to-bot-messages <true|false>] [--direct-messages <true|false>] [--ignore-edited-messages <true|false>] [--dry-run-delivery <true|false>] [--poll-interval-ms <n>] [--concurrency <n>] [--context-comments <n>] [--archive-replies <true|false>] [--json <true|false>]`,
+      `  ${cmd} runner start [--route-name <name> | --bot-name <server_name when one enabled route matches> | --bot-id <uuid when one enabled route matches>] [--project-id <uuid>] [--provider <telegram|slack|kakaotalk>] [--role <monitor|review|worker|approval>] [--role-profile <name>] [--mentions-only <true|false>] [--reply-to-bot-messages <true|false>] [--direct-messages <true|false>] [--ignore-edited-messages <true|false>] [--tui <true|false>] [--log-file <path>] [--dry-run-delivery <true|false>] [--poll-interval-ms <n>] [--concurrency <n>] [--context-comments <n>] [--archive-replies <true|false>]`,
+      `  ${cmd} runner start-detached [--route-name <name> | --bot-name <server_name when one enabled route matches> | --bot-id <uuid when one enabled route matches>] [--project-id <uuid>] [--provider <telegram|slack|kakaotalk>] [--role <monitor|review|worker|approval>] [--role-profile <name>] [--mentions-only <true|false>] [--reply-to-bot-messages <true|false>] [--direct-messages <true|false>] [--ignore-edited-messages <true|false>] [--log-file <path>] [--dry-run-delivery <true|false>] [--poll-interval-ms <n>] [--concurrency <n>] [--context-comments <n>] [--archive-replies <true|false>] [--json <true|false>]`,
       `  ${cmd} runner status [--launch-id <id> | --project-id <uuid> | --route-name <name>] [--json <true|false>]`,
       `  ${cmd} runner stop [--launch-id <id> | --project-id <uuid> | --route-name <name>] [--all <true|false>] [--json <true|false>]`,
       `  ${cmd} ctxpack pull [--project-id <uuid>] [--base-url <url>] [--workspace-dir <path|auto>] [--paths <csv>] [--timeout-seconds <n>]`,
@@ -784,6 +791,92 @@ function botRunnerProcessesFilePath() {
   return resolveHomeFilePath(BOT_RUNNER_PROCESSES_RELATIVE_PATH);
 }
 
+function botRunnerLogsDirPath() {
+  return resolveHomeFilePath(BOT_RUNNER_LOGS_RELATIVE_DIR);
+}
+
+function sanitizeRunnerLogSlug(rawValue, fallback = "runner") {
+  const normalized = String(rawValue || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  return normalized || fallback;
+}
+
+function buildDefaultRunnerLogFilePath(routes, sourceLabel = "runner start", startedAt = new Date()) {
+  const timestamp = [
+    startedAt.getFullYear(),
+    String(startedAt.getMonth() + 1).padStart(2, "0"),
+    String(startedAt.getDate()).padStart(2, "0"),
+    "T",
+    String(startedAt.getHours()).padStart(2, "0"),
+    String(startedAt.getMinutes()).padStart(2, "0"),
+    String(startedAt.getSeconds()).padStart(2, "0"),
+  ].join("");
+  const sourceSlug = sanitizeRunnerLogSlug(sourceLabel, "runner-start");
+  const routeSlug = sanitizeRunnerLogSlug(
+    ensureArray(routes)
+      .map((route) => normalizeRunnerRoute(route).name || "")
+      .filter(Boolean)
+      .slice(0, 2)
+      .join("-"),
+    "routes",
+  );
+  const dayDir = [
+    startedAt.getFullYear(),
+    String(startedAt.getMonth() + 1).padStart(2, "0"),
+    String(startedAt.getDate()).padStart(2, "0"),
+  ].join("-");
+  return path.join(botRunnerLogsDirPath(), dayDir, `${sourceSlug}-${routeSlug}-${timestamp}.jsonl`);
+}
+
+function resolveRunnerLogFilePath(rawValue, routes, sourceLabel = "runner start") {
+  const text = String(rawValue || "").trim();
+  if (["false", "none", "off", "disable"].includes(text.toLowerCase())) {
+    return "";
+  }
+  const filePath = text
+    ? path.resolve(text)
+    : buildDefaultRunnerLogFilePath(routes, sourceLabel);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  return filePath;
+}
+
+function createRunnerStartLogger({ routes, flags, sourceLabel = "runner start", jsonMode = false }) {
+  const filePath = resolveRunnerLogFilePath(flags["log-file"], routes, sourceLabel);
+  if (!filePath) {
+    return null;
+  }
+  const append = (kind, payload = {}) => {
+    try {
+      fs.appendFileSync(
+        filePath,
+        `${JSON.stringify({
+          ts: new Date().toISOString(),
+          source: sourceLabel,
+          kind: String(kind || "").trim() || "event",
+          ...safeObject(payload),
+        })}\n`,
+        "utf8",
+      );
+    } catch {
+      // best-effort logging only
+    }
+  };
+  append("runner_start", {
+    json_mode: jsonMode === true,
+    route_names: ensureArray(routes).map((route) => normalizeRunnerRoute(route).name || runnerRouteKey(normalizeRunnerRoute(route))),
+  });
+  return {
+    filePath,
+    append,
+    close(payload = {}) {
+      append("runner_stop", payload);
+    },
+  };
+}
+
 function normalizeBotProvider(rawValue) {
   return normalizeBotProviderName(rawValue, "telegram");
 }
@@ -1953,6 +2046,7 @@ function normalizeRunnerProcessLaunchEntry(rawEntry) {
     project_ids: ensureArray(entry.project_ids || entry.projectIds).map((item) => String(item || "").trim()).filter(Boolean),
     provider: normalizeBotProvider(entry.provider),
     destination_labels: ensureArray(entry.destination_labels || entry.destinationLabels).map((item) => String(item || "").trim()).filter(Boolean),
+    log_file: String(entry.log_file || entry.logFile || "").trim(),
     created_by_pid: intFromRawAllowZero(entry.created_by_pid || entry.createdByPid, 0) || undefined,
     source_command: String(entry.source_command || entry.sourceCommand || "").trim(),
   });
@@ -2827,6 +2921,10 @@ async function listProjectContextItems(params) {
   return listProjectContextItemsImpl(params, buildRunnerDataDeps());
 }
 
+async function listProjectCtxpackFiles(params) {
+  return listProjectCtxpackFilesImpl(params, buildRunnerDataDeps());
+}
+
 async function createProjectContextItem(params) {
   return createProjectContextItemImpl(params, buildRunnerDataDeps());
 }
@@ -3568,6 +3666,327 @@ function buildRunnerDeliveryDeps() {
   };
 }
 
+function normalizeComparableProjectText(value) {
+  return String(value || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[\\/_-]+/g, " ")
+    .replace(/\s+/g, " ");
+}
+
+function extractArtifactQueryTerms(messageText) {
+  const text = String(messageText || "").trim();
+  const exactNames = Array.from(
+    new Set(
+      ensureArray(text.match(/[A-Za-z0-9._-]+\.(?:md|txt|json|ya?ml|ts|tsx|js|jsx|py|go|java|cs|html|css|pdf)\b/gi))
+        .map((item) => String(item || "").trim().toLowerCase())
+        .filter(Boolean),
+    ),
+  );
+  const tokens = Array.from(
+    new Set(
+      normalizeComparableProjectText(text)
+        .split(/[^a-z0-9.]+/i)
+        .map((item) => item.trim())
+        .filter((item) => item.length >= 4 && !["where", "path", "file", "project", "guide", "current"].includes(item)),
+    ),
+  );
+  return {
+    exactNames,
+    tokens,
+  };
+}
+
+function scoreProjectFileMatch(filePath, queryTerms) {
+  const normalizedPath = String(filePath || "").trim().toLowerCase();
+  if (!normalizedPath) return 0;
+  const baseName = path.posix.basename(normalizedPath);
+  let score = 0;
+  for (const exactName of ensureArray(queryTerms.exactNames)) {
+    if (!exactName) continue;
+    if (baseName === exactName) score += 1000;
+    else if (normalizedPath.includes(exactName)) score += 600;
+  }
+  const comparablePath = normalizeComparableProjectText(normalizedPath);
+  for (const token of ensureArray(queryTerms.tokens)) {
+    if (!token) continue;
+    if (baseName.includes(token)) score += 120;
+    else if (comparablePath.includes(token)) score += 45;
+  }
+  return score;
+}
+
+async function locateProjectFilesForQuery({
+  siteBaseURL,
+  projectID,
+  token,
+  timeoutSeconds,
+  query,
+  limit = 5,
+}) {
+  const queryTerms = extractArtifactQueryTerms(query);
+  const files = ensureArray(await listProjectCtxpackFiles({
+    siteBaseURL,
+    projectID,
+    token,
+    timeoutSeconds,
+  }));
+  const matches = files
+    .map((file) => ({
+      ...safeObject(file),
+      score: scoreProjectFileMatch(String(file.path || ""), queryTerms),
+    }))
+    .filter((file) => file.score > 0)
+    .sort((left, right) => {
+      if (right.score !== left.score) return right.score - left.score;
+      return String(left.path || "").localeCompare(String(right.path || ""));
+    })
+    .slice(0, Math.max(1, intFromRaw(limit, 5)));
+  return {
+    query: String(query || "").trim(),
+    exact_names: queryTerms.exactNames,
+    tokens: queryTerms.tokens,
+    count: matches.length,
+    matches: matches.map((file) => ({
+      path: String(file.path || "").trim(),
+      doc_type: String(file.docType || "").trim(),
+      generated: file.generated === true,
+      sha256: String(file.sha256 || "").trim(),
+      size_bytes: intFromRawAllowZero(file.sizeBytes, 0),
+      score: intFromRawAllowZero(file.score, 0),
+    })),
+  };
+}
+
+function buildProjectFileLocateText(payload) {
+  const query = String(safeObject(payload).query || "").trim() || "the requested file";
+  const matches = ensureArray(safeObject(payload).matches);
+  if (!matches.length) {
+    return `현재 프로젝트 ctxpack에서 "${query}"와 일치하는 파일 경로를 찾지 못했습니다.`;
+  }
+  if (matches.length === 1) {
+    const match = safeObject(matches[0]);
+    return `현재 확인되는 "${query}" 경로는 "${String(match.path || "").trim()}" 입니다.`;
+  }
+  return [
+    `현재 프로젝트 ctxpack에서 "${query}"와 일치하는 파일 경로는 ${matches.length}개입니다:`,
+    ...matches.map((match) => `- ${String(safeObject(match).path || "").trim()}`),
+  ].join("\n");
+}
+
+function resolveProjectWorkspaceBindingSummary(projectID, workspaceDir = "") {
+  const normalizedProjectID = String(projectID || "").trim();
+  const registry = loadBotRunnerWorkspaceRegistry({ persistIfNeeded: false });
+  const mapping = normalizeBotRunnerProjectMapping(
+    normalizedProjectID,
+    safeObject(registry.projectMappings)[normalizedProjectID],
+  );
+  const boundWorkspaceDir = String(mapping.workspaceDir || "").trim();
+  const effectiveWorkspaceDir = boundWorkspaceDir
+    || String(resolveStableProjectWorkspaceCandidate(normalizedProjectID, workspaceDir) || "").trim();
+  const warnings = [];
+  const requestedWorkspaceDir = sanitizeWorkspaceCandidate(workspaceDir);
+  if (requestedWorkspaceDir && boundWorkspaceDir && requestedWorkspaceDir !== boundWorkspaceDir) {
+    warnings.push(`request workspace_dir differs from registry binding: ${requestedWorkspaceDir}`);
+  }
+  if (effectiveWorkspaceDir && !fs.existsSync(effectiveWorkspaceDir)) {
+    warnings.push(`workspace_dir does not exist: ${effectiveWorkspaceDir}`);
+  }
+  const workspaceMeta = effectiveWorkspaceDir ? loadWorkspaceMeta(effectiveWorkspaceDir) : {};
+  return {
+    ok: Boolean(boundWorkspaceDir),
+    project_id: normalizedProjectID,
+    workspace_dir: effectiveWorkspaceDir,
+    workspace_source: boundWorkspaceDir
+      ? `project-workspaces.json:${String(mapping.source || "unknown").trim() || "unknown"}`
+      : "",
+    workspace_registry_file: String(registry.filePath || botRunnerWorkspaceRegistryFilePath()).trim(),
+    workspace_meta_file: effectiveWorkspaceDir ? findSyncMetaFile(effectiveWorkspaceDir) : "",
+    ctxpack_key: buildCtxpackKeyFromMeta(workspaceMeta),
+    warnings,
+  };
+}
+
+function listProjectRunnerRoleBindings({
+  projectID,
+  provider = "",
+  destinationID = "",
+  destinationLabel = "",
+}) {
+  const normalizedProjectID = String(projectID || "").trim();
+  const normalizedProvider = normalizeBotProvider(provider || "");
+  const normalizedDestinationID = String(destinationID || "").trim();
+  const normalizedDestinationLabel = String(destinationLabel || "").trim().toLowerCase();
+  const runnerConfig = loadBotRunnerConfig({ persistIfNeeded: true });
+  const telegramEntries = ensureArray(readTelegramEnvState().entries);
+  return ensureArray(runnerConfig.routes)
+    .map((routeRaw) => normalizeRunnerRoute(routeRaw))
+    .filter((route) => route.enabled)
+    .filter((route) => route.projectID === normalizedProjectID)
+    .filter((route) => !normalizedProvider || route.provider === normalizedProvider)
+    .filter((route) => !normalizedDestinationID || route.destinationID === normalizedDestinationID)
+    .filter((route) => !normalizedDestinationLabel || String(route.destinationLabel || "").trim().toLowerCase() === normalizedDestinationLabel)
+    .map((route) => {
+      const diagnostics = collectRunnerRouteDiagnostics(route, runnerConfig);
+      const matchedTelegramEntry = findRunnerTelegramEntryForRoute(route, telegramEntries);
+      const botName = firstNonEmptyString([
+        route.botName,
+        matchedTelegramEntry?.serverBotName,
+      ]);
+      return {
+        route_name: String(route.name || runnerRouteKey(route)).trim(),
+        project_id: String(route.projectID || "").trim(),
+        provider: String(route.provider || "").trim(),
+        destination_id: String(route.destinationID || "").trim(),
+        destination_label: String(route.destinationLabel || "").trim(),
+        bot_id: String(route.botID || "").trim(),
+        bot_name: botName,
+        role: String(route.role || "").trim(),
+        role_profile_name: String(diagnostics.roleProfileName || route.roleProfile || "").trim(),
+        client: String(diagnostics.roleProfile?.client || "").trim(),
+        model: String(diagnostics.roleProfile?.model || "").trim(),
+        permission_mode: String(diagnostics.roleProfile?.permissionMode || "").trim(),
+        reasoning_effort: String(diagnostics.roleProfile?.reasoningEffort || "").trim(),
+      };
+    })
+    .sort((left, right) => String(left.bot_name || left.route_name).localeCompare(String(right.bot_name || right.route_name)));
+}
+
+function buildProjectBotRolesPayload({
+  projectID,
+  provider = "",
+  destinationID = "",
+  destinationLabel = "",
+}) {
+  const bindings = listProjectRunnerRoleBindings({
+    projectID,
+    provider,
+    destinationID,
+    destinationLabel,
+  });
+  return {
+    ok: bindings.length > 0,
+    project_id: String(projectID || "").trim(),
+    provider: normalizeBotProvider(provider || "") || "",
+    destination_id: String(destinationID || "").trim(),
+    destination_label: String(destinationLabel || "").trim(),
+    count: bindings.length,
+    bindings,
+  };
+}
+
+function buildProjectBotRolesText(payload) {
+  const bindings = ensureArray(safeObject(payload).bindings);
+  if (!bindings.length) {
+    return "현재 프로젝트의 활성 runner 설정에서 확인되는 봇 역할이 없습니다.";
+  }
+  return [
+    "현재 프로젝트의 활성 runner 설정 기준 역할은 아래와 같습니다.",
+    ...bindings.map((binding) => {
+      const current = safeObject(binding);
+      const botName = String(current.bot_name || current.route_name || "").trim() || "(unknown bot)";
+      const routeRole = String(current.role || "").trim() || "-";
+      const roleProfile = String(current.role_profile_name || "").trim() || "-";
+      const client = String(current.client || "").trim() || "-";
+      const model = String(current.model || "").trim() || "-";
+      return `- ${botName}: role=${routeRole}, profile=${roleProfile}, client=${client}, model=${model}`;
+    }),
+  ].join("\n");
+}
+
+async function resolveInformationalQueryReply({
+  intentType,
+  route,
+  routeState,
+  selectedRecord,
+  runtime,
+  executionPlan,
+}) {
+  const normalizedIntentType = String(intentType || "").trim();
+  const messageText = String(safeObject(selectedRecord?.parsedArchive).body || "").trim();
+  if (normalizedIntentType === "small_talk") {
+    return {
+      handled: true,
+      reply: "안녕하세요. 현재 프로젝트 기준으로 필요한 정보를 바로 확인해드릴게요.",
+      source: "small_talk",
+    };
+  }
+  if (normalizedIntentType === "workspace_query") {
+    const workspace = resolveProjectWorkspaceBindingSummary(route?.projectID, executionPlan?.workspaceDir || route?.workspaceDir || "");
+    const workspaceDir = String(workspace.workspace_dir || "").trim();
+    const reply = workspaceDir
+      ? `현재 이 프로젝트에 바인딩된 로컬 작업 폴더는 "${workspaceDir}" 입니다.`
+      : "현재 이 프로젝트는 project-workspaces.json에 로컬 작업 폴더가 바인딩되어 있지 않습니다.";
+    return {
+      handled: true,
+      reply,
+      source: "project.workspace",
+      lookup: workspace,
+    };
+  }
+  if (normalizedIntentType === "bot_role_query") {
+    const payload = buildProjectBotRolesPayload({
+      projectID: route?.projectID,
+      provider: route?.provider,
+      destinationID: route?.destinationID,
+      destinationLabel: route?.destinationLabel,
+    });
+    return {
+      handled: true,
+      reply: buildProjectBotRolesText(payload),
+      source: "project.bot_roles",
+      lookup: payload,
+    };
+  }
+  if (normalizedIntentType === "status_query") {
+    const activeExecution = resolveRunnerActiveExecutionState(routeState);
+    if (activeExecution.active) {
+      const startedAt = String(activeExecution.startedAt || "").trim();
+      const sourceMessage = intFromRawAllowZero(activeExecution.sourceMessageID, 0);
+      const stuckSuffix = activeExecution.stuck ? " 현재 실행이 오래 지속되어 확인이 필요합니다." : "";
+      return {
+        handled: true,
+        reply: `현재 이 runner는 작업 중입니다.${sourceMessage > 0 ? ` source_message_id=${sourceMessage}` : ""}${startedAt ? ` started_at=${startedAt}` : ""}.${stuckSuffix}`.replace(/\s+\./g, "."),
+        source: "runner.status",
+        lookup: activeExecution,
+      };
+    }
+    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 reply = lastAction
+      ? `현재 실행 중인 작업은 없습니다. 마지막 상태는 "${lastAction}"${lastIntentType ? ` (intent=${lastIntentType})` : ""}${lastReason ? `, detail=${lastReason}` : ""} 입니다.`
+      : "현재 실행 중인 작업은 없습니다. 아직 기록된 최근 작업 상태도 없습니다.";
+    return {
+      handled: true,
+      reply,
+      source: "runner.status",
+      lookup: {
+        active: false,
+        last_action: lastAction,
+        last_reason: lastReason,
+        last_intent_type: lastIntentType,
+      },
+    };
+  }
+  if (normalizedIntentType === "artifact_location_query") {
+    const payload = await locateProjectFilesForQuery({
+      siteBaseURL: runtime.baseURL,
+      projectID: route?.projectID,
+      token: runtime.token,
+      timeoutSeconds: runtime.timeoutSeconds,
+      query: messageText,
+    });
+    return {
+      handled: true,
+      reply: buildProjectFileLocateText(payload),
+      source: "project.file.locate",
+      lookup: payload,
+    };
+  }
+  return null;
+}
+
 function buildRunnerExecutionDeps() {
   return {
     analyzeHumanConversationIntentWithAI,
@@ -3594,8 +4013,10 @@ function buildRunnerExecutionDeps() {
     createWorkItemThread,
     linkWorkItemEvidence,
     listProjectContextItems,
+    listProjectCtxpackFiles,
     createProjectContextItem,
     replaceProjectCtxpackFiles,
+    resolveInformationalQueryReply,
   };
 }
 
@@ -3650,23 +4071,52 @@ function emptyRunnerActiveExecutionPatch() {
     active_comment_created_at: "",
     active_source_message_id: undefined,
     active_started_at: "",
+    active_heartbeat_at: "",
     active_runner_pid: undefined,
     active_execution_token: "",
   };
 }
 
 function buildRunnerActiveExecutionPatch(selectedRecord) {
+  const nowISO = new Date().toISOString();
   const parsed = safeObject(selectedRecord?.parsedArchive);
   return {
     active_comment_id: String(selectedRecord?.id || "").trim(),
     active_comment_created_at: firstNonEmptyString([selectedRecord?.createdAt, selectedRecord?.updatedAt]),
     active_source_message_id: intFromRawAllowZero(parsed.messageID, 0) || undefined,
-    active_started_at: new Date().toISOString(),
+    active_started_at: nowISO,
+    active_heartbeat_at: nowISO,
     active_runner_pid: process.pid,
     active_execution_token: `${Date.now()}-${process.pid}-${String(selectedRecord?.id || "").trim()}`,
   };
 }
 
+function startRunnerExecutionHeartbeat(routeKey, selectedRecord, intervalMs = BOT_RUNNER_ACTIVE_EXECUTION_HEARTBEAT_INTERVAL_MS) {
+  let stopped = false;
+  const tick = () => {
+    if (stopped) return;
+    const currentState = safeObject(loadBotRunnerState().routes[routeKey]);
+    if (String(currentState.active_comment_id || "").trim() !== String(selectedRecord?.id || "").trim()) {
+      return;
+    }
+    saveRunnerRouteState(routeKey, {
+      ...currentState,
+      active_heartbeat_at: new Date().toISOString(),
+    });
+  };
+  tick();
+  const timer = setInterval(tick, Math.max(1000, intervalMs));
+  if (typeof timer.unref === "function") {
+    timer.unref();
+  }
+  return {
+    stop() {
+      stopped = true;
+      clearInterval(timer);
+    },
+  };
+}
+
 function resolveRunnerActiveExecutionState(routeState) {
   const state = safeObject(routeState);
   const activeCommentID = String(state.active_comment_id || "").trim();
@@ -3674,19 +4124,45 @@ function resolveRunnerActiveExecutionState(routeState) {
     return {
       active: false,
       stale: false,
+      stuck: false,
       commentID: "",
       sourceMessageID: 0,
       startedAt: "",
+      ageMs: 0,
+      ageSeconds: 0,
+      warning: "",
     };
   }
   const activeRunnerPID = intFromRawAllowZero(state.active_runner_pid, 0);
   const staleByProcess = activeRunnerPID > 0 && !isProcessAlive(activeRunnerPID);
+  const startedAt = String(state.active_started_at || "").trim();
+  const startedAtMs = Date.parse(startedAt);
+  const ageMs = Number.isFinite(startedAtMs)
+    ? Math.max(0, Date.now() - startedAtMs)
+    : 0;
+  const ageSeconds = ageMs > 0 ? Math.floor(ageMs / 1000) : 0;
+  const heartbeatAt = String(state.active_heartbeat_at || "").trim();
+  const heartbeatAtMs = Date.parse(heartbeatAt);
+  const heartbeatAgeMs = Number.isFinite(heartbeatAtMs)
+    ? Math.max(0, Date.now() - heartbeatAtMs)
+    : ageMs;
+  const staleByHeartbeat = !staleByProcess && heartbeatAgeMs >= BOT_RUNNER_ACTIVE_EXECUTION_HEARTBEAT_STALE_MS;
+  const stale = staleByProcess || staleByHeartbeat;
+  const stuck = !stale && ageMs >= BOT_RUNNER_ACTIVE_EXECUTION_STUCK_WARNING_MS;
   return {
-    active: !staleByProcess,
-    stale: staleByProcess,
+    active: !stale,
+    stale,
+    stuck,
     commentID: activeCommentID,
     sourceMessageID: intFromRawAllowZero(state.active_source_message_id, 0),
-    startedAt: String(state.active_started_at || "").trim(),
+    startedAt,
+    ageMs,
+    ageSeconds,
+    warning: staleByHeartbeat
+      ? "active execution heartbeat expired; clearing busy state"
+      : stuck
+        ? "active execution is taking longer than expected"
+        : "",
   };
 }
 
@@ -4895,7 +5371,14 @@ async function runRunnerProjectUp(flags) {
     await runRunnerStartDetachedResolvedRoutes(matchingRoutes, startFlags, "runner project up");
     return;
   }
-  await runRunnerStartResolvedRoutes(matchingRoutes, startFlags);
+  await runRunnerStartResolvedRoutes(matchingRoutes, startFlags, {
+    sourceLabel: "runner project up",
+    bootstrapEvent: {
+      route_name: "runner project up",
+      outcome: "prepared",
+      detail: `prepared ${matchingRoutes.length} enabled route(s) for ${summaryPayload.destination_label || summaryPayload.destination_id || summaryPayload.project_id || "project"}`,
+    },
+  });
 }
 
 function canStartRunnerDespiteProjectUpApplyFailure({ applyRequested, applyResult, matchingRoutes }) {
@@ -5115,6 +5598,7 @@ function buildRunnerShowPayload(route, flags = {}) {
   const runnerConfig = loadBotRunnerConfig({ persistIfNeeded: true });
   const runnerState = loadBotRunnerState();
   const routeState = safeObject(runnerState.routes[runnerRouteKey(normalizedRoute)]);
+  const activeExecutionState = resolveRunnerActiveExecutionState(routeState);
   const diagnostics = collectRunnerRouteDiagnostics(normalizedRoute, runnerConfig);
   const telegramState = readTelegramEnvState();
   const telegramEntries = ensureArray(telegramState.entries);
@@ -5177,8 +5661,21 @@ function buildRunnerShowPayload(route, flags = {}) {
       artifact_errors: ensureArray(routeState.last_artifact_errors).map((item) => String(item || "").trim()).filter(Boolean),
       boundary_violations: ensureArray(routeState.last_boundary_violations).map((item) => safeObject(item)),
     },
+    active_execution: {
+      active: activeExecutionState.active === true,
+      stale: activeExecutionState.stale === true,
+      stuck: activeExecutionState.stuck === true,
+      comment_id: String(activeExecutionState.commentID || "").trim(),
+      source_message_id: intFromRawAllowZero(activeExecutionState.sourceMessageID, 0),
+      started_at: String(activeExecutionState.startedAt || "").trim(),
+      age_seconds: intFromRawAllowZero(activeExecutionState.ageSeconds, 0),
+      warning: String(activeExecutionState.warning || "").trim(),
+    },
     route_selection_note: "Routes are the executable unit. Use --route-name in production. --bot-name and --bot-id are convenience selectors that resolve one enabled route only when the match is unique.",
-    warnings: diagnostics.warnings,
+    warnings: [
+      ...ensureArray(diagnostics.warnings),
+      ...(activeExecutionState.stuck ? [activeExecutionState.warning] : []),
+    ],
     errors: diagnostics.errors,
   };
 }
@@ -5234,6 +5731,15 @@ async function runRunnerShow(flags) {
       `    artifact_paths: ${payload.last_run.artifact_paths.length ? payload.last_run.artifact_paths.join(", ") : "-"}`,
       `    artifact_errors: ${payload.last_run.artifact_errors.length ? payload.last_run.artifact_errors.join(" | ") : "-"}`,
       `    boundary_violations: ${payload.last_run.boundary_violations.length ? payload.last_run.boundary_violations.map((item) => String(item.detail || item.path || JSON.stringify(item))).join(" | ") : "-"}`,
+      "  active_execution:",
+      `    active: ${payload.active_execution.active ? "true" : "false"}`,
+      `    stale: ${payload.active_execution.stale ? "true" : "false"}`,
+      `    stuck: ${payload.active_execution.stuck ? "true" : "false"}`,
+      `    comment_id: ${payload.active_execution.comment_id || "-"}`,
+      `    source_message_id: ${payload.active_execution.source_message_id || "-"}`,
+      `    started_at: ${payload.active_execution.started_at || "-"}`,
+      `    age_seconds: ${payload.active_execution.age_seconds || 0}`,
+      `    warning: ${payload.active_execution.warning || "-"}`,
       payload.warnings.length ? `  warnings: ${payload.warnings.join("; ")}` : "  warnings: -",
       payload.errors.length ? `  errors: ${payload.errors.join("; ")}` : "  errors: -",
     ].join("\n") + "\n",
@@ -5323,7 +5829,7 @@ async function waitForRunnerPIDFile(pidFilePath, timeoutMs = 8000) {
   throw new Error(`detached runner launch did not publish a child process id: ${pidFilePath}`);
 }
 
-function buildRunnerDetachedLaunchRecord(childPID, routes, flags, sourceCommand) {
+function buildRunnerDetachedLaunchRecord(childPID, routes, flags, sourceCommand, logFilePath = "") {
   const normalizedRoutes = ensureArray(routes).map((route) => normalizeRunnerRoute(route));
   const cliPath = fileURLToPath(import.meta.url);
   return normalizeRunnerProcessLaunchEntry({
@@ -5339,6 +5845,7 @@ function buildRunnerDetachedLaunchRecord(childPID, routes, flags, sourceCommand)
     project_ids: Array.from(new Set(normalizedRoutes.map((route) => String(route.projectID || "").trim()).filter(Boolean))),
     provider: firstNonEmptyString(normalizedRoutes.map((route) => route.provider)),
     destination_labels: Array.from(new Set(normalizedRoutes.map((route) => String(route.destinationLabel || route.destinationID || "").trim()).filter(Boolean))),
+    log_file: String(logFilePath || "").trim(),
     created_by_pid: process.pid,
     source_command: sourceCommand,
   });
@@ -5355,7 +5862,12 @@ function findExistingDetachedRunnerLaunch(registry, routes) {
 
 async function launchDetachedRunnerProcess(flags, routes, sourceCommand) {
   const cliPath = fileURLToPath(import.meta.url);
-  const startArgs = [cliPath, "--no-update", "runner", "start", ...serializeCLIFlags(flags, {
+  const detachedLogFilePath = resolveRunnerLogFilePath(flags["log-file"], routes, sourceCommand);
+  const startFlags = {
+    ...safeObject(flags),
+    ...(detachedLogFilePath ? { "log-file": detachedLogFilePath } : {}),
+  };
+  const startArgs = [cliPath, "--no-update", "runner", "start", ...serializeCLIFlags(startFlags, {
     omit: ["json", "start", "start-detached", "detached"],
   })];
   if (process.platform === "win32") {
@@ -5387,7 +5899,7 @@ async function launchDetachedRunnerProcess(flags, routes, sourceCommand) {
     if (childPID <= 0) {
       throw new Error("detached runner launch did not return a child process id");
     }
-    return buildRunnerDetachedLaunchRecord(childPID, routes, flags, sourceCommand);
+    return buildRunnerDetachedLaunchRecord(childPID, routes, startFlags, sourceCommand, detachedLogFilePath);
   }
   const launchTempDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-runner-launch-"));
   const scriptPath = path.join(launchTempDir, "start-runner.sh");
@@ -5417,7 +5929,7 @@ async function launchDetachedRunnerProcess(flags, routes, sourceCommand) {
         throw new Error(String(launched.stderr || launched.stdout || "failed to launch detached runner in Terminal.app").trim());
       }
       const childPID = await waitForRunnerPIDFile(pidFilePath);
-      return buildRunnerDetachedLaunchRecord(childPID, routes, flags, sourceCommand);
+      return buildRunnerDetachedLaunchRecord(childPID, routes, startFlags, sourceCommand, detachedLogFilePath);
     }
     const terminalLauncher = resolveLinuxDetachedTerminalLauncher(scriptPath);
     if (!terminalLauncher) {
@@ -5433,7 +5945,7 @@ async function launchDetachedRunnerProcess(flags, routes, sourceCommand) {
       throw new Error("detached terminal launcher did not return a process id");
     }
     const runnerPID = await waitForRunnerPIDFile(pidFilePath);
-    return buildRunnerDetachedLaunchRecord(runnerPID, routes, flags, sourceCommand);
+    return buildRunnerDetachedLaunchRecord(runnerPID, routes, startFlags, sourceCommand, detachedLogFilePath);
   } finally {
     try {
       fs.rmSync(launchTempDir, { recursive: true, force: true });
@@ -5515,6 +6027,7 @@ async function runRunnerStatus(flags) {
         `    project_ids: ${launch.project_ids.join(", ") || "-"}`,
         `    route_names: ${launch.route_names.join(", ") || "-"}`,
         `    destination_labels: ${launch.destination_labels.join(", ") || "-"}`,
+        `    log_file: ${launch.log_file || "-"}`,
         `    command: ${launch.command || "-"}`,
       ].join("\n") + "\n",
     );
@@ -5551,7 +6064,7 @@ async function runRunnerStartDetachedResolvedRoutes(routes, flags, sourceCommand
     process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
     return payload;
   }
-  process.stdout.write(`Detached runner already running: launch_id=${existing.launch_id} pid=${existing.pid}\n`);
+  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);
@@ -5582,6 +6095,7 @@ async function runRunnerStartDetachedResolvedRoutes(routes, flags, sourceCommand
       `project_ids: ${launch.project_ids.join(", ") || "-"}`,
       `route_names: ${launch.route_names.join(", ") || "-"}`,
       `destination_labels: ${launch.destination_labels.join(", ") || "-"}`,
+      `log_file: ${launch.log_file || "-"}`,
       `command: ${launch.command}`,
     ].join("\n") + "\n",
   );
@@ -5677,8 +6191,311 @@ async function runRunnerArtifactScan(flags) {
   }
 }
 
-async function runRunnerStartResolvedRoutes(routes, flags) {
+function truncateRunnerTUIText(rawValue, width) {
+  const text = String(rawValue || "").replace(/\s+/g, " ").trim();
+  const maxWidth = Math.max(4, intFromRaw(width, 0));
+  if (!maxWidth || text.length <= maxWidth) {
+    return text;
+  }
+  if (maxWidth <= 3) {
+    return text.slice(0, maxWidth);
+  }
+  return `${text.slice(0, maxWidth - 3)}...`;
+}
+
+function normalizeRunnerTUIPhase(rawValue) {
+  const value = String(rawValue || "").trim().toLowerCase();
+  return value || "waiting";
+}
+
+function colorizeRunnerTUIPhase(phase, width, useColor) {
+  const rendered = bootstrapPadRight(String(phase || "-").toUpperCase(), width);
+  if (!useColor) return rendered;
+  const colorCode = phase === "replied" || phase === "idle"
+    ? "32"
+    : phase === "ai_running" || phase === "delivering" || phase === "context_suggesting"
+      ? "36"
+      : phase === "polling" || phase === "busy" || phase === "waiting" || phase === "primed"
+        ? "33"
+        : phase === "skipped"
+          ? "35"
+          : "31";
+  return bootstrapColorText(rendered, colorCode);
+}
+
+function mapRunnerTUIPhaseFromOutcome(outcome) {
+  const value = String(outcome || "").trim().toLowerCase();
+  if (!value) return "waiting";
+  if (value === "accepted") return "ai_running";
+  if (value === "dry_run") return "replied";
+  if (value === "policy_violation" || value === "execution_failed") return "error";
+  return value;
+}
+
+function formatRunnerTUIAge(now, startedAtMs) {
+  const ageMs = Math.max(0, Number(now) - Number(startedAtMs || 0));
+  if (!(ageMs > 0)) return "-";
+  const ageSeconds = Math.floor(ageMs / 1000);
+  if (ageSeconds < 60) return `${ageSeconds}s`;
+  const minutes = Math.floor(ageSeconds / 60);
+  const seconds = ageSeconds % 60;
+  if (minutes < 60) return `${minutes}m${String(seconds).padStart(2, "0")}`;
+  const hours = Math.floor(minutes / 60);
+  const remMinutes = minutes % 60;
+  return `${hours}h${String(remMinutes).padStart(2, "0")}`;
+}
+
+function summarizeRunnerTUIPhases(routes = []) {
+  const counts = {
+    waiting: 0,
+    polling: 0,
+    running: 0,
+    busy: 0,
+    replied: 0,
+    error: 0,
+  };
+  let warningCount = 0;
+  for (const route of ensureArray(routes)) {
+    const phase = normalizeRunnerTUIPhase(route.phase);
+    if (phase === "waiting") counts.waiting += 1;
+    else if (phase === "polling") counts.polling += 1;
+    else if (["ai_running", "delivering", "context_suggesting"].includes(phase)) counts.running += 1;
+    else if (phase === "busy") counts.busy += 1;
+    else if (["replied", "idle", "skipped", "dry_run"].includes(phase)) counts.replied += 1;
+    else if (["error", "blocked", "locked", "execution_failed", "policy_violation"].includes(phase)) counts.error += 1;
+    else counts.waiting += 1;
+    if (String(route.warning || route.last_error || "").trim()) {
+      warningCount += 1;
+    }
+  }
+  return { counts, warningCount };
+}
+
+function buildRunnerTUIFrame({ routes = [], recentEvents = [], concurrency = 1, now = Date.now(), stopping = false, useColor = false, sourceLabel = "runner start", logFilePath = "" }) {
+  const lines = [];
+  const activeCount = ensureArray(routes).filter((item) => ["polling", "ai_running", "delivering", "context_suggesting", "busy"].includes(normalizeRunnerTUIPhase(item.phase))).length;
+  const phaseSummary = summarizeRunnerTUIPhases(routes);
+  const header = `METHEUS RUNNER ${stopping ? "STOPPING" : "LIVE"} | source=${String(sourceLabel || "runner start").trim()} | routes=${routes.length} active=${activeCount} concurrency=${concurrency} time=${new Date(now).toLocaleTimeString("en-US", { hour12: false })}`;
+  lines.push(useColor ? bootstrapColorText(header, stopping ? "33" : "36") : header);
+  if (String(logFilePath || "").trim()) {
+    lines.push(`Log: ${truncateRunnerTUIText(String(logFilePath || "").trim(), 112)}`);
+  }
+  lines.push(`Summary: waiting=${phaseSummary.counts.waiting} polling=${phaseSummary.counts.polling} running=${phaseSummary.counts.running} busy=${phaseSummary.counts.busy} replied=${phaseSummary.counts.replied} error=${phaseSummary.counts.error} warnings=${phaseSummary.warningCount}`);
+  lines.push("Ctrl+C to stop. Foreground runner state is shown below.");
+  lines.push("");
+  lines.push(
+    [
+      bootstrapPadRight("Route", 24),
+      bootstrapPadRight("Phase", 18),
+      bootstrapPadRight("Age", 7),
+      bootstrapPadRight("AI", 20),
+      bootstrapPadRight("Intent", 18),
+      bootstrapPadRight("Msg", 8),
+      bootstrapPadRight("Next", 8),
+      bootstrapPadRight("Warn", 6),
+    ].join(" "),
+  );
+  lines.push("-".repeat(120));
+  for (const route of ensureArray(routes)) {
+    const phase = normalizeRunnerTUIPhase(route.phase);
+    const aiLabel = truncateRunnerTUIText(
+      route.client
+        ? `${String(route.client || "").trim()}/${String(route.model || "").trim() || "-"}`
+        : "-",
+      20,
+    );
+    const ageLabel = formatRunnerTUIAge(now, route.phase_started_at || route.updated_at || now);
+    const nextSeconds = Number.isFinite(Number(route.next_run_at)) && Number(route.next_run_at) > now
+      ? `${Math.max(0, Math.ceil((Number(route.next_run_at) - now) / 1000))}s`
+      : phase === "ai_running" || phase === "delivering" || phase === "context_suggesting"
+        ? "run"
+        : "-";
+    const warningLabel = String(route.warning || route.last_error || "").trim() ? "yes" : "-";
+    lines.push(
+      [
+        bootstrapPadRight(truncateRunnerTUIText(route.route_name, 24), 24),
+        colorizeRunnerTUIPhase(phase, 18, useColor),
+        bootstrapPadRight(ageLabel, 7),
+        bootstrapPadRight(aiLabel, 20),
+        bootstrapPadRight(truncateRunnerTUIText(route.intent_type || "-", 18), 18),
+        bootstrapPadRight(String(route.source_message_id || "-"), 8),
+        bootstrapPadRight(nextSeconds, 8),
+        bootstrapPadRight(warningLabel, 6),
+      ].join(" "),
+    );
+    const detailParts = [
+      String(route.detail || "").trim(),
+      String(route.context_suggestion_status || "").trim()
+        ? `context=${String(route.context_suggestion_status || "").trim()}`
+        : "",
+      String(route.warning || "").trim()
+        ? `warning=${String(route.warning || "").trim()}`
+        : "",
+      String(route.last_error || "").trim()
+        ? `error=${String(route.last_error || "").trim()}`
+        : "",
+    ].filter(Boolean);
+    lines.push(`  ${truncateRunnerTUIText(detailParts.join(" | ") || "-", 116)}`);
+  }
+  lines.push("");
+  lines.push(useColor ? bootstrapColorText("Recent Events", "35") : "Recent Events");
+  if (!ensureArray(recentEvents).length) {
+    lines.push("  (none yet)");
+  } else {
+    for (const event of ensureArray(recentEvents).slice(0, 8)) {
+      lines.push(
+        `  [${String(event.time || "").trim() || "--:--:--"}] ${truncateRunnerTUIText(event.route_name, 24)} ${bootstrapPadRight(String(event.outcome || "-").trim(), 12)} ${truncateRunnerTUIText(event.detail || "-", 74)}`,
+      );
+    }
+  }
+  return lines.join("\n");
+}
+
+function createRunnerStartTUI({ routes, flags, jsonMode, concurrency, sourceLabel = "runner start", bootstrapEvent = null, logFilePath = "" }) {
+  const enabled = !jsonMode && boolFromRaw(flags.tui, Boolean(process.stdout?.isTTY));
+  if (!enabled || !process.stdout?.isTTY) {
+    return null;
+  }
+  const useColor = bootstrapSupportsANSIColors();
+  const routeStates = new Map();
+  const recentEvents = [];
+  for (const route of ensureArray(routes)) {
+    const normalizedRoute = normalizeRunnerRoute(route);
+    const routeKey = runnerRouteKey(normalizedRoute);
+    routeStates.set(routeKey, {
+      route_key: routeKey,
+      route_name: normalizedRoute.name,
+      phase: "waiting",
+      detail: "awaiting next poll",
+      client: "",
+      model: "",
+      intent_type: "",
+      source_message_id: "",
+      next_run_at: 0,
+      context_suggestion_status: "",
+      warning: "",
+      last_error: "",
+      phase_started_at: Date.now(),
+      updated_at: Date.now(),
+    });
+  }
+  if (bootstrapEvent && typeof bootstrapEvent === "object") {
+    recentEvents.unshift({
+      time: new Date().toLocaleTimeString("en-US", { hour12: false }),
+      route_name: String(bootstrapEvent.route_name || sourceLabel || "runner").trim(),
+      outcome: String(bootstrapEvent.outcome || "prepared").trim(),
+      detail: String(bootstrapEvent.detail || "").trim(),
+    });
+  }
+  let intervalHandle = null;
+  let disposed = false;
+
+  const render = (stopping = false) => {
+    if (disposed) return;
+    const frame = buildRunnerTUIFrame({
+      routes: Array.from(routeStates.values()),
+      recentEvents,
+      concurrency,
+      now: Date.now(),
+      stopping,
+      useColor,
+      sourceLabel,
+      logFilePath,
+    });
+    process.stdout.write(`\u001b[?25l\u001b[2J\u001b[H${frame}`);
+  };
+
+  const setRouteState = (routeKey, patch = {}) => {
+    const current = safeObject(routeStates.get(routeKey));
+    if (!current.route_key) return;
+    const nextPhase = normalizeRunnerTUIPhase(patch.phase || current.phase);
+    const phaseChanged = nextPhase !== normalizeRunnerTUIPhase(current.phase);
+    routeStates.set(routeKey, {
+      ...current,
+      ...safeObject(patch),
+      phase: nextPhase,
+      phase_started_at: phaseChanged ? Date.now() : Number(current.phase_started_at || Date.now()),
+      updated_at: Date.now(),
+    });
+    render(false);
+  };
+
+  const recordResult = (result, routeState = null) => {
+    const routeKey = String(result?.route_key || "").trim();
+    if (routeKey && routeStates.has(routeKey)) {
+      const current = safeObject(routeStates.get(routeKey));
+      setRouteState(routeKey, {
+        phase: mapRunnerTUIPhaseFromOutcome(result?.outcome),
+        detail: String(result?.detail || "").trim(),
+        intent_type: String(routeState?.last_intent_type || current.intent_type || "").trim(),
+        source_message_id: intFromRawAllowZero(routeState?.last_source_message_id, intFromRawAllowZero(current.source_message_id, 0)) || current.source_message_id,
+        context_suggestion_status: String(result?.context_suggestion_status || routeState?.last_context_suggestion_status || current.context_suggestion_status || "").trim(),
+        warning: String(safeObject(routeState).active_execution_warning || result?.warning || "").trim(),
+        last_error: String(routeState?.last_error || "").trim(),
+      });
+    }
+    if (!result || ["idle", "busy"].includes(String(result.outcome || "").trim().toLowerCase())) {
+      return;
+    }
+    recentEvents.unshift({
+      time: new Date().toLocaleTimeString("en-US", { hour12: false }),
+      route_name: String(result.route_name || result.route_key || "").trim(),
+      outcome: String(result.outcome || "").trim(),
+      detail: String(result.detail || "").trim(),
+    });
+    if (recentEvents.length > 8) {
+      recentEvents.length = 8;
+    }
+    render(false);
+  };
+
+  const reportExecutionStage = ({ routeKey, executionPlan, selectedRecord, phase, detail, warning = "", contextSuggestionStatus = "", intentType = "" }) => {
+    const normalizedRouteKey = String(routeKey || "").trim();
+    if (!normalizedRouteKey || !routeStates.has(normalizedRouteKey)) return;
+    setRouteState(normalizedRouteKey, {
+      phase: normalizeRunnerTUIPhase(phase),
+      detail: String(detail || "").trim(),
+      client: String(safeObject(executionPlan).roleProfile?.client || "").trim(),
+      model: String(safeObject(executionPlan).roleProfile?.model || "").trim(),
+      source_message_id: intFromRawAllowZero(safeObject(selectedRecord).parsedArchive?.messageID, 0),
+      intent_type: String(intentType || safeObject(executionPlan).intentType || "").trim(),
+      warning: String(warning || "").trim(),
+      context_suggestion_status: String(contextSuggestionStatus || "").trim(),
+    });
+  };
+
+  const updateNextRunAt = (routeKey, nextRunAt) => {
+    const normalizedRouteKey = String(routeKey || "").trim();
+    if (!normalizedRouteKey || !routeStates.has(normalizedRouteKey)) return;
+    setRouteState(normalizedRouteKey, { next_run_at: Number(nextRunAt) || 0 });
+  };
+
+  return {
+    start() {
+      render(false);
+      intervalHandle = setInterval(() => render(false), 1000);
+    },
+    stop() {
+      if (intervalHandle) clearInterval(intervalHandle);
+      render(true);
+      disposed = true;
+      process.stdout.write("\u001b[?25h\n");
+    },
+    setRouteState,
+    recordResult,
+    reportExecutionStage,
+    updateNextRunAt,
+  };
+}
+
+async function runRunnerStartResolvedRoutes(routes, flags, options = {}) {
   const jsonMode = boolFromRaw(flags.json, false);
+  const sourceLabel = String(safeObject(options).sourceLabel || "runner start").trim() || "runner start";
+  const runnerLogger = createRunnerStartLogger({ routes, flags, sourceLabel, jsonMode });
+  const tui = createRunnerStartTUI({ routes, flags, jsonMode, concurrency: intFromRaw(
+    flags.concurrency ?? process.env.METHEUS_RUNNER_CONCURRENCY,
+    routes.length > 1 ? Math.min(BOT_RUNNER_DEFAULT_CONCURRENCY, routes.length) : 1,
+  ), sourceLabel, bootstrapEvent: safeObject(options).bootstrapEvent || null, logFilePath: String(runnerLogger?.filePath || "").trim() });
   const schedules = new Map();
   const inFlightExecutions = new Map();
   const requestedConcurrency = intFromRaw(
@@ -5695,6 +6512,10 @@ async function runRunnerStartResolvedRoutes(routes, flags) {
   process.on("SIGTERM", stop);
 
   try {
+    if (!tui && runnerLogger?.filePath && !jsonMode) {
+      process.stdout.write(`Runner log file: ${runnerLogger.filePath}\n`);
+    }
+    tui?.start();
     while (!stopRequested) {
       const now = Date.now();
       const dueRoutes = [];
@@ -5715,10 +6536,38 @@ async function runRunnerStartResolvedRoutes(routes, flags) {
         await runTasksWithConcurrencyLimit(dueRouteGroups, concurrency, async (routeGroup) => {
           for (const normalizedRoute of ensureArray(routeGroup)) {
             const routeKey = runnerRouteKey(normalizedRoute);
+            tui?.setRouteState(routeKey, {
+              phase: "polling",
+              detail: "checking inbound messages and archive thread",
+            });
+            runnerLogger?.append("route_poll", {
+              route_key: routeKey,
+              route_name: normalizedRoute.name,
+              logical_signature: runnerRouteLogicalSignature(normalizedRoute),
+            });
             try {
               const result = await processRunnerRouteOnce(normalizedRoute, runtime, "start", { deferExecution: true });
               const deferredExecution = safeObject(result.deferred_execution);
               if (deferredExecution.routeKey) {
+                tui?.reportExecutionStage({
+                  routeKey: deferredExecution.routeKey,
+                  executionPlan: deferredExecution.executionPlan,
+                  selectedRecord: deferredExecution.selectedRecord,
+                  phase: "ai_running",
+                  detail: `running local AI client for comment ${String(deferredExecution.selectedRecord?.id || "").trim() || "-"}`,
+                });
+                runnerLogger?.append("execution_accepted", {
+                  route_key: deferredExecution.routeKey,
+                  route_name: deferredExecution.normalizedRoute?.name,
+                  comment_id: String(deferredExecution.selectedRecord?.id || "").trim(),
+                  source_message_id: intFromRawAllowZero(deferredExecution.selectedRecord?.parsedArchive?.messageID, 0),
+                  execution_mode: String(deferredExecution.executionPlan?.mode || "").trim(),
+                  role_profile: String(deferredExecution.executionPlan?.roleProfileName || "").trim(),
+                });
+                const executionHeartbeat = startRunnerExecutionHeartbeat(
+                  deferredExecution.routeKey,
+                  deferredExecution.selectedRecord,
+                );
                 const executionPromise = (async () => {
                   try {
                     const processed = await processRunnerSelectedRecord({
@@ -5743,6 +6592,24 @@ async function runRunnerStartResolvedRoutes(routes, flags) {
                         buildRunnerDeliveryDeps,
                         buildRunnerRuntimeDeps,
                         resolveConversationPeerBots: resolveRunnerConversationPeers,
+                        reportRunnerStage: (stage) => {
+                          runnerLogger?.append("execution_stage", {
+                            route_key: deferredExecution.routeKey,
+                            route_name: deferredExecution.normalizedRoute?.name,
+                            comment_id: String(deferredExecution.selectedRecord?.id || "").trim(),
+                            source_message_id: intFromRawAllowZero(deferredExecution.selectedRecord?.parsedArchive?.messageID, 0),
+                            phase: String(safeObject(stage).phase || "").trim(),
+                            detail: String(safeObject(stage).detail || "").trim(),
+                            intent_type: String(safeObject(stage).intentType || "").trim(),
+                            context_suggestion_status: String(safeObject(stage).contextSuggestionStatus || "").trim(),
+                          });
+                          tui?.reportExecutionStage({
+                            routeKey: deferredExecution.routeKey,
+                            executionPlan: deferredExecution.executionPlan,
+                            selectedRecord: deferredExecution.selectedRecord,
+                            ...safeObject(stage),
+                          });
+                        },
                       },
                     });
                     if (processed.kind === "skipped") {
@@ -5786,20 +6653,68 @@ async function runRunnerStartResolvedRoutes(routes, flags) {
                       comment_id: deferredExecution.selectedRecord.id,
                     };
                   } finally {
+                    executionHeartbeat.stop();
                     inFlightExecutions.delete(deferredExecution.routeKey);
                     schedules.set(deferredExecution.routeKey, Date.now() + 250);
+                    tui?.updateNextRunAt(deferredExecution.routeKey, Date.now() + 250);
                   }
                 })();
                 inFlightExecutions.set(routeKey, executionPromise);
                 executionPromise.then((finalResult) => {
-                  printRunnerResult("start", finalResult, jsonMode);
+                  const latestRouteState = safeObject(loadBotRunnerState().routes[deferredExecution.routeKey]);
+                  runnerLogger?.append("execution_result", {
+                    route_key: String(finalResult?.route_key || deferredExecution.routeKey).trim(),
+                    route_name: String(finalResult?.route_name || deferredExecution.normalizedRoute?.name || "").trim(),
+                    outcome: String(finalResult?.outcome || "").trim(),
+                    detail: String(finalResult?.detail || "").trim(),
+                    comment_id: String(finalResult?.comment_id || deferredExecution.selectedRecord?.id || "").trim(),
+                    source_message_id: intFromRawAllowZero(latestRouteState?.last_source_message_id, intFromRawAllowZero(deferredExecution.selectedRecord?.parsedArchive?.messageID, 0)),
+                    intent_type: String(latestRouteState?.last_intent_type || "").trim(),
+                    context_suggestion_status: String(finalResult?.context_suggestion_status || latestRouteState?.last_context_suggestion_status || "").trim(),
+                  });
+                  if (tui) {
+                    tui.recordResult(finalResult, latestRouteState);
+                  } else {
+                    printRunnerResult("start", finalResult, jsonMode);
+                  }
                 });
-                printRunnerResult("start", {
+                const acceptedResult = {
                   ...result,
                   deferred_execution: undefined,
-                }, jsonMode);
+                };
+                runnerLogger?.append("route_result", {
+                  route_key: String(acceptedResult?.route_key || routeKey).trim(),
+                  route_name: String(acceptedResult?.route_name || normalizedRoute.name || "").trim(),
+                  outcome: String(acceptedResult?.outcome || "").trim(),
+                  detail: String(acceptedResult?.detail || "").trim(),
+                });
+                if (tui) {
+                  tui.recordResult(acceptedResult);
+                } else {
+                  printRunnerResult("start", acceptedResult, jsonMode);
+                }
               } else if (result.outcome !== "busy") {
-                printRunnerResult("start", result, jsonMode);
+                runnerLogger?.append("route_result", {
+                  route_key: String(result?.route_key || routeKey).trim(),
+                  route_name: String(result?.route_name || normalizedRoute.name || "").trim(),
+                  outcome: String(result?.outcome || "").trim(),
+                  detail: String(result?.detail || "").trim(),
+                  comment_id: String(result?.comment_id || "").trim(),
+                });
+                if (tui) {
+                  tui.recordResult(result);
+                } else {
+                  printRunnerResult("start", result, jsonMode);
+                }
+              } else {
+                runnerLogger?.append("route_result", {
+                  route_key: String(result?.route_key || routeKey).trim(),
+                  route_name: String(result?.route_name || normalizedRoute.name || "").trim(),
+                  outcome: "busy",
+                  detail: String(result?.detail || "").trim(),
+                  comment_id: String(result?.comment_id || "").trim(),
+                });
+                tui?.recordResult(result);
               }
             } catch (err) {
               const errorText = String(err?.message || err);
@@ -5816,9 +6731,26 @@ async function runRunnerStartResolvedRoutes(routes, flags) {
                 outcome: fatalArchiveBootstrapError ? "blocked" : "error",
                 detail: errorText,
               };
-              printRunnerResult("start", result, jsonMode);
+              runnerLogger?.append("route_result", {
+                route_key: routeKey,
+                route_name: normalizedRoute.name,
+                outcome: String(result.outcome || "error").trim(),
+                detail: errorText,
+              });
+              if (tui) {
+                tui.recordResult(result);
+              } else {
+                printRunnerResult("start", result, jsonMode);
+              }
             } finally {
               const routeState = safeObject(loadBotRunnerState().routes[routeKey]);
+              const activeExecutionState = resolveRunnerActiveExecutionState(routeState);
+              tui?.setRouteState(routeKey, {
+                intent_type: String(routeState.last_intent_type || "").trim(),
+                source_message_id: intFromRawAllowZero(routeState.last_source_message_id, 0),
+                warning: String(activeExecutionState.warning || "").trim(),
+                last_error: String(routeState.last_error || "").trim(),
+              });
               const lastErrorText = String(routeState.last_error || "").trim();
               const isFatalArchiveBootstrapError = lastErrorText.includes("Archive thread is missing")
                 && lastErrorText.includes("write access is denied");
@@ -5826,6 +6758,7 @@ async function runRunnerStartResolvedRoutes(routes, flags) {
                 ? 60000
                 : Math.max(1000, normalizedRoute.pollIntervalMs));
               schedules.set(routeKey, nextRunAt);
+              tui?.updateNextRunAt(routeKey, nextRunAt);
             }
           }
         });
@@ -5845,12 +6778,14 @@ async function runRunnerStartResolvedRoutes(routes, flags) {
   } finally {
     process.off("SIGINT", stop);
     process.off("SIGTERM", stop);
+    tui?.stop();
+    runnerLogger?.close({ stop_requested: stopRequested === true });
   }
 }
 
 async function runRunnerStart(flags) {
   const routes = resolveRunnerRoutes(flags, "start");
-  await runRunnerStartResolvedRoutes(routes, flags);
+  await runRunnerStartResolvedRoutes(routes, flags, { sourceLabel: "runner start" });
 }
 
 async function runRunner(argv) {
@@ -7493,6 +8428,10 @@ function buildLocalProjectDispatchDeps() {
     startDetachedRunnerWithFlags: (flags, sourceCommand) => startDetachedRunnerWithFlags(flags, sourceCommand),
     buildRunnerDetachedStatusPayload: (flags) => buildRunnerDetachedStatusPayload(flags),
     stopDetachedRunnerWithFlags: (flags) => stopDetachedRunnerWithFlags(flags),
+    buildProjectBotRolesPayload: (params) => buildProjectBotRolesPayload(params),
+    buildProjectBotRolesText,
+    locateProjectFilesForQuery: (params) => locateProjectFilesForQuery(params),
+    buildProjectFileLocateText,
     loadBotRunnerWorkspaceRegistry: (options) => loadBotRunnerWorkspaceRegistry(options),
     botRunnerWorkspaceRegistryFilePath,
     sanitizeWorkspaceCandidate,
@@ -7527,6 +8466,7 @@ function buildProxyToolHelperDeps() {
     parseToolEnvelopeFromRPCResult: (resultObj) =>
       parseToolEnvelopeFromRPCResult(resultObj, buildGatewayTransportDeps()),
     ctxpackUpdateToolNames: CTXPACK_UPDATE_TOOL_NAMES,
+    workitemMutationToolNames: WORKITEM_MUTATION_TOOL_NAMES,
     localProjectToolNames: LOCAL_PROJECT_TOOL_NAMES,
     localCtxpackMergeToolNames: LOCAL_CTXPACK_MERGE_TOOL_NAMES,
     autoCtxpackSyncTracker,
@@ -7552,6 +8492,7 @@ function buildProxyResponsePipelineDeps() {
 function buildProxyGatewayRequestDeps() {
   return {
     injectCtxpackUpdateDefaults,
+    injectWorkitemBotActorDefaults,
     injectCtxpackPreflightToken,
     stripLocalOnlyToolArgs,
     postJSON,
@@ -8027,6 +8968,8 @@ const LOCAL_PROJECT_TOOL_NAMES = [
   "project.get",
   "project.workspace",
   "project.workspace.bind",
+  "project.bot_roles",
+  "project.file.locate",
   "project.context.list",
   "project.context.get",
   "project.context.active",
@@ -8104,6 +9047,56 @@ function buildProjectWorkspaceBindInputSchema() {
   };
 }
 
+function buildProjectBotRolesInputSchema() {
+  return {
+    type: "object",
+    properties: {
+      project_id: {
+        type: "string",
+        description: "Project UUID.",
+      },
+      provider: {
+        type: "string",
+        enum: ["telegram", "slack", "kakaotalk"],
+        description: "Optional provider filter.",
+      },
+      destination_id: {
+        type: "string",
+        description: "Optional destination UUID filter.",
+      },
+      destination_label: {
+        type: "string",
+        description: "Optional destination label filter.",
+      },
+    },
+    additionalProperties: false,
+  };
+}
+
+function buildProjectFileLocateInputSchema() {
+  return {
+    type: "object",
+    properties: {
+      project_id: {
+        type: "string",
+        description: "Project UUID.",
+      },
+      query: {
+        type: "string",
+        description: "Filename, path fragment, or natural-language file location query.",
+      },
+      limit: {
+        type: "integer",
+        minimum: 1,
+        maximum: 20,
+        description: "Maximum matching file paths to return. Default: 5.",
+      },
+    },
+    required: ["project_id", "query"],
+    additionalProperties: false,
+  };
+}
+
 function buildProjectContextListInputSchema() {
   return {
     type: "object",
@@ -8417,6 +9410,18 @@ function buildLocalToolSpecs() {
         "Bind a project_id to a local workspace_dir in project-workspaces.json so local runner and AI execution use the correct project folder.",
       inputSchema: buildProjectWorkspaceBindInputSchema(),
     },
+    {
+      name: "project.bot_roles",
+      description:
+        "List the currently enabled local runner bot roles for a project and destination. Use this to answer role/ownership questions from current route config, not memory.",
+      inputSchema: buildProjectBotRolesInputSchema(),
+    },
+    {
+      name: "project.file.locate",
+      description:
+        "Locate project ctxpack file paths that match a filename or natural-language query. Use this for file/path questions.",
+      inputSchema: buildProjectFileLocateInputSchema(),
+    },
     {
       name: "project.context.list",
       description:
@@ -9116,6 +10121,16 @@ function injectCtxpackUpdateDefaults(requestObj, toolName, workspaceDir) {
   );
 }
 
+function injectWorkitemBotActorDefaults(requestObj, toolName) {
+  return injectWorkitemBotActorDefaultsImpl(
+    {
+      requestObj,
+      toolName,
+    },
+    buildProxyToolHelperDeps(),
+  );
+}
+
 async function injectCtxpackPreflightToken(requestObj, toolName, toolArgs, args, token, workspaceDir) {
   return injectCtxpackPreflightTokenImpl(
     {
@@ -10135,6 +11150,42 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     push("local_project_context_suggest_tool_dispatches", false, String(err?.message || err));
   }
 
+  const previousRunnerBotID = process.env.METHEUS_RUNNER_BOT_ID;
+  const previousRunnerBotName = process.env.METHEUS_RUNNER_BOT_NAME;
+  try {
+    process.env.METHEUS_RUNNER_BOT_ID = "bot-selftest-123";
+    process.env.METHEUS_RUNNER_BOT_NAME = "RyoAI_bot";
+    const injected = injectWorkitemBotActorDefaults(
+      {
+        jsonrpc: "2.0",
+        id: 51,
+        method: "tools/call",
+        params: {
+          name: "workitem.transition",
+          arguments: {
+            work_item_id: "w1",
+            status: "doing",
+          },
+        },
+      },
+      "workitem.transition",
+    );
+    const injectedArgs = safeObject(safeObject(injected).params).arguments || {};
+    push(
+      "workitem_bot_actor_defaults_injected",
+      String(injectedArgs.actor_bot_id || "").trim() === "bot-selftest-123"
+        && String(injectedArgs.actor_bot_name || "").trim() === "RyoAI_bot",
+      `actor_bot_id=${String(injectedArgs.actor_bot_id || "").trim() || "(none)"} actor_bot_name=${String(injectedArgs.actor_bot_name || "").trim() || "(none)"}`,
+    );
+  } catch (err) {
+    push("workitem_bot_actor_defaults_injected", false, String(err?.message || err));
+  } finally {
+    if (previousRunnerBotID === undefined) delete process.env.METHEUS_RUNNER_BOT_ID;
+    else process.env.METHEUS_RUNNER_BOT_ID = previousRunnerBotID;
+    if (previousRunnerBotName === undefined) delete process.env.METHEUS_RUNNER_BOT_NAME;
+    else process.env.METHEUS_RUNNER_BOT_NAME = previousRunnerBotName;
+  }
+
   try {
     const activeResponse = await handleLocalProjectToolDispatchImpl(
       {
@@ -10268,6 +11319,118 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     push("local_project_context_activate_tool_dispatches", false, String(err?.message || err));
   }
 
+  try {
+    const botRolesResponse = await handleLocalProjectToolDispatchImpl(
+      {
+        requestObj: {
+          jsonrpc: "2.0",
+          id: 7.1,
+          method: "tools/call",
+          params: {
+            name: "project.bot_roles",
+            arguments: {
+              project_id: selftestProjectID,
+              destination_label: "Selftest Room",
+            },
+          },
+        },
+        toolName: "project.bot_roles",
+        toolArgs: {
+          project_id: selftestProjectID,
+          destination_label: "Selftest Room",
+        },
+        args: {
+          baseURL: DEFAULT_SITE_URL,
+          timeoutSeconds: 30,
+        },
+        token: "selftest-token",
+        workspaceDir: "",
+        workspaceSignalTrusted: true,
+      },
+      {
+        ...buildLocalProjectDispatchDeps(),
+        buildProjectBotRolesPayload: () => ({
+          project_id: selftestProjectID,
+          provider: "telegram",
+          destination_label: "Selftest Room",
+          count: 2,
+          routes: [
+            { route_name: "telegram-monitor-ryoai-bot", bot_name: "RyoAI_bot", role: "monitor" },
+            { route_name: "telegram-monitor-ryoai2-bot", bot_name: "RyoAI2_bot", role: "review" },
+          ],
+        }),
+        buildProjectBotRolesText: () => "RyoAI_bot=monitor, RyoAI2_bot=review",
+      },
+    );
+    const botRolesStructured = safeObject(safeObject(botRolesResponse).result)?.structuredContent || {};
+    push(
+      "local_project_bot_roles_tool_dispatches",
+      String(botRolesStructured.project_id || "").trim() === selftestProjectID
+        && Number(botRolesStructured.count || 0) === 2
+        && ensureArray(botRolesStructured.routes).length === 2,
+      `count=${String(botRolesStructured.count || 0)} routes=${ensureArray(botRolesStructured.routes).map((item) => String(safeObject(item).route_name || "")).join(",") || "(none)"}`,
+    );
+  } catch (err) {
+    push("local_project_bot_roles_tool_dispatches", false, String(err?.message || err));
+  }
+
+  try {
+    const fileLocateResponse = await handleLocalProjectToolDispatchImpl(
+      {
+        requestObj: {
+          jsonrpc: "2.0",
+          id: 7.2,
+          method: "tools/call",
+          params: {
+            name: "project.file.locate",
+            arguments: {
+              project_id: selftestProjectID,
+              query: "project-operating-guide",
+            },
+          },
+        },
+        toolName: "project.file.locate",
+        toolArgs: {
+          project_id: selftestProjectID,
+          query: "project-operating-guide",
+        },
+        args: {
+          baseURL: DEFAULT_SITE_URL,
+          timeoutSeconds: 30,
+        },
+        token: "selftest-token",
+        workspaceDir: "",
+        workspaceSignalTrusted: true,
+      },
+      {
+        ...buildLocalProjectDispatchDeps(),
+        locateProjectFilesForQuery: async () => ({
+          query: "project-operating-guide",
+          count: 1,
+          matches: [
+            {
+              path: ".metheus/project-guides/project-operating-guide.md",
+              doc_type: "Guide",
+              generated: true,
+            },
+          ],
+        }),
+        buildProjectFileLocateText: () => ".metheus/project-guides/project-operating-guide.md",
+      },
+    );
+    const fileLocateStructured = safeObject(safeObject(fileLocateResponse).result)?.structuredContent || {};
+    push(
+      "local_project_file_locate_tool_dispatches",
+      fileLocateStructured.ok === true
+        && String(fileLocateStructured.project_id || "").trim() === selftestProjectID
+        && Number(fileLocateStructured.count || 0) === 1
+        && String(safeObject(ensureArray(fileLocateStructured.matches)[0]).path || "").trim() === ".metheus/project-guides/project-operating-guide.md",
+      `count=${String(fileLocateStructured.count || 0)} path=${String(safeObject(ensureArray(fileLocateStructured.matches)[0]).path || "").trim() || "(none)"}`,
+    );
+  } catch (err) {
+    push("local_project_file_locate_tool_dispatches", false, String(err?.message || err));
+  }
+
   let detachedRunnerRegistryTempHome = "";
   const previousDetachedRunnerUserProfile = process.env.USERPROFILE;
   const previousDetachedRunnerHome = process.env.HOME;
@@ -10336,6 +11499,41 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     push("detached_runner_cli_args_strip_control_flags", false, String(err?.message || err));
   }
 
+  try {
+    const defaultLogFilePath = buildDefaultRunnerLogFilePath(
+      [{ name: "telegram-monitor-selftest" }],
+      "runner start",
+      new Date("2026-03-19T07:45:00Z"),
+    );
+    push(
+      "runner_default_log_file_path_uses_runner_logs_directory",
+      defaultLogFilePath.includes(path.join(".metheus", "runner-logs"))
+        && defaultLogFilePath.endsWith(".jsonl")
+        && defaultLogFilePath.includes("runner-start")
+        && defaultLogFilePath.includes("telegram-monitor-selftest"),
+      defaultLogFilePath,
+    );
+  } catch (err) {
+    push("runner_default_log_file_path_uses_runner_logs_directory", false, String(err?.message || err));
+  }
+
+  try {
+    const detachedLaunch = buildRunnerDetachedLaunchRecord(
+      4321,
+      [{ name: "telegram-monitor-selftest", projectID: selftestProjectID, provider: "telegram", destinationLabel: "Selftest Room" }],
+      {},
+      "runner start-detached",
+      "C:\\logs\\runner-selftest.jsonl",
+    );
+    push(
+      "detached_runner_launch_record_persists_log_file",
+      String(detachedLaunch.log_file || "").trim() === "C:\\logs\\runner-selftest.jsonl",
+      `log_file=${String(detachedLaunch.log_file || "").trim() || "(none)"}`,
+    );
+  } catch (err) {
+    push("detached_runner_launch_record_persists_log_file", false, String(err?.message || err));
+  }
+
   let detachedRunnerPosixTempDir = "";
   try {
     detachedRunnerPosixTempDir = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-detached-script-selftest-"));
@@ -10503,6 +11701,7 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
           resolved_destination: { destination_label: "Selftest Room" },
           workspace_mapping: { workspace_dir: "C:\\selftest-workspace", workspace_source: "project-workspaces.json:manual_override" },
           execution_profile: { permission_mode: "read_only" },
+          active_execution: { active: true, stuck: true, source_message_id: 128, warning: "active execution is taking longer than expected" },
           last_run: { intent_type: "status_query" },
           warnings: [],
           errors: [],
@@ -10514,13 +11713,53 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
       "local_runner_show_tool_dispatches",
       showStructured.ok === true
         && String(showStructured.route_name || "").trim() === "telegram-monitor-selftest"
-        && String(safeObject(showStructured.last_run).intent_type || "").trim() === "status_query",
-      `route=${String(showStructured.route_name || "").trim() || "(none)"} workspace=${String(safeObject(showStructured.workspace_mapping).workspace_dir || "").trim() || "-"} intent=${String(safeObject(showStructured.last_run).intent_type || "").trim() || "-"}`,
+        && String(safeObject(showStructured.last_run).intent_type || "").trim() === "status_query"
+        && safeObject(showStructured.active_execution).stuck === true,
+      `route=${String(showStructured.route_name || "").trim() || "(none)"} workspace=${String(safeObject(showStructured.workspace_mapping).workspace_dir || "").trim() || "-"} intent=${String(safeObject(showStructured.last_run).intent_type || "").trim() || "-"} stuck=${String(safeObject(showStructured.active_execution).stuck || false)}`,
     );
   } catch (err) {
     push("local_runner_show_tool_dispatches", false, String(err?.message || err));
   }
 
+  try {
+    const heartbeatFreshState = resolveRunnerActiveExecutionState({
+      active_comment_id: "comment-live",
+      active_source_message_id: 128,
+      active_started_at: new Date(Date.now() - 15_000).toISOString(),
+      active_heartbeat_at: new Date(Date.now() - 2_000).toISOString(),
+      active_runner_pid: process.pid,
+    });
+    push(
+      "runner_active_execution_heartbeat_keeps_fresh_live_execution_active",
+      heartbeatFreshState.active === true
+        && heartbeatFreshState.stale === false
+        && heartbeatFreshState.stuck === false
+        && String(heartbeatFreshState.warning || "").trim() === "",
+      `active=${String(heartbeatFreshState.active)} stale=${String(heartbeatFreshState.stale)} stuck=${String(heartbeatFreshState.stuck)} warning=${String(heartbeatFreshState.warning || "").trim() || "-"}`,
+    );
+  } catch (err) {
+    push("runner_active_execution_heartbeat_keeps_fresh_live_execution_active", false, String(err?.message || err));
+  }
+
+  try {
+    const heartbeatExpiredState = resolveRunnerActiveExecutionState({
+      active_comment_id: "comment-stale",
+      active_source_message_id: 129,
+      active_started_at: new Date(Date.now() - (BOT_RUNNER_ACTIVE_EXECUTION_HEARTBEAT_STALE_MS + 20_000)).toISOString(),
+      active_heartbeat_at: new Date(Date.now() - (BOT_RUNNER_ACTIVE_EXECUTION_HEARTBEAT_STALE_MS + 5_000)).toISOString(),
+      active_runner_pid: process.pid,
+    });
+    push(
+      "runner_active_execution_heartbeat_marks_live_execution_stale_when_expired",
+      heartbeatExpiredState.active === false
+        && heartbeatExpiredState.stale === true
+        && String(heartbeatExpiredState.warning || "").trim() === "active execution heartbeat expired; clearing busy state",
+      `active=${String(heartbeatExpiredState.active)} stale=${String(heartbeatExpiredState.stale)} warning=${String(heartbeatExpiredState.warning || "").trim() || "-"}`,
+    );
+  } catch (err) {
+    push("runner_active_execution_heartbeat_marks_live_execution_stale_when_expired", false, String(err?.message || err));
+  }
+
   try {
     const startResponse = await handleLocalProjectToolDispatchImpl(
       {
@@ -10678,6 +11917,51 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     push("local_runner_stop_tool_returns_stopped_entries", false, String(err?.message || err));
   }
 
+  try {
+    const frame = buildRunnerTUIFrame({
+      routes: [
+        {
+          route_name: "telegram-monitor-selftest",
+          phase: "ai_running",
+          client: "gpt",
+          model: "gpt-5.4",
+          intent_type: "status_query",
+          source_message_id: 128,
+          next_run_at: Date.now() + 5000,
+          detail: "running local AI execution",
+          warning: "active execution is taking longer than expected",
+          phase_started_at: Date.now() - 15000,
+        },
+      ],
+      recentEvents: [
+        {
+          time: "12:34:56",
+          route_name: "telegram-monitor-selftest",
+          outcome: "accepted",
+          detail: "accepted comment 128 for background execution",
+        },
+      ],
+      concurrency: 1,
+      now: Date.now(),
+      useColor: false,
+      logFilePath: "C:\\logs\\runner-selftest.jsonl",
+    });
+    push(
+      "runner_tui_frame_renders_route_statuses",
+      frame.includes("METHEUS RUNNER LIVE")
+        && frame.includes("Log: C:\\logs\\runner-selftest.jsonl")
+        && frame.includes("Summary: waiting=0 polling=0 running=1 busy=0 replied=0 error=0 warnings=1")
+        && frame.includes("telegram-monitor-self...")
+        && frame.includes("AI_RUNNING")
+        && frame.includes("gpt/gpt-5.4")
+        && frame.includes("status_query")
+        && frame.includes("warning=active execution is taking longer than expected"),
+      frame.replace(/\r?\n/g, " | "),
+    );
+  } catch (err) {
+    push("runner_tui_frame_renders_route_statuses", false, String(err?.message || err));
+  }
+
   await runSelftestBotCommands(push, {
     cliPath: fileURLToPath(import.meta.url),
     parseSimpleEnvText,