@anchrd/intel-ui 0.16.0 → 0.17.0

package/src/components/ui/kanban.tsx

@@ -0,0 +1,245 @@
+import {
+  type Announcements,
+  closestCorners,
+  DndContext,
+  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"`.** 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.
+ */
+
+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>
+  );
+}
+
+export function KanbanCard({
+  id,
+  dragLabel,
+  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;
+  className?: string;
+}) {
+  const {
+    attributes,
+    listeners,
+    setNodeRef,
+    setActivatorNodeRef,
+    transition,
+    transform,
+    isDragging,
+  } = useSortable({ id });
+  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.
+      //
+      // ⚠️ 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.
+      {...listeners}
+      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,
+      )}
+    >
+      {/* 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>
+    </div>
+  );
+}
+
+export function KanbanProvider({
+  columns,
+  itemsByColumn,
+  children,
+  announcements,
+  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;
+  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),
+  );
+
+  return (
+    <DndContext
+      accessibility={{ announcements }}
+      // 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

@@ -50,6 +50,7 @@
   "tree.kind.attachment": "Datei",
   "tree.kind.table": "Tabelle",
   "tree.kind.agent": "Agent",
+  "tree.kind.board": "Board",
   "tree.kind.flow": "Flow",
   "tree.move.action": "Verschieben nach …",
   "tree.move.title": "{title} verschieben",
@@ -108,6 +109,7 @@
   "node.kind.attachment": "Upload",
   "node.kind.table": "Tabelle",
   "node.kind.agent": "Agent",
+  "node.kind.board": "Board",
   "node.kind.flow": "Flow",
   "node.share": "Freigeben",
   "node.shareAction": "Zugriff geben",
@@ -422,5 +424,90 @@
   "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.cancel": "Ablegen von {task} abgebrochen",
+  "board.dragCard": "{task} ziehen",
+  "board.statusTerminal": "Gilt als erledigt"
 }

package/src/i18n/en.json

@@ -50,6 +50,7 @@
   "tree.kind.attachment": "File",
   "tree.kind.table": "Table",
   "tree.kind.agent": "Agent",
+  "tree.kind.board": "Board",
   "tree.kind.flow": "Flow",
   "tree.move.action": "Move to…",
   "tree.move.title": "Move {title}",
@@ -108,6 +109,7 @@
   "node.kind.attachment": "Upload",
   "node.kind.table": "Table",
   "node.kind.agent": "Agent",
+  "node.kind.board": "Board",
   "node.kind.flow": "Flow",
   "node.share": "Share",
   "node.shareAction": "Grant access",
@@ -422,5 +424,90 @@
   "common.loading": "Loading…",
   "common.retry": "Try again",
   "common.close": "Close",
-  "common.unavailable": "Intel is currently unavailable."
+  "common.unavailable": "Intel is currently unavailable.",
+  "board.summary": "{tasks} tasks in {statuses} statuses",
+  "board.views": "Views of this board",
+  "board.view.kanban": "Board",
+  "board.view.table": "Table",
+  "board.view.calendar": "Calendar",
+  "board.view.graph": "Graph",
+  "board.view.gantt": "Gantt",
+  "board.statuses": "Statuses",
+  "board.statusLabel": "Status name",
+  "board.statusUp": "Move status up",
+  "board.statusDown": "Move status down",
+  "board.statusRemove": "Remove the status {label}",
+  "board.addStatus": "New status",
+  "board.shelfFixed": "Always the last one",
+  "board.showArchived": "Show archived",
+  "board.addTask": "New task",
+  "board.empty": "Nothing on this board yet. Add the first task above.",
+  "board.noTasks": "Nothing here that matches.",
+  "board.laneEmpty": "Empty",
+  "board.archivedEmpty": "Nothing archived.",
+  "board.blocked": "Blocked",
+  "board.open": "Open",
+  "board.subtaskCount": "{done}/{total} subtasks",
+  "board.unassigned": "Unassigned",
+  "board.assignee.me": "Me",
+  "board.assignee.unnamed": "Assigned",
+  "board.unknownTask": "Task not available to you",
+  "board.column.title": "Title",
+  "board.column.status": "Status",
+  "board.column.assignee": "Assignee",
+  "board.column.startDate": "Start date",
+  "board.column.dueDate": "Due date",
+  "board.column.labels": "Labels",
+  "board.columns": "Columns",
+  "board.filterTitle": "Filter by title",
+  "board.groupBy": "Group by",
+  "board.groupBy.none": "Nothing",
+  "board.groupBy.status": "Status",
+  "board.groupBy.assignee": "Assignee",
+  "board.toggleSubtasks": "Show or hide the subtasks of {task}",
+  "board.calendar.previous": "Previous month",
+  "board.calendar.next": "Next month",
+  "board.calendar.today": "Today",
+  "board.calendar.more": "+{count} more",
+  "board.calendar.undated": "{count} without a due date — not in this grid, but on the board and in the table.",
+  "board.gantt.scale": "Scale",
+  "board.gantt.scale.days": "Days",
+  "board.gantt.scale.weeks": "Weeks",
+  "board.gantt.scale.months": "Months",
+  "board.gantt.today": "Today",
+  "board.gantt.move": "Move {task}",
+  "board.gantt.resizeStart": "Change when {task} starts",
+  "board.gantt.resizeEnd": "Change when {task} is due",
+  "board.gantt.spanLabel": "{start} to {end}",
+  "board.gantt.waitsFor": "waits for {tasks}",
+  "board.gantt.hiddenLinks": "{count} dependencies are not drawn: the task waited for has no bar here.",
+  "board.gantt.undated": "Without dates",
+  "board.gantt.undatedCount": "{count} without dates — on the board, but on no timeline.",
+  "board.gantt.nothingDated": "Nothing on this board has a date yet. Give a task a due date and it appears here.",
+  "board.graph.subtree": "Subtree",
+  "board.graph.wholeBoard": "Whole board",
+  "board.graph.parentEdge": "contains",
+  "board.graph.dependsEdge": "waits for",
+  "board.detail": "Task",
+  "board.description": "Description",
+  "board.subtasks": "Subtasks",
+  "board.addSubtask": "New subtask",
+  "board.dependencies": "Waits for",
+  "board.addDependency": "Add a dependency",
+  "board.removeDependency": "Remove this dependency",
+  "board.references": "References",
+  "board.addReference": "Add a reference",
+  "board.removeReference": "Remove this reference",
+  "board.addLabel": "New label",
+  "board.removeLabel": "Remove the label {label}",
+  "board.deleteTask": "Delete task",
+  "board.deleteConfirm": "Deleting “{task}” removes it and everything below it: {count} in total. Any dependency pointing into that is cleared.",
+  "board.deleted": "Deleted: {count}.",
+  "board.archivedHint": "This task is on the archive shelf. Move it to another status to bring it back.",
+  "board.dnd.start": "Picked up {task}",
+  "board.dnd.over": "{task} is over {lane}",
+  "board.dnd.end": "Dropped {task} into {lane}",
+  "board.dnd.cancel": "Dropping {task} was cancelled",
+  "board.dragCard": "Drag {task}",
+  "board.statusTerminal": "Means done"
 }