Task #609: Per-user app enable/disable in Settings

- New `user_hidden_apps` table (userId+appId composite PK, cascade) in
  lib/db/src/schema/user-hidden-apps.ts; registered in schema index;
  pushed to dev DB via drizzle-kit.
- Backend (artifacts/api-server/src/routes/apps.ts):
  - GET /me/apps — returns every globally-active app visible to the
    user with a `hidden` flag.
  - PUT /me/apps/:appId/hidden — toggles a row in user_hidden_apps,
    gated by getVisibleAppsForUser + isActive so a user can't toggle
    apps they can't reach.
  - GET /apps (Home/Dock) now uses getVisibleNonHiddenAppsForUser so
    hidden apps disappear immediately.
- lib/appsVisibility.ts: added getHiddenAppIdsForUser and
  getVisibleNonHiddenAppsForUser helpers.
- OpenAPI: added /me/apps + /me/apps/{appId}/hidden, MyApp and
  UpdateMyAppHiddenBody schemas; regenerated api-zod + api-client-react.
- Frontend (settings-panel.tsx): added "My apps" accordion section as
  first GroupItem with MyAppsBody — Switch per app, optimistic update,
  invalidates getListMyAppsQueryKey + getListAppsQueryKey so Home/Dock
  refresh without reload.
- Translations: added settingsPanel.section.myApps + settingsPanel.myApps
  in ar.json + en.json.
- Code review fix: /me/apps and PUT gating filter isActive even for
  admins, so inactive apps don't appear in the Settings list.
- Proposed follow-up #611 (Playwright test that hidden apps disappear
  from Home and Dock).

lib/api-client-react/src/generated/api.schemas.ts

@@ -763,6 +763,15 @@ export interface AppSettings {
   updatedAt?: string;
 }
 
+export type MyApp = App & {
+  /** True when the current user has hidden this app from their Home/Dock. */
+  hidden: boolean;
+};
+
+export interface UpdateMyAppHiddenBody {
+  hidden: boolean;
+}
+
 export interface UpdateMyAppOrderBody {
   /** App IDs in the desired display order */
   order: number[];

lib/api-client-react/src/generated/api.ts

@@ -80,6 +80,7 @@ import type {
   ListReceivedNotesParams,
   ListUsersParams,
   LoginBody,
+  MyApp,
   MyNote,
   NoteFolder,
   NoteReply,
@@ -118,6 +119,7 @@ import type {
   UpdateClockStyleBody,
   UpdateGroupBody,
   UpdateLanguageBody,
+  UpdateMyAppHiddenBody,
   UpdateMyAppOrderBody,
   UpdateNoteFolderBody,
   UpdateNoteFolderParams,
@@ -2252,6 +2254,172 @@ export const useUpdateMyAppOrder = <
   return useMutation(getUpdateMyAppOrderMutationOptions(options));
 };
 
+/**
+ * Returns every globally active app (regardless of the per-user hidden
+flag), each with a `hidden` boolean indicating whether the current
+user has hidden it from their own Home/Dock via PUT /me/apps/{appId}/hidden.
+Used by the per-user Settings panel; the Home and Dock continue to use
+GET /apps which already filters out hidden apps server-side.
+
+ * @summary List apps for the current user with their per-user hidden state
+ */
+export const getListMyAppsUrl = () => {
+  return `/api/me/apps`;
+};
+
+export const listMyApps = async (options?: RequestInit): Promise<MyApp[]> => {
+  return customFetch<MyApp[]>(getListMyAppsUrl(), {
+    ...options,
+    method: "GET",
+  });
+};
+
+export const getListMyAppsQueryKey = () => {
+  return [`/api/me/apps`] as const;
+};
+
+export const getListMyAppsQueryOptions = <
+  TData = Awaited<ReturnType<typeof listMyApps>>,
+  TError = ErrorType<unknown>,
+>(options?: {
+  query?: UseQueryOptions<
+    Awaited<ReturnType<typeof listMyApps>>,
+    TError,
+    TData
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+
+  const queryKey = queryOptions?.queryKey ?? getListMyAppsQueryKey();
+
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof listMyApps>>> = ({
+    signal,
+  }) => listMyApps({ signal, ...requestOptions });
+
+  return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+    Awaited<ReturnType<typeof listMyApps>>,
+    TError,
+    TData
+  > & { queryKey: QueryKey };
+};
+
+export type ListMyAppsQueryResult = NonNullable<
+  Awaited<ReturnType<typeof listMyApps>>
+>;
+export type ListMyAppsQueryError = ErrorType<unknown>;
+
+/**
+ * @summary List apps for the current user with their per-user hidden state
+ */
+
+export function useListMyApps<
+  TData = Awaited<ReturnType<typeof listMyApps>>,
+  TError = ErrorType<unknown>,
+>(options?: {
+  query?: UseQueryOptions<
+    Awaited<ReturnType<typeof listMyApps>>,
+    TError,
+    TData
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+  const queryOptions = getListMyAppsQueryOptions(options);
+
+  const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+  };
+
+  return { ...query, queryKey: queryOptions.queryKey };
+}
+
+/**
+ * @summary Hide or show an app for the current user
+ */
+export const getUpdateMyAppHiddenUrl = (appId: number) => {
+  return `/api/me/apps/${appId}/hidden`;
+};
+
+export const updateMyAppHidden = async (
+  appId: number,
+  updateMyAppHiddenBody: UpdateMyAppHiddenBody,
+  options?: RequestInit,
+): Promise<MyApp> => {
+  return customFetch<MyApp>(getUpdateMyAppHiddenUrl(appId), {
+    ...options,
+    method: "PUT",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(updateMyAppHiddenBody),
+  });
+};
+
+export const getUpdateMyAppHiddenMutationOptions = <
+  TError = ErrorType<ErrorResponse>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof updateMyAppHidden>>,
+    TError,
+    { appId: number; data: BodyType<UpdateMyAppHiddenBody> },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationOptions<
+  Awaited<ReturnType<typeof updateMyAppHidden>>,
+  TError,
+  { appId: number; data: BodyType<UpdateMyAppHiddenBody> },
+  TContext
+> => {
+  const mutationKey = ["updateMyAppHidden"];
+  const { mutation: mutationOptions, request: requestOptions } = options
+    ? options.mutation &&
+      "mutationKey" in options.mutation &&
+      options.mutation.mutationKey
+      ? options
+      : { ...options, mutation: { ...options.mutation, mutationKey } }
+    : { mutation: { mutationKey }, request: undefined };
+
+  const mutationFn: MutationFunction<
+    Awaited<ReturnType<typeof updateMyAppHidden>>,
+    { appId: number; data: BodyType<UpdateMyAppHiddenBody> }
+  > = (props) => {
+    const { appId, data } = props ?? {};
+
+    return updateMyAppHidden(appId, data, requestOptions);
+  };
+
+  return { mutationFn, ...mutationOptions };
+};
+
+export type UpdateMyAppHiddenMutationResult = NonNullable<
+  Awaited<ReturnType<typeof updateMyAppHidden>>
+>;
+export type UpdateMyAppHiddenMutationBody = BodyType<UpdateMyAppHiddenBody>;
+export type UpdateMyAppHiddenMutationError = ErrorType<ErrorResponse>;
+
+/**
+ * @summary Hide or show an app for the current user
+ */
+export const useUpdateMyAppHidden = <
+  TError = ErrorType<ErrorResponse>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof updateMyAppHidden>>,
+    TError,
+    { appId: number; data: BodyType<UpdateMyAppHiddenBody> },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationResult<
+  Awaited<ReturnType<typeof updateMyAppHidden>>,
+  TError,
+  { appId: number; data: BodyType<UpdateMyAppHiddenBody> },
+  TContext
+> => {
+  return useMutation(getUpdateMyAppHiddenMutationOptions(options));
+};
+
 /**
  * @summary Get application settings (public)
  */