@anchrd/intel-ui 0.16.1 → 0.18.0

package/src/components/ui/kanban.tsx

@@ -0,0 +1,282 @@
+import {
+  type Announcements,
+  closestCorners,
+  DndContext,
+  type DraggableAttributes,
+  DragOverlay,
+  type DragStartEvent,
+  KeyboardSensor,
+  PointerSensor,
+  useDroppable,
+  useSensor,
+  useSensors,
+} from "@dnd-kit/core";
+import { SortableContext, useSortable, verticalListSortingStrategy } from "@dnd-kit/sortable";
+import { CSS } from "@dnd-kit/utilities";
+import { GripVertical } from "lucide-react";
+import { type ReactNode, useState } from "react";
+import { createPortal } from "react-dom";
+import { cn } from "@/lib/utils";
+
+/**
+ * A kanban board on dnd-kit, from the Kibo UI registry (MIT) and changed where it had to be.
+ *
+ * Registry code is our code, and four things about the original do not survive contact with a board
+ * whose truth is on a server:
+ *
+ * ⚠️ **It reported a drop as a new ARRAY, and it reported one twice.** The original called
+ * `onDataChange` in `onDragOver` for a cross-column move and again in `onDragEnd`, and both times
+ * with a reordered copy of the whole list. Against a server that is two writes for one drag — and
+ * the second one describes a state the first already changed. This version says nothing while the
+ * card is in the air and emits ONE drop at the end, naming what was dropped and what it was dropped
+ * on. What that means is the caller's to decide (`board-kanban.ts`), which is also where the single
+ * `board_task_move` is sent from.
+ *
+ * ⚠️ **It mutated its own props** — `newData[activeIndex].column = overColumn` writes into the
+ * object the caller passed in. With TanStack Query holding that object, a drag edited the cache in
+ * place and no re-render followed.
+ *
+ * ⚠️ **`tunnel-rat` is gone.** It existed to render the dragged card into the overlay from inside
+ * the card component; `DragOverlay` already does that, and the caller draws the overlay itself.
+ * One dependency fewer for something React has a portal for.
+ *
+ * ⚠️ **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"`, 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 {
+  id: string;
+  name: string;
+}
+
+export interface KanbanDrop {
+  activeId: string;
+  // The column or the card it was let go over. `null` means it was let go over nothing — a drag
+  // that ended outside the board, which is a cancel and not a move.
+  overId: string | null;
+}
+
+export function KanbanBoard({
+  id,
+  droppable = true,
+  children,
+  className,
+}: {
+  id: string;
+  // A column that exists to be READ but must not be written into. It still draws and still holds
+  // cards; it simply never becomes a drop target, so nothing can be dropped where the answer would
+  // be a refusal (`board-kanban.tsx`).
+  droppable?: boolean;
+  children: ReactNode;
+  className?: string;
+}) {
+  const { isOver, setNodeRef } = useDroppable({ id, disabled: !droppable });
+  return (
+    <div
+      ref={setNodeRef}
+      data-slot="kanban-column"
+      data-droppable={droppable}
+      className={cn(
+        "flex size-full min-h-40 flex-col divide-y overflow-hidden rounded-lg border bg-muted/40 text-xs ring-2 transition-colors",
+        isOver ? "ring-ring" : "ring-transparent",
+        className,
+      )}
+    >
+      {children}
+    </div>
+  );
+}
+
+export function KanbanHeader({ children }: { children: ReactNode }) {
+  return <div className="flex items-center gap-2 p-2 text-sm font-semibold">{children}</div>;
+}
+
+export function KanbanCards({ id, children }: { id: string; children: ReactNode }) {
+  return (
+    <div
+      // The column scrolls, not the page: four lanes of different lengths must not make the board
+      // as tall as its longest one.
+      className="flex min-h-0 flex-1 flex-col gap-2 overflow-y-auto p-2"
+      data-slot="kanban-cards"
+      data-column={id}
+    >
+      {children}
+    </div>
+  );
+}
+
+/**
+ * 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,
+  roleDescription,
+  children,
+  className,
+}: {
+  id: string;
+  // 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 {
+    attributes,
+    listeners,
+    setNodeRef,
+    setActivatorNodeRef,
+    transition,
+    transform,
+    isDragging,
+  } = 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` carries `role="button"` and `tabIndex`, and those on the card would wrap the
+      // control that OPENS it in a second button.
+      //
+      // ⚠️ 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
+        // it moves the drop target out from under the pointer.
+        isDragging && "opacity-40",
+        className,
+      )}
+    >
+      {/* 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,
+}: {
+  columns: KanbanColumn[];
+  // Which cards stand in which column, in the order they are drawn. The provider needs it for the
+  // sortable contexts and asks for it rather than deriving it, so the caller stays the only place
+  // that knows how a board is ordered.
+  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;
+}) {
+  const [activeId, setActiveId] = useState<string | null>(null);
+  const sensors = useSensors(
+    // ⚠️ 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, { keyboardCodes: kanbanKeyboardCodes }),
+  );
+
+  return (
+    <DndContext
+      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}
+      sensors={sensors}
+      onDragStart={(event: DragStartEvent) => setActiveId(String(event.active.id))}
+      onDragCancel={() => setActiveId(null)}
+      onDragEnd={(event) => {
+        setActiveId(null);
+        const over = event.over === null ? null : String(event.over.id);
+        onDrop({ activeId: String(event.active.id), overId: over });
+      }}
+    >
+      <div className={cn("grid size-full auto-cols-fr grid-flow-col gap-3", className)}>
+        {columns.map((column) => (
+          <SortableContext
+            key={column.id}
+            items={itemsByColumn.get(column.id) ?? []}
+            strategy={verticalListSortingStrategy}
+          >
+            {children(column)}
+          </SortableContext>
+        ))}
+      </div>
+      {typeof document === "undefined"
+        ? null
+        : createPortal(
+            <DragOverlay>{activeId === null ? null : overlay(activeId)}</DragOverlay>,
+            document.body,
+          )}
+    </DndContext>
+  );
+}

package/src/components/ui/switch.tsx

@@ -0,0 +1,25 @@
+import { Switch as SwitchPrimitive } from "radix-ui";
+import type * as React from "react";
+import { cn } from "@/lib/utils";
+
+function Switch({ className, ...props }: React.ComponentProps<typeof SwitchPrimitive.Root>) {
+  return (
+    <SwitchPrimitive.Root
+      data-slot="switch"
+      className={cn(
+        "peer inline-flex h-5 w-9 shrink-0 items-center rounded-full border border-transparent shadow-xs transition-all outline-none focus-visible:ring-2 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=unchecked]:bg-input",
+        className,
+      )}
+      {...props}
+    >
+      <SwitchPrimitive.Thumb
+        data-slot="switch-thumb"
+        className={cn(
+          "pointer-events-none block size-4 rounded-full bg-background ring-0 transition-transform data-[state=checked]:translate-x-[calc(100%-2px)] data-[state=unchecked]:translate-x-0",
+        )}
+      />
+    </SwitchPrimitive.Root>
+  );
+}
+
+export { Switch };

package/src/data/intel-data-provider/intel-data-provider.ts

@@ -1,17 +1,23 @@
 import {
+  AddBoardTaskInput,
   AgentCosts,
   AgentKeyRotated,
   AppendTableRowsInput,
   AppendTableRowsResult,
   ArchiveFlowInput,
   ArchiveNodeInput,
+  BoardTaskResult,
   BundleImportResult,
   CompleteFlowRunStepInput,
+  ConfigureBoardInput,
+  ConfigureBoardResult,
   CreateAgentInput,
   CreatedAgent,
   CreateFlowInput,
   CreateNodeInput,
   DefineTableInput,
+  DeleteBoardTaskInput,
+  DeleteBoardTaskResult,
   Flow,
   FlowDocument,
   FlowList,
@@ -26,8 +32,10 @@ import {
   ListFlowsInput,
   ListNodesInput,
   ModelCatalog,
+  MoveBoardTaskInput,
   Node,
   NodeAgent,
+  NodeBoard,
   NodeDocument,
   NodeGraph,
   NodeLinkList,
@@ -56,6 +64,7 @@ import {
   StartFlowRunInput,
   ToolCatalog,
   ToolServerCatalog,
+  UpdateBoardTaskInput,
   UpdateFlowInput,
   UpdateNodeInput,
 } from "@anchrd/intel-contract";
@@ -327,6 +336,49 @@ export function createIntelDataProvider(
         { method: "POST", body: JSON.stringify(parsed) },
       );
     },
+    async getBoard(nodeId) {
+      return await request(`/nodes/${encodeURIComponent(nodeId)}/board`, NodeBoard);
+    },
+    async configureBoard(input) {
+      const parsed = ConfigureBoardInput.parse(input);
+      return await request(
+        `/nodes/${encodeURIComponent(parsed.nodeId)}/board/configure`,
+        ConfigureBoardResult,
+        { method: "POST", body: JSON.stringify(parsed) },
+      );
+    },
+    async addBoardTask(input) {
+      const parsed = AddBoardTaskInput.parse(input);
+      return await request(
+        `/nodes/${encodeURIComponent(parsed.nodeId)}/board/tasks`,
+        BoardTaskResult,
+        { method: "POST", body: JSON.stringify(parsed) },
+      );
+    },
+    async updateBoardTask(input) {
+      const parsed = UpdateBoardTaskInput.parse(input);
+      return await request(
+        `/nodes/${encodeURIComponent(parsed.nodeId)}/board/tasks/update`,
+        BoardTaskResult,
+        { method: "POST", body: JSON.stringify(parsed) },
+      );
+    },
+    async moveBoardTask(input) {
+      const parsed = MoveBoardTaskInput.parse(input);
+      return await request(
+        `/nodes/${encodeURIComponent(parsed.nodeId)}/board/tasks/move`,
+        BoardTaskResult,
+        { method: "POST", body: JSON.stringify(parsed) },
+      );
+    },
+    async deleteBoardTask(input) {
+      const parsed = DeleteBoardTaskInput.parse(input);
+      return await request(
+        `/nodes/${encodeURIComponent(parsed.nodeId)}/board/tasks/delete`,
+        DeleteBoardTaskResult,
+        { method: "POST", body: JSON.stringify(parsed) },
+      );
+    },
     async listNodeVersions(nodeId) {
       return await request(`/nodes/${encodeURIComponent(nodeId)}/versions`, NodeVersionList);
     },

package/src/data/intel-data-provider/intel-data-provider.types.ts

@@ -1,4 +1,5 @@
 import type {
+  AddBoardTaskInput,
   AgentCosts,
   AgentKeyRotated,
   AgentScheduleTarget,
@@ -6,13 +7,18 @@ import type {
   AppendTableRowsResult,
   ArchiveFlowInput,
   ArchiveNodeInput,
+  BoardTaskResult,
   BundleImportResult,
   CompleteFlowRunStepInput,
+  ConfigureBoardInput,
+  ConfigureBoardResult,
   CreateAgentInput,
   CreatedAgent,
   CreateFlowInput,
   CreateNodeInput,
   DefineTableInput,
+  DeleteBoardTaskInput,
+  DeleteBoardTaskResult,
   Flow,
   FlowDocument,
   FlowList,
@@ -27,8 +33,10 @@ import type {
   ListFlowsInput,
   ListNodesInput,
   ModelCatalog,
+  MoveBoardTaskInput,
   Node,
   NodeAgent,
+  NodeBoard,
   NodeDocument,
   NodeGraph,
   NodeKind,
@@ -57,6 +65,7 @@ import type {
   StartFlowRunInput,
   ToolCatalog,
   ToolServerCatalog,
+  UpdateBoardTaskInput,
   UpdateFlowInput,
   UpdateNodeInput,
 } from "@anchrd/intel-contract";
@@ -127,6 +136,28 @@ export interface IntelDataProvider {
   getNodeTable(nodeId: string): Promise<NodeTable>;
   defineTable(input: DefineTableInput): Promise<NodeTable>;
   appendTableRows(input: AppendTableRowsInput): Promise<AppendTableRowsResult>;
+
+  // A board's whole document — the status list and every task — as one read (#285). There is no
+  // per-task GET and there is not meant to be: the file IS the board, and every view of it
+  // (anchrd/intel#286) draws the same list.
+  getBoard(nodeId: string): Promise<NodeBoard>;
+  // The status list, written whole and in the order it should be drawn. Adding, renaming and
+  // reordering are all this one call.
+  configureBoard(input: ConfigureBoardInput): Promise<ConfigureBoardResult>;
+  // ⚠️ The five task operations answer with the ONE task that was written, never the whole board.
+  // A board holds up to five thousand tasks, and a one-card edit that answered with all of them
+  // would make every write pay for a full read — so the cache is patched from the answer here
+  // (`board-data.ts`) rather than refetched.
+  addBoardTask(input: AddBoardTaskInput): Promise<BoardTaskResult>;
+  updateBoardTask(input: UpdateBoardTaskInput): Promise<BoardTaskResult>;
+  // Where a task sits: its column, its parent, its place among its neighbours. ⚠️ A move names
+  // its NEIGHBOURS and never an index — the server mints the order key, so one drag writes one
+  // task and renumbers nothing.
+  moveBoardTask(input: MoveBoardTaskInput): Promise<BoardTaskResult>;
+  // ⚠️ Deleting cascades to every descendant and `deleted` counts them, so a surface can say what
+  // it is about to do before it does it rather than afterwards.
+  deleteBoardTask(input: DeleteBoardTaskInput): Promise<DeleteBoardTaskResult>;
+
   // Walks the browser through the portal's OAuth flow without asking anybody anything: Gate is the
   // identity provider Cloudflare Access consumes, so a signed-in person is already known there
   // (#60). It navigates away — the caller renders no button for it and gets no answer back.

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.",
@@ -424,5 +425,93 @@
   "common.loading": "Wird geladen …",
   "common.retry": "Erneut versuchen",
   "common.close": "Schließen",
-  "common.unavailable": "Intel ist derzeit nicht verfügbar."
+  "common.unavailable": "Intel ist derzeit nicht verfügbar.",
+  "board.summary": "{tasks} Aufgaben in {statuses} Status",
+  "board.views": "Ansichten dieses Boards",
+  "board.view.kanban": "Board",
+  "board.view.table": "Tabelle",
+  "board.view.calendar": "Kalender",
+  "board.view.graph": "Graph",
+  "board.view.gantt": "Gantt",
+  "board.statuses": "Status",
+  "board.statusLabel": "Statusname",
+  "board.statusUp": "Status nach oben",
+  "board.statusDown": "Status nach unten",
+  "board.statusRemove": "Status {label} entfernen",
+  "board.addStatus": "Neuer Status",
+  "board.shelfFixed": "Immer der letzte",
+  "board.showArchived": "Archivierte zeigen",
+  "board.addTask": "Neue Aufgabe",
+  "board.empty": "Auf diesem Board steht noch nichts. Lege oben die erste Aufgabe an.",
+  "board.noTasks": "Hier passt nichts.",
+  "board.laneEmpty": "Leer",
+  "board.archivedEmpty": "Nichts archiviert.",
+  "board.blocked": "Blockiert",
+  "board.open": "Offen",
+  "board.subtaskCount": "{done}/{total} Teilaufgaben",
+  "board.unassigned": "Nicht zugewiesen",
+  "board.assignee.me": "Ich",
+  "board.assignee.unnamed": "Zugewiesen",
+  "board.unknownTask": "Aufgabe für dich nicht verfügbar",
+  "board.column.title": "Titel",
+  "board.column.status": "Status",
+  "board.column.assignee": "Zuständig",
+  "board.column.startDate": "Startdatum",
+  "board.column.dueDate": "Fällig am",
+  "board.column.labels": "Labels",
+  "board.columns": "Spalten",
+  "board.filterTitle": "Nach Titel filtern",
+  "board.groupBy": "Gruppieren nach",
+  "board.groupBy.none": "Nichts",
+  "board.groupBy.status": "Status",
+  "board.groupBy.assignee": "Zuständig",
+  "board.toggleSubtasks": "Teilaufgaben von {task} ein- oder ausblenden",
+  "board.calendar.previous": "Vorheriger Monat",
+  "board.calendar.next": "Nächster Monat",
+  "board.calendar.today": "Heute",
+  "board.calendar.more": "+{count} weitere",
+  "board.calendar.undated": "{count} ohne Fälligkeitsdatum — nicht im Raster, aber auf dem Board und in der Tabelle.",
+  "board.gantt.scale": "Maßstab",
+  "board.gantt.scale.days": "Tage",
+  "board.gantt.scale.weeks": "Wochen",
+  "board.gantt.scale.months": "Monate",
+  "board.gantt.today": "Heute",
+  "board.gantt.move": "{task} verschieben",
+  "board.gantt.resizeStart": "Beginn von {task} ändern",
+  "board.gantt.resizeEnd": "Fälligkeit von {task} ändern",
+  "board.gantt.spanLabel": "{start} bis {end}",
+  "board.gantt.waitsFor": "wartet auf {tasks}",
+  "board.gantt.hiddenLinks": "{count} Abhängigkeiten sind nicht gezeichnet: die erwartete Aufgabe hat hier keinen Balken.",
+  "board.gantt.undated": "Ohne Datum",
+  "board.gantt.undatedCount": "{count} ohne Datum — auf dem Board, aber auf keiner Zeitachse.",
+  "board.gantt.nothingDated": "Nichts auf diesem Board hat ein Datum. Gib einer Aufgabe ein Fälligkeitsdatum, dann erscheint sie hier.",
+  "board.graph.subtree": "Teilbaum",
+  "board.graph.wholeBoard": "Ganzes Board",
+  "board.graph.parentEdge": "enthält",
+  "board.graph.dependsEdge": "wartet auf",
+  "board.detail": "Aufgabe",
+  "board.description": "Beschreibung",
+  "board.subtasks": "Teilaufgaben",
+  "board.addSubtask": "Neue Teilaufgabe",
+  "board.dependencies": "Wartet auf",
+  "board.addDependency": "Abhängigkeit hinzufügen",
+  "board.removeDependency": "Diese Abhängigkeit entfernen",
+  "board.references": "Referenzen",
+  "board.addReference": "Referenz hinzufügen",
+  "board.removeReference": "Diese Referenz entfernen",
+  "board.addLabel": "Neues Label",
+  "board.removeLabel": "Label {label} entfernen",
+  "board.deleteTask": "Aufgabe löschen",
+  "board.deleteConfirm": "„{task}“ zu löschen entfernt die Aufgabe und alles darunter: insgesamt {count}. Abhängigkeiten darauf werden entfernt.",
+  "board.deleted": "Gelöscht: {count}.",
+  "board.archivedHint": "Diese Aufgabe liegt im Archiv. Ein Wechsel in einen anderen Status holt sie zurück.",
+  "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.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"
 }