@@ -0,0 +1,18 @@
+---
+'@object-ui/plugin-list': patch
+'@object-ui/permissions': patch
+---
+
+fix(plugin-list): the list toolbar offers the "In a queue" toggle only when the organization has at least one queue
+
+Clause-②: yes (widening)
+Metadata-protocol: none
+
+The "In a queue" toggle showed on every list of an owned object, because the platform adds the `queue` column to every such object. In an organization with no queue it could only ever return an empty list. It now appears when both of these hold:
+
+- **The object carries the platform's `queue` column**, as before.
+- **The session says the organization has a queue.** `GET /auth/me/permissions` answers `hasAnyQueue` (true when the organization has a declared queue or a `sys_queue` row). The console already reads that answer once per session, so opening a list sends no new request and reads no queue list.
+
+When the answer is unknown (no permission provider is mounted, the role-based `PermissionProvider` is used, or the session is anonymous), the toggle stays hidden. Turning the toggle on filters exactly as before, and the server's queue behaviour (claim, release, the read rule) does not change.
+
+`@object-ui/permissions`: `PermissionContextValue` gains one optional member, `hasAnyQueue?: boolean`. `MePermissionsProvider` sets it from the authenticated answer. It is `undefined` with no answer.
@@ -439,6 +439,9 @@ export function MePermissionsProvider({
     // `current_user.can(object, verb)` is answered from. Keyed on `dataKey`
     // like every member here, so it is the SAME object for the same payload.
     effectiveObjects: authed?.objects,
+    // [objectstack#28508] The server's one has-queues boolean, verbatim;
+    // `undefined` with no authenticated answer.
+    hasAnyQueue: authed?.hasAnyQueue,
     isLoaded,
   }));
 
 
@@ -102,6 +102,19 @@ export interface PermissionContextValue {
    * answer from it (see app-shell's `useExpressionPermissions`).
    */
   effectiveObjects?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+  /**
+   * [objectstack#28508] Whether the caller's organization has at least one
+   * ownership queue, declared or a `sys_queue` row: the server resolves it and
+   * `/auth/me/permissions` serves it as `hasAnyQueue`, handed on here verbatim.
+   * It names no queue.
+   *
+   * `undefined` means no answer: `MePermissionsProvider` before its first
+   * answer or for an anonymous session, the role-based `PermissionProvider`,
+   * or no provider at all. A consumer reads only `=== true` as "there is a
+   * queue": an unknown answer cannot show one exists (the list's "In a queue"
+   * toggle stays hidden on it, objectstack#28428).
+   */
+  hasAnyQueue?: boolean;
   /** Whether permissions are loaded */
   isLoaded: boolean;
 }
 
@@ -0,0 +1,98 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * objectstack#28428 — `hasAnyQueue`: the `/auth/me/permissions` boolean
+ * (objectstack#28508) saying the caller's organization has at least one
+ * ownership queue, handed on verbatim for the list's "In a queue" toggle.
+ *
+ * The truth table, one row per `PermissionContextValue` source:
+ *   - `MePermissionsProvider` with an authenticated answer → the answer's own
+ *     boolean, `true` and `false` alike;
+ *   - `MePermissionsProvider` with the anonymous answer → `undefined`;
+ *   - a scope below it (`ServerReadScope`) → the parent's value, forwarded;
+ *   - `PermissionProvider` (roles from config, no server payload) → `undefined`;
+ *   - no provider at all → `undefined`.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { render } from '@testing-library/react';
+import React from 'react';
+import { MePermissionsProvider, type MePermissionsAuthenticatedResponse } from '../MePermissionsProvider';
+import { PermissionProvider } from '../PermissionProvider';
+import { ServerReadScope } from '../ServerReadScope';
+import { usePermissions } from '../usePermissions';
+
+const seen: Array<ReturnType<typeof usePermissions>> = [];
+
+function Probe() {
+  seen.push(usePermissions());
+  return null;
+}
+
+function answer(hasAnyQueue: boolean): MePermissionsAuthenticatedResponse {
+  return {
+    authenticated: true,
+    userId: 'u1',
+    tenantId: 'org_1',
+    hasAnyQueue,
+    positions: [],
+    permissionSets: ['member_default'],
+    objects: {},
+    fields: {},
+  };
+}
+
+describe('objectstack#28428 — hasAnyQueue on the permission context', () => {
+  it.each([true, false])('MePermissionsProvider hands on the served %s', (value) => {
+    seen.length = 0;
+    render(
+      <MePermissionsProvider initialPermissions={answer(value)}>
+        <Probe />
+      </MePermissionsProvider>,
+    );
+    expect(seen.at(-1)?.isLoaded).toBe(true);
+    expect(seen.at(-1)?.hasAnyQueue).toBe(value);
+  });
+
+  it('the anonymous answer carries no has-queues answer', () => {
+    seen.length = 0;
+    render(
+      <MePermissionsProvider initialPermissions={{ authenticated: false }}>
+        <Probe />
+      </MePermissionsProvider>,
+    );
+    expect(seen.at(-1)?.isLoaded).toBe(true);
+    expect(seen.at(-1)?.hasAnyQueue).toBeUndefined();
+  });
+
+  it('a scope below the provider forwards the parent\'s answer', () => {
+    seen.length = 0;
+    render(
+      <MePermissionsProvider initialPermissions={answer(true)}>
+        <ServerReadScope objects={['sys_user']}>
+          <Probe />
+        </ServerReadScope>
+      </MePermissionsProvider>,
+    );
+    expect(seen.at(-1)?.hasAnyQueue).toBe(true);
+  });
+
+  it('PermissionProvider has no server payload: undefined', () => {
+    seen.length = 0;
+    render(
+      <PermissionProvider roles={[]} permissions={[]} userRoles={[]}>
+        <Probe />
+      </PermissionProvider>,
+    );
+    expect(seen.at(-1)?.isLoaded).toBe(true);
+    expect(seen.at(-1)?.hasAnyQueue).toBeUndefined();
+  });
+
+  it('no provider at all: undefined', () => {
+    seen.length = 0;
+    render(<Probe />);
+    expect(seen.at(-1)?.isLoaded).toBe(false);
+    expect(seen.at(-1)?.hasAnyQueue).toBeUndefined();
+  });
+});
@@ -43,6 +43,8 @@ const NO_PROVIDER_PERMISSIONS: PermissionsWithHelpers = Object.freeze({
   // for an unreported backend and keeps `hasCapabilities` fail-open.
   systemPermissions: undefined,
   hasCapabilities: () => true,
+  // [objectstack#28508] No provider → no has-queues answer.
+  hasAnyQueue: undefined,
   isLoaded: false,
   can: () => true,
   cannot: () => false,
 
@@ -2159,11 +2159,17 @@ export const ListView = React.forwardRef<ListViewHandle, ListViewProps>(({
       : userFilterConditions;
 
   // The "In a queue" toggle (objectstack ADR-0142 D3). Offered only on an
-  // object the server serves with its injected `queue` column; withheld with
-  // the user filters on a dataset-bound chart. Ephemeral like the toolbar's
-  // other unpersisted toggles: it narrows what is on screen, nothing else.
+  // object the server serves with its injected `queue` column, AND only when
+  // the session says the organization has at least one queue (`hasAnyQueue`
+  // on `/auth/me/permissions`, objectstack#28428): with no queue the toggle
+  // could only ever return an empty list. The flag rides the permissions
+  // answer the console already holds, so a list mount reads no queue list.
+  // An unknown answer (no provider, the role-based one, anonymous) hides it.
+  // Withheld with the user filters on a dataset-bound chart. Ephemeral like
+  // the toolbar's other unpersisted toggles: it narrows what is on screen.
   const [sittingInQueueOnly, setSittingInQueueOnly] = React.useState(false);
-  const queueFilterOffered = objectHasOwnershipQueue(objectDef);
+  const { hasAnyQueue } = usePermissions();
+  const queueFilterOffered = hasAnyQueue === true && objectHasOwnershipQueue(objectDef);
   const appliedQueueSittingConditions =
     queueFilterOffered && sittingInQueueOnly && !datasetChartOnScreen
       ? QUEUE_SITTING_CONDITIONS
 
@@ -12,9 +12,15 @@
  *
  * Pinned:
  *  - the render condition: the toggle appears only when the SERVED object
- *    definition carries the platform-injected `queue` column (`system: true`);
- *    an object without it, or with an author's own non-system `queue` field,
- *    gets no toggle;
+ *    definition carries the platform-injected `queue` column (`system: true`)
+ *    AND the session's `/auth/me/permissions` answer says the organization has
+ *    at least one queue (`hasAnyQueue`, objectstack#28428); an object without
+ *    the column, or with an author's own non-system `queue` field, gets no
+ *    toggle, and neither does any object while `hasAnyQueue` is false or
+ *    unknown (no permission provider, or an anonymous answer);
+ *  - the cost: the flag rides the permissions answer the session already
+ *    holds, so a list mount makes the same data-source calls and no other
+ *    request whether or not a queue exists;
  *  - the request: pressing it AND-s exactly `owner_id is_empty` and `queue
  *    is_not_empty` into the fetch filter, and releasing it drops them. Empty is
  *    the server's reading (null OR ''), so the null-only operators are not
@@ -27,6 +33,7 @@ import { describe, it, expect, vi, afterEach } from 'vitest';
 import { render, waitFor, cleanup, fireEvent, screen } from '@testing-library/react';
 import { ListView, buildEffectiveFilter, objectHasOwnershipQueue, QUEUE_SITTING_CONDITIONS } from '../ListView';
 import { SchemaRendererProvider } from '@object-ui/react';
+import { MePermissionsProvider, type MePermissionsResponse } from '@object-ui/permissions';
 import type { ListViewSchema } from '@object-ui/types';
 
 afterEach(cleanup);
@@ -49,14 +56,38 @@ function dataSourceServing(fields: Record<string, unknown>) {
 
 const schema = { type: 'list-view', objectName: OBJECT, fields: ['subject'] } as unknown as ListViewSchema;
 
-function mount(ds: ReturnType<typeof dataSourceServing>) {
+/** The session double: the `/auth/me/permissions` answer, serving `hasAnyQueue`. */
+function session(hasAnyQueue: boolean): MePermissionsResponse {
+  return {
+    authenticated: true,
+    userId: 'u1',
+    tenantId: 'org_1',
+    hasAnyQueue,
+    positions: [],
+    permissionSets: ['member_default'],
+    objects: { [OBJECT]: { allowRead: true, allowCreate: true, allowEdit: true, allowDelete: true } },
+    fields: {},
+  };
+}
+
+/** The organization has a queue unless a test says otherwise. */
+const WITH_QUEUE = session(true);
+
+function mount(ds: ReturnType<typeof dataSourceServing>, perms: MePermissionsResponse | null = WITH_QUEUE) {
+  const list = <ListView schema={schema} dataSource={ds as any} />;
   return render(
     <SchemaRendererProvider dataSource={ds as any}>
-      <ListView schema={schema} dataSource={ds as any} />
+      {perms ? <MePermissionsProvider initialPermissions={perms}>{list}</MePermissionsProvider> : list}
     </SchemaRendererProvider>,
   );
 }
 
+/** Settles a mount that renders no toggle: the definition is read and the rows fetched. */
+async function settled(ds: ReturnType<typeof dataSourceServing>) {
+  await waitFor(() => expect(ds.getObjectSchema).toHaveBeenCalled());
+  await waitFor(() => expect(ds.find).toHaveBeenCalled());
+}
+
 const lastFilter = (ds: ReturnType<typeof dataSourceServing>) => {
   const calls = ds.find.mock.calls;
   return (calls[calls.length - 1]?.[1] as { $filter?: unknown } | undefined)?.$filter;
@@ -128,8 +159,61 @@ describe('ListView "In a queue" toggle (ADR-0142 D3)', () => {
   it('does not render on an object without the injected column', async () => {
     const ds = dataSourceServing({ queue: { name: 'queue', type: 'text' } });
     mount(ds);
-    await waitFor(() => expect(ds.getObjectSchema).toHaveBeenCalled());
-    await waitFor(() => expect(ds.find).toHaveBeenCalled());
+    await settled(ds);
     expect(screen.queryByTestId('queue-sitting-filter')).toBeNull();
   });
 });
+
+describe('ListView "In a queue" toggle — offered only when the organization has a queue (objectstack#28428)', () => {
+  it('an organization with no queue: no toggle, even on an object with the injected column', async () => {
+    const ds = dataSourceServing({ queue: INJECTED_QUEUE });
+    mount(ds, session(false));
+    await settled(ds);
+    expect(screen.queryByTestId('queue-sitting-filter')).toBeNull();
+    expect(JSON.stringify(lastFilter(ds) ?? null)).not.toContain('owner_id');
+  });
+
+  it('an organization with one queue: the toggle on the injected column\'s object', async () => {
+    const ds = dataSourceServing({ queue: INJECTED_QUEUE });
+    mount(ds, session(true));
+    expect(await screen.findByTestId('queue-sitting-filter')).toBeTruthy();
+  });
+
+  it('an unknown answer hides it: no permission provider, or an anonymous answer', async () => {
+    for (const perms of [null, { authenticated: false } as MePermissionsResponse]) {
+      const ds = dataSourceServing({ queue: INJECTED_QUEUE });
+      const { unmount } = mount(ds, perms);
+      await settled(ds);
+      expect(screen.queryByTestId('queue-sitting-filter')).toBeNull();
+      unmount();
+    }
+  });
+
+  it('a list mount costs the same calls with and without a queue, and reads no queue list', async () => {
+    const fetchSpy = vi.spyOn(globalThis, 'fetch');
+    try {
+      const calls = async (hasAnyQueue: boolean) => {
+        const ds = dataSourceServing({ queue: INJECTED_QUEUE });
+        const { unmount } = mount(ds, session(hasAnyQueue));
+        await settled(ds);
+        if (hasAnyQueue) await screen.findByTestId('queue-sitting-filter');
+        const counts = {
+          getObjectSchema: ds.getObjectSchema.mock.calls.length,
+          find: ds.find.mock.calls.length,
+          findOne: ds.findOne.mock.calls.length,
+          // Every `find` targets the listed object: no `sys_queue` read.
+          resources: [...new Set(ds.find.mock.calls.map((c) => c[0]))],
+        };
+        unmount();
+        return counts;
+      };
+      const without = await calls(false);
+      const withQueue = await calls(true);
+      expect(withQueue).toEqual(without);
+      expect(without.resources).toEqual([OBJECT]);
+      expect(fetchSpy).not.toHaveBeenCalled();
+    } finally {
+      fetchSpy.mockRestore();
+    }
+  });
+});