diff --git a/apps/api/src/integrations/application/services/connection.service.spec.ts b/apps/api/src/integrations/application/services/connection.service.spec.ts
index b593ea47f..96ec17504 100644
--- a/apps/api/src/integrations/application/services/connection.service.spec.ts
+++ b/apps/api/src/integrations/application/services/connection.service.spec.ts
@@ -128,6 +128,14 @@ describe('ConnectionService', () => {
             })
         ),
       update: jest.fn(),
+      getByRef: jest.fn().mockResolvedValue({
+        id: 'cred-row-1',
+        ref: 'cred-ref-1',
+        platformType: 'prestashop',
+        credentialsJson: {},
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      }),
       delete: jest.fn().mockResolvedValue(true),
     } as unknown as jest.Mocked<ICredentialsService>;
 
@@ -815,6 +823,36 @@ describe('ConnectionService', () => {
       });
     });
 
+    it('should merge onto existing stored fields instead of replacing the whole blob', async () => {
+      const dbConnection = new Connection(
+        'connection-123',
+        'prestashop',
+        'Test Connection',
+        'active',
+        {},
+        'db:cred-ref-1',
+        new Date(),
+        new Date(),
+        undefined,
+        ['ProductMaster']
+      );
+      connectionPort.get.mockResolvedValue(dbConnection);
+      credentials.getByRef.mockResolvedValue({
+        id: 'cred-row-1',
+        ref: 'cred-ref-1',
+        platformType: 'prestashop',
+        credentialsJson: { webserviceApiKey: 'OLD', otherField: 'keep-me' },
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      });
+
+      await service.updateCredentials('connection-123', { webserviceApiKey: 'NEW' });
+
+      expect(credentials.update).toHaveBeenCalledWith('cred-ref-1', {
+        credentialsJson: { webserviceApiKey: 'NEW', otherField: 'keep-me' },
+      });
+    });
+
     it('should reject rotation on non-db-backed connection', async () => {
       const legacy = new Connection(
         'connection-123',
diff --git a/apps/api/src/integrations/application/services/connection.service.ts b/apps/api/src/integrations/application/services/connection.service.ts
index 103c8209f..2e662e653 100644
--- a/apps/api/src/integrations/application/services/connection.service.ts
+++ b/apps/api/src/integrations/application/services/connection.service.ts
@@ -416,9 +416,16 @@ export class ConnectionService implements IConnectionService {
       platformType: connection.platformType,
       adapterKey: connection.adapterKey,
     });
-    await this.validateCredentialsShape(metadata.adapterKey, credentials);
     const ref = connection.credentialsRef.slice('db:'.length);
-    await this.credentials.update(ref, { credentialsJson: credentials });
+    // Merge onto the existing stored credentials rather than replacing the
+    // whole blob: callers only send the fields they actually changed (e.g.
+    // rotating just `apiKey`), and a full replace would silently delete any
+    // other previously-stored field (e.g. Erli's optional Allegro
+    // `allegroClientId`/`allegroClientSecret` pair, #1401 review).
+    const existing = await this.credentials.getByRef(ref);
+    const mergedCredentials = { ...existing.credentialsJson, ...credentials };
+    await this.validateCredentialsShape(metadata.adapterKey, mergedCredentials);
+    await this.credentials.update(ref, { credentialsJson: mergedCredentials });
     this.logger.log(`Rotated credentials for connection ${connectionId}`);
   }
 
diff --git a/apps/web/src/features/listings/components/create-offer-request-to-form-values.ts b/apps/web/src/features/listings/components/create-offer-request-to-form-values.ts
index b7f913e56..a5c3ca2e8 100644
--- a/apps/web/src/features/listings/components/create-offer-request-to-form-values.ts
+++ b/apps/web/src/features/listings/components/create-offer-request-to-form-values.ts
@@ -53,8 +53,13 @@ function readString(params: Record<string, unknown> | undefined, key: string): s
  * (product). The form-state map is keyed by parameter id alone — re-submission
  * re-derives the section split from the freshly-loaded category-parameters
  * metadata, so the section distinction is not preserved on the form side.
+ *
+ * Exported for reuse by the Erli retry mapper (#1384) — both platforms
+ * persist the same neutral `overrides.parameters` wire shape.
  */
-function readParameters(overrides: CreateOfferOverrides | undefined): CategoryParameterFormValues {
+export function readParameters(
+  overrides: CreateOfferOverrides | undefined,
+): CategoryParameterFormValues {
   const out: CategoryParameterFormValues = {};
   appendWireParameters(out, overrides?.parameters);
   // Transitional fallback for snapshots persisted before #1071.
diff --git a/apps/web/src/features/listings/components/erli/create-erli-offer-request-to-form-values.test.ts b/apps/web/src/features/listings/components/erli/create-erli-offer-request-to-form-values.test.ts
index e3294b746..08fd8b8d6 100644
--- a/apps/web/src/features/listings/components/erli/create-erli-offer-request-to-form-values.test.ts
+++ b/apps/web/src/features/listings/components/erli/create-erli-offer-request-to-form-values.test.ts
@@ -55,6 +55,24 @@ describe('createErliOfferRequestToFormValues', () => {
     expect(values.dispatchPeriod).toBe(2);
     expect(values.dispatchUnit).toBe('day');
   });
+
+  it('restores category-parameter values from the wire snapshot on retry', () => {
+    const values = createErliOfferRequestToFormValues(
+      snapshot({
+        overrides: {
+          title: 'With parameters',
+          categoryId: '12345',
+          parameters: [
+            { id: 'p1', values: ['Red'], section: 'offer' },
+            { id: 'p2', valuesIds: ['v1', 'v2'], section: 'offer' },
+          ],
+        },
+      }),
+      FALLBACK,
+    );
+
+    expect(values.parameters).toEqual({ p1: 'Red', p2: ['v1', 'v2'] });
+  });
 });
 
 describe('readErliOfferRequestPrefill', () => {
diff --git a/apps/web/src/features/listings/components/erli/create-erli-offer-request-to-form-values.ts b/apps/web/src/features/listings/components/erli/create-erli-offer-request-to-form-values.ts
index 7d06ef493..3d75bfc24 100644
--- a/apps/web/src/features/listings/components/erli/create-erli-offer-request-to-form-values.ts
+++ b/apps/web/src/features/listings/components/erli/create-erli-offer-request-to-form-values.ts
@@ -26,6 +26,7 @@ import {
   SUPPORTED_OFFER_CREATION_REQUEST_SCHEMA_VERSION,
   type CreateOfferRequest,
 } from '../../api/listings.types';
+import { readParameters } from '../create-offer-request-to-form-values';
 import type { ErliCreateOfferValues } from './erli-create-offer.schema';
 import { isValidDispatch, type ErliDispatchTimeParam } from './erli-offer-fields.schema';
 
@@ -62,6 +63,10 @@ export function createErliOfferRequestToFormValues(
     publishImmediately: request.publishImmediately,
     dispatchPeriod: dispatch.period,
     dispatchUnit: dispatch.unit,
+    // Reuses the Allegro retry mapper's heuristic (#1384) — both platforms
+    // persist the same neutral `overrides.parameters` wire shape, so a
+    // retried offer re-opens with its previously entered parameter values.
+    parameters: readParameters(overrides),
   };
 }
 
diff --git a/apps/web/src/features/listings/components/erli/erli-create-offer-wizard.test.tsx b/apps/web/src/features/listings/components/erli/erli-create-offer-wizard.test.tsx
index 059e7ff68..eeb82c645 100644
--- a/apps/web/src/features/listings/components/erli/erli-create-offer-wizard.test.tsx
+++ b/apps/web/src/features/listings/components/erli/erli-create-offer-wizard.test.tsx
@@ -28,6 +28,15 @@ const erliConnection: Connection = {
   updatedAt: '2026-01-01T00:00:00Z',
 };
 
+// #1384 — a per-connection-instance signal (`config.allegroCategoryAccessEnabled`),
+// deliberately NOT reflected in `supportedCapabilities` (static per-adapterKey,
+// see ADR-031 "Correction") — both connections keep the same `supportedCapabilities`.
+const erliConnectionWithCategoryAccess: Connection = {
+  ...erliConnection,
+  id: 'conn_erli_2',
+  config: { ...erliConnection.config, allegroCategoryAccessEnabled: true },
+};
+
 function productWith(images: string[] | null): Product {
   return {
     id: 'ol_product_abc',
@@ -205,4 +214,140 @@ describe('ErliCreateOfferWizard', () => {
       dispatchTime: { period: 5, unit: 'hour' },
     });
   });
+
+  // #1384 — capability-conditional category/parameters steps.
+  describe('Allegro category access (#1384)', () => {
+    it('keeps the plain-text category field and shows the fallback hint when access is not configured', async () => {
+      renderWithProviders(
+        <ErliCreateOfferWizard connection={erliConnection} onCancel={vi.fn()} onSubmitted={vi.fn()} />,
+        { apiClient: mocks(productWith(['https://cdn.example.com/a.jpg'])) },
+      );
+
+      await pickVariantAndAdvance();
+
+      expect(await screen.findByPlaceholderText(/e\.g\. 12345/i)).toBeInTheDocument();
+      expect(
+        screen.getByText(/add allegro category browsing to this connection/i),
+      ).toBeInTheDocument();
+      expect(screen.getByRole('link', { name: /configure category browsing/i })).toHaveAttribute(
+        'href',
+        `/connections/${erliConnection.id}/edit`,
+      );
+      // Only the 3-step shape — no "Category" / "Category parameters" steps.
+      expect(screen.queryByText('Category parameters')).not.toBeInTheDocument();
+    });
+
+    it('renders the Category and Category-parameters steps, blocks on a required parameter, and submits overrides.parameters', async () => {
+      const mockApi = mocks(productWith(['https://cdn.example.com/a.jpg']), {
+        connections: { list: vi.fn().mockResolvedValue([erliConnectionWithCategoryAccess]) },
+        listings: {
+          createOffer: vi
+            .fn()
+            .mockResolvedValue({ jobId: 'job-1', offerCreationRecordId: 'rec-1' }),
+          resolveCategory: vi.fn().mockResolvedValue({ allegroCategoryId: null, method: 'manual' }),
+          getCategoryParameters: vi.fn().mockResolvedValue({
+            parameters: [
+              {
+                id: 'p_stan',
+                name: 'Stan',
+                type: 'dictionary',
+                required: true,
+                section: 'offer',
+                restrictions: {},
+                dictionary: [{ id: 'nowy', value: 'Nowy' }],
+              },
+            ],
+          }),
+        },
+        mappings: {
+          getAllegroCategories: vi
+            .fn()
+            .mockResolvedValue([{ id: '12345', name: 'Test Category', parentId: null, leaf: true }]),
+        },
+      });
+      renderWithProviders(
+        <ErliCreateOfferWizard
+          connection={erliConnectionWithCategoryAccess}
+          onCancel={vi.fn()}
+          onSubmitted={vi.fn()}
+        />,
+        { apiClient: mockApi },
+      );
+
+      await pickVariantAndAdvance();
+      // Offer-details step: no plain-text category field or hint anymore —
+      // it moved to its own step.
+      fireEvent.change(await screen.findByLabelText(/^price \(PLN\)$/i), {
+        target: { value: '99.99' },
+      });
+      expect(screen.queryByPlaceholderText(/e\.g\. 12345/i)).not.toBeInTheDocument();
+      fireEvent.click(screen.getByRole('button', { name: /next/i }));
+
+      // Category step — pick the leaf via the reused CategoryPicker.
+      const selectButton = await screen.findByRole('button', { name: /^select$/i });
+      fireEvent.click(selectButton);
+      await waitFor(() =>
+        expect(screen.getByRole('button', { name: /^selected$/i })).toBeInTheDocument(),
+      );
+      fireEvent.click(screen.getByRole('button', { name: /next/i }));
+
+      // Category-parameters step — required "Stan" field blocks Next until filled.
+      await screen.findByText('Stan');
+      fireEvent.click(screen.getByRole('button', { name: /next/i }));
+      expect(await screen.findByText(/stan is required/i)).toBeInTheDocument();
+
+      fireEvent.change(screen.getByLabelText('Stan'), { target: { value: 'nowy' } });
+      fireEvent.click(screen.getByRole('button', { name: /next/i }));
+
+      fireEvent.click(await screen.findByRole('button', { name: /create offer/i }));
+
+      const createOffer = vi.mocked(mockApi.listings.createOffer);
+      await waitFor(() => expect(createOffer).toHaveBeenCalledTimes(1));
+      const [, request] = createOffer.mock.calls[0] as [string, CreateOfferRequest];
+      expect(request.overrides?.categoryId).toBe('12345');
+      expect(request.overrides?.parameters).toEqual([
+        { id: 'p_stan', valuesIds: ['nowy'], section: 'offer' },
+      ]);
+    });
+
+    it('blocks Next on the Category step until a category is selected (#1401 review)', async () => {
+      const mockApi = mocks(productWith(['https://cdn.example.com/a.jpg']), {
+        connections: { list: vi.fn().mockResolvedValue([erliConnectionWithCategoryAccess]) },
+        listings: {
+          createOffer: vi
+            .fn()
+            .mockResolvedValue({ jobId: 'job-1', offerCreationRecordId: 'rec-1' }),
+          resolveCategory: vi.fn().mockResolvedValue({ allegroCategoryId: null, method: 'manual' }),
+          getCategoryParameters: vi.fn().mockResolvedValue({ parameters: [] }),
+        },
+        mappings: {
+          getAllegroCategories: vi
+            .fn()
+            .mockResolvedValue([{ id: '12345', name: 'Test Category', parentId: null, leaf: true }]),
+        },
+      });
+      renderWithProviders(
+        <ErliCreateOfferWizard
+          connection={erliConnectionWithCategoryAccess}
+          onCancel={vi.fn()}
+          onSubmitted={vi.fn()}
+        />,
+        { apiClient: mockApi },
+      );
+
+      await pickVariantAndAdvance();
+      fireEvent.change(await screen.findByLabelText(/^price \(PLN\)$/i), {
+        target: { value: '99.99' },
+      });
+      fireEvent.click(screen.getByRole('button', { name: /next/i }));
+
+      // Category step — click Next without touching the CategoryPicker at all.
+      await screen.findByText('Category');
+      fireEvent.click(screen.getByRole('button', { name: /next/i }));
+
+      expect(await screen.findByText(/select a category to continue/i)).toBeInTheDocument();
+      // Still on the Category step — Category-parameters never rendered.
+      expect(screen.queryByText(/no additional parameters required/i)).not.toBeInTheDocument();
+    });
+  });
 });
diff --git a/apps/web/src/features/listings/components/erli/erli-create-offer-wizard.tsx b/apps/web/src/features/listings/components/erli/erli-create-offer-wizard.tsx
index fe56c2199..b5b73dfdd 100644
--- a/apps/web/src/features/listings/components/erli/erli-create-offer-wizard.tsx
+++ b/apps/web/src/features/listings/components/erli/erli-create-offer-wizard.tsx
@@ -31,8 +31,9 @@
  * @module features/listings/components/erli
  */
 import { useEffect, useMemo, useRef, useState, type ReactElement } from 'react';
-import { FormProvider, useForm } from 'react-hook-form';
+import { Controller, FormProvider, useForm, type FieldPath } from 'react-hook-form';
 import { zodResolver } from '@hookform/resolvers/zod';
+import { Link } from 'react-router-dom';
 
 import { Alert } from '../../../../shared/ui/alert';
 import { Button } from '../../../../shared/ui/button';
@@ -49,8 +50,21 @@ import { useProductQuery, useProductsQuery, useVariantQuery } from '../../../pro
 import type { Product, ProductVariant } from '../../../products';
 import { useCreateOfferMutation } from '../../hooks/use-create-offer-mutation';
 import { useResolveCategoryQuery } from '../../hooks/use-resolve-category-query';
-import type { CreateOfferRequest } from '../../api/listings.types';
-import { erliCreateOfferSchema, type ErliCreateOfferValues } from './erli-create-offer.schema';
+import { useCategoryParametersQuery } from '../../hooks/use-category-parameters-query';
+import { CategoryPicker } from '../CategoryPicker';
+import { CategoryParametersStep } from '../category-parameters-step';
+import { buildParametersZodSchema } from '../build-parameters-zod-schema';
+import {
+  MissingCategoryParameterSectionError,
+  categoryParametersToOfferParameters,
+} from '../category-parameters-to-offer-parameters';
+import type { CategoryParameterFormValues } from '../category-parameter-form.types';
+import type { CreateOfferRequest, OfferParameter } from '../../api/listings.types';
+import {
+  erliCreateOfferSchema,
+  type ErliCreateOfferSubmission,
+  type ErliCreateOfferValues,
+} from './erli-create-offer.schema';
 import { ErliDispatchTimeField } from './erli-dispatch-time-field';
 import {
   formatDispatch,
@@ -59,10 +73,38 @@ import {
 } from './erli-offer-fields.schema';
 import { readErliOfferRequestPrefill } from './create-erli-offer-request-to-form-values';
 
-const ERLI_STEP_LABELS = ['Variant', 'Offer details', 'Review'] as const;
+/**
+ * Step labels — capability-conditional (#1384). Erli borrows Allegro's
+ * category/attribute taxonomy (ADR-023, ADR-031); when the connection has
+ * Allegro app credentials configured (`config.allegroCategoryAccessEnabled`,
+ * a per-connection-instance-visible flag — NOT `supportedCapabilities`,
+ * which is static per-adapterKey and cannot reflect this, see ADR-031
+ * "Correction"), the wizard grows a dedicated Category step (CategoryPicker)
+ * and a Category-parameters step, mirroring `AllegroCreateOfferWizard`.
+ * Otherwise it keeps today's 3-step shape with the plain-text category field
+ * folded into "Offer details".
+ */
+const ERLI_STEP_LABELS_BASIC = ['Variant', 'Offer details', 'Review'] as const;
+const ERLI_STEP_LABELS_WITH_CATEGORY = [
+  'Variant',
+  'Offer details',
+  'Category',
+  'Category parameters',
+  'Review',
+] as const;
 const VARIANT_SEARCH_DEBOUNCE_MS = 300;
 const VARIANT_PICKER_PAGE_SIZE = 20;
 
+/**
+ * RHF cannot infer the dynamic `parameters.{paramId}` path from
+ * `ErliCreateOfferValues` (the `parameters` slice is `z.record(z.unknown())`
+ * by design — per-field shapes come from the runtime `CategoryParameter`
+ * list). Mirrors `AllegroCreateOfferWizard`'s `parametersFieldPath` helper.
+ */
+function parametersFieldPath(paramId: string): FieldPath<ErliCreateOfferValues> {
+  return `parameters.${paramId}` as FieldPath<ErliCreateOfferValues>;
+}
+
 function variantLabel(product: Product, variant: ProductVariant): string {
   const attrs = variant.attributes ? Object.values(variant.attributes).join(' · ') : '';
   if (attrs) return `${product.name} — ${attrs}`;
@@ -106,7 +148,18 @@ export function ErliCreateOfferWizard({
   // Shared, declared-once Erli validator (image gate). Resolved via usePlatform.
   const erliValidation = usePlatform(connection.platformType)?.offerValidation;
 
-  const form = useForm<ErliCreateOfferValues>({
+  // #1384 — per-connection-instance signal (NOT `connection.supportedCapabilities`,
+  // which is static per-adapterKey — see ADR-031 "Correction"). Read directly off
+  // the connection's already-returned `config`, no new query needed.
+  const allegroCategoryAccessEnabled = connection.config.allegroCategoryAccessEnabled === true;
+  const stepLabels = allegroCategoryAccessEnabled
+    ? ERLI_STEP_LABELS_WITH_CATEGORY
+    : ERLI_STEP_LABELS_BASIC;
+  const categoryStepIndex = allegroCategoryAccessEnabled ? 2 : null;
+  const categoryParametersStepIndex = allegroCategoryAccessEnabled ? 3 : null;
+  const reviewStepIndex = stepLabels.length - 1;
+
+  const form = useForm<ErliCreateOfferValues, undefined, ErliCreateOfferSubmission>({
     defaultValues: prefill ?? {
       internalVariantId: defaultVariantId ?? '',
       variantLabel: '',
@@ -118,6 +171,7 @@ export function ErliCreateOfferWizard({
       publishImmediately: false,
       dispatchPeriod: dispatchDefault.period,
       dispatchUnit: dispatchDefault.unit,
+      parameters: {},
     },
     resolver: zodResolver(erliCreateOfferSchema),
     mode: 'onBlur',
@@ -170,6 +224,35 @@ export function ErliCreateOfferWizard({
     }
   }, [categoryQuery.data, form]);
 
+  // #1384 — category-parameter schema, only fetched once a category is
+  // selected AND the connection has Allegro category access configured.
+  // Same hook Allegro's wizard uses (`useCategoryParametersQuery`) — no new
+  // hook needed, per the plan.
+  const currentCategoryId = form.watch('categoryId');
+  const categoryParametersQuery = useCategoryParametersQuery(
+    allegroCategoryAccessEnabled ? connection.id : undefined,
+    allegroCategoryAccessEnabled ? currentCategoryId || undefined : undefined,
+  );
+  const categoryParameters = useMemo(
+    () => categoryParametersQuery.data ?? [],
+    [categoryParametersQuery.data],
+  );
+  // Clear the parameters slice whenever the chosen category changes — the
+  // shape is category-specific so prior values would never be valid under a
+  // new schema (mirrors `AllegroCreateOfferWizard`).
+  const lastCategoryIdRef = useRef<string>(currentCategoryId);
+  useEffect(() => {
+    if (lastCategoryIdRef.current && lastCategoryIdRef.current !== currentCategoryId) {
+      form.setValue('parameters', {}, { shouldDirty: false, shouldValidate: false });
+      form.clearErrors('parameters');
+    }
+    lastCategoryIdRef.current = currentCategoryId;
+  }, [currentCategoryId, form]);
+  // #423 — surfaces `MissingCategoryParameterSectionError` (stale cache
+  // predating #417) with an actionable "reload" message, mirroring Allegro's
+  // wizard.
+  const [staleSchemaError, setStaleSchemaError] = useState<string | null>(null);
+
   useEffect(() => {
     function handleBeforeUnload(event: BeforeUnloadEvent): void {
       if (!form.formState.isDirty) return;
@@ -187,10 +270,10 @@ export function ErliCreateOfferWizard({
     () =>
       erliValidation?.validateRow({
         imageCount: imageUrls.length,
-        needsProductParameters: false,
+        needsProductParameters: allegroCategoryAccessEnabled,
         willLinkProductCard: false,
       }) ?? [],
-    [erliValidation, imageUrls.length],
+    [erliValidation, imageUrls.length, allegroCategoryAccessEnabled],
   );
   const hasImageBlocker = pickedProduct !== null && imageBlockers.length > 0;
 
@@ -207,19 +290,59 @@ export function ErliCreateOfferWizard({
     setPickedVariantEan(variant.ean ?? variant.gtin ?? null);
   }
 
-  const STEP_FIELDS: ReadonlyArray<ReadonlyArray<keyof ErliCreateOfferValues>> = [
-    ['internalVariantId'],
-    ['title', 'priceAmount', 'stock', 'dispatchPeriod', 'dispatchUnit'],
-    [],
-  ];
+  const STEP_FIELDS: ReadonlyArray<ReadonlyArray<keyof ErliCreateOfferValues>> = allegroCategoryAccessEnabled
+    ? [
+        ['internalVariantId'],
+        ['title', 'priceAmount', 'stock', 'dispatchPeriod', 'dispatchUnit'],
+        [], // Category — CategoryPicker, no static-field trigger
+        [], // Category parameters — validated dynamically below
+        [],
+      ]
+    : [['internalVariantId'], ['title', 'priceAmount', 'stock', 'dispatchPeriod', 'dispatchUnit'], []];
 
   async function goNext(): Promise<void> {
     const fields = STEP_FIELDS[stepIndex] ?? [];
     const valid = fields.length === 0 ? true : await form.trigger(fields);
     if (!valid) return;
     if (stepIndex === 1 && hasImageBlocker) return; // can't advance with a missing image
+
+    // #1401 review — Category is a static `[]` STEP_FIELDS entry (CategoryPicker
+    // has no static-field trigger), so `categoryId` must be enforced manually here,
+    // mirroring `AllegroCreateOfferWizard`'s required `categoryId` field. Without
+    // this an operator can click through the Category step without picking one.
+    if (allegroCategoryAccessEnabled && stepIndex === categoryStepIndex) {
+      if (!form.getValues('categoryId')) {
+        form.setError('categoryId', { type: 'manual', message: 'Select a category to continue.' });
+        return;
+      }
+      form.clearErrors('categoryId');
+    }
+
+    // #1384 — dynamic per-category Zod validation, mirrors
+    // `AllegroCreateOfferWizard`'s Step-3 gate. Skipped when the category has
+    // no parameters or the schema is still loading.
+    if (
+      allegroCategoryAccessEnabled &&
+      stepIndex === categoryParametersStepIndex &&
+      categoryParameters.length > 0
+    ) {
+      const paramValues =
+        (form.getValues('parameters') as CategoryParameterFormValues | undefined) ?? {};
+      const result = buildParametersZodSchema(categoryParameters).safeParse(paramValues);
+      if (!result.success) {
+        form.clearErrors('parameters');
+        for (const issue of result.error.issues) {
+          const paramId = String(issue.path[0] ?? '');
+          if (paramId === '') continue;
+          form.setError(parametersFieldPath(paramId), { type: 'manual', message: issue.message });
+        }
+        return;
+      }
+      form.clearErrors('parameters');
+    }
+
     setCompletedSteps((prev) => new Set(prev).add(stepIndex));
-    setStepIndex((i) => Math.min(i + 1, ERLI_STEP_LABELS.length - 1));
+    setStepIndex((i) => Math.min(i + 1, stepLabels.length - 1));
   }
 
   function goBack(): void {
@@ -236,6 +359,28 @@ export function ErliCreateOfferWizard({
     // the `defaultVariantId` path where no product was interactively picked.
     if (imageBlockers.length > 0) return;
 
+    setStaleSchemaError(null); // clear from any prior submit
+
+    // #1384 — serialize the Step-4 category-parameter values into the
+    // neutral `OfferParameter[]` shape, exactly like Allegro's wizard.
+    // `OfferBuilderService.buildOfferParameters` merges `overrides.parameters`
+    // server-side unchanged — no BE change needed (confirmed in ADR-031's plan).
+    let parameters: OfferParameter[] = [];
+    if (allegroCategoryAccessEnabled) {
+      try {
+        parameters = categoryParametersToOfferParameters(
+          (submitted.parameters as CategoryParameterFormValues | undefined) ?? {},
+          categoryParameters,
+        );
+      } catch (error) {
+        if (error instanceof MissingCategoryParameterSectionError) {
+          setStaleSchemaError(error.parameterName);
+          return;
+        }
+        throw error;
+      }
+    }
+
     const request: CreateOfferRequest = {
       internalVariantId: submitted.internalVariantId,
       stock: submitted.stock,
@@ -246,6 +391,7 @@ export function ErliCreateOfferWizard({
         ...(submitted.categoryId ? { categoryId: submitted.categoryId } : {}),
         description: submitted.description ? submitted.description : null,
         imageUrls,
+        ...(parameters.length > 0 ? { parameters } : {}),
         platformParams: {
           dispatchTime: { period: submitted.dispatchPeriod, unit: submitted.dispatchUnit },
         },
@@ -291,7 +437,7 @@ export function ErliCreateOfferWizard({
       </header>
 
       <SetupStepper
-        steps={ERLI_STEP_LABELS}
+        steps={stepLabels}
         currentStep={stepIndex}
         completedSteps={completedSteps}
       />
@@ -304,6 +450,22 @@ export function ErliCreateOfferWizard({
           {mutation.error.message}
         </Alert>
       ) : null}
+      {staleSchemaError !== null ? (
+        <Alert tone="error" title="Wizard data is out of date">
+          <p>
+            Category parameter <strong>{staleSchemaError}</strong> is missing data that was added
+            in a recent update. Please reload this page to refetch the latest category schema.
+          </p>
+          <div className="alert__actions">
+            <Button type="button" tone="primary" onClick={() => window.location.reload()}>
+              Reload now
+            </Button>
+            <Button type="button" tone="ghost" onClick={() => setStaleSchemaError(null)}>
+              Dismiss
+            </Button>
+          </div>
+        </Alert>
+      ) : null}
 
       <FormProvider {...form}>
         <form
@@ -408,16 +570,24 @@ export function ErliCreateOfferWizard({
                 <Input {...form.register('title')} maxLength={120} />
               </FormField>
 
-              <FormField
-                label="Category (resolved by EAN)"
-                name="categoryId"
-                description="Resolved from the variant barcode against the marketplace catalog. Leave blank to let the backend resolve at create time."
-              >
-                <Input
-                  {...form.register('categoryId')}
-                  placeholder={categoryQuery.isLoading ? 'Resolving…' : 'e.g. 12345'}
-                />
-              </FormField>
+              {!allegroCategoryAccessEnabled ? (
+                <>
+                  <FormField
+                    label="Category (resolved by EAN)"
+                    name="categoryId"
+                    description="Resolved from the variant barcode against the marketplace catalog. Leave blank to let the backend resolve at create time."
+                  >
+                    <Input
+                      {...form.register('categoryId')}
+                      placeholder={categoryQuery.isLoading ? 'Resolving…' : 'e.g. 12345'}
+                    />
+                  </FormField>
+                  <p className="erli-config__note">
+                    Add Allegro category browsing to this connection to pick from a list instead
+                    of typing a raw category id. <Link to={`/connections/${connection.id}/edit`}>Configure category browsing</Link>.
+                  </p>
+                </>
+              ) : null}
 
               <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 'var(--space-3)' }}>
                 <FormField
@@ -466,7 +636,61 @@ export function ErliCreateOfferWizard({
             </div>
           ) : null}
 
-          {stepIndex === 2 ? (
+          {allegroCategoryAccessEnabled && stepIndex === categoryStepIndex ? (
+            <div className="form-field">
+              <span id="erli-categoryId-label" className="form-field__label">
+                Category
+              </span>
+              <Controller
+                control={form.control}
+                name="categoryId"
+                render={({ field, fieldState }) => (
+                  <CategoryPicker
+                    connectionId={connection.id}
+                    value={field.value || null}
+                    onChange={field.onChange}
+                    invalid={Boolean(fieldState.error)}
+                    aria-labelledby="erli-categoryId-label"
+                    aria-describedby="erli-categoryId-description erli-categoryId-error"
+                  />
+                )}
+              />
+              <p id="erli-categoryId-description" className="form-field__description">
+                Browse the Allegro-borrowed category tree (ADR-023/ADR-031) and pick a leaf
+                category.
+              </p>
+              {form.formState.errors.categoryId?.message ? (
+                <p id="erli-categoryId-error" className="form-field__error" role="alert">
+                  {form.formState.errors.categoryId.message}
+                </p>
+              ) : null}
+            </div>
+          ) : null}
+
+          {allegroCategoryAccessEnabled && stepIndex === categoryParametersStepIndex ? (
+            categoryParametersQuery.isLoading ? (
+              <p className="muted-text" role="status" aria-live="polite">
+                Loading category parameters…
+              </p>
+            ) : categoryParametersQuery.error ? (
+              <Alert tone="error" title="Unable to load category parameters">
+                <span>{categoryParametersQuery.error.message}</span>
+                <Button
+                  tone="secondary"
+                  type="button"
+                  onClick={() => void categoryParametersQuery.refetch()}
+                >
+                  Retry
+                </Button>
+              </Alert>
+            ) : categoryParameters.length === 0 ? (
+              <p className="muted-text">No additional parameters required for this category.</p>
+            ) : (
+              <CategoryParametersStep parameters={categoryParameters} formNamespace="parameters" />
+            )
+          ) : null}
+
+          {stepIndex === reviewStepIndex ? (
             <dl className="create-offer-review">
               <dt>Variant</dt>
               <dd>{values.variantLabel || values.internalVariantId}</dd>
@@ -499,7 +723,7 @@ export function ErliCreateOfferWizard({
                   ← Back
                 </Button>
               ) : null}
-              {stepIndex < ERLI_STEP_LABELS.length - 1 ? (
+              {stepIndex < stepLabels.length - 1 ? (
                 <Button
                   type="button"
                   onClick={() => void goNext()}
diff --git a/apps/web/src/features/listings/components/erli/erli-create-offer.schema.ts b/apps/web/src/features/listings/components/erli/erli-create-offer.schema.ts
index f6ea991c7..15526ca87 100644
--- a/apps/web/src/features/listings/components/erli/erli-create-offer.schema.ts
+++ b/apps/web/src/features/listings/components/erli/erli-create-offer.schema.ts
@@ -2,10 +2,17 @@
  * Erli single-offer wizard schema
  *
  * Field schema for `ErliCreateOfferWizard`. Erli offers are products — no
- * seller/delivery policies and no Allegro-style category parameters — so the
- * field set is smaller than Allegro's: variant, title, category (Allegro-id
- * reuse #985), price (PLN), stock, description, and dispatch time. Images come
- * from the master product (not operator-entered).
+ * seller/delivery policies — so the field set is smaller than Allegro's:
+ * variant, title, category (Allegro-id reuse #985), price (PLN), stock,
+ * description, and dispatch time. Images come from the master product (not
+ * operator-entered).
+ *
+ * `parameters` (#1384) mirrors Allegro's `createOfferFieldsSchema` shape —
+ * a dynamic per-category dict validated at step-advance time via
+ * `buildParametersZodSchema`, not by this static resolver. It is only
+ * populated when the connection has Allegro category access configured
+ * (`connection.config.allegroCategoryAccessEnabled`); otherwise it stays
+ * `{}` and is dropped from the submit payload.
  *
  * @module features/listings/components/erli
  */
@@ -31,7 +38,12 @@ export const erliCreateOfferSchema = z
       .min(0, 'Stock must be 0 or greater'),
     description: z.string().optional(),
     publishImmediately: z.boolean(),
+    parameters: z.record(z.string(), z.unknown()).default({}),
   })
   .merge(erliOfferFieldsSchema);
 
-export type ErliCreateOfferValues = z.infer<typeof erliCreateOfferSchema>;
+// `.default({})` on `parameters` makes it optional on input (RHF form state,
+// pre-submit) and required on output (post-resolver submit handler) — same
+// split `createOfferFieldsSchema` uses for Allegro's wizard.
+export type ErliCreateOfferValues = z.input<typeof erliCreateOfferSchema>;
+export type ErliCreateOfferSubmission = z.output<typeof erliCreateOfferSchema>;
diff --git a/apps/web/src/plugins/erli/components/erli-credentials-panel.test.tsx b/apps/web/src/plugins/erli/components/erli-credentials-panel.test.tsx
index 590186817..1f52ecd99 100644
--- a/apps/web/src/plugins/erli/components/erli-credentials-panel.test.tsx
+++ b/apps/web/src/plugins/erli/components/erli-credentials-panel.test.tsx
@@ -1,9 +1,11 @@
 /**
  * ErliCredentialsPanel Tests
  *
- * Coverage for the rotate-API-key flow for Erli connections. Erli carries a
- * single `apiKey` credential, so the panel rotates one field (unlike the
- * WooCommerce key/secret pair).
+ * Coverage for the rotate-API-key flow for Erli connections, plus (#1384)
+ * the "Browse Allegro categories" checkbox: reveal/hide behaviour, the
+ * client-side "both or neither" validation for the Client ID/Secret pair,
+ * and the sequenced credentials-then-config atomicity write for
+ * `allegroCategoryAccessEnabled` (both the enable and disable directions).
  */
 import { cleanup, fireEvent, screen, waitFor } from '@testing-library/react';
 import { afterEach, describe, expect, it, vi } from 'vitest';
@@ -16,6 +18,10 @@ import {
 import { ErliCredentialsPanel } from './erli-credentials-panel';
 
 const erliConnection = { ...sampleConnection, platformType: 'erli' };
+const erliConnectionWithAllegroAccess = {
+  ...erliConnection,
+  config: { ...erliConnection.config, allegroCategoryAccessEnabled: true },
+};
 
 describe('ErliCredentialsPanel', () => {
   afterEach(cleanup);
@@ -43,23 +49,23 @@ describe('ErliCredentialsPanel', () => {
     fireEvent.change(screen.getByPlaceholderText('New API key'), {
       target: { value: 'sk_new_456' },
     });
-    fireEvent.click(screen.getByRole('button', { name: 'Save new API key' }));
+    fireEvent.click(screen.getByRole('button', { name: 'Save credentials' }));
 
     await waitFor(() => {
       expect(updateCredentials).toHaveBeenCalledWith(erliConnection.id, { apiKey: 'sk_new_456' });
     });
-    expect(await findToastTitle('Credentials rotated')).toBeInTheDocument();
+    expect(await findToastTitle('Credentials saved')).toBeInTheDocument();
   });
 
-  it('disables save while the field is empty', () => {
+  it('disables save while every field is empty and the checkbox is unchanged', () => {
     renderWithProviders(<ErliCredentialsPanel connection={erliConnection} />);
     fireEvent.click(screen.getByText('Rotate API key'));
-    expect(screen.getByRole('button', { name: 'Save new API key' })).toBeDisabled();
+    expect(screen.getByRole('button', { name: 'Save credentials' })).toBeDisabled();
 
     fireEvent.change(screen.getByPlaceholderText('New API key'), {
       target: { value: 'sk_new_456' },
     });
-    expect(screen.getByRole('button', { name: 'Save new API key' })).toBeEnabled();
+    expect(screen.getByRole('button', { name: 'Save credentials' })).toBeEnabled();
   });
 
   it('collapses the form after a successful save', async () => {
@@ -71,11 +77,196 @@ describe('ErliCredentialsPanel', () => {
     fireEvent.change(screen.getByPlaceholderText('New API key'), {
       target: { value: 'sk_new_456' },
     });
-    fireEvent.click(screen.getByRole('button', { name: 'Save new API key' }));
+    fireEvent.click(screen.getByRole('button', { name: 'Save credentials' }));
 
     await waitFor(() => {
       expect(screen.getByText('Rotate API key')).toBeInTheDocument();
       expect(screen.queryByPlaceholderText('New API key')).not.toBeInTheDocument();
     });
   });
+
+  it('reveals the Allegro Client ID/Secret fields only when the checkbox is checked', () => {
+    renderWithProviders(<ErliCredentialsPanel connection={erliConnection} />);
+    fireEvent.click(screen.getByText('Rotate API key'));
+
+    expect(screen.queryByPlaceholderText('Allegro Client ID')).not.toBeInTheDocument();
+
+    fireEvent.click(
+      screen.getByRole('checkbox', { name: /browse allegro categories/i }),
+    );
+    expect(screen.getByPlaceholderText('Allegro Client ID')).toBeInTheDocument();
+    expect(screen.getByPlaceholderText('Allegro Client Secret')).toBeInTheDocument();
+
+    fireEvent.click(
+      screen.getByRole('checkbox', { name: /browse allegro categories/i }),
+    );
+    expect(screen.queryByPlaceholderText('Allegro Client ID')).not.toBeInTheDocument();
+  });
+
+  it('blocks submit client-side when only one of Client ID / Client Secret is filled', () => {
+    renderWithProviders(<ErliCredentialsPanel connection={erliConnection} />);
+    fireEvent.click(screen.getByText('Rotate API key'));
+    fireEvent.click(screen.getByRole('checkbox', { name: /browse allegro categories/i }));
+    fireEvent.change(screen.getByPlaceholderText('Allegro Client ID'), {
+      target: { value: 'client-123' },
+    });
+
+    fireEvent.click(screen.getByRole('button', { name: 'Save credentials' }));
+
+    expect(
+      screen.getByText(/enter both the allegro client id and client secret/i),
+    ).toBeInTheDocument();
+  });
+
+  it('toggles the secret field between masked and plain text', () => {
+    renderWithProviders(<ErliCredentialsPanel connection={erliConnection} />);
+    fireEvent.click(screen.getByText('Rotate API key'));
+    fireEvent.click(screen.getByRole('checkbox', { name: /browse allegro categories/i }));
+
+    const secretInput = screen.getByPlaceholderText<HTMLInputElement>('Allegro Client Secret');
+    expect(secretInput.type).toBe('password');
+
+    fireEvent.click(screen.getByRole('button', { name: /show client secret/i }));
+    expect(secretInput.type).toBe('text');
+  });
+
+  it('saves apiKey + Allegro credentials in one call, then patches allegroCategoryAccessEnabled=true', async () => {
+    const updateCredentials = vi.fn().mockResolvedValue(undefined);
+    const update = vi.fn().mockResolvedValue(erliConnectionWithAllegroAccess);
+    const apiClient = createMockApiClient({ connections: { updateCredentials, update } });
+    renderWithProviders(<ErliCredentialsPanel connection={erliConnection} />, { apiClient });
+
+    fireEvent.click(screen.getByText('Rotate API key'));
+    fireEvent.change(screen.getByPlaceholderText('New API key'), {
+      target: { value: 'sk_new_456' },
+    });
+    fireEvent.click(screen.getByRole('checkbox', { name: /browse allegro categories/i }));
+    fireEvent.change(screen.getByPlaceholderText('Allegro Client ID'), {
+      target: { value: 'client-123' },
+    });
+    fireEvent.change(screen.getByPlaceholderText('Allegro Client Secret'), {
+      target: { value: 'secret-456' },
+    });
+    fireEvent.click(screen.getByRole('button', { name: 'Save credentials' }));
+
+    await waitFor(() => {
+      expect(updateCredentials).toHaveBeenCalledWith(erliConnection.id, {
+        apiKey: 'sk_new_456',
+        allegroClientId: 'client-123',
+        allegroClientSecret: 'secret-456',
+      });
+    });
+    await waitFor(() => {
+      expect(update).toHaveBeenCalledWith(erliConnection.id, {
+        config: { ...erliConnection.config, allegroCategoryAccessEnabled: true },
+      });
+    });
+    // Ordering: credentials write resolves strictly before the config patch fires.
+    const credentialsOrder = updateCredentials.mock.invocationCallOrder[0];
+    const configOrder = update.mock.invocationCallOrder[0];
+    expect(credentialsOrder).toBeLessThan(configOrder);
+  });
+
+  it('unchecking a previously-enabled connection patches allegroCategoryAccessEnabled=false without resending credentials', async () => {
+    const updateCredentials = vi.fn().mockResolvedValue(undefined);
+    const update = vi.fn().mockResolvedValue(erliConnection);
+    const apiClient = createMockApiClient({ connections: { updateCredentials, update } });
+    renderWithProviders(<ErliCredentialsPanel connection={erliConnectionWithAllegroAccess} />, {
+      apiClient,
+    });
+
+    fireEvent.click(screen.getByText('Rotate API key'));
+    fireEvent.click(screen.getByRole('checkbox', { name: /browse allegro categories/i }));
+    fireEvent.click(screen.getByRole('button', { name: 'Save credentials' }));
+
+    await waitFor(() => {
+      expect(update).toHaveBeenCalledWith(erliConnectionWithAllegroAccess.id, {
+        config: { ...erliConnectionWithAllegroAccess.config, allegroCategoryAccessEnabled: false },
+      });
+    });
+    expect(updateCredentials).not.toHaveBeenCalled();
+  });
+
+  it('disables save after typing a Client ID then unchecking the box (no discarded-input false success)', async () => {
+    const updateCredentials = vi.fn().mockResolvedValue(undefined);
+    const update = vi.fn().mockResolvedValue(erliConnection);
+    const apiClient = createMockApiClient({ connections: { updateCredentials, update } });
+    renderWithProviders(<ErliCredentialsPanel connection={erliConnection} />, { apiClient });
+
+    fireEvent.click(screen.getByText('Rotate API key'));
+    fireEvent.click(screen.getByRole('checkbox', { name: /browse allegro categories/i }));
+    fireEvent.change(screen.getByPlaceholderText('Allegro Client ID'), {
+      target: { value: 'client-123' },
+    });
+    fireEvent.click(screen.getByRole('checkbox', { name: /browse allegro categories/i }));
+
+    expect(screen.getByRole('button', { name: 'Save credentials' })).toBeDisabled();
+    expect(updateCredentials).not.toHaveBeenCalled();
+    expect(update).not.toHaveBeenCalled();
+  });
+
+  it('blocks submit when enabling the checkbox without ever entering credentials', () => {
+    renderWithProviders(<ErliCredentialsPanel connection={erliConnection} />);
+    fireEvent.click(screen.getByText('Rotate API key'));
+    fireEvent.click(screen.getByRole('checkbox', { name: /browse allegro categories/i }));
+
+    fireEvent.click(screen.getByRole('button', { name: 'Save credentials' }));
+
+    expect(
+      screen.getByText(/enter the allegro client id and client secret to enable/i),
+    ).toBeInTheDocument();
+  });
+
+  it('never fires the config patch when the credentials write rejects', async () => {
+    const updateCredentials = vi.fn().mockRejectedValue(new Error('Invalid Allegro credentials'));
+    const update = vi.fn().mockResolvedValue(erliConnectionWithAllegroAccess);
+    const apiClient = createMockApiClient({ connections: { updateCredentials, update } });
+    renderWithProviders(<ErliCredentialsPanel connection={erliConnection} />, { apiClient });
+
+    fireEvent.click(screen.getByText('Rotate API key'));
+    fireEvent.click(screen.getByRole('checkbox', { name: /browse allegro categories/i }));
+    fireEvent.change(screen.getByPlaceholderText('Allegro Client ID'), {
+      target: { value: 'client-123' },
+    });
+    fireEvent.change(screen.getByPlaceholderText('Allegro Client Secret'), {
+      target: { value: 'secret-456' },
+    });
+    fireEvent.click(screen.getByRole('button', { name: 'Save credentials' }));
+
+    await waitFor(() => {
+      expect(updateCredentials).toHaveBeenCalledTimes(1);
+    });
+    expect(update).not.toHaveBeenCalled();
+    expect(await screen.findByText('Invalid Allegro credentials')).toBeInTheDocument();
+    // Panel stays open with the entered fields intact so a retry can resend them.
+    expect(screen.getByPlaceholderText('Allegro Client ID')).toHaveValue('client-123');
+  });
+
+  it('keeps allegroCategoryAccessEnabled at its prior value and shows an inline error when the config patch rejects after credentials succeeded', async () => {
+    const updateCredentials = vi.fn().mockResolvedValue(undefined);
+    const update = vi.fn().mockRejectedValue(new Error('Connection update failed'));
+    const apiClient = createMockApiClient({ connections: { updateCredentials, update } });
+    renderWithProviders(<ErliCredentialsPanel connection={erliConnection} />, { apiClient });
+
+    fireEvent.click(screen.getByText('Rotate API key'));
+    fireEvent.click(screen.getByRole('checkbox', { name: /browse allegro categories/i }));
+    fireEvent.change(screen.getByPlaceholderText('Allegro Client ID'), {
+      target: { value: 'client-123' },
+    });
+    fireEvent.change(screen.getByPlaceholderText('Allegro Client Secret'), {
+      target: { value: 'secret-456' },
+    });
+    fireEvent.click(screen.getByRole('button', { name: 'Save credentials' }));
+
+    await waitFor(() => {
+      expect(update).toHaveBeenCalledTimes(1);
+    });
+    expect(
+      await screen.findByText(/category-browsing setting failed to save/i),
+    ).toBeInTheDocument();
+    // Panel stays open (flag write failed, so it never got a chance to reflect the
+    // new value anywhere the operator can see) and the fields aren't discarded.
+    expect(screen.getByPlaceholderText('Allegro Client ID')).toHaveValue('client-123');
+    expect(screen.queryByText('Credentials saved')).not.toBeInTheDocument();
+  });
 });
diff --git a/apps/web/src/plugins/erli/components/erli-credentials-panel.tsx b/apps/web/src/plugins/erli/components/erli-credentials-panel.tsx
index e68b9218d..c36b9daac 100644
--- a/apps/web/src/plugins/erli/components/erli-credentials-panel.tsx
+++ b/apps/web/src/plugins/erli/components/erli-credentials-panel.tsx
@@ -8,21 +8,59 @@
  * env-backed (`credentialsBacked === false`) the panel shows a read-only
  * affordance instead.
  *
+ * #1384 — also carries the "Browse Allegro categories when creating Erli
+ * offers" checkbox. Checking it reveals the Allegro app's Client ID / Client
+ * Secret fields (masked, show/hide toggle); saving writes them into the same
+ * `useUpdateConnectionCredentialsMutation` call as `apiKey` (merged, only the
+ * fields the operator actually filled), then, in a second sequenced request,
+ * patches `connection.config.allegroCategoryAccessEnabled` to match the
+ * checkbox.
+ *
+ * Atomicity note (see ADR-031 "Correction" + the PR description): the
+ * backend's generic `PUT .../credentials` and `PATCH /connections/:id`
+ * (config) routes are independent, single-purpose endpoints with no
+ * cross-write coupling for any platform — there is no single backend request
+ * that can set both the credential pair and the config flag together. This
+ * panel therefore sequences two mutations from one Save click, in the order
+ * that fails safe: credentials first, then the config flag. If the
+ * credentials write fails, nothing else runs — the flag is untouched, so a
+ * connection never ends up advertising category access it can't actually
+ * serve. If the second (config) write fails after the first succeeded, the
+ * flag simply stays at its prior value — the wizard keeps showing today's
+ * safe plain-text fallback until the operator retries (the fields stay
+ * filled and the retry re-sends both mutations, which is idempotent on the
+ * credentials side).
+ *
  * @module plugins/erli/components
  */
 import { useState, type FormEvent, type ReactElement } from 'react';
 import type { Connection } from '../../../features/connections';
-import { useUpdateConnectionCredentialsMutation } from '../../../features/connections';
+import {
+  useUpdateConnectionCredentialsMutation,
+  useUpdateConnectionMutation,
+} from '../../../features/connections';
 import { Alert } from '../../../shared/ui/alert';
 import { Button } from '../../../shared/ui/button';
 import { FormField } from '../../../shared/ui/form-field';
 import { Input } from '../../../shared/ui/input';
 import { useToast } from '../../../shared/ui/toast-provider';
 
+function isAllegroCategoryAccessEnabled(connection: Connection): boolean {
+  return connection.config.allegroCategoryAccessEnabled === true;
+}
+
 export function ErliCredentialsPanel({ connection }: { connection: Connection }): ReactElement {
   const [showRotate, setShowRotate] = useState(false);
   const [apiKey, setApiKey] = useState('');
+  const [allegroEnabled, setAllegroEnabled] = useState(() =>
+    isAllegroCategoryAccessEnabled(connection),
+  );
+  const [allegroClientId, setAllegroClientId] = useState('');
+  const [allegroClientSecret, setAllegroClientSecret] = useState('');
+  const [showSecret, setShowSecret] = useState(false);
+  const [validationError, setValidationError] = useState<string | null>(null);
   const rotate = useUpdateConnectionCredentialsMutation();
+  const updateConfig = useUpdateConnectionMutation();
   const { showToast } = useToast();
 
   if (!connection.credentialsBacked) {
@@ -33,25 +71,87 @@ export function ErliCredentialsPanel({ connection }: { connection: Connection })
     );
   }
 
-  const canSubmit = apiKey.trim().length > 0;
+  const initialAllegroEnabled = isAllegroCategoryAccessEnabled(connection);
+  const idFilled = allegroClientId.trim().length > 0;
+  const secretFilled = allegroClientSecret.trim().length > 0;
+  const canSubmit =
+    apiKey.trim().length > 0 ||
+    (allegroEnabled && (idFilled || secretFilled)) ||
+    allegroEnabled !== initialAllegroEnabled;
 
-  const onRotate = async (event: FormEvent): Promise<void> => {
+  function openPanel(): void {
+    // Seed the checkbox from the connection's current server-confirmed state
+    // every time the panel opens — it may have changed since the last open
+    // (e.g. another operator, or a prior save in this session).
+    setAllegroEnabled(initialAllegroEnabled);
+    setShowRotate(true);
+  }
+
+  function closePanel(): void {
+    setShowRotate(false);
+    setApiKey('');
+    setAllegroClientId('');
+    setAllegroClientSecret('');
+    setShowSecret(false);
+    setValidationError(null);
+  }
+
+  const onSave = async (event: FormEvent): Promise<void> => {
     event.preventDefault();
+    setValidationError(null);
     if (!canSubmit) return;
+
+    if (allegroEnabled) {
+      if (idFilled !== secretFilled) {
+        setValidationError(
+          'Enter both the Allegro Client ID and Client Secret, or leave both blank.',
+        );
+        return;
+      }
+      if (!idFilled && !secretFilled && !initialAllegroEnabled) {
+        setValidationError(
+          'Enter the Allegro Client ID and Client Secret to enable category browsing.',
+        );
+        return;
+      }
+    }
+
+    const credentials: Record<string, unknown> = {};
+    if (apiKey.trim()) credentials.apiKey = apiKey.trim();
+    // Both-or-neither is already enforced above; omit both fields entirely
+    // (not empty strings) when the checkbox is unchecked, so the backend's
+    // shape validator's "both or neither" rule is satisfied by omission.
+    if (allegroEnabled && idFilled && secretFilled) {
+      credentials.allegroClientId = allegroClientId.trim();
+      credentials.allegroClientSecret = allegroClientSecret.trim();
+    }
+
     try {
-      await rotate.mutateAsync({
-        connectionId: connection.id,
-        credentials: { apiKey: apiKey.trim() },
-      });
+      if (Object.keys(credentials).length > 0) {
+        await rotate.mutateAsync({ connectionId: connection.id, credentials });
+      }
+      // Second, sequenced request: keep `allegroCategoryAccessEnabled` in
+      // sync with the checkbox whenever either changed or new Allegro
+      // credentials were just written. Only reached once the credentials
+      // write above has succeeded (or wasn't needed) — see the module
+      // header for why this ordering fails safe.
+      if (allegroEnabled !== initialAllegroEnabled || 'allegroClientId' in credentials) {
+        await updateConfig.mutateAsync({
+          connectionId: connection.id,
+          input: {
+            config: { ...connection.config, allegroCategoryAccessEnabled: allegroEnabled },
+          },
+        });
+      }
       showToast({
         tone: 'success',
-        title: 'Credentials rotated',
-        description: 'The new Erli API key is now in use.',
+        title: 'Credentials saved',
+        description: 'Erli connection credentials are now in use.',
       });
-      setApiKey('');
-      setShowRotate(false);
+      closePanel();
     } catch {
-      // surfaced via rotate.error
+      // Surfaced via rotate.error / updateConfig.error below. Fields are
+      // deliberately NOT cleared on failure so a retry can resend them.
     }
   };
 
@@ -64,6 +164,13 @@ export function ErliCredentialsPanel({ connection }: { connection: Connection })
       {showRotate ? (
         <div className="form-grid">
           {rotate.error ? <Alert tone="error">{rotate.error.message}</Alert> : null}
+          {updateConfig.error ? (
+            <Alert tone="error">
+              Category-browsing setting failed to save: {updateConfig.error.message}. Click Save
+              again to retry.
+            </Alert>
+          ) : null}
+          {validationError ? <Alert tone="error">{validationError}</Alert> : null}
           <Input
             type="password"
             autoComplete="off"
@@ -71,28 +178,76 @@ export function ErliCredentialsPanel({ connection }: { connection: Connection })
             value={apiKey}
             onChange={(event) => setApiKey(event.target.value)}
           />
+
+          <label style={{ display: 'flex', alignItems: 'flex-start', gap: 'var(--space-2)' }}>
+            <input
+              type="checkbox"
+              checked={allegroEnabled}
+              onChange={(event) => setAllegroEnabled(event.target.checked)}
+            />
+            <span>
+              <strong>Browse Allegro categories when creating Erli offers</strong>
+              <small style={{ display: 'block', color: 'var(--text-muted)' }}>
+                Turn this on to pick categories and fill required parameters from a list, the same
+                way you do for Allegro. Leave it off and you&apos;ll enter category IDs by hand.
+              </small>
+            </span>
+          </label>
+
+          {allegroEnabled ? (
+            <div className="form-grid">
+              <div>
+                <Input
+                  autoComplete="off"
+                  placeholder="Allegro Client ID"
+                  value={allegroClientId}
+                  onChange={(event) => setAllegroClientId(event.target.value)}
+                />
+                <small style={{ display: 'block', color: 'var(--text-muted)' }}>
+                  From an Allegro app you register at apps.developer.allegro.pl. Used only to read
+                  the public category catalog - never to sign in as a seller or place offers.
+                </small>
+              </div>
+              <div>
+                <div style={{ display: 'flex', gap: 'var(--space-2)', alignItems: 'center' }}>
+                  <Input
+                    type={showSecret ? 'text' : 'password'}
+                    autoComplete="off"
+                    placeholder="Allegro Client Secret"
+                    value={allegroClientSecret}
+                    onChange={(event) => setAllegroClientSecret(event.target.value)}
+                  />
+                  <Button
+                    tone="ghost"
+                    type="button"
+                    onClick={() => setShowSecret((v) => !v)}
+                    aria-label={showSecret ? 'Hide Client Secret' : 'Show Client Secret'}
+                  >
+                    {showSecret ? 'Hide' : 'Show'}
+                  </Button>
+                </div>
+                <small style={{ display: 'block', color: 'var(--text-muted)' }}>
+                  Stored encrypted. You won&apos;t see it again after saving.
+                </small>
+              </div>
+            </div>
+          ) : null}
+
           <div className="form-actions">
             <Button
               type="button"
-              onClick={(event) => void onRotate(event)}
-              disabled={rotate.isPending || !canSubmit}
+              onClick={(event) => void onSave(event)}
+              disabled={rotate.isPending || updateConfig.isPending || !canSubmit}
             >
-              {rotate.isPending ? 'Rotating...' : 'Save new API key'}
+              {rotate.isPending || updateConfig.isPending ? 'Saving...' : 'Save credentials'}
             </Button>
-            <Button
-              tone="secondary"
-              type="button"
-              onClick={() => {
-                setShowRotate(false);
-                setApiKey('');
-              }}
-            >
+            <Button tone="secondary" type="button" onClick={closePanel}>
               Cancel
             </Button>
           </div>
         </div>
       ) : (
-        <Button tone="secondary" type="button" onClick={() => setShowRotate(true)}>
+        <Button tone="secondary" type="button" onClick={openPanel}>
           Rotate API key
         </Button>
       )}
diff --git a/docs/architecture/adrs/031-erli-allegro-category-catalog-via-client-credentials.md b/docs/architecture/adrs/031-erli-allegro-category-catalog-via-client-credentials.md
index 10228a23c..89a40e3e1 100644
--- a/docs/architecture/adrs/031-erli-allegro-category-catalog-via-client-credentials.md
+++ b/docs/architecture/adrs/031-erli-allegro-category-catalog-via-client-credentials.md
@@ -18,6 +18,8 @@ Erli owns its own small Allegro client-credentials HTTP client (`AllegroCategory
 
 **Correction (found during #1383 implementation)**: the connection-list DTO's `supportedCapabilities` field is populated from the static, per-`adapterKey` `AdapterMetadata.supportedCapabilities` declared at plugin registration — it is **not** computed by resolving each connection's live adapter instance and running the `is*` guards. It therefore cannot differ between two Erli connections regardless of whether either has Allegro app credentials configured, and the bulk-wizard's `connection.supportedCapabilities.includes('CategoryBrowser')` gate (#1367) is consequently **unaffected** by this feature (it stays `false` for Erli either way — a pre-existing bulk-wizard limitation, unchanged, and out of scope here per the plan's non-goals). The frontend single-offer wizard therefore needs its own, per-connection-instance-visible signal: a new non-secret `ErliConnectionConfig.allegroCategoryAccessEnabled?: boolean` field, written/cleared by the backend in the same operation that writes/clears `allegroClientId`/`allegroClientSecret`, and read directly by the FE from the connection's `config` (already returned verbatim by the generic connection-read endpoints — no DTO changes needed). This keeps the mechanism entirely inside Erli's own plugin-local config shape; it does not touch the generic capability system.
 
+**Second correction (found during #1401 review)**: the sentence above — "written/cleared by the backend in the same operation that writes/clears `allegroClientId`/`allegroClientSecret`" — does not hold in the shipped implementation. No single backend endpoint accepts both the Allegro credential pair and `config.allegroCategoryAccessEnabled` in one request; `PUT /connections/:id/credentials` and `PATCH /connections/:id` (config) remain independent, generic, single-purpose routes for every platform, with zero cross-write coupling. `ErliCredentialsPanel` instead sequences two **FE-orchestrated** mutations from one Save click — credentials first, then the config flag — ordered to fail safe (credentials-write failure skips the config patch entirely; a config-patch failure after a successful credentials write leaves the flag at its prior value and surfaces an inline retryable error). See the component's module header and the PR #1401 description's "Atomicity design decision" section for the full analysis. This ADR's Decision section is corrected accordingly.
+
 ## Alternatives considered
 
 - **Require a real Allegro seller `Connection`, resolve its taxonomy from there**: rejected — forces Erli-only operators to create and maintain an unrelated Allegro seller account/connection just to browse a public catalog; also reintroduces the "which of N Allegro connections is the owner" ambiguity noted in `category-mapping.repository.ts`'s existing "Ambiguous borrowed-taxonomy category mapping" log.
@@ -37,6 +39,8 @@ Erli owns its own small Allegro client-credentials HTTP client (`AllegroCategory
 - Small, self-contained duplication of OAuth `client_credentials` + category-fetch logic between the Allegro and Erli packages (~100-150 lines) rather than one shared implementation.
 - Per-connection Allegro app credentials mean each operator manages their own Allegro Developer Portal app registration (extra setup step, mitigated by the optional/recommended framing in the connection wizard).
 - Category/parameter data is genuinely seller-independent, so a future multi-tenant SaaS deployment may still want the shared-credential alternative — deferred, not precluded, by this design.
+- **FE wizard step topology deviates from the approved mockup, deliberately** (flagged in the #1401 review, confirmed here as an accepted scope cut, not an oversight): the mockup keeps a constant 5-step shape, with the Category step itself rendering the plain-text fallback when Allegro access is off. The shipped `ErliCreateOfferWizard` instead collapses to 3 steps in that state, folding category entry into "Offer details." Functionally equivalent, fully tested, and simpler to reason about than a step that changes shape in place — but explicitly noted here so it isn't re-discovered as an unstated deviation.
+- **No credential-verification status indicator on save** (also flagged in the #1401 review, confirmed as an accepted scope cut): the mockup shows a live "Not verified yet" / "Verification failed" badge and `aria-invalid` on the Allegro Client ID/Secret fields. This is deferred because there is no synchronous Allegro credential-verification call in the backend today — the `client_credentials` token exchange only happens lazily, on the first category-catalog fetch, so the FE has nothing to poll or await at save time. Tracked as a fast-follow candidate for once a synchronous verification endpoint exists (would need its own issue).
 
 **Migration path (if applicable):**
 - Purely additive: existing Erli connections without `allegroClientId`/`allegroClientSecret` keep today's plain-text category-ID behavior unchanged.