@anchrd/intel-ui 0.18.0 → 0.20.0

package/src/agent/agent-state/agent-state.ts

@@ -1,85 +0,0 @@
-import { type UseQueryResult, useQuery } from "@tanstack/react-query";
-import type { AgentState } from "@/data/agent-runtime/agent-runtime.ts";
-import { IntelRequestError } from "@/data/intel-data-provider/intel-data-provider.ts";
-import { useIntelRouterContext } from "@/router/router-context.ts";
-
-export const agentStateKey = (agentId: string) => ["agent-state", agentId] as const;
-
-/**
- * Whether this agent is switched off, read from the runtime through intel.
- *
- * ⚠️ One query for the whole page, shared by the status line, the two head actions and the tabs
- * that have to say "not for you". It is also the page's PROBE: the answer to "may this reader drive
- * this agent" is only knowable by asking, because `/session` deliberately carries identity and no
- * capabilities (`SessionUser` — "no capabilities, no token"). So a 403 here is not a failure to
- * report but a fact to render.
- */
-export function useAgentState(agentId: string): UseQueryResult<AgentState> {
-  const { data } = useIntelRouterContext();
-  return useQuery({
-    queryKey: agentStateKey(agentId),
-    queryFn: () => data.getAgentState(agentId),
-    // A refusal is an answer, and retrying it three times only delays the sentence that explains it.
-    retry: false,
-  });
-}
-
-/**
- * The refusal that is about permission rather than about something being broken.
- *
- * ⚠️ 403 and nothing else. A 401 has already sent the page to the sign-in, and a 503 means this
- * installation runs no agent runtime — reading either as "you may not" would tell somebody they
- * lack a permission they actually have.
- */
-export function agentAccessDenied(error: unknown): boolean {
-  return error instanceof IntelRequestError && error.status === 403;
-}
-
-/**
- * The refusal that says this installation runs no agent runtime at all (#190).
- *
- * ⚠️ The code, not the 503: a runtime that exists but is down may answer 503 too, and reading that
- * as "this deployment has no agents" would explain a permanent absence to somebody who is looking
- * at an outage. Normally `/capabilities` has already said so and the page never asks — this is the
- * belt to that brace, for the probe that reached the door anyway.
- */
-export function agentRuntimeMissing(error: unknown): boolean {
-  return error instanceof IntelRequestError && error.code === "agent_runtime_not_configured";
-}
-
-/**
- * The failure that has a repair path, and a name for it (D29, #207, and the short half of #200).
- *
- * ⚠️ The code, not the 500. An agent whose Durable Object holds no key starts no run at all — the
- * runtime refuses before Gate is asked — and until #207 that arrived on this page as
- * `That did not work. Try again.` next to `Run now`, which is advice that cannot work: trying again
- * produces the same refusal forever. Naming it is what lets the page send the reader to the one
- * thing that fixes it, which is replacing the key in the agent's profile.
- *
- * ⚠️ `agent_key_unreadable` counts as the same case on purpose. Its cause is different — the
- * deployment's master secret was replaced — but the reader's move is identical, and a second
- * sentence saying the same thing differently would only be a second thing to keep in step.
- */
-/**
- * The refusal in the words the refusal itself used (#201).
- *
- * ⚠️ Only for an answer that carried a problem document — `code` is what proves it did. Everything
- * else that reaches here is a timeout, a proxy page or a parse failure, whose `message` is
- * `Intel responded with 502`: true, and no help to anybody. Those keep the generic sentence.
- *
- * The reason has to reach the screen because `Resume` can fail for reasons only the runtime knows —
- * "none of this agent's schedules has a next fire time" is one, and it is not something a reader
- * can guess from `That did not work. Try again.` The runtime words its problems to be read (see
- * `packages/agent`'s guard on model-facing errors), and the log tab already shows a run's failure
- * verbatim for the same reason.
- */
-export function agentProblemDetail(error: unknown): string | null {
-  return error instanceof IntelRequestError && error.code !== null ? error.message : null;
-}
-
-export function agentKeyMissing(error: unknown): boolean {
-  return (
-    error instanceof IntelRequestError &&
-    (error.code === "agent_key_missing" || error.code === "agent_key_unreadable")
-  );
-}

package/src/agent/agent-status-dot/agent-status-dot.ts

@@ -1,73 +0,0 @@
-import type { AgentRun } from "@/data/agent-runtime/agent-runtime.ts";
-
-/**
- * The five things an agent's head can have to say. There is deliberately no "idle": the absence of
- * a state is not a state, and writing it out at the most prominent place on the page was what #253
- * removed.
- */
-export type AgentStatusKind = "unknown" | "paused" | "running" | "failed" | "waiting";
-
-export interface AgentStatusReading {
-  kind: AgentStatusKind;
-  /** When the newest finished run ended — `null` while the agent has never finished one. */
-  lastRunAt: string | null;
-}
-
-export interface AgentStatusInput {
-  /** The run list could not be read. NOT the same as "no runs". */
-  runsUnreadable: boolean;
-  /** Newest first, the way the runtime answers. */
-  runs: AgentRun[];
-  paused: boolean;
-  /** Whether any schedule will fire — derived from the cron expressions, never asked. */
-  scheduled: boolean;
-}
-
-/**
- * What the head says about this agent, or `null` when it has nothing to say (#253).
- *
- * ⚠️ `null` is the ordinary case and the whole point of the ticket: an agent with no schedule, no
- * run in flight and no failure behind it is not "Idle · no scheduled run", it is a name. Two
- * sentences spelling out the same absence stood at the most prominent place on the page.
- *
- * ⚠️ It is NOT simply "has a schedule". An agent somebody drives from the chat can be running, can
- * be switched off, and can have failed its last run without ever carrying a schedule — hiding any
- * of those would trade two useless sentences for one missing fact. What disappears is the absence,
- * not the presence.
- *
- * ⚠️ An unreadable run list outranks everything and is its own state. A runtime that cannot be
- * reached says nothing about what the agent is doing, and reporting "waiting" for it would be wrong
- * exactly when something is wrong.
- *
- * ⚠️ Paused outranks running, the way the status line has always read it: a run still finishing
- * while the agent is switched off does not make the agent switched on, and the reader's next
- * question is why nothing starts afterwards.
- */
-export function agentStatus(input: AgentStatusInput): AgentStatusReading | null {
-  const finished = input.runs.find((run) => run.status !== "running") ?? null;
-  const lastRunAt = finished?.finishedAt ?? finished?.startedAt ?? null;
-
-  if (input.runsUnreadable) return { kind: "unknown", lastRunAt: null };
-  if (input.paused) return { kind: "paused", lastRunAt };
-  if (input.runs.some((run) => run.status === "running")) return { kind: "running", lastRunAt };
-  if (finished?.status === "failed") return { kind: "failed", lastRunAt };
-  if (input.scheduled) return { kind: "waiting", lastRunAt };
-  return null;
-}
-
-/**
- * How each state is drawn.
- *
- * ⚠️ Shape carries what colour cannot. This theme is monochrome apart from `destructive` (see
- * `styles.css`), so five states cannot be five hues without inventing colours the customer's own
- * theme would then fight — and colour alone is no information for a reader who cannot separate two
- * greys. Filled, hollow, dashed and moving are told apart without any hue at all, and the state is
- * in the trigger's accessible name regardless.
- */
-export const statusDotClass: Record<AgentStatusKind, string> = {
-  unknown: "border border-dashed border-muted-foreground",
-  paused: "bg-muted-foreground",
-  running: "bg-primary motion-safe:animate-pulse",
-  failed: "bg-destructive",
-  waiting: "border border-muted-foreground",
-};

package/src/agent/agent.tsx

@@ -1,507 +0,0 @@
-import type { AgentDefinition, AgentScheduleTarget, Node } from "@anchrd/intel-contract";
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-import { Pause, Play } from "lucide-react";
-import { useState } from "react";
-import { AgentCalendar } from "@/agent/agent-calendar/agent-calendar.tsx";
-import { AgentChat } from "@/agent/agent-chat/agent-chat.tsx";
-import { nextRunAt, useAgentDefinition } from "@/agent/agent-definition/agent-definition.ts";
-import { useEntryTitle } from "@/agent/agent-entry-title/agent-entry-title.ts";
-import { AgentLog } from "@/agent/agent-log/agent-log.tsx";
-import { AgentProfile } from "@/agent/agent-profile/agent-profile.tsx";
-import {
-  agentAccessDenied,
-  agentKeyMissing,
-  agentProblemDetail,
-  agentRuntimeMissing,
-  agentStateKey,
-  useAgentState,
-} from "@/agent/agent-state/agent-state.ts";
-import { agentStatus, statusDotClass } from "@/agent/agent-status-dot/agent-status-dot.ts";
-import { ActionSlot } from "@/app/action-slot/action-slot.tsx";
-import {
-  DropdownMenu,
-  DropdownMenuContent,
-  DropdownMenuItem,
-  DropdownMenuTrigger,
-} from "@/components/ui/dropdown-menu";
-import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/components/ui/tooltip";
-import { useCapabilities } from "@/hooks/use-capabilities.ts";
-import { useI18n } from "@/i18n/i18n-context.tsx";
-import { useIntelRouterContext } from "@/router/router-context.ts";
-import { useUserName } from "@/user-name/user-name.ts";
-
-const tabs = ["profile", "chat", "calendar", "log"] as const;
-type Tab = (typeof tabs)[number];
-
-/**
- * The agent's page: the lower of the shell's two bars, carrying this one agent's four views.
- *
- * ⚠️ The name, the menu, the status line and the two head actions all live in the SAME title line —
- * the one `TitleRow` draws for every open thing (#53). The status and the actions are portalled
- * into its slots rather than drawn again here, because an agent with a header of its own would be
- * the one kind of file whose rename sits somewhere else.
- *
- * ⚠️ One state query stands for the whole page, and it is also how the page learns whether this
- * reader may drive this agent at all: `/session` carries identity and no capabilities on purpose, so
- * a 403 from the runtime door is the only place the answer exists (#178). It is then rendered as an
- * answer — a sentence in the two tabs that would have needed it — rather than as a red failure.
- */
-export function AgentPanel({ node }: { node: Node }) {
-  const i18n = useI18n();
-  const [tab, setTab] = useState<Tab>("profile");
-  const agent = useAgentDefinition(node.id);
-  const state = useAgentState(node.id);
-  const denied = agentAccessDenied(state.error);
-  const capabilities = useCapabilities();
-
-  // An installation without an agent runtime (#190): the node from an earlier deployment still
-  // opens, but it explains itself instead of rendering four views whose every call would end in a
-  // 503. `/capabilities` is the answer; the probe's own `agent_runtime_not_configured` is the belt
-  // to that brace. ⚠️ Only an explicit `false` takes the page away — while the answer is still
-  // loading the tabs stand, because tearing down a rendered page over a pending request would blank
-  // the screen for every agent on every load.
-  if (capabilities.data?.agentRuntime === false || agentRuntimeMissing(state.error)) {
-    return <NoRuntime />;
-  }
-
-  return (
-    <>
-      <ActionSlot name="title-meta">
-        <AgentStatus agentId={node.id} definition={agent.definition} />
-      </ActionSlot>
-      <ActionSlot name="title-byline">
-        <AgentByline node={node} />
-      </ActionSlot>
-      <ActionSlot name="title-actions">
-        <AgentActions agentId={node.id} definition={agent.definition} />
-      </ActionSlot>
-      <Tabs
-        value={tab}
-        onValueChange={(value) => setTab(value as Tab)}
-        className="flex min-h-0 flex-1 flex-col gap-0"
-      >
-        {/* The file-specific bar. It stands under the title line and above the view it switches —
-            the order the flow screen's own switch already uses (#19). */}
-        <div className="border-b px-6 py-2">
-          <TabsList aria-label={i18n.t("agent.tabs")}>
-            {tabs.map((name) => (
-              <TabsTrigger key={name} value={name}>
-                {i18n.t(`agent.tab.${name}`)}
-              </TabsTrigger>
-            ))}
-          </TabsList>
-        </div>
-        <TabsContent value="profile" className="flex min-h-0 flex-col">
-          <AgentProfile node={node} agent={agent} />
-        </TabsContent>
-        {/* ⚠️ Each of the three below is mounted only while its own tab is open. The chat is the
-            reason: it holds a live SSE connection, and one kept open behind three other views is a
-            stream nobody is reading. The other two follow so that a switch back re-reads rather
-            than showing a run list from ten minutes ago. */}
-        <TabsContent value="chat" className="flex min-h-0 flex-col">
-          {tab === "chat" ? denied ? <NotForYou /> : <AgentChat agentId={node.id} /> : null}
-        </TabsContent>
-        <TabsContent value="calendar" className="flex min-h-0 flex-col">
-          {tab === "calendar" ? (
-            <AgentCalendar
-              definition={agent.definition}
-              now={new Date()}
-              // ⚠️ The same `state` the header reads, so the two cannot disagree about one agent —
-              // and the pause button writes its answer straight into this query key, so the note
-              // goes the moment somebody resumes, without this tab refetching (#203).
-              paused={state.data?.paused ?? false}
-            />
-          ) : null}
-        </TabsContent>
-        <TabsContent value="log" className="flex min-h-0 flex-col">
-          {tab === "log" ? denied ? <NotForYou /> : <AgentLog agentId={node.id} /> : null}
-        </TabsContent>
-      </Tabs>
-    </>
-  );
-}
-
-/**
- * Who made this agent — the first question anybody asks about one that works in folders with rights
- * of its own (#258).
- *
- * ⚠️ Provenance and nothing else. An agent does NOT run with its creator's rights: it has a Gate
- * Application of its own (D29), the assertion's subject is the agent, and Intel's grants on the
- * tree decide what a run may read and write. Only the TOOLS run on a human's connection, and that
- * is `delegatedBy` — a different field, in a different place on this page, on purpose. So this line
- * says "by", never "runs as", and it carries no permission wording that would imply otherwise.
- *
- * ⚠️ `ownerId` and not the current version's `createdBy`: the owner is written once, from the actor
- * who created the node, and never again — while `createdBy` moves to whoever saved last, which is a
- * different fact and belongs to a different question.
- *
- * ⚠️ Unresolvable means NO line, not "by —". Most ids are unresolvable today (see `useUserName`),
- * and an em dash under every foreign agent's name would be a row of furniture saying nothing.
- */
-function AgentByline({ node }: { node: Node }) {
-  const i18n = useI18n();
-  const name = useUserName(node.ownerId);
-  if (name === null) return null;
-
-  return (
-    <span className="block truncate text-xs text-muted-foreground" title={name}>
-      {i18n.t("agent.createdBy", { name })}
-    </span>
-  );
-}
-
-/**
- * What somebody without `agents/run` sees instead of the chat and the log.
- *
- * ⚠️ Muted text, not `role="alert"` and not the destructive colour. Nothing is broken and there is
- * nothing to retry: they may read this agent, they may not drive it. A red box would send them to
- * whoever runs the installation over a working system.
- */
-function NotForYou() {
-  const i18n = useI18n();
-  return (
-    <p className="m-auto max-w-md px-6 py-5 text-center text-sm text-muted-foreground">
-      {i18n.t("agent.notPermitted")}
-    </p>
-  );
-}
-
-/**
- * What an agent node from an earlier deployment shows where no runtime is configured (#190).
- *
- * ⚠️ The same muted sentence as `NotForYou`, and for the same reason: nothing is broken and there
- * is nothing to retry. The node and its definition are intact; the installation simply does not run
- * agents, which is the operator's choice, not the reader's problem to debug.
- */
-function NoRuntime() {
-  const i18n = useI18n();
-  return (
-    <p className="m-auto max-w-md px-6 py-5 text-center text-sm text-muted-foreground">
-      {i18n.t("agent.noRuntime")}
-    </p>
-  );
-}
-
-/**
- * Whether the agent is working, whether it is switched off, and when it next will be — as a dot
- * beside the name, and only when there is something to say (#253).
- *
- * ⚠️ A dot and not a sentence, and NOT ALWAYS a dot. What stood here was "Idle · no scheduled run"
- * — the absence of a state, spelled out twice, at the most prominent place on the page. `null` from
- * `agentStatus` is the ordinary case and renders nothing at all.
- *
- * ⚠️ The colour is never the only information. The state is the trigger's accessible NAME, the dot
- * itself is `aria-hidden`, and the shapes differ as well as the hues — see `statusDotClass`. A
- * reader who cannot separate two greys, and every reader who is listening rather than looking, gets
- * the same answer as everybody else.
- *
- * ⚠️ "Running" is read from the runtime's own run list, and its absence is NOT read as "idle" — a
- * runtime that cannot be reached says nothing about what the agent is doing.
- *
- * ⚠️ "Next run" is derived from the cron expressions rather than asked. The runtime arms one alarm
- * and publishes neither it nor a schedule, so this is the same reading `AgentCalendar` does — and
- * while the agent is paused it is not shown at all, because a paused agent will not run then.
- */
-export function AgentStatus({
-  agentId,
-  definition,
-}: {
-  agentId: string;
-  definition: AgentDefinition | null;
-}) {
-  const { data } = useIntelRouterContext();
-  const i18n = useI18n();
-  const state = useAgentState(agentId);
-  const runs = useQuery({
-    queryKey: ["agent-runs", agentId],
-    queryFn: () => data.listAgentRuns(agentId),
-    // A status dot is not worth a red screen: the runtime being unreachable is reported by the
-    // Log tab, which is the view that is actually about runs.
-    retry: false,
-  });
-  const next = nextRunAt(definition, new Date());
-  const status = agentStatus({
-    runsUnreadable: runs.isError,
-    runs: runs.data?.items ?? [],
-    paused: state.data?.paused ?? false,
-    scheduled: next !== null,
-  });
-  if (status === null) return null;
-
-  const when =
-    status.kind === "paused"
-      ? i18n.t("agent.pausedNoRuns")
-      : next
-        ? // ⚠️ Formatted in the SCHEDULE's zone and named with it (#228), not in the reader's.
-          // The agent fires at the hour its schedule says; showing that instant in the zone of
-          // whoever happens to be looking would put a different hour on screen from the one the
-          // agent keeps, and the difference only surfaces as "it ran at the wrong time".
-          i18n.t("agent.nextRun", {
-            when: new Intl.DateTimeFormat(i18n.locale, {
-              dateStyle: "medium",
-              timeStyle: "short",
-              timeZone: next.timezone,
-            }).format(next.at),
-            zone: next.timezone,
-          })
-        : null;
-  // ⚠️ A past instant, so it is read in the reader's own zone and names none: unlike a schedule,
-  // which fires in the zone it carries, a finished run happened at one moment for everybody.
-  const last =
-    status.lastRunAt === null
-      ? null
-      : i18n.t("agent.lastRun", {
-          when: new Intl.DateTimeFormat(i18n.locale, {
-            dateStyle: "medium",
-            timeStyle: "short",
-          }).format(new Date(status.lastRunAt)),
-        });
-  const label = [i18n.t(`agent.status.${status.kind}`), last, when].filter(Boolean).join(" · ");
-
-  return (
-    <TooltipProvider delayDuration={300}>
-      <Tooltip>
-        {/* A real button, so the dot is reached by Tab and opened without a pointer. */}
-        <TooltipTrigger
-          type="button"
-          aria-label={label}
-          className="inline-flex items-center rounded-full p-1 outline-none focus-visible:ring-2 focus-visible:ring-ring"
-        >
-          <span
-            aria-hidden="true"
-            className={`block size-2.5 rounded-full ${statusDotClass[status.kind]}`}
-          />
-        </TooltipTrigger>
-        <TooltipContent className="max-w-xs">{label}</TooltipContent>
-      </Tooltip>
-    </TooltipProvider>
-  );
-}
-
-/**
- * Pause, and run now.
- *
- * ⚠️ Both are shown even where they cannot be used, against this repo's usual rule that an
- * inapplicable action is absent. The rule is about actions that do not APPLY to a kind — a folder
- * has no retrieval mode. These two apply to every agent, and a head that quietly dropped them would
- * hide from the reader that the agent can be stopped at all. Disabled always carries its reason on
- * the screen, pointed at by `aria-describedby`, so the keyboard hears it too.
- *
- * ⚠️ "Run now" fires a schedule the agent already has; it does not invent one. A run acts with the
- * AGENT's Gate token, so a free choice of target here would let anybody who may drive the agent read
- * with its grants instead of their own — the runtime refuses an undeclared target for that reason,
- * and this menu offers only what it would accept.
- */
-export function AgentActions({
-  agentId,
-  definition,
-}: {
-  agentId: string;
-  definition: AgentDefinition | null;
-}) {
-  const { data } = useIntelRouterContext();
-  const i18n = useI18n();
-  const queryClient = useQueryClient();
-  const state = useAgentState(agentId);
-  const denied = agentAccessDenied(state.error);
-  const paused = state.data?.paused ?? false;
-
-  const toggle = useMutation({
-    mutationFn: async () =>
-      paused ? await data.resumeAgent(agentId) : await data.pauseAgent(agentId),
-    // The answer is the new state, so the cache is set from it rather than refetched: a round trip
-    // would leave a window in which the button still offers what was just done.
-    onSuccess: (next) => queryClient.setQueryData(agentStateKey(agentId), next),
-  });
-  const runNow = useMutation({
-    mutationFn: async (target: AgentScheduleTarget) => await data.runAgentNow(agentId, target),
-    // The run is worked off the runtime's alarm, so it appears in the list rather than in this
-    // answer. Invalidating is what puts it on the Log tab and in the status line.
-    onSuccess: () => queryClient.invalidateQueries({ queryKey: ["agent-runs", agentId] }),
-  });
-
-  /**
-   * ⚠️ One entry per TARGET, not per schedule (#323). Two schedules on the same flow — 08:00 and
-   * 17:00 — are the ordinary configuration this list exists for, and they produced two menu items
-   * nobody could choose between: both start the same run, and the time that tells them apart is
-   * not on either. They also shared a React key.
-   *
-   * Deduplicating is the honest reading of what this button does. "Run now" fires the target
-   * immediately; the schedule is the thing it is deliberately NOT waiting for, so which of the two
-   * entries somebody picked could never have meant anything. The alternative — two entries labelled
-   * with their cron — offers a choice that has no consequence.
-   */
-  const targets = [
-    ...new Map(
-      (definition?.schedules ?? []).map((schedule) => [
-        `${schedule.target.kind}:${schedule.target.id}`,
-        schedule.target,
-      ]),
-    ).values(),
-  ];
-  const reason = denied
-    ? i18n.t("agent.notPermitted")
-    : state.isError
-      ? i18n.t("agent.status.unknown")
-      : null;
-  const runReason =
-    reason ??
-    (paused
-      ? i18n.t("agent.runNowPaused")
-      : targets.length === 0
-        ? i18n.t("agent.runNowNoTarget")
-        : null);
-  const failure = toggle.error ?? runNow.error;
-
-  return (
-    <span className="flex items-center gap-2">
-      {/* ⚠️ `sr-only` and no longer beside the buttons (#253): the reason belongs in the tooltip of
-          the control it disables, not as a sentence in the title line. But it stays IN THE
-          ACCESSIBILITY TREE — `hidden` or `display: none` would leave `aria-describedby` pointing at
-          nothing, and Radix puts the tooltip's own content there only while it is open. So the words
-          are here for the keyboard and on the hover for the pointer, and never in the bar. */}
-      {runReason ? (
-        <span id="agent-actions-reason" className="sr-only">
-          {runReason}
-        </span>
-      ) : null}
-      {/* ⚠️ An agent with no key in its Durable Object fails every run the same way forever, so
-          "try again" is advice that cannot work (#200). The one refusal with a repair path says
-          what the repair is, and names where it lives — the profile, not this bar (D29).
-
-          ⚠️ Every other refusal is shown in its OWN words where it brought any (#201). `Resume`
-          fails for reasons only the runtime knows, and "that did not work" turns each of them into
-          the same shrug — which is how a resume that could not arm the alarm looked like one that
-          simply needed another click. */}
-      {failure ? (
-        <span role="alert" className="text-xs text-destructive max-sm:sr-only sm:inline">
-          {agentKeyMissing(failure)
-            ? i18n.t("agent.keyMissing")
-            : (agentProblemDetail(failure) ?? i18n.t("agent.actionFailed"))}
-        </span>
-      ) : null}
-      <WhyDisabled reason={reason}>
-        <button
-          type="button"
-          onClick={() => toggle.mutate()}
-          disabled={reason !== null || state.isPending || toggle.isPending}
-          aria-busy={toggle.isPending}
-          {...(reason ? { "aria-describedby": "agent-actions-reason" } : {})}
-          className="inline-flex items-center gap-1.5 rounded-md border px-2.5 py-1.5 text-sm outline-none hover:bg-muted focus-visible:ring-2 focus-visible:ring-ring disabled:opacity-50"
-        >
-          {paused ? (
-            <Play aria-hidden="true" className="size-4" />
-          ) : (
-            <Pause aria-hidden="true" className="size-4" />
-          )}
-          {i18n.t(paused ? "agent.resume" : "agent.pause")}
-        </button>
-      </WhyDisabled>
-      <WhyDisabled reason={runReason}>
-        <RunNow
-          targets={targets}
-          disabled={runReason !== null || runNow.isPending}
-          busy={runNow.isPending}
-          describedBy={runReason ? "agent-actions-reason" : undefined}
-          start={(target) => runNow.mutate(target)}
-        />
-      </WhyDisabled>
-    </span>
-  );
-}
-
-/**
- * The reason a control is shut, on its own hover instead of beside it (#253).
- *
- * ⚠️ The wrapping span is not decoration. A disabled button fires no pointer events, so a trigger
- * bound directly to it never opens — the same trick the profile's disabled "Add contact" needs, and
- * the reason both keep an `sr-only` paragraph for `aria-describedby` beside the tooltip.
- *
- * ⚠️ The wrapper is ALWAYS here, and only the content comes and goes. A reason appears and vanishes
- * as the state query settles, and a version of this that returned the bare child when there was
- * nothing to say re-created the button on every such change — which throws away its focus and, in a
- * test, leaves whoever grabbed it holding a node that is no longer on screen. Without content Radix
- * opens nothing at all, so the empty case costs a span and shows no bubble.
- */
-function WhyDisabled({ reason, children }: { reason: string | null; children: React.ReactNode }) {
-  return (
-    <TooltipProvider delayDuration={300}>
-      <Tooltip>
-        <TooltipTrigger asChild>
-          <span className="inline-flex">{children}</span>
-        </TooltipTrigger>
-        {reason === null ? null : <TooltipContent className="max-w-xs">{reason}</TooltipContent>}
-      </Tooltip>
-    </TooltipProvider>
-  );
-}
-
-/**
- * ⚠️ One schedule runs straight away; several open a menu. A button that silently picked the first
- * of three targets would run the wrong thing at a moment somebody chose deliberately, and a menu in
- * front of a single obvious target is a click that answers nothing.
- */
-function RunNow({
-  targets,
-  disabled,
-  busy,
-  describedBy,
-  start,
-}: {
-  targets: AgentScheduleTarget[];
-  disabled: boolean;
-  busy: boolean;
-  describedBy: string | undefined;
-  start(target: AgentScheduleTarget): void;
-}) {
-  const i18n = useI18n();
-  const only = targets.length === 1 ? targets[0] : undefined;
-  const className =
-    "inline-flex items-center gap-1.5 rounded-md border px-2.5 py-1.5 text-sm outline-none hover:bg-muted focus-visible:ring-2 focus-visible:ring-ring disabled:opacity-50";
-
-  if (targets.length > 1) {
-    return (
-      <DropdownMenu>
-        <DropdownMenuTrigger asChild>
-          <button
-            type="button"
-            disabled={disabled}
-            aria-busy={busy}
-            {...(describedBy ? { "aria-describedby": describedBy } : {})}
-            className={className}
-          >
-            <Play aria-hidden="true" className="size-4" />
-            {i18n.t("agent.runNow")}
-          </button>
-        </DropdownMenuTrigger>
-        <DropdownMenuContent align="end">
-          {targets.map((target) => (
-            <DropdownMenuItem key={`${target.kind}:${target.id}`} onSelect={() => start(target)}>
-              <TargetLabel target={target} />
-            </DropdownMenuItem>
-          ))}
-        </DropdownMenuContent>
-      </DropdownMenu>
-    );
-  }
-
-  return (
-    <button
-      type="button"
-      onClick={() => only && start(only)}
-      disabled={disabled || !only}
-      aria-busy={busy}
-      {...(describedBy ? { "aria-describedby": describedBy } : {})}
-      className={className}
-    >
-      <Play aria-hidden="true" className="size-4" />
-      {i18n.t("agent.runNow")}
-    </button>
-  );
-}
-
-function TargetLabel({ target }: { target: AgentScheduleTarget }) {
-  const { title } = useEntryTitle(target.id, target.kind === "flow");
-  return <span className="truncate">{title}</span>;
-}