@@ -0,0 +1,13 @@
+---
+'@object-ui/app-shell': patch
+---
+
+fix(app-shell): a ⌘K record hit opens under the app that lists its object, not under the app the palette was opened in (#28890)
+
+Clause-②: no
+Metadata-protocol: none
+
+An app whose navigation names no object (a component-only app, such as cloud's Account app) searches every object from the command palette, so its hits name objects it does not list. Each hit opened under that app all the same, and the record page drew its sidebar and app switcher, neither of which reaches the object: an environment found from the Account app opened in the Account app, not in the Cloud app that lists environments.
+
+- **Now.** A record hit opens under the palette's own app when that app lists the hit's object; otherwise under the first app the user can open (active, not hidden, in metadata order) that lists it; and under the palette's own app when none does. "Lists" means a `type: 'object'` entry naming the object, at any depth of the app's `navigation` or of any `areas[].navigation`, among the entries the member is shown there.
+- **Unchanged.** When the palette's app lists the object, the hit opens there as before. The palette's search scope is untouched: an app with no object navigation still searches every object.
@@ -0,0 +1,133 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * A ⌘K record hit opens under the app that lists its object
+ * (objectstack#28890).
+ *
+ * An app whose navigation names no object (a component-only app, as cloud's
+ * Account app is) searches every object, so its hits name objects it does not
+ * list. Each opened under that app all the same, `/apps/<palette app>/OBJECT/
+ * record/ID`, and the record page drew a sidebar and a switcher that reach
+ * nothing of the object. The hit now opens under the palette's own app when
+ * that app lists the object, else under the first app the user can open that
+ * lists it, else under the palette's own app.
+ *
+ * Pinned against the real `CommandPaletteProvider` (opened through its
+ * `?palette=1` deep link) over the per-object `find` fanout; the address is
+ * read off the router after the hit is chosen.
+ */
+
+import * as React from 'react';
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { render, fireEvent, waitFor, cleanup, screen } from '@testing-library/react';
+import { MemoryRouter, useLocation } from 'react-router-dom';
+
+vi.mock('@object-ui/auth', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useAuth: () => ({ user: { id: 'u1' }, activeOrganization: null }),
+}));
+
+import { CommandPalette } from './CommandPalette';
+import { CommandPaletteProvider } from '../context/CommandPaletteProvider';
+
+const OBJECT = 'sys_environment_28890';
+const REC = 'E1';
+const RECORD = { id: REC, name: 'Release Check 1001' };
+const OBJECTS = [{ name: OBJECT, label: 'Environment', fields: { name: { label: 'Name', type: 'text' } } }];
+
+/** A component-only app: its navigation names no object. */
+const ACCOUNT = {
+  name: 'account',
+  label: 'Account',
+  navigation: [{ id: 'n_profile', type: 'component', componentName: 'account/profile_card', label: 'Profile' }],
+};
+/** An app that does not list the object either, ahead of the one that does. */
+const DOCS = { name: 'docs', label: 'Docs', navigation: [{ id: 'n_docs', type: 'page', pageName: 'docs_home', label: 'Docs' }] };
+/** The app that lists the object, inside a group, addressed by its package id. */
+const CLOUD = {
+  name: 'cloud',
+  _packageId: 'com.objectstack.cloud',
+  label: 'Cloud',
+  navigation: [
+    {
+      id: 'g_infra',
+      type: 'group',
+      label: 'Infrastructure',
+      children: [{ id: 'n_env', type: 'object', objectName: OBJECT, label: 'Environments' }],
+    },
+  ],
+};
+/** Lists the object in an area's navigation, not in its own. */
+const OPS = {
+  name: 'ops',
+  label: 'Ops',
+  navigation: [],
+  areas: [{ id: 'a_main', label: 'Main', navigation: [{ id: 'n_env', type: 'object', objectName: OBJECT, label: 'Environments' }] }],
+};
+/** Lists the object but is hidden from the launcher: no place to send anyone. */
+const HIDDEN = { ...CLOUD, name: 'hidden_cloud', _packageId: undefined, hidden: true };
+
+function Probe() {
+  const location = useLocation();
+  return <span data-testid="location" data-path={location.pathname} />;
+}
+
+function mount(apps: Array<Record<string, unknown>>, activeApp: Record<string, unknown>) {
+  const ds = { find: vi.fn(async (name: string) => ({ data: name === OBJECT ? [{ ...RECORD }] : [] })) };
+  const segment = (activeApp._packageId as string | undefined) ?? (activeApp.name as string);
+  render(
+    <MemoryRouter initialEntries={[`/apps/${segment}?palette=1`]}>
+      <CommandPaletteProvider>
+        <Probe />
+        <CommandPalette apps={apps} activeApp={activeApp} objects={OBJECTS} onAppChange={() => {}} dataSource={ds} />
+      </CommandPaletteProvider>
+    </MemoryRouter>,
+  );
+  const input = document.querySelector('[cmdk-input]');
+  if (!input) throw new Error('the palette did not open');
+  fireEvent.change(input, { target: { value: 'release' } });
+}
+
+/** Choose the record hit once it is on screen (the hook debounces 250ms); answer the address it opened. */
+async function openHit(): Promise<string | null> {
+  const item = await waitFor(
+    () => {
+      const found = document.querySelector('[cmdk-item][data-value^="record "]');
+      if (!found) throw new Error('the record hit is not on screen yet');
+      return found;
+    },
+    { timeout: 4000 },
+  );
+  fireEvent.click(item);
+  return screen.getByTestId('location').getAttribute('data-path');
+}
+
+afterEach(() => cleanup());
+
+describe('objectstack#28890 — a ⌘K record hit opens under the app that lists its object', () => {
+  it('from an app that does not list the object, the hit opens under the first app that does', async () => {
+    mount([ACCOUNT, DOCS, HIDDEN, CLOUD, OPS], ACCOUNT);
+    expect(await openHit()).toBe(`/apps/com.objectstack.cloud/${OBJECT}/record/${REC}`);
+  });
+
+  it('an app that lists the object only in an area counts as listing it', async () => {
+    mount([ACCOUNT, OPS, CLOUD], ACCOUNT);
+    expect(await openHit()).toBe(`/apps/ops/${OBJECT}/record/${REC}`);
+  });
+
+  it('CONTROL: from an app that lists the object, the hit stays under that app', async () => {
+    mount([ACCOUNT, OPS, CLOUD], CLOUD);
+    expect(await openHit()).toBe(`/apps/com.objectstack.cloud/${OBJECT}/record/${REC}`);
+  });
+
+  it('CONTROL: when no app the user can open lists the object, the hit stays under the palette app', async () => {
+    mount([ACCOUNT, DOCS, HIDDEN], ACCOUNT);
+    expect(await openHit()).toBe(`/apps/account/${OBJECT}/record/${REC}`);
+  });
+});
@@ -55,6 +55,8 @@ import { useTheme } from './ThemeProvider.js';
 import { navEntriesShownToMember, useNavMemberGates, type NavMemberGates } from '../hooks/useNavMemberGates.js';
 import { useObjectTranslation } from '@object-ui/i18n';
 import { resolveKeyedI18nLabel, getRecordDisplayName, appRouteSegment } from '../utils/index.js';
+import { appAddressSegment, filterActiveApps } from '../utils/appRoute.js';
+import { navigationNames } from '../console/appObjectScope.js';
 import { getIcon } from '../utils/getIcon.js';
 import { useRecentItems } from '../context/RecentItemsProvider.js';
 import { useRecentItemLabel } from '../hooks/useRecentItemLabel.js';
@@ -115,6 +117,53 @@ const NO_APP: Omit<AppCommandPaletteProps, 'scope'> = {
   dataSource: undefined,
 };
 
+/** The keys of an app the record-hit resolution reads: its route keys and navigation trees. */
+type PaletteApp = { navigation?: unknown; areas?: unknown } & Record<string, unknown>;
+
+/**
+ * Whether `app` lists `objectName` (objectstack#28890): a `type: 'object'`
+ * entry naming it, at any depth of its `navigation` or of any
+ * `areas[].navigation`, among the entries the member is shown there
+ * (`navEntriesShownToMember` under the palette's gates, as
+ * `activityObjectRoster` reads every app's navigation). `gates` is `null`
+ * only in the `studio` scope, which searches no record.
+ */
+function appListsObject(app: PaletteApp | null | undefined, objectName: string, gates: NavMemberGates | null): boolean {
+  if (!app) return false;
+  const areas: unknown[] = Array.isArray(app.areas) ? app.areas : [];
+  const trees = [app.navigation, ...areas.map((area) => (area as { navigation?: unknown } | null)?.navigation)];
+  const pick = (item: Record<string, unknown>) => (item.type === 'object' ? item.objectName : undefined);
+  return trees.some(
+    (tree) =>
+      Array.isArray(tree) &&
+      navigationNames(gates ? navEntriesShownToMember(tree as NavigationItem[], gates) : tree, pick).includes(objectName),
+  );
+}
+
+/**
+ * The app a record hit opens under (objectstack#28890), as the segment of its
+ * `/apps/APP` link: the palette's own app when it lists the hit's object;
+ * otherwise the first app the user can open (`filterActiveApps`, metadata
+ * order) that lists it, addressed by `appAddressSegment`; and the palette's
+ * own app again when none does, so `undefined` means "stay here".
+ *
+ * An app with no object navigation searches every object (the scope below),
+ * so its hits named objects it does not list, and each opened under it: the
+ * record page drew that app's sidebar and switcher, neither of which reaches
+ * the object (cloud's Account app, a component-only app, opened an
+ * environment there instead of under the Cloud app that lists it).
+ */
+function recordHitAppSegment(
+  apps: readonly PaletteApp[],
+  activeApp: PaletteApp | null | undefined,
+  objectName: string,
+  gates: NavMemberGates | null,
+): string | undefined {
+  if (appListsObject(activeApp, objectName, gates)) return undefined;
+  const host = filterActiveApps(apps).find((app) => appListsObject(app, objectName, gates));
+  return host ? appAddressSegment(apps, host) : undefined;
+}
+
 /**
  * The palette, behind its own error boundary (objectui#13387). It is mounted in
  * the console's frame, beside the routes, so an error thrown inside it (a
@@ -196,6 +245,11 @@ function CommandPaletteBody(props: CommandPaletteProps & { gates: NavMemberGates
   }, [open]);
 
   const baseUrl = `/apps/${appName || appRouteSegment(activeApp)}`;
+  // A record hit's own base: the app that lists its object (objectstack#28890).
+  const recordHitBaseUrl = (objectName: string): string => {
+    const segment = recordHitAppSegment(apps, activeApp, objectName, gates);
+    return segment ? `/apps/${segment}` : baseUrl;
+  };
   const { user, activeOrganization } = useAuth();
   const templateContext = useMemo(
     () => ({ currentUserId: user?.id ?? null, currentOrgId: activeOrganization?.id ?? null }),
@@ -483,7 +537,7 @@ function CommandPaletteBody(props: CommandPaletteProps & { gates: NavMemberGates
                   // Stable across queries: cmdk filters nothing here
                   // (`shouldFilter` false), it only selects by the value.
                   value={`record ${hit.display} ${hit.objectLabel} ${hit.objectName} ${hit.recordId}`}
-                  onSelect={() => leaveTo(`${baseUrl}/${hit.objectName}/record/${hit.recordId}`)}
+                  onSelect={() => leaveTo(`${recordHitBaseUrl(hit.objectName)}/${hit.objectName}/record/${hit.recordId}`)}
                 >
                   <Icon className="mr-2 h-4 w-4" />
                   <span className="truncate">{hit.display}</span>