fix(menus): build every separator guard from its items' exact conditions

Review caught two places where the grouping rule and the code disagreed.

The tables row menu guarded its rule on `onMove` while the Move submenu
needs a non-empty `moveOptions`, so a table whose other actions were all
absent and whose move list was empty would draw the rule with nothing
above it — the exact looseness the rule warns about.

The logs row menu puts its one rule after Retry and Cancel Run rather
than before a destructive group, which the rule as written did not
cover. Retry is the primary action on a failed run and belongs at the
top; the rule now describes the separator as fencing the consequential
group at whichever end it sits, and names the logs menu as the one place
that group leads.

Also aligns three empty-space menu labels with the header chips they
mirror: "Add document" and "Create chunk" were the only create actions
not matching their toolbar, and the files menu said "Upload file" where
its header says "Upload".

Run order in the two column run menus now matches the action bar and the
row menu — incomplete before all, not all before incomplete.

Author: waleedlatif1

.claude/rules/sim-list-ordering.md

@@ -26,12 +26,20 @@ Left-to-right becomes top-to-bottom. A toolbar reading `Filter · Sort · Export
 
 Platform-only entries (desktop **Browser** and **Terminal**) trail the shared set rather than interleaving, so the common prefix is identical on every platform.
 
-## Grouping: one rule, before the destructive action
+## Grouping: one rule, against the consequential group
 
 Order is governed above. **Separators are governed here** — and the answer is: use at most one.
 
-Put a single `DropdownMenuSeparator` immediately before the destructive group (Delete, Leave,
-Close, Hide) and nowhere else. Everything above it runs uninterrupted in toolbar-mirroring order.
+Put a single `DropdownMenuSeparator` against the **consequential group** — the actions that
+delete, detach, or change a run — and nowhere else. Everything on the other side of it runs
+uninterrupted in toolbar-mirroring order.
+
+That group trails in almost every menu, so in practice the rule reads "one rule immediately
+before Delete / Leave / Close / Hide". It leads in exactly one place: the **logs row menu**,
+where `Retry` and `Cancel Run` are the primary actions on a failed run and sit at the top, with
+the rule beneath them. Ordering follows the surface (see "The rule" above); the separator simply
+fences whichever end the consequential group occupies. A menu whose consequential actions are
+merely *disabled* still gets no extra rule — `disabled` is not a group.
 
 ```tsx
 // ✗ Bad — four semantic bands the user meets nowhere else

CLAUDE.md

@@ -388,7 +388,7 @@ A list orders itself the way the user already reads the same things somewhere el
 
 Encode the order in ONE exported constant and sort by it — never a hand-maintained literal per menu (`RESOURCE_MENU_ORDER` / `byResourceMenuOrder` in `home/components/mothership-view/components/resource-registry`). Render mixed item kinds in a single ordered pass; emitting all submenu-backed families and then all flat ones silently pins every submenu to the top no matter what the constant says. Divergence is allowed only for search ranking, user-controlled ordering, and recency.
 
-**Grouping**: at most ONE `DropdownMenuSeparator` per menu, immediately before the destructive group (Delete/Leave/Close/Hide). No toolbar in the app renders a divider, so multi-band menus teach a taxonomy that exists on no other surface. Build each separator's guard from the EXACT render conditions of the items on both sides — a looser guard is what leaves a dangling rule when its group is conditional. Never add a prop to move a rule. Full rule in `.claude/rules/sim-list-ordering.md`.
+**Grouping**: at most ONE `DropdownMenuSeparator` per menu, fencing the consequential group — immediately before Delete/Leave/Close/Hide in almost every menu, and immediately after Retry/Cancel Run in the logs row menu, where those lead. No toolbar in the app renders a divider, so multi-band menus teach a taxonomy that exists on no other surface. Build each separator's guard from the EXACT render conditions of the items on both sides — a looser guard is what leaves a dangling rule when its group is conditional. Never add a prop to move a rule. Full rule in `.claude/rules/sim-list-ordering.md`.
 
 ## Styling
 

apps/sim/app/workspace/[workspaceId]/files/components/files-list-context-menu/files-list-context-menu.tsx

@@ -48,7 +48,7 @@ export const FilesListContextMenu = memo(function FilesListContextMenu({
         {onUploadFile && (
           <DropdownMenuItem disabled={disableUpload} onSelect={onUploadFile}>
             <Upload />
-            Upload file
+            Upload
           </DropdownMenuItem>
         )}
         {onCreateFolder && (

apps/sim/app/workspace/[workspaceId]/knowledge/[id]/[documentId]/components/chunk-context-menu/chunk-context-menu.tsx

@@ -33,7 +33,7 @@ interface ChunkContextMenuProps {
 
 /**
  * Context menu for chunks table.
- * Shows chunk actions when right-clicking a row, or "Create chunk" when right-clicking empty space.
+ * Shows chunk actions when right-clicking a row, or "New chunk" when right-clicking empty space.
  * Supports batch operations when multiple chunks are selected.
  */
 export function ChunkContextMenu({
@@ -135,7 +135,7 @@ export function ChunkContextMenu({
           onAddChunk && (
             <DropdownMenuItem disabled={disableAddChunk} onSelect={onAddChunk}>
               <Plus />
-              Create chunk
+              New chunk
             </DropdownMenuItem>
           )
         )}

apps/sim/app/workspace/[workspaceId]/knowledge/[id]/components/document-context-menu/document-context-menu.tsx

@@ -141,7 +141,7 @@ export function DocumentContextMenu({
           onAddDocument && (
             <DropdownMenuItem disabled={disableAddDocument} onSelect={onAddDocument}>
               <Plus />
-              Add document
+              New documents
             </DropdownMenuItem>
           )
         )}

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/headers/workflow-group-meta-cell.tsx

@@ -44,6 +44,12 @@ const LIMITED_RUN_PRESETS = [10, 1000] as const
 /** Labels for the table-scoped run items. With an active filter the run is
  *  scoped to matching rows, so the labels say "filtered rows" to make the
  *  narrowed target visible. Shared by both menu surfaces. */
+/**
+ * Incomplete before all, matching the action bar and the row context menu, which both
+ * present Play (empty or failed) ahead of Refresh (every row). These two menus read the
+ * same four run actions the user already met on the action bar, so they must not invert
+ * the pair — see `.claude/rules/sim-list-ordering.md`.
+ */
 function runMenuLabels(hasActiveFilter: boolean) {
   const rows = hasActiveFilter ? 'filtered rows' : 'rows'
   return {
@@ -171,12 +177,12 @@ export function ColumnOptionsMenu({
                   {`Run ${selectedRowCount} selected ${selectedRowCount === 1 ? 'row' : 'rows'}`}
                 </DropdownMenuItem>
               )}
-              <DropdownMenuItem onSelect={() => onRunColumnAll?.()}>
-                {runLabels.all}
-              </DropdownMenuItem>
               <DropdownMenuItem onSelect={() => onRunColumnIncomplete?.()}>
                 {runLabels.incomplete}
               </DropdownMenuItem>
+              <DropdownMenuItem onSelect={() => onRunColumnAll?.()}>
+                {runLabels.all}
+              </DropdownMenuItem>
               {onRunColumnLimited &&
                 LIMITED_RUN_PRESETS.map((max) => (
                   <DropdownMenuItem key={max} onSelect={() => onRunColumnLimited(max)}>
@@ -510,10 +516,10 @@ export function WorkflowGroupMetaCell({
                   {`Run ${selectedCount} selected ${selectedCount === 1 ? 'row' : 'rows'}`}
                 </DropdownMenuItem>
               )}
-              <DropdownMenuItem onSelect={handleRunAll}>{runLabels.all}</DropdownMenuItem>
               <DropdownMenuItem onSelect={handleRunIncomplete}>
                 {runLabels.incomplete}
               </DropdownMenuItem>
+              <DropdownMenuItem onSelect={handleRunAll}>{runLabels.all}</DropdownMenuItem>
               {LIMITED_RUN_PRESETS.map((max) => (
                 <DropdownMenuItem key={max} onSelect={() => handleRunLimited(max)}>
                   {runLabels.limited(max)}

apps/sim/app/workspace/[workspaceId]/tables/components/table-context-menu/table-context-menu.tsx

@@ -57,6 +57,23 @@ export function TableContextMenu({
   disableImport = false,
   disableExport = false,
 }: TableContextMenuProps) {
+  /**
+   * `Move to` needs a NON-EMPTY `moveOptions`, not just the handler — the looser
+   * `onMove` alone draws the rule with nothing above it for a table whose other
+   * actions are all absent and whose move list is empty.
+   *
+   * @see `.claude/rules/sim-list-ordering.md` — one rule, before the destructive
+   * group, with both sides built from the items' exact render conditions.
+   */
+  const hasActionsAboveDestructive =
+    onViewSchema ||
+    onRename ||
+    onImportCsv ||
+    onExportCsv ||
+    (onMove && moveOptions && moveOptions.length > 0) ||
+    onCopyId ||
+    onTogglePin
+
   return (
     <DropdownMenu open={isOpen} onOpenChange={(open) => !open && onClose()} modal={false}>
       <DropdownMenuTrigger asChild>
@@ -126,14 +143,7 @@ export function TableContextMenu({
             Copy ID
           </DropdownMenuItem>
         )}
-        {(onViewSchema ||
-          onRename ||
-          onImportCsv ||
-          onExportCsv ||
-          onMove ||
-          onCopyId ||
-          onTogglePin) &&
-          onDelete && <DropdownMenuSeparator />}
+        {hasActionsAboveDestructive && onDelete && <DropdownMenuSeparator />}
         {onDelete && (
           <DropdownMenuItem disabled={disableDelete} onSelect={onDelete}>
             <Trash />

apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/workflow-list/components/context-menu/context-menu.tsx

@@ -185,6 +185,9 @@ export function ContextMenu({
    * rendered a trailing rule under the last item.
    */
   const hasActionsAboveDestructive =
+    /* No `openInNewTabPosition` term: the item renders in the 'first' slot or the
+       'last' one, and the prop is a closed two-value union, so `showOpenInNewTab &&
+       onOpenInNewTab` already means exactly "the nav item renders somewhere above". */
     (showOpenInNewTab && onOpenInNewTab) ||
     (showMarkAsRead && onMarkAsRead) ||
     (showMarkAsUnread && onMarkAsUnread) ||