@anchrd/intel-ui 0.31.0 → 0.33.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anchrd/intel-ui",
-  "version": "0.31.0",
+  "version": "0.33.0",
   "type": "module",
   "license": "UNLICENSED",
   "repository": {
@@ -33,7 +33,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@anchrd/intel-contract": "^0.19.0",
+    "@anchrd/intel-contract": "^0.20.0",
     "@blocknote/core": "^0.52.1",
     "@blocknote/react": "^0.52.1",
     "@blocknote/shadcn": "^0.52.1",

package/src/access-summary/access-summary.tsx

@@ -255,14 +255,25 @@ export function AccessSummary({
 export function ResourceAccessSummary({
   resourceId,
   ownerId,
+  kind = "node",
 }: {
   resourceId: string;
   ownerId: string;
+  // Which side of the tree the id belongs to (#530). A flow is not a node, so it is a different
+  // route — but the same answer, which is why one component draws both.
+  kind?: "node" | "flow";
 }) {
   const { data } = useIntelRouterContext();
   const grants = useQuery({
-    queryKey: ["effective-node-grants", resourceId],
-    queryFn: () => data.listEffectiveAccess(resourceId),
+    // ⚠️ Both kinds share the `effective-node-grants` prefix on purpose: a share mutation
+    // invalidates that prefix, and a flow grant changes what a folder summary above it shows just
+    // as a folder grant changes what the flow below it shows. Two prefixes would mean one of the
+    // two keeps drawing an access picture that is no longer in force.
+    queryKey: ["effective-node-grants", kind, resourceId],
+    queryFn: () =>
+      kind === "flow"
+        ? data.listEffectiveFlowAccess(resourceId)
+        : data.listEffectiveAccess(resourceId),
     retry: false,
     // Time cannot change this answer locally. Share mutations invalidate the whole effective prefix
     // because changing one folder also changes every descendant summary already on screen.

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

@@ -55,8 +55,10 @@ import {
 import {
   ResourceAccessList,
   ResourceGrantList,
+  RevokeFlowGrantInput,
   RevokeGrantInput,
   RevokeGrantResult,
+  ShareFlowInput,
   ShareInput,
   ShareResult,
 } from "@anchrd/intel-contract/share";
@@ -64,6 +66,7 @@ import {
   AppendTableRowsInput,
   AppendTableRowsResult,
   DefineTableInput,
+  RedefineTableInput,
 } from "@anchrd/intel-contract/table";
 import { ToolCatalog, ToolServerCatalog } from "@anchrd/intel-contract/tool";
 import type { z } from "zod";
@@ -317,6 +320,16 @@ export function createIntelDataProvider(
         { method: "POST", body: JSON.stringify(parsed) },
       );
     },
+    // ⚠️ `PATCH`, where the two writes above are `POST`. The route is the same address as the
+    // header itself, and this changes it — `POST /nodes/:id/table` is the one that WRITES a header
+    // and refuses on a table that already has one.
+    async redefineTable(input) {
+      const parsed = RedefineTableInput.parse(input);
+      return await request(`/nodes/${encodeURIComponent(parsed.nodeId)}/table`, NodeTable, {
+        method: "PATCH",
+        body: JSON.stringify(parsed),
+      });
+    },
     async listNodeVersions(nodeId) {
       return await request(`/nodes/${encodeURIComponent(nodeId)}/versions`, NodeVersionList);
     },
@@ -384,6 +397,30 @@ export function createIntelDataProvider(
         { method: "POST", body: JSON.stringify(parsed) },
       );
     },
+    async listFlowGrants(flowId) {
+      return await request(`/flows/${encodeURIComponent(flowId)}/grants`, ResourceGrantList);
+    },
+    async listEffectiveFlowAccess(flowId) {
+      return await request(
+        `/flows/${encodeURIComponent(flowId)}/effective-access`,
+        ResourceAccessList,
+      );
+    },
+    async shareFlow(input) {
+      const parsed = ShareFlowInput.parse(input);
+      return await request(`/flows/${encodeURIComponent(parsed.flowId)}/grants`, ShareResult, {
+        method: "POST",
+        body: JSON.stringify(parsed),
+      });
+    },
+    async revokeFlowGrant(input) {
+      const parsed = RevokeFlowGrantInput.parse(input);
+      return await request(
+        `/flows/${encodeURIComponent(parsed.flowId)}/grants/${encodeURIComponent(parsed.grantId)}/revoke`,
+        RevokeGrantResult,
+        { method: "POST", body: JSON.stringify(parsed) },
+      );
+    },
     listFlows,
     async getFlow(flowId) {
       return await request(`/flows/${encodeURIComponent(flowId)}`, FlowDocument);

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

@@ -54,8 +54,10 @@ import type {
 } from "@anchrd/intel-contract/node";
 import type {
   ResourceGrantList,
+  RevokeFlowGrantInput,
   RevokeGrantInput,
   RevokeGrantResult,
+  ShareFlowInput,
   ShareInput,
   ShareResult,
 } from "@anchrd/intel-contract/share";
@@ -63,6 +65,7 @@ import type {
   AppendTableRowsInput,
   AppendTableRowsResult,
   DefineTableInput,
+  RedefineTableInput,
 } from "@anchrd/intel-contract/table";
 import type { ToolCatalog, ToolServerCatalog } from "@anchrd/intel-contract/tool";
 
@@ -123,6 +126,14 @@ export interface IntelDataProvider {
   getNodeTable(nodeId: string): Promise<NodeTable>;
   defineTable(input: DefineTableInput): Promise<NodeTable>;
   appendTableRows(input: AppendTableRowsInput): Promise<AppendTableRowsResult>;
+  // Changing the header of a table that already has one (#135). The mapping is explicit — every new
+  // column names the current one whose cells fill it, or `null` for an empty one — because a new
+  // header without it would reinterpret every stored row under names nobody matched to the old ones.
+  //
+  // ⚠️ `baseVersionId` is the `versionId` the mapping was written against, and the server refuses
+  // with `version_conflict` when the table has moved on. Not optional: a mapping onto a header
+  // somebody else has since changed would move the wrong cells, silently.
+  redefineTable(input: RedefineTableInput): Promise<NodeTable>;
 
   // 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
@@ -147,6 +158,16 @@ export interface IntelDataProvider {
   // the new principal still cannot. A warning, never a refusal (ADR-0004 §4).
   shareNode(input: ShareInput): Promise<ShareResult>;
   revokeGrant(input: RevokeGrantInput): Promise<RevokeGrantResult>;
+  // The same four for one flow (#530). Separate calls rather than a widened `resourceId`, because
+  // the id names a different table on the other side and the routes are separate there too.
+  listFlowGrants(flowId: string): Promise<ResourceGrantList>;
+  listEffectiveFlowAccess(
+    flowId: string,
+  ): Promise<import("@anchrd/intel-contract/share").ResourceAccessList>;
+  // ⚠️ `ShareResult.unrunnable` is only ever filled in here: a grant on one flow does not reach the
+  // flows it calls, and this is where that gets said.
+  shareFlow(input: ShareFlowInput): Promise<ShareResult>;
+  revokeFlowGrant(input: RevokeFlowGrantInput): Promise<RevokeGrantResult>;
   listFlows(input?: ListFlowsInput): Promise<FlowList>;
   getFlow(flowId: string): Promise<FlowDocument>;
   // What a flow calls, read out of its graph. It answers a different question from `listTreeChildren`

package/src/flows/flows.tsx

@@ -421,9 +421,6 @@ function FlowsEditor() {
   // Lifted out of the bar because the canvas dismisses it too — a click on the pane is the third way
   // out, next to the trigger and Escape.
   const [paletteOpen, setPaletteOpen] = usePaletteOpen();
-  // A flow is shared through the folder it is filed in, on the Intelligence screen (ADR-0004 §2). It
-  // has no share action of its own — a narrower grant beside the folder's would break the guarantee
-  // that a flow only reaches flows in its own subtree.
   const document = useQuery({
     queryKey: ["flow", selectedFlowId],
     queryFn: () => data.getFlow(selectedFlowId ?? ""),

package/src/i18n/de.json

@@ -74,9 +74,9 @@
   "resource.move": "Verschieben",
   "resource.renameTitle": "{title} umbenennen",
   "resource.archive": "Archivieren",
+  "resource.columns": "Spalten",
   "resource.export": "Export",
   "resource.import": "Import",
-  "resource.downloadCsv": "CSV herunterladen",
   "resource.validate": "Prüfen",
   "resource.links": "Verweise",
   "resource.share": "Freigeben",
@@ -116,10 +116,25 @@
   "node.download": "Datei herunterladen",
   "node.attachmentHelp": "Die kanonische Datei liegt privat in Intel. Ihre KI-lesbare Projektion wird getrennt indexiert.",
   "node.table.summary": "{rows} Zeilen, {columns} Spalten",
-  "node.table.download": "CSV herunterladen",
-  "node.table.downloadFailed": "Die CSV konnte nicht erzeugt werden. Möglicherweise ist die Tabelle noch leer.",
   "node.table.empty": "Noch keine Zeilen. Zeilen werden von Flows angehängt.",
   "node.table.undefined": "Diese Tabelle hat noch keine Spalten.",
+  "node.table.columnsTitle": "Spalten von {title}",
+  "node.table.columnName": "Name der Spalte „{column}“",
+  "node.table.columnNewName": "Name der neuen Spalte",
+  "node.table.columnAdd": "Spalte hinzufügen",
+  "node.table.columnDrop": "Die Spalte „{column}“ entfernen",
+  "node.table.columnDropNew": "Die neue Spalte entfernen",
+  "node.table.columnsDistinct": "Zwei Spalten können nicht denselben Namen tragen.",
+  "node.table.columnsNamed": "Jede Spalte braucht einen Namen.",
+  "node.table.columnsAtLeastOne": "Eine Tabelle braucht mindestens eine Spalte.",
+  "node.table.columnsTooLong": "Ein Spaltenname darf höchstens 120 Zeichen lang sein.",
+  "node.table.columnsTooMany": "Eine Tabelle kann höchstens 64 Spalten haben.",
+  "node.table.columnsDropWarning.one": "Diese Spalte wird mitsamt allen Zellen darin entfernt: {columns}",
+  "node.table.columnsDropWarning.many": "Diese Spalten werden mitsamt allen Zellen darin entfernt: {columns}",
+  "node.table.columnsDropRows.none": "Keine Zeile trägt dort Inhalt, es geht also nichts mit ihnen verloren.",
+  "node.table.columnsDropRows.one": "Eine Zeile trägt dort Inhalt. Er bleibt im Versionsverlauf lesbar und sonst nirgends.",
+  "node.table.columnsDropRows.many": "{count} Zeilen tragen dort Inhalt. Er bleibt im Versionsverlauf lesbar und sonst nirgends.",
+  "node.table.columnsDropConfirm": "Entfernen und speichern",
   "node.select": "Wähle ein Dokument oder einen Ordner, um damit zu arbeiten.",
   "node.folderEmpty": "In diesem Ordner ist noch nichts. Lege etwas über das Plus in der Seitenleiste an.",
   "node.folderFailed": "Dieser Ordner konnte nicht gelesen werden.",
@@ -347,6 +362,7 @@
   "common.loading": "Wird geladen …",
   "common.retry": "Erneut versuchen",
   "common.close": "Schließen",
+  "common.cancel": "Abbrechen",
   "common.unavailable": "Intel ist derzeit nicht verfügbar.",
   "common.noAccess": "Das ist für dich nicht verfügbar. Es existiert nicht, oder es ist nicht mehr für dich freigegeben.",
   "common.noPermission": "Dir fehlt die Berechtigung, das zu sehen.",
@@ -364,5 +380,17 @@
   "flows.toolStepNeedsServer": "Dem Schritt „{label}“ fehlt noch ein Server.",
   "flows.toolFunctionsFailed": "Die Funktionsliste ließ sich nicht laden, daher ist die Auswahl möglicherweise unvollständig.",
   "flows.publishPreviewToolUnavailable": "Diesen Server erreichst du nicht, daher wird das Veröffentlichen abgelehnt.",
-  "flows.publishPreviewToolAllow": "Eingefroren auf: {functions}"
+  "flows.publishPreviewToolAllow": "Eingefroren auf: {functions}",
+  "flow.shareUnreadable": "Dieser Flow liest Dokumente, die diese Freigabe nicht abdeckt: {titles}.",
+  "flow.shareUnreadableMore": "{count} weitere liegen ebenfalls außer Reichweite, und du kannst sie nicht sehen.",
+  "flow.shareUnreadableHidden": "{count} Dokumente, die dieser Flow liest, liegen mit dieser Freigabe außer Reichweite. Du kannst sie nicht sehen.",
+  "flow.shareUnreadableHint": "Nichts ist blockiert. Ein Lauf hält für sie schlicht an dieser Stelle an.",
+  "flow.shareUnrunnable": "Dieser Flow ruft Flows auf, die diese Freigabe nicht abdeckt: {titles}.",
+  "flow.shareUnrunnableMore": "{count} weitere liegen ebenfalls außer Reichweite, und du kannst sie nicht sehen.",
+  "flow.shareUnrunnableHidden": "{count} Flows, die dieser aufruft, liegen mit dieser Freigabe außer Reichweite. Du kannst sie nicht sehen.",
+  "flow.shareUnrunnableHint": "Eine Freigabe auf einem Flow reicht nur bis zu diesem Flow. Gib die anderen ebenfalls frei oder den Ordner, in dem sie liegen. Mit „Prüfen“ sehen die Beschenkten es vor dem Start selbst.",
+  "flow.verbHint.read": "Diesen Flow öffnen und lesen",
+  "flow.verbHint.write": "Diesen Flow ändern",
+  "flow.verbHint.execute": "Diesen Flow starten",
+  "flow.verbHint.share": "Anderen Zugriff darauf geben"
 }

package/src/i18n/en.json

@@ -74,9 +74,9 @@
   "resource.move": "Move",
   "resource.renameTitle": "Rename {title}",
   "resource.archive": "Archive",
+  "resource.columns": "Columns",
   "resource.export": "Export",
   "resource.import": "Import",
-  "resource.downloadCsv": "Download CSV",
   "resource.validate": "Check",
   "resource.links": "Links",
   "resource.share": "Share",
@@ -116,10 +116,25 @@
   "node.download": "Download file",
   "node.attachmentHelp": "The canonical file is stored privately in Intel. Its AI-readable projection is indexed separately.",
   "node.table.summary": "{rows} rows, {columns} columns",
-  "node.table.download": "Download CSV",
-  "node.table.downloadFailed": "The CSV could not be created. The table may still be empty.",
   "node.table.empty": "No rows yet. Rows are appended by flows.",
   "node.table.undefined": "This table has no columns yet.",
+  "node.table.columnsTitle": "Columns of {title}",
+  "node.table.columnName": "Name of the column “{column}”",
+  "node.table.columnNewName": "Name of the new column",
+  "node.table.columnAdd": "Add column",
+  "node.table.columnDrop": "Remove the column “{column}”",
+  "node.table.columnDropNew": "Remove the new column",
+  "node.table.columnsDistinct": "Two columns cannot carry the same name.",
+  "node.table.columnsNamed": "Every column needs a name.",
+  "node.table.columnsAtLeastOne": "A table needs at least one column.",
+  "node.table.columnsTooLong": "A column name can be at most 120 characters long.",
+  "node.table.columnsTooMany": "A table can have at most 64 columns.",
+  "node.table.columnsDropWarning.one": "This column is removed with every cell in it: {columns}",
+  "node.table.columnsDropWarning.many": "These columns are removed with every cell in them: {columns}",
+  "node.table.columnsDropRows.none": "No row carries content there, so nothing is lost with them.",
+  "node.table.columnsDropRows.one": "One row carries content there. It stays readable in the version history and nowhere else.",
+  "node.table.columnsDropRows.many": "{count} rows carry content there. It stays readable in the version history and nowhere else.",
+  "node.table.columnsDropConfirm": "Remove and save",
   "node.select": "Select a document or folder to work with it.",
   "node.folderEmpty": "Nothing in this folder yet. Create something with the plus in the sidebar.",
   "node.folderFailed": "This folder could not be read.",
@@ -347,6 +362,7 @@
   "common.loading": "Loading…",
   "common.retry": "Try again",
   "common.close": "Close",
+  "common.cancel": "Cancel",
   "common.unavailable": "Intel is currently unavailable.",
   "common.noAccess": "This is not available to you. It may not exist, or it may no longer be shared with you.",
   "common.noPermission": "You do not have permission to see this.",
@@ -364,5 +380,17 @@
   "flows.toolStepNeedsServer": "The step “{label}” still needs a server.",
   "flows.toolFunctionsFailed": "The list of functions could not be loaded, so the selection may be incomplete.",
   "flows.publishPreviewToolUnavailable": "You do not reach this server, so publishing will be refused.",
-  "flows.publishPreviewToolAllow": "Frozen to: {functions}"
+  "flows.publishPreviewToolAllow": "Frozen to: {functions}",
+  "flow.shareUnreadable": "This flow reads documents this grant does not cover: {titles}.",
+  "flow.shareUnreadableMore": "{count} more are out of reach too, and you cannot see them.",
+  "flow.shareUnreadableHidden": "{count} documents this flow reads are out of reach with this grant. You cannot see them.",
+  "flow.shareUnreadableHint": "Nothing is blocked. A run will simply stop at that step for them.",
+  "flow.shareUnrunnable": "This flow calls flows this grant does not cover: {titles}.",
+  "flow.shareUnrunnableMore": "{count} more are out of reach too, and you cannot see them.",
+  "flow.shareUnrunnableHidden": "{count} flows this one calls are out of reach with this grant. You cannot see them.",
+  "flow.shareUnrunnableHint": "A grant on one flow reaches that flow alone. Share those flows too, or share the folder they are filed in. Let them check with Validate before they run it.",
+  "flow.verbHint.read": "Open this flow and read it",
+  "flow.verbHint.write": "Change this flow",
+  "flow.verbHint.execute": "Start this flow",
+  "flow.verbHint.share": "Give others access to it"
 }

package/src/i18n/es.json

@@ -74,9 +74,9 @@
   "resource.move": "Mover",
   "resource.renameTitle": "Cambiar el nombre de {title}",
   "resource.archive": "Archivar",
+  "resource.columns": "Columnas",
   "resource.export": "Exportar",
   "resource.import": "Importar",
-  "resource.downloadCsv": "Descargar CSV",
   "resource.validate": "Comprobar",
   "resource.links": "Enlaces",
   "resource.share": "Compartir",
@@ -116,10 +116,25 @@
   "node.download": "Descargar el archivo",
   "node.attachmentHelp": "El archivo canónico se guarda en privado en Intel. Su proyección legible por la IA se indexa por separado.",
   "node.table.summary": "{rows} filas, {columns} columnas",
-  "node.table.download": "Descargar CSV",
-  "node.table.downloadFailed": "No se pudo crear el CSV. Puede que la tabla todavía esté vacía.",
   "node.table.empty": "Todavía no hay filas. Las filas las añaden los flujos.",
   "node.table.undefined": "Esta tabla todavía no tiene columnas.",
+  "node.table.columnsTitle": "Columnas de {title}",
+  "node.table.columnName": "Nombre de la columna «{column}»",
+  "node.table.columnNewName": "Nombre de la nueva columna",
+  "node.table.columnAdd": "Añadir columna",
+  "node.table.columnDrop": "Eliminar la columna «{column}»",
+  "node.table.columnDropNew": "Eliminar la nueva columna",
+  "node.table.columnsDistinct": "Dos columnas no pueden llevar el mismo nombre.",
+  "node.table.columnsNamed": "Cada columna necesita un nombre.",
+  "node.table.columnsAtLeastOne": "Una tabla necesita al menos una columna.",
+  "node.table.columnsTooLong": "Un nombre de columna puede tener como máximo 120 caracteres.",
+  "node.table.columnsTooMany": "Una tabla puede tener como máximo 64 columnas.",
+  "node.table.columnsDropWarning.one": "Esta columna se elimina con todas sus celdas: {columns}",
+  "node.table.columnsDropWarning.many": "Estas columnas se eliminan con todas sus celdas: {columns}",
+  "node.table.columnsDropRows.none": "Ninguna fila tiene contenido ahí, así que no se pierde nada con ellas.",
+  "node.table.columnsDropRows.one": "Una fila tiene contenido ahí. Seguirá siendo legible en el historial de versiones y en ningún otro sitio.",
+  "node.table.columnsDropRows.many": "{count} filas tienen contenido ahí. Seguirá siendo legible en el historial de versiones y en ningún otro sitio.",
+  "node.table.columnsDropConfirm": "Eliminar y guardar",
   "node.select": "Elige un documento o una carpeta para trabajar con ello.",
   "node.folderEmpty": "En esta carpeta todavía no hay nada. Crea algo con el más de la barra lateral.",
   "node.folderFailed": "Esta carpeta no se ha podido leer.",
@@ -347,6 +362,7 @@
   "common.loading": "Cargando…",
   "common.retry": "Intentarlo de nuevo",
   "common.close": "Cerrar",
+  "common.cancel": "Cancelar",
   "common.unavailable": "Intel no está disponible en este momento.",
   "common.noAccess": "Esto no está disponible para ti. Puede que no exista o que ya no esté compartido contigo.",
   "common.noPermission": "No tienes permiso para ver esto.",
@@ -364,5 +380,17 @@
   "flows.toolStepNeedsServer": "Al paso «{label}» todavía le falta un servidor.",
   "flows.toolFunctionsFailed": "No se pudo cargar la lista de funciones, así que la selección puede estar incompleta.",
   "flows.publishPreviewToolUnavailable": "No alcanzas este servidor, así que la publicación será rechazada.",
-  "flows.publishPreviewToolAllow": "Congelado en: {functions}"
+  "flows.publishPreviewToolAllow": "Congelado en: {functions}",
+  "flow.shareUnreadable": "Este flujo lee documentos que este acceso no cubre: {titles}.",
+  "flow.shareUnreadableMore": "{count} más también quedan fuera de alcance, y no puedes verlos.",
+  "flow.shareUnreadableHidden": "{count} documentos que lee este flujo quedan fuera de alcance con este acceso. No puedes verlos.",
+  "flow.shareUnreadableHint": "No se bloquea nada. Una ejecución simplemente se detendrá en ese paso para esa persona.",
+  "flow.shareUnrunnable": "Este flujo llama a flujos que este acceso no cubre: {titles}.",
+  "flow.shareUnrunnableMore": "{count} más también quedan fuera de alcance, y no puedes verlos.",
+  "flow.shareUnrunnableHidden": "{count} flujos a los que llama este quedan fuera de alcance con este acceso. No puedes verlos.",
+  "flow.shareUnrunnableHint": "Un acceso sobre un flujo llega solo a ese flujo. Comparte también esos flujos, o la carpeta donde están. Con «Validar» lo verán ellos mismos antes de ejecutarlo.",
+  "flow.verbHint.read": "Abrir este flujo y leerlo",
+  "flow.verbHint.write": "Cambiar este flujo",
+  "flow.verbHint.execute": "Iniciar este flujo",
+  "flow.verbHint.share": "Dar acceso a otras personas"
 }

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

@@ -32,8 +32,10 @@ export function NodeTablePanel({ node }: { node: Node }) {
           query lives; the screen would otherwise have to load a table it does not show.
 
           ⚠️ The CSV export used to stand here too, as a button WITH TEXT beside two icon buttons.
-          Since #454 it is an entry in the title line's three-dot menu (`resource-menu.tsx`) — where
-          the bundle export sits as well, because both do the same: hand out the whole thing. */}
+          #454 moved it into the title line's three-dot menu, and #532 dropped it there: the bundle
+          export beside it already writes the table into the zip as `<title>.csv` (`bundle.ts`), so
+          the two entries handed out the same bytes. Taking a table home is `Export`, here and
+          nowhere else. */}
       <ActionSlot name="title-meta">
         {table.data
           ? i18n.t("node.table.summary", {

package/src/resource-error.ts

@@ -0,0 +1,33 @@
+/**
+ * Which sentence a refused change to a resource is told with.
+ *
+ * ⚠️ A conflict is the one that must not be swallowed: every write in the product names the state it
+ * was made against — `baseUpdatedAt` for a record, `baseVersionId` for a table — and turns a parallel
+ * edit into a refusal. A refusal nobody words is indistinguishable from a change that went through.
+ *
+ * ⚠️ Flat and on its own since #531, where the table's column dialog became the second reader. It
+ * used to live in `resource-menu.tsx`; importing it from there would have made the menu and the
+ * dialog import each other, and a cycle is a thing that works until the bundler splits differently.
+ */
+export function resourceErrorKey(error: unknown): string {
+  const code =
+    typeof error === "object" && error !== null && "code" in error
+      ? String((error as { code: unknown }).code)
+      : null;
+  switch (code) {
+    // ⚠️ `version_conflict` is the table's word for the same event (`nodes.ts`, `tableStateFor`):
+    // the positions or the mapping were read from a version that is no longer the newest. It is the
+    // conflict sentence and not the general one — "reload it and try again" is exactly the way out,
+    // and letting it fall through to `resource.failed` would tell somebody to reload in the same
+    // breath as claiming nobody knows what happened.
+    case "version_conflict":
+    case "update_conflict":
+    case "flow_update_conflict":
+      return "resource.conflict";
+    case "node_forbidden":
+    case "flow_edit_forbidden":
+      return "resource.forbidden";
+    default:
+      return "resource.failed";
+  }
+}

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

@@ -5,8 +5,8 @@ import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { useNavigate, useRouterState } from "@tanstack/react-router";
 import {
   Archive,
+  Columns3,
   CornerLeftUp,
-  Download,
   Ellipsis,
   FileArchive,
   FolderDown,
@@ -35,8 +35,10 @@ import type { TreeEntry } from "@/data/intel-data-provider/intel-data-provider.t
 import { useI18n } from "@/i18n/i18n-context.tsx";
 import { useBundleImport } from "@/import-bundle/import-bundle.tsx";
 import { Modal } from "@/modal/modal.tsx";
+import { resourceErrorKey } from "@/resource-error.ts";
 import { useIntelRouterContext } from "@/router/router-context.ts";
 import { selectedFrom } from "@/router/selection-search.ts";
+import { TableColumnsDialog } from "@/table-columns/table-columns.tsx";
 import { RelativeTime } from "@/time/relative-time.tsx";
 import { useDateTime } from "@/time/time-context.tsx";
 
@@ -49,9 +51,9 @@ import { useDateTime } from "@/time/time-context.tsx";
  * row menu could do is reached here — including moving, which is why this component owns the folder
  * picker rather than being handed one.
  *
- * ⚠️ An entry that does not apply is absent, never disabled: a folder has no retrieval mode, a flow
- * is shared through the folder it is filed in rather than on its own (ADR-0004 §2). A greyed-out row
- * still promises something is there.
+ * ⚠️ An entry that does not apply is absent, never disabled: a folder has no retrieval mode and no
+ * links, a flow has no version history of the node kind. A greyed-out row still promises something
+ * is there. Sharing applies to all of them since #530.
  */
 export type ResourceTarget = { type: "node"; node: Node } | { type: "flow"; flow: Flow };
 
@@ -83,33 +85,14 @@ function titleOf(target: ResourceTarget): string {
 /**
  * Which sentence explains a verb.
  *
- * ⚠️ One sentence per verb, and that is only true again since Agents were parked (#388). "Run"
- * used to mean two different things — starting the flows filed in a folder, and using an agent
- * through its chat, its schedules and its MCP address — so #143 gave the agent its own wording.
- * With one meaning left, a per-kind branch would be a fork nothing takes.
+ * ⚠️ The hint is about the SUBJECT as much as the verb, and the branch came back with #530. "See
+ * everything in here" is right for a folder and wrong for one flow, and a hint describing the wrong
+ * reach is worse than none — it is the sentence somebody reads INSTEAD of thinking about what they
+ * are granting. The wording that used to fork here was the agent's (#143), parked with it (#388);
+ * this is a different fork, on the subject rather than on a second meaning of one word.
  */
-export function verbHintKey(verb: ResourceVerb): string {
-  return `node.verbHint.${verb}`;
-}
-
-// ⚠️ The same reading `moveErrorKey` does for a move, for the changes this menu makes. A conflict is
-// the one that must not be swallowed: `baseUpdatedAt` turns a parallel edit into a refusal, and a
-// refusal nobody words is indistinguishable from a change that went through.
-export function resourceErrorKey(error: unknown): string {
-  const code =
-    typeof error === "object" && error !== null && "code" in error
-      ? String((error as { code: unknown }).code)
-      : null;
-  switch (code) {
-    case "update_conflict":
-    case "flow_update_conflict":
-      return "resource.conflict";
-    case "node_forbidden":
-    case "flow_edit_forbidden":
-      return "resource.forbidden";
-    default:
-      return "resource.failed";
-  }
+export function verbHintKey(verb: ResourceVerb, subject: ResourceTarget["type"] = "node"): string {
+  return `${subject}.verbHint.${verb}`;
 }
 
 /**
@@ -140,6 +123,7 @@ export function ResourceMenu({
   const [sharing, setSharing] = useState(false);
   const [linksOpen, setLinksOpen] = useState(false);
   const [versionsOpen, setVersionsOpen] = useState(false);
+  const [columnsOpen, setColumnsOpen] = useState(false);
   const selected = useRouterState({ select: (state) => selectedFrom(state.location.search) });
   const pathname = useRouterState({ select: (state) => state.location.pathname });
   // ⚠️ Dragging is a pointer gesture and nothing else: no keyboard, no screen reader, no touch worth
@@ -165,6 +149,10 @@ export function ResourceMenu({
   // ⚠️ Absent, not disabled — the rule at the top of this file. An import needs a folder to file
   // into; a document has nowhere to put a subtree, and a greyed-out entry would promise it does.
   const importable = node !== null && node.kind === "folder";
+  // ⚠️ Only a table has a header to change, so only a table carries the entry — absent, not
+  // disabled, the rule at the top of this file. Until #531 the header could be changed over MCP and
+  // nowhere else: a person had strictly less reach on their own table than a model did.
+  const isTable = node !== null && node.kind === "table";
   const bundleImport = useBundleImport({ where: title });
 
   // Everything a change here can make stale. The row sits in one level of the tree, the open screen
@@ -271,37 +259,6 @@ export function ResourceMenu({
     },
   });
 
-  // #454: a table's CSV export — an ENTRY, not a button of its own. It was the only control WITH
-  // TEXT beside two icon buttons in the title line, and it was needed no more often than what sits
-  // in here anyway; it was merely wider. Intel has made the same decision twice already (#363 for
-  // status and archive, #346 for the import).
-  //
-  // ⚠️ It lives HERE and no longer in `NodeTablePanel`: there it hung off the table query in order
-  // to prevent an empty export. The condition survives the move without a second query — the
-  // canonical content IS the CSV, and if it is empty nothing is downloaded, it is refused instead.
-  // A file of zero bytes is the worse answer.
-  const downloadCsv = useMutation({
-    mutationFn: async () => {
-      if (target.type !== "node") throw new Error("csv export is a node's");
-      const document_ = await data.getNode(target.node.id);
-      const content = document_.content ?? "";
-      if (content === "") throw new Error("nothing to export yet");
-      return new Blob([content], { type: "text/csv;charset=utf-8" });
-    },
-    onSuccess: (blob) => {
-      const url = URL.createObjectURL(blob);
-      const anchor = document.createElement("a");
-      anchor.href = url;
-      // No doubled `.csv` when the title already carries the extension — unchanged from #40.
-      anchor.download = title.toLowerCase().endsWith(".csv") ? title : `${title}.csv`;
-      document.body.append(anchor);
-      anchor.click();
-      anchor.remove();
-      setTimeout(() => URL.revokeObjectURL(url), 0);
-    },
-  });
-  const isTable = target.type === "node" && target.node.kind === "table";
-
   const failure = rename.isError
     ? null // the rename dialog words its own refusal, beside the field that caused it
     : archive.isError
@@ -327,6 +284,15 @@ export function ResourceMenu({
             <Pencil aria-hidden="true" />
             {i18n.t("resource.rename")}
           </DropdownMenuItem>
+          {/* Directly under the rename, because they are the same gesture at two levels: one names
+              the table, the other names its columns. A reader looking for "change what this is
+              called" finds both without reading the rest of the menu (#531). */}
+          {isTable ? (
+            <DropdownMenuItem onSelect={() => setColumnsOpen(true)}>
+              <Columns3 aria-hidden="true" />
+              {i18n.t("resource.columns")}
+            </DropdownMenuItem>
+          ) : null}
           {/* The dialog stays the complete keyboard and touch path. Dragging is only a mouse
               shortcut; it does not need a second label beside this action. */}
           {/* ⚠️ `undefined`, and that is the honest answer rather than a missing one: this menu hangs
@@ -340,19 +306,21 @@ export function ResourceMenu({
           </DropdownMenuItem>
           {/* Every kind exports: a folder takes its subtree along, everything else is a bundle of
               one (#136). The entry sits with rename and move because it acts on the whole thing,
-              not on its content. */}
+              not on its content.
+
+              ⚠️ A table has NO second entry beside this one (#532). It used to carry "Download CSV"
+              here, and for a table WITH a header both handed out the same bytes: `bundle.ts` writes
+              such a node into the zip as `<title>.csv`. Two ways to one file are two strings, two
+              catalogs and two tests — the zip costs one step more and is the whole difference.
+
+              ⚠️ The one case where they differed is the table that has no header yet: `downloadCsv`
+              refused it out loud, `tableCsv` joins no segments and writes a file of zero bytes
+              (#534). That is the export's gap on every kind it can hit, not something this entry
+              was covering — which is why it is fixed there and not by keeping a second entry. */}
           <DropdownMenuItem onSelect={() => exportBundle.mutate()}>
             <FolderDown aria-hidden="true" />
             {i18n.t("resource.export")}
           </DropdownMenuItem>
-          {/* Only a table has a CSV — and it stands beside the bundle export because both do the
-              same thing: hand out the whole thing, not a part of its content. */}
-          {isTable ? (
-            <DropdownMenuItem onSelect={() => downloadCsv.mutate()}>
-              <Download aria-hidden="true" />
-              {i18n.t("resource.downloadCsv")}
-            </DropdownMenuItem>
-          ) : null}
           {/* The other half of the same round trip, next to it rather than in the tree's plus
               (#346): one word in the menu, both sources under it. */}
           {importable ? (
@@ -387,15 +355,12 @@ export function ResourceMenu({
               {i18n.t("resource.links")}
             </DropdownMenuItem>
           ) : null}
-          {/* A flow has no share of its own: it is reached through the folder it is filed in, and a
-              narrower grant beside the folder's would break the rule that a flow only calls flows in
-              its own subtree (ADR-0004 §2). */}
-          {node ? (
-            <DropdownMenuItem onSelect={() => setSharing(true)}>
-              <Share2 aria-hidden="true" />
-              {i18n.t("resource.share")}
-            </DropdownMenuItem>
-          ) : null}
+          {/* Every kind of resource is shared here, a flow included since #530. What a grant on one
+              flow does NOT reach is said in the dialog rather than refused here. */}
+          <DropdownMenuItem onSelect={() => setSharing(true)}>
+            <Share2 aria-hidden="true" />
+            {i18n.t("resource.share")}
+          </DropdownMenuItem>
           {(node === null || node.kind !== "folder") && (
             <DropdownMenuItem onSelect={() => setVersionsOpen(true)}>
               <History aria-hidden="true" />
@@ -419,9 +384,6 @@ export function ResourceMenu({
       {/* Its own sentence, not `resourceErrorKey`'s: nothing was changed, something failed to
           arrive, and "the change was not saved" would send the reader looking for a change. */}
       {exportBundle.isError ? <MenuFailure>{i18n.t("resource.exportFailed")}</MenuFailure> : null}
-      {downloadCsv.isError ? (
-        <MenuFailure>{i18n.t("node.table.downloadFailed")}</MenuFailure>
-      ) : null}
       {/* The import's own sentence, and its own pickers — only where the entry exists, because two
           file inputs on every document's menu would be two elements nothing can ever open. */}
       {bundleImport.isError ? <MenuFailure>{i18n.t("tree.importFailed")}</MenuFailure> : null}
@@ -490,8 +452,11 @@ export function ResourceMenu({
           submit={(next) => rename.mutate(next)}
         />
       ) : null}
-      {sharing && node ? <SharePanel node={node} close={() => setSharing(false)} /> : null}
+      {sharing ? <SharePanel target={target} close={() => setSharing(false)} /> : null}
       {linksOpen && node ? <NodeLinksPanel node={node} close={() => setLinksOpen(false)} /> : null}
+      {columnsOpen && node ? (
+        <TableColumnsDialog node={node} close={() => setColumnsOpen(false)} />
+      ) : null}
       {versionsOpen ? (
         <VersionHistory target={target} close={() => setVersionsOpen(false)} />
       ) : null}
@@ -688,10 +653,10 @@ function NodeLinksPanel({ node, close }: { node: Node; close(): void }) {
   );
 }
 
-// The one share dialog in the product. It sits on the folder that holds the documents and the
-// flows, which is where a permission decision belongs (ADR-0004 §2). Which verbs it offers is the
-// server's answer, not this component's: `execute` never appears on a document, because a document
-// has nothing to run.
+// The one share dialog in the product, for every kind of resource that can be shared — a folder, a
+// document, a table, and since #530 a flow on its own. Which verbs it offers is the server's
+// answer, not this component's: `execute` never appears on a document, because a document has
+// nothing to run, and all four appear on a flow.
 /**
  * Which of the three principals the dialog can SET (#431).
  *
@@ -709,7 +674,18 @@ function NodeLinksPanel({ node, close }: { node: Node; close(): void }) {
  */
 type SharePrincipalKind = "email" | "organization";
 
-function SharePanel({ node, close }: { node: Node; close(): void }) {
+// What the grant just made does not cover, in the two directions it can fail to (#530): documents
+// the grantee cannot read, and flows the grantee cannot start. Both are `null` until an answer
+// arrives, so "no warning yet" and "nothing to warn about" stay distinguishable.
+type ShareWarnings = { unreadable: UnreadableNodes; unrunnable: UnreadableNodes } | null;
+
+// Whether there is anything to say. A warning with neither a title nor a count is silence, and
+// drawing an empty box for it would make every ordinary grant look like it had a caveat.
+function withheld(value: UnreadableNodes): boolean {
+  return value.titles.length > 0 || value.hidden > 0;
+}
+
+function SharePanel({ target, close }: { target: ResourceTarget; close(): void }) {
   const { data } = useIntelRouterContext();
   const i18n = useI18n();
   const queryClient = useQueryClient();
@@ -718,31 +694,50 @@ function SharePanel({ node, close }: { node: Node; close(): void }) {
   const [verbs, setVerbs] = useState<ResourceVerb[]>(["read"]);
   // What the grant just made does not cover. It survives the form being cleared, because it is the
   // answer to the question the user just asked and they need a moment to read it.
-  const [unreadable, setUnreadable] = useState<UnreadableNodes | null>(null);
+  const [warnings, setWarnings] = useState<ShareWarnings>(null);
+  const isFlow = target.type === "flow";
+  const resourceId = idOf(target);
   const grants = useQuery({
-    queryKey: ["node-grants", node.id],
-    queryFn: () => data.listGrants(node.id),
+    queryKey: ["resource-grants", target.type, resourceId],
+    queryFn: () => (isFlow ? data.listFlowGrants(resourceId) : data.listGrants(resourceId)),
   });
+  // ⚠️ Both queries are invalidated by every mutation below, and the flow key is under the same
+  // effective prefix as the node key: a grant on a flow changes what the summary of the folder
+  // above it shows, and the other way round.
+  const invalidate = async () => {
+    await Promise.all([
+      queryClient.invalidateQueries({ queryKey: ["resource-grants", target.type, resourceId] }),
+      queryClient.invalidateQueries({ queryKey: ["effective-node-grants"] }),
+    ]);
+  };
   const share = useMutation({
     // One request per verb, because one grant is one verb. The keys differ so a retry of the whole
     // form replays each verb on its own rather than collapsing them into one.
     mutationFn: async () => {
-      let last: UnreadableNodes | null = null;
+      let last: ShareWarnings = null;
       for (const verb of verbs) {
+        const principal =
+          principalKind === "organization"
+            ? ({ type: "organization" } as const)
+            : ({ type: "email", email } as const);
         // The last verb's answer is the one kept: every request describes the access in force after
         // it, so the newest is the only one still true.
-        last = (
-          await data.shareNode({
-            resourceId: node.id,
-            principal:
-              principalKind === "organization"
-                ? { type: "organization" }
-                : { type: "email", email },
-            verb,
-            expiresAt: null,
-            idempotencyKey: crypto.randomUUID(),
-          })
-        ).unreadable;
+        const result = isFlow
+          ? await data.shareFlow({
+              flowId: resourceId,
+              principal,
+              verb,
+              expiresAt: null,
+              idempotencyKey: crypto.randomUUID(),
+            })
+          : await data.shareNode({
+              resourceId,
+              principal,
+              verb,
+              expiresAt: null,
+              idempotencyKey: crypto.randomUUID(),
+            });
+        last = { unreadable: result.unreadable, unrunnable: result.unrunnable };
       }
       return last;
     },
@@ -752,32 +747,28 @@ function SharePanel({ node, close }: { node: Node; close(): void }) {
       // until the review of #431 caught it, and "everyone in the organization" is the one setting
       // that must never be the quiet default for the NEXT grant somebody makes in the same dialog.
       setPrincipalKind("email");
-      setUnreadable(result);
+      setWarnings(result);
     },
     // ⚠️ `onSettled`, not `onSuccess`. One request per verb means a run can end halfway: three verbs
     // granted, the fourth refused. On `onSuccess` the list would then still show the state from
     // before, and the user would read a permission picture that is not the one in force. Of all the
     // things to be silently wrong about, access is the worst.
-    onSettled: async () => {
-      await Promise.all([
-        queryClient.invalidateQueries({ queryKey: ["node-grants", node.id] }),
-        queryClient.invalidateQueries({ queryKey: ["effective-node-grants"] }),
-      ]);
-    },
+    onSettled: invalidate,
   });
   const revoke = useMutation({
     mutationFn: (grantId: string) =>
-      data.revokeGrant({
-        resourceId: node.id,
-        grantId,
-        idempotencyKey: crypto.randomUUID(),
-      }),
-    onSettled: async () => {
-      await Promise.all([
-        queryClient.invalidateQueries({ queryKey: ["node-grants", node.id] }),
-        queryClient.invalidateQueries({ queryKey: ["effective-node-grants"] }),
-      ]);
-    },
+      isFlow
+        ? data.revokeFlowGrant({
+            flowId: resourceId,
+            grantId,
+            idempotencyKey: crypto.randomUUID(),
+          })
+        : data.revokeGrant({
+            resourceId,
+            grantId,
+            idempotencyKey: crypto.randomUUID(),
+          }),
+    onSettled: invalidate,
   });
 
   /**
@@ -817,19 +808,45 @@ function SharePanel({ node, close }: { node: Node; close(): void }) {
       {/* ⚠️ `status`, not `alert`, and beside the grant rather than in place of it: the access was
           given. A node reference across the folder edge is a possible failure, not a way around
           permissions, so nothing here blocks anything (ADR-0004 §4). */}
-      {unreadable && (unreadable.titles.length > 0 || unreadable.hidden > 0) && (
+      {warnings && withheld(warnings.unreadable) && (
+        <div role="status" className="mb-4 rounded-md border bg-muted p-3 text-sm">
+          {warnings.unreadable.titles.length > 0 ? (
+            <p>
+              {i18n.t(`${target.type}.shareUnreadable`, {
+                titles: warnings.unreadable.titles.join(", "),
+              })}
+              {warnings.unreadable.hidden > 0
+                ? ` ${i18n.t(`${target.type}.shareUnreadableMore`, { count: warnings.unreadable.hidden })}`
+                : ""}
+            </p>
+          ) : (
+            <p>
+              {i18n.t(`${target.type}.shareUnreadableHidden`, {
+                count: warnings.unreadable.hidden,
+              })}
+            </p>
+          )}
+          <p className="mt-1 text-xs text-muted-foreground">
+            {i18n.t(`${target.type}.shareUnreadableHint`)}
+          </p>
+        </div>
+      )}
+      {/* The half a folder grant never needed: a grant on ONE flow stops at that flow, so the flows
+          it calls are somebody else's to grant. `status` and not `alert` for the same reason as
+          above — the access was given, and this says what it does not reach (#530). */}
+      {warnings && withheld(warnings.unrunnable) && (
         <div role="status" className="mb-4 rounded-md border bg-muted p-3 text-sm">
-          {unreadable.titles.length > 0 ? (
+          {warnings.unrunnable.titles.length > 0 ? (
             <p>
-              {i18n.t("node.shareUnreadable", { titles: unreadable.titles.join(", ") })}
-              {unreadable.hidden > 0
-                ? ` ${i18n.t("node.shareUnreadableMore", { count: unreadable.hidden })}`
+              {i18n.t("flow.shareUnrunnable", { titles: warnings.unrunnable.titles.join(", ") })}
+              {warnings.unrunnable.hidden > 0
+                ? ` ${i18n.t("flow.shareUnrunnableMore", { count: warnings.unrunnable.hidden })}`
                 : ""}
             </p>
           ) : (
-            <p>{i18n.t("node.shareUnreadableHidden", { count: unreadable.hidden })}</p>
+            <p>{i18n.t("flow.shareUnrunnableHidden", { count: warnings.unrunnable.hidden })}</p>
           )}
-          <p className="mt-1 text-xs text-muted-foreground">{i18n.t("node.shareUnreadableHint")}</p>
+          <p className="mt-1 text-xs text-muted-foreground">{i18n.t("flow.shareUnrunnableHint")}</p>
         </div>
       )}
       {grants.data && grants.data.items.length > 0 ? (
@@ -922,7 +939,13 @@ function SharePanel({ node, close }: { node: Node; close(): void }) {
                 It is a warning and not a block, deliberately: the library is a documented, wanted
                 shape, MCP has always been able to make one, and refusing it here would put a person
                 back below a model on the same tree — the very asymmetry this ticket removed. */}
-            {verbs.includes("execute") ? (
+            {/* ⚠️ Only on a node, and that is not an oversight. What makes a folder a library is
+                `execute` for the organization ON THE FOLDER: `callReach` reads `node_grants` along
+                the callee's ancestors and nothing else, so the same grant on a flow itself makes no
+                library and reaches no caller outside its subtree. Showing this line there would
+                warn about a consequence that cannot happen — and about a refusal on the way back
+                that would never come (#530). */}
+            {!isFlow && verbs.includes("execute") ? (
               <p role="note" className="font-medium text-destructive">
                 {i18n.t("node.shareLibraryWarning")}
               </p>
@@ -946,7 +969,9 @@ function SharePanel({ node, close }: { node: Node; close(): void }) {
                 className="size-4 rounded border outline-none focus-visible:ring-2 focus-visible:ring-ring"
               />
               <span>{i18n.t(`node.verb.${verb}`)}</span>
-              <span className="text-xs text-muted-foreground">{i18n.t(verbHintKey(verb))}</span>
+              <span className="text-xs text-muted-foreground">
+                {i18n.t(verbHintKey(verb, target.type))}
+              </span>
             </label>
           ))}
         </fieldset>

package/src/table-columns/table-columns.tsx

@@ -0,0 +1,379 @@
+import type { Node } from "@anchrd/intel-contract/node";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { Plus, X } from "lucide-react";
+import { useEffect, useRef, useState } from "react";
+import { useI18n } from "@/i18n/i18n-context.tsx";
+import { Modal } from "@/modal/modal.tsx";
+import { resourceErrorKey } from "@/resource-error.ts";
+import { useIntelRouterContext } from "@/router/router-context.ts";
+
+/**
+ * Changing a table's header from the UI (#531).
+ *
+ * ⚠️ Adding and renaming are free; removing is confirmed. That asymmetry is the whole point of the
+ * dialog and not a courtesy: a rename keeps every cell, an added column starts empty and takes
+ * nothing away, and a removal is the one gesture whose cost is invisible in this dialog — the cells
+ * stand in the grid behind it, and after the write they are only in the version history.
+ *
+ * ⚠️ The confirmation is a SECOND STEP of this dialog, not `window.confirm` and not a modal over a
+ * modal. It has to name which columns go and how much content goes with them, and a browser prompt
+ * carries neither markup nor the reader's language.
+ */
+type Draft = { key: string; name: string; source: string | null };
+
+/**
+ * The mapping together with the state it was written against (#531, review finding).
+ *
+ * ⚠️ `versionId` is pinned HERE and not read from the query at save time, and that is the whole
+ * optimistic lock. The query behind it shares its key with the grid and refetches on window focus,
+ * so a mapping written against `version-3` would otherwise be sent with whatever version the table
+ * had grown to in the meantime — the server would accept it, and a column somebody else added in
+ * between falls with its cells, because no entry in this mapping names it. Measured in the review:
+ * a refetch between renaming and saving turned `version-3` into `version-9` and the guard never
+ * fired. `columns` and `rows` are pinned with it, so the warning counts the state the reader saw.
+ */
+type Snapshot = {
+  versionId: string | null;
+  columns: string[];
+  rows: string[][];
+  entries: Draft[];
+};
+
+// One entry per column the table will have afterwards, in order — the shape `RedefineTableInput`
+// takes. `source` is the CURRENT name of the column whose cells fill it, so renaming is keeping the
+// source and changing the name, and a current column no entry names is the one that falls.
+//
+// ⚠️ The key of an existing column is its source, not a fresh id. This runs on every render for as
+// long as nothing has been edited, and `crypto.randomUUID()` would hand React a new key each time —
+// every field remounts, and a refetch behind the open dialog takes the caret out of the one being
+// typed in. Sources are distinct on every path that writes a table, so they are already keys.
+function draftOf(columns: string[]): Draft[] {
+  return columns.map((column) => ({ key: `source:${column}`, name: column, source: column }));
+}
+
+// Which current columns no draft entry claims. Reading it off the draft rather than tracking a
+// second "removed" list is what makes taking a removal back the same gesture as adding: there is one
+// list, and it is the answer.
+function droppedFrom(columns: string[], draft: Draft[]): string[] {
+  const kept = new Set(draft.map((entry) => entry.source).filter((source) => source !== null));
+  return columns.filter((column) => !kept.has(column));
+}
+
+/**
+ * How many rows actually lose something.
+ *
+ * ⚠️ Not `rows.length`. Dropping a column nobody ever filled costs nothing, and telling the reader
+ * "42 rows lose cells" when none of them carried content there is a wrong sentence about the one
+ * thing they are being asked to confirm. Counted per row, because a row is what a person sees.
+ */
+function rowsWithContentIn(columns: string[], rows: string[][], dropped: string[]): number {
+  const indexes = dropped.map((column) => columns.indexOf(column)).filter((index) => index >= 0);
+  return rows.filter((row) => indexes.some((index) => (row[index] ?? "") !== "")).length;
+}
+
+export function TableColumnsDialog({ node, close }: { node: Node; close(): void }) {
+  const { data } = useIntelRouterContext();
+  const i18n = useI18n();
+  const queryClient = useQueryClient();
+  // The same key the grid reads under, so the dialog and the table behind it are one loaded state
+  // and never two that disagree about how many columns there are.
+  const table = useQuery({
+    queryKey: ["node-table", node.id],
+    queryFn: () => data.getNodeTable(node.id),
+  });
+  const [draft, setDraft] = useState<Snapshot | null>(null);
+  const [confirming, setConfirming] = useState(false);
+  // The focus on the way back out of the confirmation. A ref alone cannot do it: the button does
+  // not exist yet at the moment the step is left, so the wish is recorded and spent on the render
+  // that brings the form back.
+  const [refocusSave, setRefocusSave] = useState(false);
+  const saveButton = useRef<HTMLButtonElement>(null);
+  useEffect(() => {
+    if (!refocusSave) return;
+    saveButton.current?.focus();
+    setRefocusSave(false);
+  }, [refocusSave]);
+
+  // ⚠️ Derived rather than seeded through an effect: the query answers after the first render, and
+  // an effect would leave one frame in which the dialog is a form over no rows. The FIRST edit
+  // freezes this into state, and from then on the pinned snapshot is what is read — including its
+  // `versionId`, which is what makes the server's refusal reachable at all.
+  const current: Snapshot = draft ?? {
+    versionId: table.data?.versionId ?? null,
+    columns: table.data?.columns ?? [],
+    rows: table.data?.rows ?? [],
+    entries: draftOf(table.data?.columns ?? []),
+  };
+  const entries = current.entries;
+  const dropped = droppedFrom(current.columns, entries);
+  const losing = rowsWithContentIn(current.columns, current.rows, dropped);
+
+  const names = entries.map((entry) => entry.name.trim());
+  const blank = names.some((name) => name === "");
+  const duplicate = new Set(names.map((name) => name.toLowerCase())).size !== names.length;
+  // ⚠️ The bounds of `TableColumn` and `RedefineTableInput`, mirrored rather than left to the
+  // provider's `parse`. A `ZodError` never reaches `resourceErrorKey` with a code, so it arrives as
+  // "reload the latest version and try again" — advice that cannot help somebody whose column name
+  // is simply too long.
+  //
+  // ⚠️ And it is not `maxLength`'s job: that attribute bounds what is TYPED or pasted, and it does
+  // not touch a value that is already in the field. The header this dialog starts from comes from
+  // the server, and `bundle.ts` checks an imported CSV header against neither bound — so a table
+  // that is already over one of them is where this check earns its place.
+  const tooLong = names.some((name) => name.length > 120);
+  const tooMany = entries.length > 64;
+  const empty = entries.length === 0;
+  const incomplete = empty || blank || duplicate || tooLong || tooMany;
+
+  const save = useMutation({
+    mutationFn: async () => {
+      const idempotencyKey = crypto.randomUUID();
+      // ⚠️ Two calls, because the server has two: `defineTable` refuses on a table that already has
+      // a header, and `redefineTable` refuses on one that has none (`table_undefined`). A table
+      // without a header is reachable through MCP and through the bundle import, so this dialog is
+      // the only place in the UI where such a table can be given one at all.
+      //
+      // ⚠️ `current.versionId`, never `table.data.versionId`: the mapping below was written against
+      // the pinned snapshot, and sending it under a version it was not written against is exactly
+      // the silent wrong-cells move `Snapshot` exists to prevent.
+      const base = current.versionId;
+      if (base === null) {
+        await data.defineTable({ nodeId: node.id, columns: names, idempotencyKey });
+        return;
+      }
+      await data.redefineTable({
+        nodeId: node.id,
+        baseVersionId: base,
+        columns: entries.map((entry, index) => ({
+          name: names[index] ?? "",
+          source: entry.source,
+        })),
+        idempotencyKey,
+      });
+    },
+    onSuccess: async () => {
+      // The grid, the count beside the title and the record itself: the header is drawn from the
+      // first, the summary from the first, and `updatedAt` — which every other change in the menu
+      // sends as `baseUpdatedAt` — from the last.
+      await Promise.all([
+        queryClient.invalidateQueries({ queryKey: ["node-table", node.id] }),
+        queryClient.invalidateQueries({ queryKey: ["node", node.id] }),
+      ]);
+      close();
+    },
+  });
+
+  // Every edit writes the WHOLE snapshot back, which is what pins the version: the first CHANGE —
+  // a keystroke, a ✕, an added column — is the moment the reader started working against a
+  // particular state of the table.
+  //
+  // ⚠️ Between opening and that first change there is deliberately no guard. Nothing has been
+  // composed yet that points at a particular header, so a version arriving in between is simply the
+  // one the reader is now looking at. Saying otherwise would promise more than is here.
+  function edit(key: string, name: string): void {
+    setDraft({
+      ...current,
+      entries: entries.map((entry) => (entry.key === key ? { ...entry, name } : entry)),
+    });
+  }
+
+  function drop(key: string): void {
+    setDraft({ ...current, entries: entries.filter((entry) => entry.key !== key) });
+  }
+
+  function add(): void {
+    setDraft({
+      ...current,
+      // A fresh id, because an added column has no source to be named after — and no `source:`
+      // prefix, so it can never collide with the key of a column that has one.
+      entries: [...entries, { key: crypto.randomUUID(), name: "", source: null }],
+    });
+  }
+
+  function submit(): void {
+    // Removing is the only branch that asks. Everything else — a rename, an added column, both at
+    // once — goes straight through, because nothing stored is lost by either.
+    if (dropped.length > 0 && !confirming) {
+      setConfirming(true);
+      return;
+    }
+    save.mutate();
+  }
+
+  return (
+    <Modal title={i18n.t("node.table.columnsTitle", { title: node.title })} close={close}>
+      {table.isPending ? (
+        <p className="text-sm text-muted-foreground">{i18n.t("common.loading")}</p>
+      ) : table.isError ? (
+        <p role="alert" className="text-sm text-destructive">
+          {i18n.t("node.loadFailed")}
+        </p>
+      ) : confirming ? (
+        <div className="space-y-4">
+          {/* ⚠️ `alert`, not `status`: this is the one screen in the dialog that must be read before
+              the button under it is pressed, and it is the only place the cost is named at all. */}
+          <div role="alert" className="space-y-2 rounded-md border border-destructive/30 p-3">
+            {/* ⚠️ One sentence per number, the `.none`/`.one`/`.many` shape `archive.purge.links`
+                already uses for the same job. A single plural template reads as broken German the
+                moment the count is one — "Diese Spalten … : note", "1 Zeilen tragen dort Inhalt" —
+                and this is the screen a reader is asked to trust before losing cells. Found in the
+                browser, not in jsdom: the tests were written around the two-row case. */}
+            <p className="text-sm font-medium text-destructive">
+              {i18n.t(
+                dropped.length === 1
+                  ? "node.table.columnsDropWarning.one"
+                  : "node.table.columnsDropWarning.many",
+                { columns: dropped.join(", ") },
+              )}
+            </p>
+            {/* The honest number, and the honest sentence when it is zero. A column nobody ever
+                filled costs nothing, and saying "42 rows" about it would be the wrong sentence. */}
+            <p className="text-xs text-muted-foreground">
+              {losing === 0
+                ? i18n.t("node.table.columnsDropRows.none")
+                : losing === 1
+                  ? i18n.t("node.table.columnsDropRows.one")
+                  : i18n.t("node.table.columnsDropRows.many", { count: losing })}
+            </p>
+          </div>
+          {save.isError ? (
+            <p role="alert" className="text-sm text-destructive">
+              {i18n.t(resourceErrorKey(save.error))}
+            </p>
+          ) : null}
+          <div className="flex gap-2">
+            {/* The way back is first and it is a real button: somebody who reads the warning and
+                changes their mind must not have to find the × in the corner.
+
+                ⚠️ And it takes the focus, because this step REPLACES the form the focus was in —
+                without it the focus falls to `<body>` and a keyboard reader stands outside the
+                dialog at the one step that destroys something (review finding to #531). The safe
+                button, not the destructive one: focus is where Enter lands. */}
+            <button
+              type="button"
+              // biome-ignore lint/a11y/noAutofocus: the step replaces the focused form; see above
+              autoFocus
+              // ⚠️ And the way BACK carries the focus too. `autoFocus` only fires on the way in;
+              // returning to the form dropped it on `<body>` again — half a keyboard path is the
+              // same defect as none, one step further on (second review round of #531).
+              onClick={() => {
+                setConfirming(false);
+                setRefocusSave(true);
+              }}
+              className="flex-1 rounded-md border px-4 py-2 text-sm font-medium outline-none hover:bg-muted focus-visible:ring-2 focus-visible:ring-ring"
+            >
+              {i18n.t("common.cancel")}
+            </button>
+            <button
+              type="button"
+              onClick={() => save.mutate()}
+              disabled={save.isPending}
+              className="flex-1 rounded-md bg-destructive px-4 py-2 text-sm font-medium text-destructive-foreground outline-none hover:bg-destructive/90 focus-visible:ring-2 focus-visible:ring-ring disabled:opacity-50"
+            >
+              {save.isPending ? i18n.t("common.saving") : i18n.t("node.table.columnsDropConfirm")}
+            </button>
+          </div>
+        </div>
+      ) : (
+        <form
+          className="space-y-4"
+          onSubmit={(event) => {
+            event.preventDefault();
+            if (!save.isPending && !incomplete) submit();
+          }}
+        >
+          {save.isError ? (
+            <p role="alert" className="text-sm text-destructive">
+              {i18n.t(resourceErrorKey(save.error))}
+            </p>
+          ) : null}
+          <ul className="max-h-72 space-y-2 overflow-y-auto">
+            {entries.map((entry) => (
+              <li key={entry.key} className="flex items-center gap-2">
+                <label className="min-w-0 flex-1 text-sm">
+                  {/* ⚠️ The name is the accessible name of the field, and it is the CURRENT column's
+                      name rather than a bare "Column": with five fields on screen, five labels
+                      reading the same word leave a screen reader with no way to say which one is
+                      being edited. An added column has no current name and says so. */}
+                  <span className="sr-only">
+                    {entry.source === null
+                      ? i18n.t("node.table.columnNewName")
+                      : i18n.t("node.table.columnName", { column: entry.source })}
+                  </span>
+                  <input
+                    value={entry.name}
+                    // The bound `TableColumn` carries, for what is typed or pasted here. What
+                    // arrives from the server already over it is caught by `tooLong` above.
+                    maxLength={120}
+                    onChange={(event) => edit(entry.key, event.target.value)}
+                    className="w-full rounded-md border bg-background px-3 py-2 outline-none focus-visible:ring-2 focus-visible:ring-ring"
+                  />
+                </label>
+                <button
+                  type="button"
+                  onClick={() => drop(entry.key)}
+                  // ⚠️ A column with no name yet has its own label. The fallback used to fill the
+                  // template with an empty string, and the button then announced itself as
+                  // `Die Spalte „" entfernen` — seen in the browser right after adding one.
+                  aria-label={
+                    entry.name.trim() === "" && entry.source === null
+                      ? i18n.t("node.table.columnDropNew")
+                      : i18n.t("node.table.columnDrop", {
+                          column: entry.name.trim() === "" ? (entry.source ?? "") : entry.name,
+                        })
+                  }
+                  className="shrink-0 rounded-md p-2 text-muted-foreground outline-none hover:bg-muted hover:text-destructive focus-visible:ring-2 focus-visible:ring-ring"
+                >
+                  <X aria-hidden="true" className="size-4" />
+                </button>
+              </li>
+            ))}
+          </ul>
+          <button
+            type="button"
+            onClick={add}
+            disabled={entries.length >= 64}
+            className="flex w-full items-center justify-center gap-2 rounded-md border border-dashed px-4 py-2 text-sm outline-none hover:bg-muted focus-visible:ring-2 focus-visible:ring-ring disabled:opacity-50"
+          >
+            <Plus aria-hidden="true" className="size-4" />
+            {i18n.t("node.table.columnAdd")}
+          </button>
+          {/* ⚠️ EVERY reason the button is grey is named while it holds, and there are five. The
+              first version of this listed two and left the empty header — the state a reader
+              reaches by removing the last column — with a dead button and no sentence at all
+              (review finding to #531). A submit that is grey for a reason nobody states is a dialog
+              that has stopped answering. Ordered so the one the reader just caused comes first. */}
+          {duplicate ? (
+            <p role="alert" className="text-sm text-destructive">
+              {i18n.t("node.table.columnsDistinct")}
+            </p>
+          ) : blank ? (
+            <p role="alert" className="text-sm text-destructive">
+              {i18n.t("node.table.columnsNamed")}
+            </p>
+          ) : tooLong ? (
+            <p role="alert" className="text-sm text-destructive">
+              {i18n.t("node.table.columnsTooLong")}
+            </p>
+          ) : tooMany ? (
+            <p role="alert" className="text-sm text-destructive">
+              {i18n.t("node.table.columnsTooMany")}
+            </p>
+          ) : empty ? (
+            <p role="alert" className="text-sm text-destructive">
+              {i18n.t("node.table.columnsAtLeastOne")}
+            </p>
+          ) : null}
+          <button
+            ref={saveButton}
+            type="submit"
+            disabled={save.isPending || incomplete}
+            className="w-full rounded-md bg-primary px-4 py-2 text-sm font-medium text-primary-foreground outline-none hover:bg-primary/90 focus-visible:ring-2 focus-visible:ring-ring disabled:opacity-50"
+          >
+            {save.isPending ? i18n.t("common.saving") : i18n.t("common.save")}
+          </button>
+        </form>
+      )}
+    </Modal>
+  );
+}

package/src/title-row/title-row.tsx

@@ -98,6 +98,15 @@ export function TitleRow({
             {target.type === "node" && target.node.kind === "folder" ? (
               <ResourceAccessSummary resourceId={target.node.id} ownerId={target.node.ownerId} />
             ) : null}
+            {/* A flow carries its own grants since #530, so who reaches it is worth showing where
+                it stands — the same question the folder above already answers here. */}
+            {target.type === "flow" ? (
+              <ResourceAccessSummary
+                kind="flow"
+                resourceId={target.flow.id}
+                ownerId={target.flow.ownerId}
+              />
+            ) : null}
             <span data-slot="title-meta" className="text-sm text-muted-foreground" />
           </div>
           {description ? <DescriptionDisclosure key={targetId} description={description} /> : null}