@anchrd/intel-ui 0.4.0 → 0.6.0

package/src/flows/node-icon/node-icon.ts

@@ -0,0 +1,28 @@
+import type { FlowNode } from "@anchrd/intel-contract";
+import {
+  CheckCircle2,
+  CirclePlay,
+  FileSearch,
+  GitBranch,
+  ShieldCheck,
+  Sparkles,
+  Workflow,
+  Wrench,
+} from "lucide-react";
+import type { ComponentType, SVGProps } from "react";
+
+// The canvas card and the palette entry have to show the same symbol for the same kind — a step that
+// looks one way in the bar and another on the graph is two things to learn instead of one. The map
+// lives apart from both so neither has to import the other.
+export type NodeIcon = ComponentType<SVGProps<SVGSVGElement>>;
+
+export const nodeIcon: Record<FlowNode["kind"], NodeIcon> = {
+  trigger: CirclePlay,
+  instruction: Sparkles,
+  knowledge: FileSearch,
+  tool: Wrench,
+  condition: GitBranch,
+  approval: ShieldCheck,
+  subflow: Workflow,
+  output: CheckCircle2,
+};

package/src/flows/node-palette/node-palette.tsx

@@ -0,0 +1,200 @@
+import { Plus, X } from "lucide-react";
+import { useId, useRef, useState } from "react";
+import { type NodeIcon, nodeIcon } from "@/flows/node-icon/node-icon.ts";
+import { cn } from "@/lib/utils.ts";
+import { useIntelRouterContext } from "@/router/router-context.ts";
+import type { NodePaletteProps, PaletteKind } from "./node-palette.types.ts";
+
+const storageKey = "intel.flow-palette";
+
+// ⚠️ Reading `localStorage` throws outright in a few privacy modes, so the guard is a try, not a
+// typeof check — the same reason `sidebar-preferences` guards it that way. Losing the preference is
+// acceptable; losing the editor is not.
+function readOpen(): boolean {
+  try {
+    return typeof window !== "undefined" && window.localStorage.getItem(storageKey) === "open";
+  } catch {
+    return false;
+  }
+}
+
+function writeOpen(open: boolean): void {
+  try {
+    if (typeof window !== "undefined")
+      window.localStorage.setItem(storageKey, open ? "open" : "closed");
+  } catch {}
+}
+
+// Closed is the default, and the preference is written through: the bar is chrome, exactly like the
+// sidebar whose open state already survives a reload. Someone who builds flows all day would
+// otherwise re-open it on every load, and the ticket's own reason for collapsing it — the canvas
+// belongs to the graph — is just as true for someone who never opens it.
+export function usePaletteOpen(): [boolean, (open: boolean) => void] {
+  const [open, setOpen] = useState(readOpen);
+  return [
+    open,
+    (next: boolean) => {
+      setOpen(next);
+      writeOpen(next);
+    },
+  ];
+}
+
+export function NodePalette<K extends PaletteKind>({
+  kinds,
+  open,
+  setOpen,
+  add,
+  disabledReason,
+}: NodePaletteProps<K>) {
+  const { i18n } = useIntelRouterContext();
+  const listId = useId();
+  const triggerRef = useRef<HTMLButtonElement>(null);
+  const listRef = useRef<HTMLDivElement>(null);
+  // A toolbar carries one tab stop, so the group is entered with a single Tab and left with the
+  // next one instead of costing seven.
+  const [active, setActive] = useState(0);
+
+  // The focus goes back where it came from, so closing does not drop the caret at the top of the
+  // document and make the next Tab start over from the page.
+  function close() {
+    setOpen(false);
+    triggerRef.current?.focus();
+  }
+
+  function entries(): HTMLButtonElement[] {
+    return [
+      ...(listRef.current?.querySelectorAll<HTMLButtonElement>("button[data-palette-item]") ?? []),
+    ];
+  }
+
+  // A disabled entry is stepped over rather than focused: its reason is already on the entry, and
+  // stopping there would only be a dead end for the keyboard.
+  function focusEntry(from: number, delta: number) {
+    const items = entries();
+    if (items.length === 0) return;
+    for (let step = 1; step <= items.length; step += 1) {
+      const index = (((from + delta * step) % items.length) + items.length) % items.length;
+      const item = items[index];
+      if (item && !item.disabled) {
+        setActive(index);
+        item.focus();
+        return;
+      }
+    }
+  }
+
+  function onListKeyDown(event: React.KeyboardEvent<HTMLDivElement>) {
+    if (event.key === "Escape") {
+      event.stopPropagation();
+      close();
+      return;
+    }
+    const forward = event.key === "ArrowDown" || event.key === "ArrowRight";
+    const backward = event.key === "ArrowUp" || event.key === "ArrowLeft";
+    if (!forward && !backward) return;
+    event.preventDefault();
+    const items = entries();
+    const current = items.indexOf(document.activeElement as HTMLButtonElement);
+    focusEntry(current < 0 ? 0 : current, forward ? 1 : -1);
+  }
+
+  function onTriggerKeyDown(event: React.KeyboardEvent<HTMLButtonElement>) {
+    if (!open) return;
+    if (event.key === "Escape") {
+      event.stopPropagation();
+      close();
+      return;
+    }
+    if (event.key === "ArrowDown" || event.key === "ArrowRight") {
+      event.preventDefault();
+      focusEntry(-1, 1);
+    }
+  }
+
+  // Open, the trigger is the first segment of the bar itself rather than a second box above it: one
+  // closes a bar where it is. Two details carry that and neither is decoration:
+  //
+  // ⚠️ The negative margin is the frame's own padding plus its border. Opening hands the frame from
+  // the trigger to the row around it, and a frame drawn inside would push the trigger down and right
+  // by exactly that sum. The margin lets the row grow outwards instead, so the 36px one clicks stays
+  // on the same pixel open and collapsed. Change `p-1` and this has to change with it.
+  //
+  // ⚠️ The toolbar stays an element of its own inside the row: it is what `aria-controls` names and
+  // what the arrow keys walk, and the trigger must not become an eighth entry in that ring.
+  //
+  // The `w-max` that used to stand here went with the structure it guarded. While the bar was a
+  // block below the trigger, the shrink-wrapped box took the collapsed 36px as its maximum and
+  // folded the entries into a column; one flex row is sized from its content in either state, which
+  // was measured at 1280px and at 420px with the class and without it (#55).
+  return (
+    <div
+      className={cn(
+        "absolute left-4 top-4 z-10 max-w-[calc(100%-2rem)]",
+        open &&
+          "-m-[calc(0.25rem+1px)] flex flex-wrap items-center gap-1 rounded-lg border bg-card/95 p-1 shadow-sm backdrop-blur",
+      )}
+    >
+      <button
+        ref={triggerRef}
+        type="button"
+        aria-expanded={open}
+        aria-controls={listId}
+        onClick={() => (open ? close() : setOpen(true))}
+        onKeyDown={onTriggerKeyDown}
+        className={cn(
+          "inline-flex size-9 shrink-0 items-center justify-center rounded-lg text-card-foreground outline-none hover:bg-accent focus-visible:ring-2 focus-visible:ring-ring",
+          !open && "border bg-card/95 shadow-sm backdrop-blur",
+        )}
+      >
+        {open ? (
+          <X aria-hidden="true" className="size-4" />
+        ) : (
+          <Plus aria-hidden="true" className="size-4" />
+        )}
+        <span className="sr-only">{i18n.t(open ? "flows.closePalette" : "flows.addNode")}</span>
+      </button>
+      {/* Over the canvas rather than pushing it: the graph is a spatial workspace, and resizing the
+          viewport would shift every node under the pointer each time the bar opens. It is dismissed
+          instead — the trigger, Escape, or a click on the canvas. */}
+      {open && (
+        <div
+          ref={listRef}
+          id={listId}
+          role="toolbar"
+          aria-orientation="horizontal"
+          aria-label={i18n.t("flows.nodePalette")}
+          onKeyDown={onListKeyDown}
+          // `min-w-0` so a narrow bar makes the entries wrap among themselves instead of forcing the
+          // whole row wider than the canvas allows.
+          className="flex min-w-0 max-w-full flex-wrap gap-1"
+        >
+          {kinds.map((kind, index) => {
+            const Icon: NodeIcon = nodeIcon[kind];
+            const reason = disabledReason?.(kind) ?? null;
+            return (
+              <button
+                key={kind}
+                type="button"
+                data-palette-item=""
+                disabled={reason !== null}
+                title={reason ?? undefined}
+                tabIndex={index === active ? 0 : -1}
+                onClick={() => {
+                  setActive(index);
+                  add(kind);
+                }}
+                // `h-9` is the trigger's height: sharing one row only reads as one row if the entries
+                // start on the trigger's top edge instead of floating in the middle of it.
+                className="inline-flex h-9 items-center gap-1.5 rounded-md px-2 text-xs outline-none hover:bg-muted focus-visible:ring-2 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50 disabled:hover:bg-transparent"
+              >
+                <Icon aria-hidden="true" className="size-3.5" />
+                {i18n.t(`flows.node.${kind}`)}
+              </button>
+            );
+          })}
+        </div>
+      )}
+    </div>
+  );
+}

package/src/flows/node-palette/node-palette.types.ts

@@ -0,0 +1,15 @@
+import type { FlowNode } from "@anchrd/intel-contract";
+
+export type PaletteKind = FlowNode["kind"];
+
+// Generic over the kinds it is given: the caller decides which subset the bar offers, and `add` is
+// handed back exactly that subset rather than "any node kind" it would have to re-narrow.
+export interface NodePaletteProps<K extends PaletteKind = PaletteKind> {
+  kinds: readonly K[];
+  open: boolean;
+  setOpen(open: boolean): void;
+  add(kind: K): void;
+  // Why an entry is off, in words, or `null` when it is not. One function rather than a flag and a
+  // string: an entry that is greyed out without a reason is just a broken button.
+  disabledReason?(kind: K): string | null;
+}

package/src/graph-pane/graph-pane.tsx

@@ -0,0 +1,44 @@
+import type { RelationGraph } from "@anchrd/intel-contract";
+import type { UseQueryResult } from "@tanstack/react-query";
+import { lazy, Suspense } from "react";
+import { useIntelRouterContext } from "@/router/router-context.ts";
+
+const RelationGraphView = lazy(async () => ({
+  default: (await import("@/knowledge-graph/knowledge-graph.tsx")).RelationGraphView,
+}));
+
+// The graph half of the editor ↔ graph switch, with its own loading, error and empty states (#19).
+// One component for both screens: a folder and a single flow ask the same question of the same
+// endpoint, and two copies of this would drift the moment one of them grew a state.
+export function GraphPane({
+  query,
+  select,
+}: {
+  query: UseQueryResult<RelationGraph>;
+  select(node: RelationGraph["nodes"][number]): void;
+}) {
+  const { i18n } = useIntelRouterContext();
+  const loading = <p className="p-6 text-sm text-muted-foreground">{i18n.t("common.loading")}</p>;
+  if (query.isPending) return loading;
+  if (query.isError || !query.data) {
+    return (
+      <div role="alert" className="grid flex-1 place-items-center p-8 text-center text-sm">
+        <div className="space-y-3">
+          <p className="text-destructive">{i18n.t("view.graphFailed")}</p>
+          <button
+            type="button"
+            onClick={() => void query.refetch()}
+            className="rounded-md border px-3 py-2 text-sm outline-none hover:bg-muted focus-visible:ring-2 focus-visible:ring-ring"
+          >
+            {i18n.t("common.retry")}
+          </button>
+        </div>
+      </div>
+    );
+  }
+  return (
+    <Suspense fallback={loading}>
+      <RelationGraphView data={query.data} i18n={i18n} select={select} />
+    </Suspense>
+  );
+}

package/src/i18n/en.json

@@ -2,13 +2,14 @@
   "$locale": "en-US",
   "app.name": "Intel",
   "nav.primary": "Primary navigation",
-  "nav.knowledge": "Knowledge",
+  "nav.knowledge": "Intelligence",
   "nav.flows": "Flows",
   "nav.tools": "Tools",
   "shell.toggleSidebar": "Collapse or expand the sidebar",
   "shell.resizeSidebar": "Sidebar width",
   "shell.signedInUser": "Signed-in user",
   "shell.userUnavailable": "Account unavailable",
+  "shell.userMenu": "Account and tools for {name}",
   "search.open": "Search",
   "search.title": "Search Intel",
   "search.description": "Find knowledge, flows, and tools you are allowed to see.",
@@ -23,27 +24,65 @@
   "search.empty": "Nothing found for “{query}”.",
   "search.failed": "The search could not be completed.",
   "tree.label": "Knowledge and flows",
+  "tree.contents": "Inside {title}",
+  "tree.calls": "Flows called by {title}",
   "tree.empty": "Nothing here yet.",
-  "tree.emptyFolder": "This folder is empty.",
   "tree.failed": "This part of the tree could not be loaded.",
   "tree.expand": "Show what is inside {title}",
   "tree.collapse": "Hide what is inside {title}",
+  "tree.expandCalls": "Show the flows {title} calls",
+  "tree.collapseCalls": "Hide the flows {title} calls",
+  "tree.noCalls": "This flow calls no other flow.",
   "tree.add": "Add to {title}",
   "tree.addRoot": "Add at the top level",
   "tree.new.folder": "New folder",
   "tree.new.document": "New document",
+  "tree.new.table": "New table",
   "tree.new.upload": "Upload file",
   "tree.new.flow": "New flow",
   "tree.upload": "File to upload",
+  "tree.table.columns": "Columns",
+  "tree.table.columnsHint": "Separate the column names with commas. They are the header, and every row appended later must match it.",
   "tree.createFailed": "It could not be created. Check your access and try again.",
   "tree.uploadFailed": "The file could not be uploaded. Check the 15 MB limit and try again.",
   "tree.kind.folder": "Folder",
   "tree.kind.document": "Document",
   "tree.kind.attachment": "File",
+  "tree.kind.table": "Table",
   "tree.kind.flow": "Flow",
+  "tree.move.action": "Move to…",
+  "tree.move.title": "Move {title}",
+  "tree.move.root": "Top level",
+  "tree.move.dropRoot": "Drop here to move to the top level",
+  "tree.move.pick": "Choose the folder to move it into.",
+  "tree.move.up": "Back to the folder above",
+  "tree.move.open": "Open {title}",
+  "tree.move.noFolders": "There is no folder here to move it into.",
+  "tree.move.here": "Move into {title}",
+  "tree.move.alreadyThere": "It is already filed here.",
+  "tree.move.destination": "New place: {title}",
+  "tree.move.sharingWarning": "Sharing follows the folder. After the move, everyone who can reach {title} can reach this entry, and anyone who only reached it through its old folder loses it. Nobody is notified.",
+  "tree.move.elsewhere": "Choose another folder",
+  "tree.move.confirm": "Move",
+  "tree.move.failed.forbidden": "It was not moved: you may not write into that folder. Ask for write access there.",
+  "tree.move.failed.notFolder": "It was not moved: only a folder can hold other entries.",
+  "tree.move.failed.cycle": "It was not moved: a folder cannot be put inside itself or inside anything it contains.",
+  "tree.move.failed.conflict": "It was not moved: somebody else changed this entry first. The tree has been reloaded — look again, then move it.",
+  "tree.move.failed.gone": "It was not moved: that folder no longer exists.",
+  "tree.move.failed.other": "It could not be moved. Check your access and try again.",
+  "resource.menu": "More actions for {title}",
+  "resource.rename": "Rename",
+  "resource.renameTitle": "Rename {title}",
+  "resource.conflict": "It was not changed: somebody else changed this entry first. Reload it and try again.",
+  "resource.forbidden": "It was not changed: you may not change this entry.",
+  "resource.failed": "The change was not saved. Reload the latest version and try again.",
   "knowledge.empty": "No knowledge has been added yet.",
   "knowledge.download": "Download file",
   "knowledge.attachmentHelp": "The canonical file is stored privately in Intel. Its AI-readable projection is indexed separately.",
+  "knowledge.table.summary": "{rows} rows, {columns} columns",
+  "knowledge.table.download": "Download CSV",
+  "knowledge.table.empty": "No rows yet. Rows are appended by flows and agents.",
+  "knowledge.table.undefined": "This table has no columns yet.",
   "knowledge.select": "Select a document or folder to work with it.",
   "knowledge.folderHelp": "Select a child document, or create something inside this folder.",
   "knowledge.contextPolicy": "AI context policy",
@@ -53,39 +92,55 @@
   "knowledge.share": "Share",
   "knowledge.shareAction": "Grant access",
   "knowledge.email": "Email address",
-  "knowledge.role": "Access level",
-  "knowledge.viewer": "Can view",
-  "knowledge.editor": "Can edit",
-  "knowledge.manager": "Can manage and share",
+  "knowledge.verbs": "What this grant allows",
+  "knowledge.verb.read": "Read",
+  "knowledge.verb.write": "Write",
+  "knowledge.verb.execute": "Run",
+  "knowledge.verb.share": "Share",
+  "knowledge.verbHint.read": "See everything in here",
+  "knowledge.verbHint.write": "Change and add things",
+  "knowledge.verbHint.execute": "Start the flows in here",
+  "knowledge.verbHint.share": "Give others access",
+  "knowledge.organization": "Everyone in the organization",
+  "knowledge.revokeShare": "Revoke access",
+  "knowledge.noGrants": "Nobody outside the owner has access yet.",
+  "knowledge.shareFailed": "Access was not changed. Check your permission and try again.",
+  "knowledge.shareUnreadable": "Flows in this folder read documents this grant does not cover: {titles}.",
+  "knowledge.shareUnreadableMore": "{count} more are out of reach too, and you cannot see them.",
+  "knowledge.shareUnreadableHidden": "{count} documents that flows in this folder read are out of reach with this grant. You cannot see them.",
+  "knowledge.shareUnreadableHint": "Nothing is blocked. A run of those flows will simply stop at that step for them.",
   "knowledge.versions": "Version history",
   "knowledge.version": "Version {sequence}",
   "knowledge.archive": "Archive",
-  "knowledge.graph": "Knowledge graph",
-  "knowledge.graphDescription": "{nodes} authorized nodes and {links} explicit relationships.",
+  "view.showGraph": "Show this level as a graph",
+  "view.showEditor": "Back to the editor",
+  "view.showRuns": "Show this flow's runs",
+  "view.graph": "Relation graph",
+  "view.graphDescription": "{nodes} nodes and {edges} relationships you are allowed to see.",
+  "view.graphTruncated": "{omitted} more left out — this view draws at most {limit}.",
+  "view.graphEmpty": "Nothing here that you may see.",
+  "view.graphFailed": "The graph could not be loaded.",
   "knowledge.graphZoomIn": "Zoom in",
   "knowledge.graphZoomOut": "Zoom out",
   "knowledge.graphReset": "Fit graph",
-  "knowledge.graphFailed": "The authorized knowledge graph could not be loaded.",
   "knowledge.operationFailed": "The change was not saved. Reload the latest version and try again.",
   "knowledge.loadFailed": "This item could not be loaded. Check your access and try again.",
   "knowledge.downloadFailed": "The attachment could not be downloaded. Check your access and try again.",
   "knowledge.links": "Links and backlinks",
   "knowledge.noLinks": "No explicit relationships yet.",
-  "knowledge.linkTarget": "Link to",
-  "knowledge.selectLinkTarget": "Select knowledge",
-  "knowledge.relation": "Relationship",
-  "knowledge.relation.related": "Related to",
-  "knowledge.relation.references": "References",
-  "knowledge.relation.depends_on": "Depends on",
-  "knowledge.relation.implements": "Implements",
-  "knowledge.createLink": "Create relationship",
-  "knowledge.deleteLink": "Delete relationship",
+  "knowledge.linksHelp": "Relationships are written in the text. Link a document from the editor with the / command; this list shows the result and who points here.",
+  "knowledge.linkOutgoing": "This document links to it",
+  "knowledge.linkIncoming": "It links to this document",
+  "knowledge.link.insert": "Link a document",
+  "knowledge.link.group": "Knowledge",
+  "knowledge.link.search": "Search documents you can see",
+  "knowledge.link.noMatches": "No document of yours matches.",
+  "knowledge.link.unresolved": "Unavailable document",
   "knowledge.saveConflict": "This document changed elsewhere. Reload it before saving again.",
   "knowledge.saveError": "This document could not be saved. Reload and try again.",
-  "tools.connect": "Connect the portal",
-  "tools.reconnect": "Reconnect the portal",
-  "tools.disconnected": "Portal not connected",
-  "tools.disconnectedHelp": "Sign in to the company MCP portal once. The portal decides which servers you may use and holds their credentials; Intel never sees them.",
+  "tools.signingIn": "Signing you in to the company portal…",
+  "tools.noAccess": "No access to the company portal",
+  "tools.noAccessHelp": "Your Intel account does not reach the company MCP portal, so there is nothing to show here. An administrator decides in the portal who may use which server; ask them to include you.",
   "tools.empty": "No tools available to you",
   "tools.emptyHelp": "The portal answered, and it offers your account no tools. An administrator decides in the portal which servers exist and who may reach them.",
   "tools.unreachable": "Portal not reachable",
@@ -96,39 +151,99 @@
   "tools.outputSchema": "Result schema",
   "tools.destructiveShort": "Destructive",
   "tools.liveNote": "This list is a live query with your own portal access. Intel stores neither the tools nor who may use them; the portal decides both.",
-  "tools.connectFailed": "The portal could not be connected with your current access.",
   "tools.arguments": "Arguments",
   "tools.invalidJson": "The arguments must be a JSON object in curly braces; a list or a single value will not work.",
   "flows.select": "Select a flow or create one to open the visual editor.",
   "flows.inspect": "Select a node to edit its configuration.",
   "flows.publish": "Publish",
+  "flows.publishNothing": "Nothing new to publish",
+  "flows.publishNeeded": "Publish — no run can start until you do",
   "flows.run": "Start run",
-  "flows.share": "Share flow",
-  "flows.revokeShare": "Revoke flow access",
-  "flows.organization": "Everyone in the organization",
   "flows.runStarted": "Durable run started",
-  "flows.node.trigger": "Trigger",
+  "flows.addNode": "Add a step",
+  "flows.closePalette": "Close the step bar",
+  "flows.nodePalette": "Step types",
+  "flows.node.trigger": "Start",
+  "flows.startExists": "A flow has exactly one start, and this one already has it.",
   "flows.node.instruction": "Instruction",
   "flows.node.knowledge": "Knowledge",
   "flows.node.tool": "Tool",
   "flows.node.condition": "Condition",
   "flows.node.approval": "Approval",
+  "flows.node.subflow": "Sub-flow",
   "flows.node.output": "Output",
-  "flows.nodeDescription": "Description",
   "flows.instruction": "Instruction for the AI or person",
+  "flows.instructionHint": "Conditions, checks and branches can be described here in words. You do not need a separate node for every small decision.",
   "flows.knowledgeIds": "Knowledge references",
   "flows.knowledgeEmpty": "Create a knowledge item before adding this step.",
   "flows.knowledgeQuery": "Semantic retrieval hint",
+  "flows.subflowTarget": "Flow to call",
+  "flows.selectSubflow": "Select a flow to call",
+  "flows.subflowRule": "A flow may call a flow in its own folder or below it, or one in a folder every user may run. Publishing names the reason if it may not.",
+  "flows.subflowVersion": "Version to call",
+  "flows.subflowVersion.latest": "Latest — frozen when this flow is published",
+  "flows.subflowVersion.follows": "Always latest — this call runs along",
+  "flows.subflowVersion.pinned": "Frozen version",
+  "flows.subflowVersionHint.latest": "Publishing replaces this with the version the called flow has published then, so a later change to it leaves this flow alone.",
+  "flows.subflowVersionHint.follows": "This call takes whatever the called flow has published at the moment it runs. A change there changes this flow too.",
+  "flows.subflowVersionHint.pinned": "This call keeps running the version it was frozen to. Switch it back to latest to pick up the called flow's next publication.",
+  "flows.subflowBadge.follows": "runs along",
+  "flows.subflowBadge.pinned": "frozen",
+  "flows.publishPreview": "Before publishing",
+  "flows.publishPreviewIntro": "Publishing freezes every call marked below to the version it names. A call set to always latest stays as it is.",
+  "flows.publishPreviewEmpty": "This flow calls no other flow, so publishing freezes nothing.",
+  "flows.publishPreviewFreeze": "freezes to version {sequence}",
+  "flows.publishPreviewPinned": "already frozen to version {sequence}",
+  "flows.publishPreviewFollows": "runs along with the called flow",
+  "flows.publishPreviewUnavailable": "The called flow has published nothing yet, so this cannot be frozen.",
+  "flows.publishConfirm": "Publish",
+  "flows.publishFailed": "Publishing failed. Reload the latest version and try again.",
   "flows.tool": "MCP tool",
   "flows.selectTool": "Select a discovered tool",
   "flows.operationFailed": "The flow operation failed. Reload the latest version and try again.",
-  "flows.shareFailed": "Flow access was not changed. Check your permission and try again.",
+  "flows.needs": "What this flow needs",
+  "flows.needsHint": "Read out of the graph. Whether a given person may reach any of it is decided when they run it.",
+  "flows.needsKnowledge": "Documents",
+  "flows.needsTools": "Tools",
+  "flows.needsHidden": "{count} more you cannot see",
+  "flows.needsEmpty": "This flow reads no documents and calls no tools.",
+  "flows.needsFailed": "What this flow needs could not be loaded.",
+  "runs.title": "Runs",
+  "runs.onlyFailed": "Only failed runs",
+  "runs.empty": "This flow has not run yet.",
+  "runs.emptyFailed": "No run of this flow has failed.",
+  "runs.more": "Show older runs",
+  "runs.stillRunning": "still running",
+  "runs.failedAt": "Failed at {step}:",
+  "runs.failedToLoad": "The runs of this flow could not be loaded.",
+  "runs.stepsFailedToLoad": "The steps of this run could not be loaded.",
+  "runs.stepsEmpty": "This run has not completed a step yet.",
+  "runs.stepsTitle": "Steps",
+  "runs.durationMs": "{value} ms",
+  "runs.durationSeconds": "{value} s",
+  "runs.durationMinutes": "{value} min",
+  "runs.status.queued": "Queued",
+  "runs.status.running": "Running",
+  "runs.status.waiting": "Waiting",
+  "runs.status.completed": "Completed",
+  "runs.status.failed": "Failed",
+  "runs.status.cancelled": "Cancelled",
+  "runs.trigger.manual": "started by hand",
+  "runs.trigger.subflow": "called by another flow",
+  "runs.outcome.completed": "done",
+  "runs.outcome.failed": "failed",
   "auth.signOut": "Sign out",
   "auth.signOutFailed": "Signing out failed. Check your connection and try again.",
   "common.title": "Title",
   "common.create": "Create",
   "common.save": "Save",
   "common.saving": "Saving…",
+  "common.saved": "Saved",
+  "common.saveDirty": "Save unsaved changes",
+  "common.unsavedTitle": "Unsaved changes",
+  "common.unsavedBody": "This has changes that have not been saved. Leaving now discards them.",
+  "common.unsavedStay": "Stay and save",
+  "common.unsavedLeave": "Leave without saving",
   "common.loading": "Loading…",
   "common.retry": "Try again",
   "common.close": "Close",