@agent-native/core 0.164.15 → 0.164.17

package/corpus/templates/factory/actions/start-builder-for-item.ts

@@ -25,10 +25,40 @@ import {
 import { detectOwnerOwnedArea } from "../server/triage/pr-policy.js";
 import { createSlackReader } from "../server/triage/slack-client.js";
 
-const replyTextPrefix =
-  "@builder.io please run /address-feedback in the repo to address this feedback. Read the address-feedback, address-feedback-with-replies, review-latest-feedback, and review-prs skills as relevant, inspect the full thread and linked evidence, and fix the owning boundary. Please send a PR when ready.";
+/** Slack notifies only with `<@USERID>`. Plaintext @handles do not ping anyone. */
+const REPLY_INSTRUCTION =
+  "please run /address-feedback in the repo to address this feedback. Read the address-feedback, address-feedback-with-replies, review-latest-feedback, and review-prs skills as relevant, inspect the full thread and linked evidence, and fix the owning boundary. Please send a PR when ready, then have the @agent-native bot post a concise Fixed, In progress, or Clarification needed disposition in this same thread; an 👀 reaction or this handoff alone is not completion.";
+const plaintextBuilderReplyPrefix =
+  "@builder.io please run /address-feedback in the repo to address this feedback.";
 const legacyReplyTextPrefix = "@builderio please fix this in a reply.";
 
+export function requireBuilderSlackUserId(
+  value: string | null | undefined,
+): string {
+  const id = typeof value === "string" ? value.trim() : "";
+  if (!/^[UW][A-Z0-9]+$/i.test(id)) {
+    throw new Error(
+      "Configure a Builder Slack member id in Factory settings before tagging Builder.",
+    );
+  }
+  return id.toUpperCase();
+}
+
+export function replyTextPrefixFor(builderSlackUserId: string): string {
+  return `<@${requireBuilderSlackUserId(builderSlackUserId)}> ${REPLY_INSTRUCTION}`;
+}
+
+function messageHasBuilderHandoff(
+  text: string,
+  builderSlackUserId: string,
+): boolean {
+  return (
+    text.includes(replyTextPrefixFor(builderSlackUserId)) ||
+    text.includes(plaintextBuilderReplyPrefix) ||
+    text.includes(legacyReplyTextPrefix)
+  );
+}
+
 type RelatedFeedbackItem = {
   id: string;
   sourceUrl: string | null;
@@ -93,6 +123,7 @@ export function replyTextForItem(
     sourceUrl: string | null;
   },
   relatedItems: RelatedFeedbackItem[] = [],
+  builderSlackUserId: string,
 ): string {
   const relatedText =
     relatedItems.length > 0
@@ -105,7 +136,7 @@ export function replyTextForItem(
         ]
       : [];
   return [
-    replyTextPrefix,
+    replyTextPrefixFor(builderSlackUserId),
     `Factory item: ${item.id}`,
     item.sourceUrl ? `Source: ${item.sourceUrl}` : "",
     ...relatedText,
@@ -199,7 +230,7 @@ export async function recordAutomaticBuilderDecision(input: {
 
 export default defineAction({
   description:
-    "Start the governed clear-bug Builder flow for a Factory item, or record a skip with a reason when clearBug is false. Slack items are kept in-thread by adding 👀 and tagging @builder.io; grouped Slack repeats share one Builder thread. GitHub issues and Sentry errors use the Builder agent run API. Owner-managed Clips, Design, and Content items are always left for their owner.",
+    "Start the governed clear-bug Builder flow for a Factory item, or record a skip with a reason when clearBug is false. Slack items stay in-thread: this action adds 👀 and pings Builder with the configured Slack member id; do not post Slack messages or @handles yourself. Grouped Slack repeats share one Builder thread. GitHub issues and Sentry errors use the Builder agent run API. Owner-managed Clips, Design, and Content items are always left for their owner.",
   schema: z.object({
     itemId: z.string().min(1),
     clearBug: z.boolean(),
@@ -464,7 +495,10 @@ export default defineAction({
         }
         const config = (
           await db
-            .select({ slackWorkspace: triageConfig.slackWorkspace })
+            .select({
+              slackWorkspace: triageConfig.slackWorkspace,
+              builderSlackUserId: triageConfig.builderSlackUserId,
+            })
             .from(triageConfig)
             .where(
               and(eq(triageConfig.id, orgId), eq(triageConfig.orgId, orgId)),
@@ -473,67 +507,115 @@ export default defineAction({
         )[0];
         const workspace =
           config?.slackWorkspace === "secondary" ? "secondary" : "primary";
+        const builderSlackUserId = requireBuilderSlackUserId(
+          config?.builderSlackUserId,
+        );
         const slack = createSlackReader({ ownerEmail: userEmail, orgId });
-        for (const feedbackItem of [item, ...relatedItems]) {
-          const feedbackMetadata =
-            feedbackItem.id === itemId
-              ? metadata
-              : parseTriageMetadata(feedbackItem.metadataJson);
-          if (metadataBoolean(feedbackMetadata, "slackEyesReactedAt")) {
-            continue;
+        const thread = await slack.getCompleteThread(
+          workspace,
+          item.channelId,
+          item.threadTs,
+        );
+        const completeThreads = new Map([[item.id, thread]]);
+        if (thread.hasMore) {
+          throw new Error(
+            "Slack thread is truncated; refusing to dispatch without complete evidence.",
+          );
+        }
+        for (const related of relatedItems) {
+          if (!related.channelId || !related.threadTs) {
+            throw new Error(
+              "Grouped Slack feedback is missing a channel or thread identity.",
+            );
+          }
+          const relatedThread = await slack.getCompleteThread(
+            workspace,
+            related.channelId,
+            related.threadTs,
+          );
+          completeThreads.set(related.id, relatedThread);
+          if (relatedThread.hasMore) {
+            throw new Error(
+              "A grouped Slack thread is truncated; refusing to dispatch without complete evidence.",
+            );
           }
-          const reaction = await slack.addEyesReaction(
+        }
+        for (const feedbackItem of [item, ...relatedItems]) {
+          const reactionState = await slack.getEyesReaction(
             workspace,
             feedbackItem.channelId!,
             feedbackItem.threadTs!,
           );
+          const reaction = reactionState.eyesPresent
+            ? { added: false, already_present: true }
+            : await slack.addEyesReaction(
+                workspace,
+                feedbackItem.channelId!,
+                feedbackItem.threadTs!,
+              );
           await writeMetadata(feedbackItem.id, orgId, {
             slackEyesReactedAt: new Date().toISOString(),
             slackEyesReactionAlreadyPresent: reaction.already_present,
           });
         }
-        const thread = await slack.getThread(
-          workspace,
-          item.channelId,
-          item.threadTs,
-          100,
-        );
-        const hasCurrentBuilderReply = thread.messages.some((message) =>
-          message.text.includes(replyTextPrefix),
-        );
-        const hasLegacyBuilderReply = thread.messages.some((message) =>
-          message.text.includes(legacyReplyTextPrefix),
+        const hasBuilderReply = thread.messages.some((message) =>
+          messageHasBuilderHandoff(message.text, builderSlackUserId),
         );
         const hasRelatedClusterDetails = thread.messages.some((message) =>
           message.text.includes(
             "Related feedback in the same issue cluster - inspect and fix all of these too:",
           ),
         );
-        if (
-          thread.has_more &&
-          !hasCurrentBuilderReply &&
-          !hasLegacyBuilderReply
-        ) {
+        if (thread.hasMore && !hasBuilderReply) {
           throw new Error(
             "Slack thread is truncated; refusing to risk a duplicate Builder handoff.",
           );
         }
         if (
           !metadataBoolean(metadata, "slackBuilderReplyAt") &&
-          ((!hasCurrentBuilderReply && !hasLegacyBuilderReply) ||
+          (!hasBuilderReply ||
             (relatedItems.length > 0 && !hasRelatedClusterDetails))
         ) {
           const posted = await slack.postThreadReply(
             workspace,
             item.channelId,
             item.threadTs,
-            replyTextForItem(item, relatedItems),
+            replyTextForItem(item, relatedItems, builderSlackUserId),
           );
           await writeMetadata(itemId, orgId, {
             slackBuilderReplyAt: new Date().toISOString(),
             slackBuilderReplyTs: posted.ts,
           });
         }
+        const agentNative = await slack.getAgentNativeIdentity(workspace);
+        for (const feedbackItem of [item, ...relatedItems]) {
+          const feedbackThread = completeThreads.get(feedbackItem.id);
+          if (!feedbackThread) {
+            throw new Error(
+              `Slack thread evidence is missing for Factory item ${feedbackItem.id}.`,
+            );
+          }
+          const hasAgentNativeDisposition = feedbackThread.messages.some(
+            (message) =>
+              (message.user === agentNative.userId ||
+                message.username?.trim().toLowerCase() === "agent-native") &&
+              /^(Fixed|In progress|Clarification needed):/i.test(
+                message.text.trim(),
+              ),
+          );
+          if (hasAgentNativeDisposition) continue;
+          const disposition = await slack.postThreadReply(
+            workspace,
+            feedbackItem.channelId!,
+            feedbackItem.threadTs!,
+            `Thanks - Builder owns this feedback cluster and will follow up after verification. In progress: ${reason}`,
+          );
+          await writeMetadata(feedbackItem.id, orgId, {
+            slackDispositionAt: new Date().toISOString(),
+            slackDispositionTs: disposition.ts,
+            slackDisposition: "In progress",
+          });
+        }
         const clusterItemIds = [itemId, ...relatedItems.map(({ id }) => id)];
         const clusterMetadata = {
           feedbackClusterRepresentativeId: itemId,

package/corpus/templates/factory/actions/view-screen.ts

@@ -41,6 +41,18 @@ export default defineAction({
     const screen: Record<string, unknown> = {};
     if (navigation) screen.navigation = navigation;
 
+    if (
+      navigation &&
+      typeof navigation === "object" &&
+      "view" in navigation &&
+      navigation.view === "factory-settings"
+    ) {
+      screen.factorySettings = {
+        scope: "workspace",
+        path: "/factory-settings",
+      };
+    }
+
     if (
       navigation &&
       typeof navigation === "object" &&

package/corpus/templates/factory/app/components/factory/FactorySettingsView.tsx

@@ -0,0 +1,457 @@
+import {
+  useActionMutation,
+  useActionQuery,
+} from "@agent-native/core/client/hooks";
+import { useT } from "@agent-native/core/client/i18n";
+import { buildSettingsRoute } from "@agent-native/core/client/navigation";
+import { SettingsGroup, SettingsRow } from "@agent-native/core/client/settings";
+import { ActionQueryError } from "@agent-native/dispatch/components";
+import { IconLoader2 } from "@tabler/icons-react";
+import { useEffect, useState } from "react";
+import { Link } from "react-router";
+import { toast } from "sonner";
+
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Switch } from "@/components/ui/switch";
+
+type TriageConfig = {
+  slackWorkspace?: "primary" | "secondary";
+  slackChannelId?: string | null;
+  slackChannelName?: string | null;
+  builderSlackUserId?: string | null;
+  pollingEnabled?: boolean;
+  githubPollingEnabled?: boolean;
+  sentryPollingEnabled?: boolean;
+  sentryOrgSlug?: string | null;
+  sentryProjectSlug?: string | null;
+  sentryEnvironment?: string | null;
+  repository?: string | null;
+  automationFailureAlertsEnabled?: boolean;
+  automationFailureAlertEmail?: string | null;
+  emailReadiness?: {
+    status: "ready" | "not-configured" | "misconfigured" | "unavailable";
+    provider: string;
+  };
+};
+
+type FactoryAutomationHealth = {
+  status: "healthy" | "stale" | "error" | "no-data";
+  lastCheckedAt?: number | null;
+  lastDispatchedAt?: number | null;
+  lastError?: string | null;
+  runtime?: string | null;
+};
+
+function formatAutomationDate(value: string | number | null | undefined) {
+  if (!value) return "-";
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? String(value) : date.toLocaleString();
+}
+
+export function FactorySettingsView() {
+  const t = useT();
+  const [workspace, setWorkspace] = useState<"primary" | "secondary">(
+    "primary",
+  );
+  const [channelId, setChannelId] = useState("");
+  const [channelName, setChannelName] = useState("");
+  const [builderSlackUserId, setBuilderSlackUserId] = useState("");
+  const [repository, setRepository] = useState("");
+  const [polling, setPolling] = useState(false);
+  const [githubPolling, setGithubPolling] = useState(false);
+  const [sentryPolling, setSentryPolling] = useState(false);
+  const [sentryOrgSlug, setSentryOrgSlug] = useState("");
+  const [sentryProjectSlug, setSentryProjectSlug] = useState("");
+  const [sentryEnvironment, setSentryEnvironment] = useState("");
+  const [automationFailureAlertsEnabled, setAutomationFailureAlertsEnabled] =
+    useState(true);
+  const [automationFailureAlertEmail, setAutomationFailureAlertEmail] =
+    useState("");
+  const query = useActionQuery("get-triage-config", {});
+  const schedulerHealthQuery = useActionQuery<FactoryAutomationHealth>(
+    "get-factory-automation-health",
+    {},
+    { refetchInterval: 60_000 },
+  );
+  const mutation = useActionMutation("save-triage-config");
+
+  useEffect(() => {
+    const data = query.data as TriageConfig | undefined;
+    if (!data) return;
+    setWorkspace(data.slackWorkspace ?? "primary");
+    setChannelId(data.slackChannelId ?? "");
+    setChannelName(data.slackChannelName ?? "");
+    setBuilderSlackUserId(data.builderSlackUserId ?? "");
+    setRepository(data.repository ?? "");
+    setPolling(data.pollingEnabled ?? false);
+    setGithubPolling(data.githubPollingEnabled ?? false);
+    setSentryPolling(data.sentryPollingEnabled ?? false);
+    setSentryOrgSlug(data.sentryOrgSlug ?? "");
+    setSentryProjectSlug(data.sentryProjectSlug ?? "");
+    setSentryEnvironment(data.sentryEnvironment ?? "");
+    setAutomationFailureAlertsEnabled(
+      data.automationFailureAlertsEnabled ?? true,
+    );
+    setAutomationFailureAlertEmail(data.automationFailureAlertEmail ?? "");
+  }, [query.data]);
+
+  const configLoaded = Boolean(query.data) && !query.isError;
+
+  const saveSettings = async () => {
+    if (!configLoaded) {
+      toast.error(t("triage.settingsError"));
+      return;
+    }
+    try {
+      await mutation.mutateAsync({
+        slackWorkspace: workspace,
+        slackChannelId: channelId,
+        slackChannelName: channelName,
+        builderSlackUserId,
+        repository,
+        pollingEnabled: polling,
+        githubPollingEnabled: githubPolling,
+        sentryPollingEnabled: sentryPolling,
+        sentryOrgSlug,
+        sentryProjectSlug,
+        sentryEnvironment,
+        automationFailureAlertsEnabled,
+        automationFailureAlertEmail: automationFailureAlertEmail.trim(),
+      });
+      toast.success(t("triage.settingsSaved"));
+    } catch (error) {
+      toast.error(
+        error instanceof Error ? error.message : t("triage.settingsError"),
+      );
+    }
+  };
+
+  if (query.isLoading) {
+    return (
+      <div className="mx-auto w-full max-w-3xl space-y-6 p-4 lg:p-6">
+        <FactorySettingsSkeleton t={t} />
+      </div>
+    );
+  }
+
+  if (!configLoaded) {
+    return (
+      <div className="mx-auto w-full max-w-3xl p-4 lg:p-6">
+        <ActionQueryError
+          error={query.error}
+          onRetry={() => void query.refetch()}
+        />
+      </div>
+    );
+  }
+
+  const fieldControlClass = "h-9 w-full sm:w-64";
+
+  return (
+    <div className="mx-auto w-full max-w-3xl space-y-6 p-4 lg:p-6">
+      <SettingsGroup variant="soft">
+        <SettingsRow
+          label={t("factoryRoute.workspaceIntegrations")}
+          description={t("settings.workspaceDescription")}
+          control={
+            <Button asChild type="button" variant="outline">
+              <Link to={buildSettingsRoute("integrations")}>Manage</Link>
+            </Button>
+          }
+        />
+        <SettingsRow
+          label={t("factoryRoute.agentAccess")}
+          description={t("settings.agentDescription")}
+          control={
+            <Button asChild type="button" variant="outline">
+              <Link to={buildSettingsRoute("agent")}>Manage</Link>
+            </Button>
+          }
+        />
+      </SettingsGroup>
+
+      <SettingsGroup variant="soft">
+        <SettingsRow
+          label={t("triage.slackWorkspace")}
+          control={
+            <select
+              aria-label={t("triage.slackWorkspace")}
+              value={workspace}
+              onChange={(event) =>
+                setWorkspace(event.target.value as "primary" | "secondary")
+              }
+              className="h-9 w-full rounded-md border border-input bg-background px-3 text-sm sm:w-64"
+            >
+              <option value="primary">primary</option>
+              <option value="secondary">secondary</option>
+            </select>
+          }
+        />
+        <SettingsRow
+          label={t("triage.slackChannelId")}
+          control={
+            <Input
+              aria-label={t("triage.slackChannelId")}
+              value={channelId}
+              onChange={(event) => setChannelId(event.target.value)}
+              placeholder={t("triage.slackChannelPlaceholder")}
+              className={fieldControlClass}
+            />
+          }
+        />
+        <SettingsRow
+          label={t("triage.slackChannelName")}
+          control={
+            <Input
+              aria-label={t("triage.slackChannelName")}
+              value={channelName}
+              onChange={(event) => setChannelName(event.target.value)}
+              placeholder={t("triage.slackChannelNamePlaceholder")}
+              className={fieldControlClass}
+            />
+          }
+        />
+        <SettingsRow
+          label={t("triage.builderSlackUserId")}
+          control={
+            <Input
+              aria-label={t("triage.builderSlackUserId")}
+              value={builderSlackUserId}
+              onChange={(event) => setBuilderSlackUserId(event.target.value)}
+              placeholder={t("triage.builderSlackUserIdPlaceholder")}
+              className={fieldControlClass}
+            />
+          }
+        />
+        <SettingsRow
+          label={t("triage.repository")}
+          control={
+            <Input
+              aria-label={t("triage.repository")}
+              value={repository}
+              onChange={(event) => setRepository(event.target.value)}
+              placeholder={t("triage.repositoryPlaceholder")}
+              className={fieldControlClass}
+            />
+          }
+        />
+        <SettingsRow
+          label={t("triage.enablePolling")}
+          control={
+            <Switch
+              aria-label={t("triage.enablePolling")}
+              checked={polling}
+              onCheckedChange={(checked) => setPolling(checked === true)}
+            />
+          }
+        />
+        <SettingsRow
+          label={t("triage.enableGithubPolling")}
+          control={
+            <Switch
+              aria-label={t("triage.enableGithubPolling")}
+              checked={githubPolling}
+              onCheckedChange={(checked) => setGithubPolling(checked === true)}
+            />
+          }
+        />
+        <SettingsRow
+          label={t("triage.sentryOrgSlug")}
+          control={
+            <Input
+              aria-label={t("triage.sentryOrgSlug")}
+              value={sentryOrgSlug}
+              onChange={(event) => setSentryOrgSlug(event.target.value)}
+              placeholder={t("triage.sentryOrgPlaceholder")}
+              className={fieldControlClass}
+            />
+          }
+        />
+        <SettingsRow
+          label={t("triage.sentryProjectSlug")}
+          control={
+            <Input
+              aria-label={t("triage.sentryProjectSlug")}
+              value={sentryProjectSlug}
+              onChange={(event) => setSentryProjectSlug(event.target.value)}
+              placeholder={t("triage.sentryProjectPlaceholder")}
+              className={fieldControlClass}
+            />
+          }
+        />
+        <SettingsRow
+          label={t("triage.sentryEnvironment")}
+          control={
+            <Input
+              aria-label={t("triage.sentryEnvironment")}
+              value={sentryEnvironment}
+              onChange={(event) => setSentryEnvironment(event.target.value)}
+              placeholder={t("triage.sentryEnvironmentPlaceholder")}
+              className={fieldControlClass}
+            />
+          }
+        />
+        <SettingsRow
+          label={t("triage.enableSentryPolling")}
+          control={
+            <Switch
+              aria-label={t("triage.enableSentryPolling")}
+              checked={sentryPolling}
+              onCheckedChange={(checked) => setSentryPolling(checked === true)}
+            />
+          }
+        />
+      </SettingsGroup>
+
+      <SettingsGroup variant="soft">
+        <SettingsRow
+          label={t("factoryRoute.automationFailureAlertsTitle")}
+          description={t("factoryRoute.automationFailureAlertsDescription")}
+          control={
+            <Switch
+              aria-label={t("factoryRoute.automationFailureAlertsEnabled")}
+              checked={automationFailureAlertsEnabled}
+              onCheckedChange={(checked) =>
+                setAutomationFailureAlertsEnabled(checked === true)
+              }
+            />
+          }
+        />
+        <SettingsRow
+          label={t("factoryRoute.automationFailureAlertEmail")}
+          description={t("factoryRoute.automationFailureAlertEmailPlaceholder")}
+          control={
+            <Input
+              aria-label={t("factoryRoute.automationFailureAlertEmail")}
+              type="email"
+              value={automationFailureAlertEmail}
+              onChange={(event) =>
+                setAutomationFailureAlertEmail(event.target.value)
+              }
+              placeholder={t(
+                "factoryRoute.automationFailureAlertEmailPlaceholder",
+              )}
+              className={fieldControlClass}
+            />
+          }
+        />
+        <SettingsRow
+          label={t("factoryRoute.automationFailureEmailReadiness")}
+          description={t("factoryRoute.automationEmailReadinessHint")}
+          control={
+            <span className="rounded-full bg-muted px-2.5 py-1 text-xs font-medium text-muted-foreground">
+              {(query.data as TriageConfig | undefined)?.emailReadiness
+                ?.status ?? "unknown"}
+            </span>
+          }
+        />
+      </SettingsGroup>
+
+      <div className="flex flex-wrap items-center justify-end gap-3">
+        <Button
+          onClick={() => void saveSettings()}
+          disabled={mutation.isPending || !configLoaded}
+        >
+          {mutation.isPending && <IconLoader2 className="animate-spin" />}
+          {t("triage.saveSettings")}
+        </Button>
+      </div>
+
+      <SchedulerHealthStatus
+        health={schedulerHealthQuery.data}
+        isError={schedulerHealthQuery.isError}
+        error={schedulerHealthQuery.error}
+        t={t}
+      />
+    </div>
+  );
+}
+
+function FactorySettingsSkeleton({ t }: { t: ReturnType<typeof useT> }) {
+  return (
+    <div className="space-y-6" aria-label={t("triage.loading")}>
+      {[2, 11, 3].map((rowCount, index) => (
+        <div key={index} className="grid gap-2">
+          <div className="grid gap-2">
+            {Array.from({ length: rowCount }).map((_, rowIndex) => (
+              <div
+                key={rowIndex}
+                className="flex min-h-20 items-center justify-between gap-4 rounded-xl bg-card px-5 py-4 shadow-sm sm:px-6"
+              >
+                <div className="h-3.5 w-36 animate-pulse rounded bg-muted" />
+                <div className="h-9 w-24 animate-pulse rounded bg-muted" />
+              </div>
+            ))}
+          </div>
+        </div>
+      ))}
+    </div>
+  );
+}
+
+function SchedulerHealthStatus({
+  health,
+  isError,
+  error,
+  t,
+}: {
+  health?: FactoryAutomationHealth;
+  isError: boolean;
+  error: unknown;
+  t: ReturnType<typeof useT>;
+}) {
+  const healthLabel = isError
+    ? t("factoryRoute.automationHealthError")
+    : health
+      ? {
+          healthy: t("factoryRoute.automationHealthHealthy"),
+          stale: t("factoryRoute.automationHealthStale"),
+          error: t("factoryRoute.automationHealthError"),
+          "no-data": t("factoryRoute.automationHealthNoData"),
+        }[health.status]
+      : t("factoryRoute.automationHealthNoData");
+  const hasNoHeartbeat =
+    !isError &&
+    (!health || health.status === "no-data") &&
+    !health?.lastCheckedAt;
+  const healthDescription = isError
+    ? `${t("factoryRoute.automationDiagnosticsLoadError")} ${error instanceof Error ? error.message : String(error)}`
+    : health?.lastError
+      ? `${t("factoryRoute.automationHealthErrorDetail")}: ${health.lastError}`
+      : health?.status === "stale"
+        ? t("factoryRoute.automationHealthStaleHint")
+        : hasNoHeartbeat
+          ? t("factoryRoute.automationHealthNoDataHint")
+          : undefined;
+
+  return (
+    <SettingsGroup variant="soft">
+      <SettingsRow
+        label={t("factoryRoute.automationHealthTitle")}
+        description={
+          healthDescription ?? t("factoryRoute.automationHealthDescription")
+        }
+        control={
+          <div className="flex flex-wrap items-center justify-end gap-x-4 gap-y-1">
+            <span className="rounded-full bg-muted px-2.5 py-1 text-xs font-medium">
+              {healthLabel}
+            </span>
+            {health?.lastCheckedAt && (
+              <span className="text-xs text-muted-foreground">
+                {t("factoryRoute.automationLastCheck")}:{" "}
+                {formatAutomationDate(health.lastCheckedAt)}
+              </span>
+            )}
+            {health?.lastDispatchedAt && (
+              <span className="text-xs text-muted-foreground">
+                {t("factoryRoute.automationLastDispatch")}:{" "}
+                {formatAutomationDate(health.lastDispatchedAt)}
+              </span>
+            )}
+          </div>
+        }
+      />
+    </SettingsGroup>
+  );
+}