@anchrd/intel-ui 0.17.0 → 0.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anchrd/intel-ui",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "type": "module",
   "license": "UNLICENSED",
   "repository": {
@@ -33,7 +33,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@anchrd/intel-contract": "^0.11.0",
+    "@anchrd/intel-contract": "^0.12.0",
     "@assistant-ui/react": "^0.15.4",
     "@assistant-ui/react-ai-sdk": "^1.4.4",
     "@blocknote/core": "^0.52.1",

package/src/agent/agent-calendar/agent-calendar.tsx

@@ -30,24 +30,40 @@ const PerSchedule = 5;
  * ⚠️ And only for a zone somebody SET. `useChosenTimezone` answers `null` where nothing was chosen,
  * and then this screen is exactly what it was — no browser guess dressed up as "your time", and no
  * second time on every row for a reader who never asked for one.
+ *
+ * ⚠️ A paused agent gets a sentence over the list, because this is the tab somebody opens to find
+ * out WHETHER something runs (#203). Without it two places on one page said opposite things: the
+ * header read `Paused · no schedule fires`, and this list went on naming the next five times as if
+ * they would happen. The list is kept rather than emptied — what the agent WOULD do is still the
+ * answer to "what did I switch off" — but it may not read as a plan.
  */
 export function AgentCalendar({
   definition,
   now,
+  paused,
 }: {
   definition: AgentDefinition | null;
   // Handed in rather than read from the clock, so the view is a function of its input and a test
   // does not have to travel in time to assert on it.
   now: Date;
+  // ⚠️ Handed in for the same reason, and not read from `useAgentState` here: that hook needs the
+  // router context and a query client, and reaching for it would turn every test of this view into
+  // an integration test of two providers. The caller already holds the state for the header.
+  paused: boolean;
 }) {
   const i18n = useI18n();
   const mine = useChosenTimezone();
   const schedules = definition?.schedules ?? [];
   const upcoming = schedules
-    .flatMap((schedule) =>
+    // ⚠️ The schedule's own position rides along, and it is the only thing that separates two
+    // LITERALLY identical entries (#323). Two schedules with the same cron, zone and target are a
+    // definition somebody can save, and every other part of the key would be equal for them —
+    // including the fire time, which is computed from exactly those three.
+    .flatMap((schedule, position) =>
       nextCronFires(schedule.cron, now, PerSchedule, schedule.timezone).map((at) => ({
         at,
         schedule,
+        position,
       })),
     )
     .sort((left, right) => left.at.getTime() - right.at.getTime());
@@ -94,6 +110,15 @@ export function AgentCalendar({
       {/* ⚠️ An agent with no schedule shows an empty calendar and nothing else (#254). The sentence
           that used to stand here described the emptiness the reader is already looking at; the two
           other states below are different, because each of them is a fact the list cannot show. */}
+      {/* ⚠️ Only where there is a list to qualify. A paused agent WITHOUT schedules shows the same
+          empty calendar it always did — the two states have to stay distinguishable, and a sentence
+          about times that do not happen, over no times at all, describes nothing. Same reason it
+          does not appear over `calendarUnreadable`: that one already says nothing is planned. */}
+      {paused && upcoming.length > 0 ? (
+        <p role="status" className="mt-4 rounded-lg border bg-muted px-4 py-3 text-sm">
+          {i18n.t("agent.calendarPaused")}
+        </p>
+      ) : null}
       {schedules.length === 0 ? null : upcoming.length === 0 ? (
         // Schedules exist and none of them fires: every expression is unusable. A different answer
         // from "no schedules", because it is a different problem and needs a different fix.
@@ -104,7 +129,7 @@ export function AgentCalendar({
         <ol className="mt-4 space-y-2">
           {upcoming.map((entry) => (
             <li
-              key={`${entry.schedule.cron}@${entry.schedule.timezone}:${entry.schedule.target.id}:${entry.at.toISOString()}`}
+              key={`${entry.position}:${entry.schedule.cron}@${entry.schedule.timezone}:${entry.schedule.target.id}:${entry.at.toISOString()}`}
               className="flex flex-wrap items-center gap-3 rounded-lg border bg-card px-4 py-3 text-sm"
             >
               <CalendarClock aria-hidden="true" className="size-4 shrink-0 text-muted-foreground" />

package/src/agent/agent-profile/agent-profile.tsx

@@ -584,6 +584,20 @@ function ToolsSection({
         <ul className="space-y-2">
           {selected.map((handle) => {
             const known = servers.data?.items.find((server) => server.handle === handle);
+            /**
+             * ⚠️ Silence about the question is not a negative answer to it (#350). While the list is
+             * loading — and after a failed read — `servers.data` is `undefined`, and `known` is
+             * then falsy for exactly the same reason as "the portal answered and this handle was
+             * not in it". Drawn as one, a row said `You no longer reach this server` for half a
+             * second on every visit: a statement about a REVOKED permission, and the sentence that
+             * makes somebody re-delegate, sign in to the portal again, or open a ticket.
+             *
+             * It is the same rule `adapters/tools` keeps for `portalConnected` and `reached` on the
+             * server side, where `packages/api/CLAUDE.md` spells it out — a missing field is a
+             * reason to say less, never to refuse more. This is the one place that said it the
+             * other way round.
+             */
+            const answered = servers.isSuccess;
             return (
               <li
                 key={handle}
@@ -597,11 +611,15 @@ function ToolsSection({
                 </span>
                 {/* A server the signed-in person no longer reaches still stands in the definition,
                     and saying so beats drawing it as if it worked. The agent gets nothing from it
-                    either — the catalog is cut against what the delegator reaches. */}
+                    either — the catalog is cut against what the delegator reaches. But only once
+                    the portal has actually answered: until then the row carries the handle and
+                    nothing else, which is everything that is known about it. */}
                 <span className="text-xs text-muted-foreground">
                   {known
                     ? i18n.t("tools.toolCount", { count: String(known.toolCount) })
-                    : i18n.t("agent.toolServerUnavailable")}
+                    : answered
+                      ? i18n.t("agent.toolServerUnavailable")
+                      : null}
                 </span>
                 <button
                   type="button"

package/src/agent/agent.tsx

@@ -104,7 +104,14 @@ export function AgentPanel({ node }: { node: Node }) {
         </TabsContent>
         <TabsContent value="calendar" className="flex min-h-0 flex-col">
           {tab === "calendar" ? (
-            <AgentCalendar definition={agent.definition} now={new Date()} />
+            <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">
@@ -314,7 +321,25 @@ export function AgentActions({
     onSuccess: () => queryClient.invalidateQueries({ queryKey: ["agent-runs", agentId] }),
   });
 
-  const targets = definition?.schedules.map((schedule) => schedule.target) ?? [];
+  /**
+   * ⚠️ 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

package/src/board/board-gantt/board-gantt.ts

@@ -489,7 +489,7 @@ export type GanttEdit = "move" | "start" | "end";
  *
  * ⚠️ It answers `null` for a gesture that changed no date, and that is half of what it is for. A
  * bar picked up and put back is the commonest drag there is; sent anyway it would mint a version,
- * bump the board and stand in the audit as work that did not happen — the same rule `moveFromDrop`
+ * bump the board and stand in the audit as work that did not happen — the same rule `dropOutcome`
  * holds for a card dropped on its own place.
  *
  * ⚠️ A move shifts the dates the task HAS. A task with only a due date is drawn as the single day it

package/src/board/board-kanban/board-kanban.ts

@@ -3,22 +3,42 @@ import type { MoveTask } from "@/board/board-data/board-data.types.ts";
 import type { KanbanDrop } from "@/components/ui/kanban.tsx";
 
 /**
- * What a drop means, as the one `board_task_move` it is worth.
+ * What a drop DID: the one `board_task_move` it is worth, or the reason there is none.
  *
+ * ⚠️ Three answers rather than a move or a `null`, and the third one is the whole of
+ * anchrd/intel#345. Two of the ways a drag ends write nothing, and they are not the same event to
+ * whoever is being told about it: a card let go on its own place stayed put, and a card let go over
+ * a lane the board cannot write into was REFUSED. Announced as one — or, as it was, announced as a
+ * move that never happened — the difference is exactly the one a reader needs, because since
+ * anchrd/intel#315 the announcement is the only feedback the keyboard path has.
+ */
+export type DropOutcome =
+  // ⚠️ `status` is optional on the wire — a move may be a reparent and name no column — but a drop
+  // always lands in a lane and always names it. Narrowed here so the sentence a reader hears can
+  // name the lane the card really went into rather than the one the pointer was last over.
+  | { kind: "move"; move: MoveTask & { status: string } }
+  // The status the drop resolved to: drawn by the board, and not one it may write into. Carried
+  // rather than looked up again, so the sentence a reader hears names the lane that said no.
+  | { kind: "refused"; status: string }
+  // Nothing to write and nothing refused: the card ends where it began, or it was let go over
+  // something the board does not draw.
+  | { kind: "unchanged" };
+
+/**
  * ⚠️ Neighbours, never an index. The server mints the fractional key between the two tasks named
  * here (#285), so one drag writes one task and renumbers nothing — the reason a board is addressed
  * by task id and not by position at all. A UI that sent a position would have to send the whole
  * column with it to be unambiguous.
  *
- * ⚠️ `null` for a drag that changed nothing, and that is half the point of this function. dnd-kit
- * reports a drop wherever the pointer was let go, including back on the card's own place; sending
- * a move for that would write a version, bump the board and show up in the audit as work that did
- * not happen.
+ * ⚠️ Nothing to write for a drag that changed nothing, and that is half the point of this function.
+ * dnd-kit reports a drop wherever the pointer was let go, including back on the card's own place;
+ * sending a move for that would write a version, bump the board and show up in the audit as work
+ * that did not happen.
  *
  * `lanes` is what the board DRAWS — root tasks per column, in order. Subtasks are not lane cards
  * (they are a counter on their parent), so they are not in it and cannot be dropped on either.
  */
-export function moveFromDrop(
+export function dropOutcome(
   drop: KanbanDrop,
   lanes: Map<string, BoardTask[]>,
   byId: Map<string, BoardTask>,
@@ -27,22 +47,39 @@ export function moveFromDrop(
   // not be somewhere a card can be MOVED. The server refuses a task in a status the board does not
   // have, so a drop there would be a refusal, an invalidation and no word to the reader.
   writable: ReadonlySet<string>,
-): MoveTask | null {
+): DropOutcome {
   const active = byId.get(drop.activeId);
   // ⚠️ Let go over itself is the commonest drag of all — a click that travelled five pixels — and
   // it has to be nothing before any of the arithmetic below runs. Read as "dropped on a card", it
   // would compute a landing place for a card that never left, which is the shape of a write that
   // says work happened.
-  if (drop.overId === null || drop.overId === drop.activeId || active === undefined) return null;
+  //
+  // ⚠️ And it is `unchanged` even when the card stands in a lane that cannot be written into: what
+  // happened there is that a card came back to its own place, not that a lane turned a card away.
+  if (drop.overId === null || drop.overId === drop.activeId || active === undefined)
+    return { kind: "unchanged" };
 
   // The drop landed either on a column's empty space — then its id is the status — or on a card,
   // and then the column is that card's. A card the board does not draw (a subtask, or one filtered
   // away) resolves to neither and the drag is a no-op rather than a guess.
   const overTask = byId.get(drop.overId);
   const status = overTask?.status ?? (lanes.has(drop.overId) ? drop.overId : null);
-  if (status === null || !writable.has(status)) return null;
+  if (status === null) return { kind: "unchanged" };
 
   const lane = lanes.get(status) ?? [];
+  // ⚠️ "Is this a card the board draws" is read BEFORE the refusal, and the order is the whole of
+  // it. `byId` holds subtasks too — they are counters on their parent, not lane cards — and one of
+  // them left in a status the board no longer lists resolves to a status without ever standing in
+  // that lane. Refused first, such a drop would be announced as a lane turning the card away while
+  // no lane was involved at all. Nothing renders a subtask as a droppable today; this is a guard on
+  // the order, so that the day one does, the sentence does not start lying.
+  if (overTask !== undefined && !lane.some((task) => task.id === overTask.id))
+    return { kind: "unchanged" };
+  // ⚠️ Refused BEFORE the request, and said so. The lane is drawn and its cards are still sortables,
+  // so a drop lands here on both the pointer path and the keyboard one; the server would answer a
+  // task in a status the board does not have with a refusal.
+  if (!writable.has(status)) return { kind: "refused", status };
+
   const from = lane.findIndex((task) => task.id === active.id);
   const rest = lane.filter((task) => task.id !== active.id);
 
@@ -51,8 +88,8 @@ export function moveFromDrop(
     // Let go over the column rather than over a card: the end of it.
     landing = rest.length;
   } else {
+    // In the lane (checked above) and not the active card (checked at the top), so it is in `rest`.
     const overIndex = rest.findIndex((task) => task.id === overTask.id);
-    if (overIndex === -1) return null;
     // Dragged downwards inside its own column, the card takes the place BELOW the one it was let go
     // over — the same reading `arrayMove` has, and the one the pointer suggests. Every other case
     // puts it above.
@@ -61,13 +98,16 @@ export function moveFromDrop(
   }
 
   // Re-inserting where it came from is the arrangement it already had.
-  if (from !== -1 && landing === from) return null;
+  if (from !== -1 && landing === from) return { kind: "unchanged" };
 
   return {
-    taskId: active.id,
-    status,
-    afterTaskId: rest[landing - 1]?.id ?? null,
-    beforeTaskId: rest[landing]?.id ?? null,
+    kind: "move",
+    move: {
+      taskId: active.id,
+      status,
+      afterTaskId: rest[landing - 1]?.id ?? null,
+      beforeTaskId: rest[landing]?.id ?? null,
+    },
   };
 }
 

package/src/board/board-kanban/board-kanban.tsx

@@ -12,7 +12,7 @@ import {
   KanbanProvider,
 } from "@/components/ui/kanban.tsx";
 import { useI18n } from "@/i18n/i18n-context.tsx";
-import { moveFromDrop, subtaskCount } from "./board-kanban.ts";
+import { dropOutcome, subtaskCount } from "./board-kanban.ts";
 
 /**
  * The board as lanes (anchrd/intel#286).
@@ -98,6 +98,33 @@ export function BoardKanban({ board, select, showArchived }: BoardViewProps) {
     [lanes],
   );
 
+  /**
+   * What a finished drag is announced as — and it is the OUTCOME that is announced, not what the
+   * pointer was last over (anchrd/intel#345).
+   *
+   * ⚠️ Asked of the same function the write is asked of, which is the point: a second reading of a
+   * drop would be a second opinion about it, and the one a reader hears would be the one nothing
+   * checks. Two of the three answers write nothing, and each says so in its own words — a lane that
+   * cannot take the card names itself, and a card that came back to its own place says it stayed.
+   * Announced as "dropped into X" (which is what all three used to say), a keyboard user who never
+   * sees the card jump has nothing to correct it with.
+   */
+  const dropped = (activeId: string, overId: string | null) => {
+    const active = board.byId.get(activeId);
+    const task = active?.title ?? "";
+    const from = columnName(active?.status ?? "", columns);
+    const outcome = dropOutcome({ activeId, overId }, lanes, board.byId, writable);
+    if (outcome.kind === "move")
+      return i18n.t("board.dnd.end", { task, lane: columnName(outcome.move.status, columns) });
+    if (outcome.kind === "refused")
+      return i18n.t("board.dnd.endRefused", {
+        task,
+        lane: columnName(outcome.status, columns),
+        from,
+      });
+    return i18n.t("board.dnd.endUnchanged", { task, lane: from });
+  };
+
   const card = (task: BoardTask) => (
     <BoardCardBody
       task={task}
@@ -123,28 +150,31 @@ export function BoardKanban({ board, select, showArchived }: BoardViewProps) {
               lane: over === null ? "" : laneName(String(over.id), board, columns),
             }),
           onDragEnd: ({ active, over }) =>
-            i18n.t("board.dnd.end", {
-              task: board.byId.get(String(active.id))?.title ?? "",
-              lane: over === null ? "" : laneName(String(over.id), board, columns),
-            }),
+            dropped(String(active.id), over === null ? null : String(over.id)),
           onDragCancel: ({ active }) =>
             i18n.t("board.dnd.cancel", { task: board.byId.get(String(active.id))?.title ?? "" }),
         }}
+        instructions={i18n.t("board.dnd.instructions")}
         overlay={(activeId) => {
           const task = board.byId.get(activeId);
           return task ? (
-            <div className="w-72 rounded-lg border bg-card p-3 shadow-lg ring-2 ring-ring">
+            <div
+              data-slot="board-card-overlay"
+              className="w-72 rounded-lg border bg-card p-3 shadow-lg ring-2 ring-ring"
+            >
               {card(task)}
             </div>
           ) : null;
         }}
         // ⚠️ Exactly one write per drag, and only when the card actually went somewhere.
-        // `moveFromDrop` answers `null` for a drop back onto its own place, and the mutation names
-        // the NEIGHBOURS rather than an index — the server mints the order key between them, so one
-        // drag writes one task and the other cards are not touched (#285).
+        // `dropOutcome` answers with something other than a move for a drop back onto its own place
+        // and for a lane the board cannot write into, and the mutation names the NEIGHBOURS rather
+        // than an index — the server mints the order key between them, so one drag writes one task
+        // and the other cards are not touched (#285). The same answer is what the reader is told
+        // about (anchrd/intel#345), so the sentence and the write can never drift apart.
         onDrop={(drop) => {
-          const move = moveFromDrop(drop, lanes, board.byId, writable);
-          if (move) board.move.mutate(move);
+          const outcome = dropOutcome(drop, lanes, board.byId, writable);
+          if (outcome.kind === "move") board.move.mutate(outcome.move);
         }}
       >
         {(column) => (
@@ -171,18 +201,27 @@ export function BoardKanban({ board, select, showArchived }: BoardViewProps) {
                 <KanbanCard
                   key={task.id}
                   id={task.id}
-                  dragLabel={i18n.t("board.dragCard", { task: task.title })}
+                  roleDescription={i18n.t("board.card.roleDescription")}
                 >
-                  {/* Two controls, each with a name of its own: the handle beside this one drags,
-                      this one opens. The pointer sensor's four-pixel threshold is what keeps a
-                      click on it from counting as a drag of nothing. */}
-                  <button
-                    type="button"
-                    className="w-full rounded text-left outline-none focus-visible:ring-2 focus-visible:ring-ring"
-                    onClick={() => select(task.id)}
-                  >
-                    {card(task)}
-                  </button>
+                  {/* ⚠️ ONE control per card, and it means two things — click or Enter opens the
+                      task, Space picks it up to be moved by the arrow keys (anchrd/intel#315).
+                      `control` is what makes the second half true: it carries dnd-kit's activator
+                      ref, so the keyboard sensor accepts a key press here and nowhere else in the
+                      card, and the `aria-roledescription`/`aria-describedby` that say so.
+
+                      The pointer sensor's four-pixel threshold is what keeps a click from counting
+                      as a drag of nothing. */}
+                  {({ ref, ...control }) => (
+                    <button
+                      type="button"
+                      ref={ref}
+                      {...control}
+                      className="w-full rounded text-left outline-none focus-visible:ring-2 focus-visible:ring-ring"
+                      onClick={() => select(task.id)}
+                    >
+                      {card(task)}
+                    </button>
+                  )}
                 </KanbanCard>
               ))}
               {(lanes.get(column.id) ?? []).length === 0 ? (
@@ -200,12 +239,19 @@ export function BoardKanban({ board, select, showArchived }: BoardViewProps) {
   );
 }
 
+// What stands over a lane: the column's name, and the raw status id for a lane the board no longer
+// lists — the same fallback `labelOf` makes, so one status is not called two things on one screen.
+function columnName(statusId: string, columns: { id: string; name: string }[]): string {
+  return columns.find((column) => column.id === statusId)?.name ?? statusId;
+}
+
+// What a drag is currently OVER, read as a lane: a card answers with its own lane, a column with
+// itself. Only the running commentary needs this — what a finished drag is announced as comes from
+// the outcome, not from the thing under the pointer (anchrd/intel#345).
 function laneName(
   overId: string,
   board: BoardViewProps["board"],
   columns: { id: string; name: string }[],
 ): string {
-  const task = board.byId.get(overId);
-  const statusId = task?.status ?? overId;
-  return columns.find((column) => column.id === statusId)?.name ?? statusId;
+  return columnName(board.byId.get(overId)?.status ?? overId, columns);
 }

package/src/components/ui/kanban.tsx

@@ -2,6 +2,7 @@ import {
   type Announcements,
   closestCorners,
   DndContext,
+  type DraggableAttributes,
   DragOverlay,
   type DragStartEvent,
   KeyboardSensor,
@@ -42,13 +43,14 @@ import { cn } from "@/lib/utils";
  * ⚠️ **The screen reader announcements are handed in.** The originals are English string literals
  * in the component; Intel speaks three languages and its text comes from `useI18n()`.
  *
- * ⚠️ **The card is not itself a `role="button"`.** The original spread `useSortable().attributes`
- * onto the card, which contributes `role="button"` and `tabIndex={0}` — and a card that also has to
- * be OPENED then holds a real button inside that one. Two tab stops computing the same accessible
- * name from the same contents, and an Enter that means "start dragging" on the outside and "open
- * this" on the inside. Split instead: the card keeps `listeners`, so a pointer can still drag it
- * from anywhere, and `attributes` moves to a handle that is the one tab stop for dragging and says
- * so.
+ * ⚠️ **The card is not itself a `role="button"`, and it holds exactly ONE tab stop.** The original
+ * spread `useSortable().attributes` onto the card, which contributes `role="button"` and
+ * `tabIndex={0}` — and a card that also has to be OPENED then holds a real button inside that one:
+ * two tab stops computing the same accessible name from the same contents, and an Enter that means
+ * "start dragging" outside and "open this" inside (anchrd/intel#286). This version keeps the
+ * `listeners` on the card so a pointer still drags it from anywhere, and hands the ACTIVATOR to the
+ * caller's own control instead of minting a second button beside it (anchrd/intel#315). What
+ * separates the two meanings is then the key, not the element: see `KanbanProvider`.
  */
 
 export interface KanbanColumn {
@@ -112,16 +114,33 @@ export function KanbanCards({ id, children }: { id: string; children: ReactNode
   );
 }
 
+/**
+ * What a card hands to the one control inside it: the activator ref and dnd-kit's ARIA attributes.
+ *
+ * ⚠️ It is spread onto a control the CALLER renders, which is the whole point — the alternative is
+ * a handle of the primitive's own beside it, and that is the second tab stop anchrd/intel#315 is
+ * about. `role` and `tabIndex` are in here and are what a native `<button>` already is; what is not
+ * already there is `aria-roledescription` and the `aria-describedby` pointing at dnd-kit's keyboard
+ * instructions, and those are the half a reader needs to be told the control can also be picked up.
+ */
+export type KanbanCardControl = DraggableAttributes & {
+  ref: (node: HTMLElement | null) => void;
+};
+
 export function KanbanCard({
   id,
-  dragLabel,
+  roleDescription,
   children,
   className,
 }: {
   id: string;
-  // What the drag handle is called. Handed in because only the caller knows what the card is of.
-  dragLabel: string;
-  children: ReactNode;
+  // What a reader is told this card IS, past its accessible name — dnd-kit's `aria-roledescription`,
+  // whose own default is the English literal "draggable". Handed in because text comes from
+  // `useI18n()` and only the caller has it.
+  roleDescription: string;
+  // A function, not a node: the one control in a card has to receive `control`, and a primitive that
+  // rendered its own control instead would be back to two tab stops.
+  children: (control: KanbanCardControl) => ReactNode;
   className?: string;
 }) {
   const {
@@ -132,22 +151,24 @@ export function KanbanCard({
     transition,
     transform,
     isDragging,
-  } = useSortable({ id });
+  } = useSortable({ id, attributes: { roleDescription } });
   return (
     <div
       ref={setNodeRef}
       style={{ transition, transform: CSS.Transform.toString(transform) }}
       // ⚠️ `listeners` here, `attributes` NOT. The pointer sensor has to see a press anywhere on the
       // card — a kanban whose cards can only be dragged by a grip is a kanban nobody drags — but
-      // `attributes` is what carries `role="button"` and `tabIndex`, and those on the card would
-      // wrap the control that OPENS it in a second button. Pointer drag from the whole card,
-      // keyboard drag from the handle, one tab stop each.
+      // `attributes` carries `role="button"` and `tabIndex`, and those on the card would wrap the
+      // control that OPENS it in a second button.
       //
-      // ⚠️ The split only holds because the handle registers itself as the ACTIVATOR below. Without
-      // that, `listeners` on this element make every Enter and Space inside the card a drag: the
-      // key handler bubbles up from whatever is focused, `KeyboardSensor` accepts it and calls
-      // `preventDefault()`, and the button that opens the task never sees its own activation.
+      // ⚠️ Handing the activator down only holds because something claims to BE it. dnd-kit's
+      // `KeyboardSensor` opens with `if (activator && event.target !== activator) return false` — a
+      // guard that does not exist until `setActivatorNodeRef` has been given a node. Unclaimed, the
+      // keyboard sensor accepts a key press from anywhere under these listeners, which is how a card
+      // ended up impossible to open by keyboard (anchrd/intel#286). The pointer drag is unaffected
+      // either way: `PointerSensor` never consults the activator node.
       {...listeners}
+      data-slot="kanban-card"
       className={cn(
         "flex cursor-grab items-start gap-1 rounded-lg border bg-card p-3 text-left shadow-sm",
         // Left where it was, faded, rather than removed: a lane that reflows while a card is over
@@ -156,35 +177,47 @@ export function KanbanCard({
         className,
       )}
     >
-      {/* The keyboard half of the drag: `attributes` puts the card into the tab order exactly once,
-          here, where it has a name of its own that says what it does.
-
-          ⚠️ `setActivatorNodeRef` is what makes that true rather than merely intended. dnd-kit's
-          `KeyboardSensor` opens with `if (activator && event.target !== activator) return false` —
-          a guard that only exists once something has claimed to BE the activator. Unclaimed, the
-          keyboard sensor accepts a key press from anywhere under the listeners, so Enter on the
-          card's own "open" button started a drag and swallowed the click. The pointer drag is
-          unaffected: `PointerSensor` never consults the activator node. */}
-      <button
-        type="button"
-        ref={setActivatorNodeRef}
-        aria-label={dragLabel}
-        {...listeners}
-        {...attributes}
-        className="mt-0.5 shrink-0 cursor-grab rounded text-muted-foreground outline-none focus-visible:ring-2 focus-visible:ring-ring"
-      >
-        <GripVertical aria-hidden="true" className="size-4" />
-      </button>
-      <div className="min-w-0 flex-1">{children}</div>
+      {/* Decoration, and deliberately not a control: it says "this can be taken hold of" to whoever
+          uses a pointer, and a pointer can take hold of the whole card anyway. As a button it was a
+          tab stop of its own on every card in the lane. */}
+      <GripVertical aria-hidden="true" className="mt-0.5 size-4 shrink-0 text-muted-foreground" />
+      <div className="min-w-0 flex-1">{children({ ...attributes, ref: setActivatorNodeRef })}</div>
     </div>
   );
 }
 
+/**
+ * ⚠️ Space picks a card up, Enter does not — and that is the whole of anchrd/intel#315.
+ *
+ * dnd-kit's default is `start: ['Space', 'Enter']`, which forces the activator to be an element of
+ * its own: a control that is also the card's "open" button cannot answer both keys with two
+ * different things. With the start key narrowed to Space, the two meanings are told apart by the
+ * KEY instead of by the element, and a card costs one tab stop rather than two — fifty cards, fifty
+ * stops instead of a hundred.
+ *
+ * ⚠️ `start` is the ONLY list that is narrowed. `end` and `cancel` are dnd-kit's defaults spelled
+ * out — Space, Enter and **Tab** put a card down, Escape leaves it where it was — and dropping one
+ * of them here is not a smaller change than it looks. Tab is neither an end key nor a cancel key
+ * once it is missing from this list, and `defaultKeyboardCoordinateGetter` answers nothing for it,
+ * so nothing calls `preventDefault()`: the focus walks on to the next card while the first one is
+ * still in the air and still following the arrow keys.
+ *
+ * Enter stays an END key, and it cannot open the card while ending a move: `handleEnd` calls
+ * `preventDefault()` before the browser turns the key press into a click. Somebody holding a card
+ * who presses the key they associate with "yes" should put it down, not be told nothing happened.
+ */
+const kanbanKeyboardCodes = {
+  start: ["Space"],
+  cancel: ["Escape"],
+  end: ["Space", "Enter", "Tab"],
+};
+
 export function KanbanProvider({
   columns,
   itemsByColumn,
   children,
   announcements,
+  instructions,
   overlay,
   onDrop,
   className,
@@ -196,6 +229,10 @@ export function KanbanProvider({
   itemsByColumn: Map<string, string[]>;
   children: (column: KanbanColumn) => ReactNode;
   announcements: Announcements;
+  // ⚠️ Not optional, and not a nicety. dnd-kit's built-in text is an English literal naming the
+  // default keys, and this board answers different ones. A card whose `aria-describedby` says
+  // "press space or enter" while Enter opens it describes a widget that is not there.
+  instructions: string;
   overlay(activeId: string): ReactNode;
   onDrop(drop: KanbanDrop): void;
   className?: string;
@@ -205,12 +242,12 @@ export function KanbanProvider({
     // ⚠️ A distance before a drag starts, and it is not decoration: without it every click on a
     // card is a drag of zero pixels, and the card can then no longer be opened by clicking it.
     useSensor(PointerSensor, { activationConstraint: { distance: 4 } }),
-    useSensor(KeyboardSensor),
+    useSensor(KeyboardSensor, { keyboardCodes: kanbanKeyboardCodes }),
   );
 
   return (
     <DndContext
-      accessibility={{ announcements }}
+      accessibility={{ announcements, screenReaderInstructions: { draggable: instructions } }}
       // Corners rather than centres: a tall card over a short one wins on centre distance even
       // when the pointer is nowhere near it.
       collisionDetection={closestCorners}

package/src/i18n/de.json

@@ -373,6 +373,7 @@
   "agent.calendarZones": "Jede Zeit steht in der Zeitzone ihres eigenen Zeitplans, denn dann läuft der Agent. Weicht deine eigene Zeitzone ab, steht sie daneben.",
   "agent.calendarYourTime": "{when} bei dir",
   "agent.calendarUnreadable": "Keiner der Zeitpläne dieses Agenten lässt sich als Cron-Ausdruck lesen, es ist also nichts geplant.",
+  "agent.calendarPaused": "Dieser Agent ist pausiert, keiner dieser Läufe findet statt. Sie zeigen, was er täte, sobald er fortgesetzt wird.",
   "agent.log": "Läufe",
   "agent.logEmpty": "Dieser Agent ist noch nicht gelaufen.",
   "agent.logFailed": "Die Läufe konnten nicht gelesen werden. Vielleicht ist die Agenten-Laufzeit von hier aus nicht erreichbar.",
@@ -507,7 +508,10 @@
   "board.dnd.start": "{task} aufgenommen",
   "board.dnd.over": "{task} über {lane}",
   "board.dnd.end": "{task} in {lane} abgelegt",
+  "board.dnd.endUnchanged": "{task} wurde nicht verschoben und steht weiterhin in {lane}",
+  "board.dnd.endRefused": "{lane} nimmt keine Karten mehr auf, {task} wurde nicht verschoben und steht weiterhin in {from}",
   "board.dnd.cancel": "Ablegen von {task} abgebrochen",
-  "board.dragCard": "{task} ziehen",
+  "board.dnd.instructions": "Mit der Eingabetaste diese Aufgabe öffnen. Zum Verschieben stattdessen die Leertaste darauf drücken und sie mit den Pfeiltasten an eine andere Position oder in eine andere Spalte bringen, dann mit Leertaste, Eingabetaste oder Tabulator ablegen oder mit Escape dort lassen, wo sie war.",
+  "board.card.roleDescription": "Aufgabe, verschiebbar",
   "board.statusTerminal": "Gilt als erledigt"
 }

package/src/i18n/en.json

@@ -373,6 +373,7 @@
   "agent.calendarZones": "Each time is shown in the timezone of its own schedule, because that is when the agent runs. Where your own timezone differs, it is added beside it.",
   "agent.calendarYourTime": "{when} your time",
   "agent.calendarUnreadable": "None of this agent's schedules can be read as a cron expression, so nothing is planned.",
+  "agent.calendarPaused": "This agent is paused, so none of these runs will happen. They are what it would do once it is resumed.",
   "agent.log": "Runs",
   "agent.logEmpty": "This agent has not run yet.",
   "agent.logFailed": "The runs could not be read. The agent runtime may be unreachable from here.",
@@ -507,7 +508,10 @@
   "board.dnd.start": "Picked up {task}",
   "board.dnd.over": "{task} is over {lane}",
   "board.dnd.end": "Dropped {task} into {lane}",
+  "board.dnd.endUnchanged": "{task} was not moved and is still in {lane}",
+  "board.dnd.endRefused": "{lane} no longer takes cards, {task} was not moved and is still in {from}",
   "board.dnd.cancel": "Dropping {task} was cancelled",
-  "board.dragCard": "Drag {task}",
+  "board.dnd.instructions": "Press enter to open this task. To move it instead, press the space bar on it and use the arrow keys to take it to another position or lane, then press space, enter or tab to put it down, or escape to leave it where it was.",
+  "board.card.roleDescription": "task, movable",
   "board.statusTerminal": "Means done"
 }

package/src/i18n/es.json

@@ -373,6 +373,7 @@
   "agent.calendarZones": "Cada hora se muestra en la zona horaria de su propio horario, porque es cuando se ejecuta el agente. Si tu propia zona horaria difiere, se añade al lado.",
   "agent.calendarYourTime": "{when} en tu hora",
   "agent.calendarUnreadable": "Ninguno de los horarios de este agente se puede leer como expresión cron, así que no hay nada planificado.",
+  "agent.calendarPaused": "Este agente está en pausa, así que ninguna de estas ejecuciones ocurrirá. Muestran lo que haría al reanudarlo.",
   "agent.log": "Ejecuciones",
   "agent.logEmpty": "Este agente todavía no se ha ejecutado.",
   "agent.logFailed": "Las ejecuciones no se han podido leer. Puede que el entorno de ejecución de agentes no sea accesible desde aquí.",
@@ -507,7 +508,10 @@
   "board.dnd.start": "{task} tomada",
   "board.dnd.over": "{task} sobre {lane}",
   "board.dnd.end": "{task} soltada en {lane}",
+  "board.dnd.endUnchanged": "{task} no se movió y sigue en {lane}",
+  "board.dnd.endRefused": "{lane} ya no admite tarjetas, {task} no se movió y sigue en {from}",
   "board.dnd.cancel": "Se canceló soltar {task}",
-  "board.dragCard": "Arrastrar {task}",
+  "board.dnd.instructions": "Pulsa intro para abrir esta tarea. Para moverla, pulsa la barra espaciadora sobre ella y llévala con las flechas a otra posición o columna; después suéltala con espacio, intro o tabulador, o pulsa escape para dejarla donde estaba.",
+  "board.card.roleDescription": "tarea, movible",
   "board.statusTerminal": "Cuenta como hecho"
 }

package/src/node-table/node-table.tsx

@@ -105,8 +105,9 @@ export function NodeTablePanel({ node }: { node: Node }) {
             <thead className="sticky top-0 bg-card">
               <tr>
                 {table.data.columns.map((column) => (
-                  // Column names are distinct by contract (`DefineTableInput`), so the
-                  // name is the key and nothing has to fall back to a position.
+                  // Column names are distinct on every path that writes a table — `DefineTableInput`,
+                  // `RedefineTableInput` and, since #322, the bundle import, which used to walk past
+                  // both — so the name is the key and nothing has to fall back to a position.
                   <th
                     key={column}
                     scope="col"

package/src/resource-menu/resource-menu.tsx

@@ -357,12 +357,32 @@ export function ResourceMenu({
             <p className="text-sm">{i18n.t("flows.validateReady")}</p>
           ) : (
             <ul className="space-y-2">
-              {validation.problems.map((problem) => (
-                <li key={problem.code} className="rounded-md border p-3 text-sm">
-                  <span className="block font-medium">
-                    {i18n.t(`flows.problem.${problem.code}`)}
-                  </span>
-                  <span className="mt-1 block text-xs text-muted-foreground">{problem.detail}</span>
+              {/* ⚠️ Grouped by code, one entry per reason with every detail under it (#324).
+                  `validateFlow` files one problem per sub-flow node, so a flow calling two
+                  unpublished flows — the NORMAL case of that error, not its edge — produced two
+                  entries whose head sentence is the same line of text, one under the other, and
+                  two React children under one key.
+
+                  Grouping rather than making the keys unique, because the head sentence is per CODE
+                  (`flows.problem.<code>` is one string) and repeating it under itself says nothing
+                  the reader did not just read. What differs is the detail, and every detail is
+                  still here — which is the promise the comment above makes: somebody with two
+                  missing tools should not have to ask twice. */}
+              {[
+                ...validation.problems
+                  .reduce((byCode, problem) => {
+                    byCode.set(problem.code, [...(byCode.get(problem.code) ?? []), problem.detail]);
+                    return byCode;
+                  }, new Map<string, string[]>())
+                  .entries(),
+              ].map(([code, details]) => (
+                <li key={code} className="rounded-md border p-3 text-sm">
+                  <span className="block font-medium">{i18n.t(`flows.problem.${code}`)}</span>
+                  {details.map((detail) => (
+                    <span key={detail} className="mt-1 block text-xs text-muted-foreground">
+                      {detail}
+                    </span>
+                  ))}
                 </li>
               ))}
             </ul>