diff --git a/apps/web/e2e/infakt-connection.mjs b/apps/web/e2e/infakt-connection.mjs
new file mode 100644
index 000000000..000e3e34c
--- /dev/null
+++ b/apps/web/e2e/infakt-connection.mjs
@@ -0,0 +1,106 @@
+/**
+ * inFakt setup-guide screenshot capture — connection walkthrough.
+ *
+ * Drives the running web app (:4173): opens /connections/new, selects the
+ * inFakt card, fills out the guided setup form with the real sandbox API
+ * key, submits, and runs "Test connection". Captures libs/integrations/infakt/docs/assets/.
+ *
+ * Presentation requirement (these screenshots are reused verbatim in the
+ * operator-facing setup guide): the API-key input stays `type="password"`
+ * throughout — this script never switches it to reveal the raw key, and
+ * never logs the key to stdout. Use a realistic connection name, not
+ * placeholder junk.
+ *
+ * Usage: node apps/web/e2e/infakt-connection.mjs
+ * Env:
+ *   WEB_BASE                web preview base (default http://localhost:4173)
+ *   INFAKT_SANDBOX_API_KEY  required — real inFakt sandbox API key
+ *   INFAKT_CONN_NAME        connection name (default "inFakt Sandbox")
+ */
+import { chromium } from '@playwright/test';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SHOTS = resolve(__dirname, '../../../libs/integrations/infakt/docs/assets');
+const BASE = process.env.WEB_BASE ?? 'http://localhost:4173';
+const API_KEY = process.env.INFAKT_SANDBOX_API_KEY ?? '';
+const CONN_NAME = process.env.INFAKT_CONN_NAME ?? 'inFakt Sandbox';
+// inFakt's adapter defaults to the production base URL — sandbox key holders
+// must override it, or every call (including the connection-test probe) 401s.
+const INFAKT_BASE_URL = process.env.INFAKT_BASE_URL ?? 'https://api.sandbox-infakt.pl/api/v3';
+
+if (!API_KEY) {
+  console.error('INFAKT_CONNECTION_ERROR: INFAKT_SANDBOX_API_KEY is required (not committed, not logged).');
+  process.exit(1);
+}
+
+async function forceLightTheme(page) {
+  // These screenshots are reused in the tutorial — always capture OpenLinker's
+  // light theme regardless of the OS/browser color-scheme preference.
+  await page.addInitScript(() => {
+    window.localStorage.setItem('openlinker.theme', 'light');
+  });
+}
+
+async function login(page) {
+  await page.goto(`${BASE}/login`, { waitUntil: 'domcontentloaded' });
+  await page.getByPlaceholder('Enter your username').fill('operator');
+  await page.getByPlaceholder('Enter your password').fill('infakt-e2e-pw');
+  await page.getByRole('button', { name: 'Sign in' }).click();
+  await page.waitForURL((u) => !u.pathname.startsWith('/login'), { timeout: 15000 });
+}
+
+async function shot(page, name) {
+  await page.waitForTimeout(700);
+  await page.screenshot({ path: resolve(SHOTS, `${name}.png`), fullPage: true });
+  console.log('captured', name);
+}
+
+const browser = await chromium.launch();
+const page = await browser.newPage({ viewport: { width: 1440, height: 900 } });
+try {
+  await forceLightTheme(page);
+  await login(page);
+
+  // 1. Platform picker — inFakt card visible.
+  await page.goto(`${BASE}/connections/new`, { waitUntil: 'networkidle' });
+  await shot(page, '00-platform-picker');
+
+  // 2. Guided setup form (empty).
+  const infaktCard = page.locator('.platform-picker__card', { hasText: 'inFakt' });
+  await infaktCard.click();
+  await page.waitForURL(/\/connections\/new\/infakt/, { timeout: 10000 });
+  await shot(page, '01-infakt-wizard-empty');
+
+  // 3. Filled form — realistic name, real sandbox key (masked on screen).
+  await page.getByLabel('Connection name').fill(CONN_NAME);
+  await page.getByLabel('API key').fill(API_KEY);
+  await page.getByLabel(/Base URL/i).fill(INFAKT_BASE_URL);
+  await shot(page, '02-infakt-wizard-filled');
+
+  // 4. Submit — connection created.
+  await page.getByRole('button', { name: 'Connect inFakt' }).click();
+  await page.waitForTimeout(1500);
+  await shot(page, '03-infakt-connection-created');
+
+  // 5. Test connection.
+  const testBtn = page.getByRole('button', { name: 'Test connection' });
+  if (await testBtn.count()) {
+    await testBtn.click();
+    await page.waitForTimeout(3000);
+    await shot(page, '04-infakt-connection-test-ok');
+  }
+
+  // 6. Connections list — the new inFakt connection visible.
+  await page.goto(`${BASE}/connections`, { waitUntil: 'networkidle' });
+  await shot(page, '05-connections-list-with-infakt');
+
+  console.log('DONE');
+} catch (err) {
+  console.error('INFAKT_CONNECTION_ERROR', err.message);
+  await page.screenshot({ path: resolve(SHOTS, 'error-connection.png'), fullPage: true }).catch(() => {});
+  process.exitCode = 1;
+} finally {
+  await browser.close();
+}
diff --git a/apps/web/e2e/infakt-invoice.mjs b/apps/web/e2e/infakt-invoice.mjs
new file mode 100644
index 000000000..1faef7aed
--- /dev/null
+++ b/apps/web/e2e/infakt-invoice.mjs
@@ -0,0 +1,176 @@
+/**
+ * inFakt setup-guide screenshot capture — issue an invoice through inFakt.
+ *
+ * Drives the running web app (:4173): opens a real ingested order, issues an
+ * invoice through the order-detail Invoice panel, waits for the real
+ * OL -> InfaktInvoicingAdapter -> inFakt sandbox -> KSeF round-trip, then
+ * captures the submitted (pending) and accepted (cleared) reg-card states,
+ * and drives one KOR correction. Captures into libs/integrations/infakt/docs/assets/.
+ *
+ * The document is created end-to-end against the real inFakt sandbox — this
+ * script only drives + screenshots the OL browser side.
+ *
+ * Presentation requirement: use a real seeded order, let every toast/alert
+ * settle before each shot, and re-take any frame that shows a dev artifact
+ * (raw JSON, console error toast, stray localhost URL) rather than shipping
+ * it — these screenshots are reused verbatim in the operator setup guide.
+ *
+ * Usage: node apps/web/e2e/infakt-invoice.mjs
+ * Env:
+ *   WEB_BASE          web preview base (default http://localhost:4173)
+ *   ORDER_ID          OL order id to issue against — required (no order picked automatically,
+ *                     to avoid accidentally issuing against the wrong seeded fixture)
+ *   INFAKT_CONN_NAME  connection label to pick when >1 invoicing connection
+ *   CLEARANCE_POLL_MS max time to poll for KSeF acceptance (default 120000 — sandbox clears
+ *                     in ~90s per the feasibility POC)
+ */
+import { chromium } from '@playwright/test';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SHOTS = resolve(__dirname, '../../../libs/integrations/infakt/docs/assets');
+const BASE = process.env.WEB_BASE ?? 'http://localhost:4173';
+const ORDER_ID = process.env.ORDER_ID ?? '';
+const CONN_NAME = process.env.INFAKT_CONN_NAME ?? 'inFakt';
+const CONNECTION_ID = process.env.INFAKT_CONNECTION_ID ?? '';
+const CLEARANCE_POLL_MS = Number(process.env.CLEARANCE_POLL_MS ?? 120000);
+
+if (!ORDER_ID) {
+  console.error('INFAKT_INVOICE_ERROR: ORDER_ID is required — pick a real seeded order id.');
+  process.exit(1);
+}
+
+async function forceLightTheme(page) {
+  // These screenshots are reused in the tutorial — always capture OpenLinker's
+  // light theme regardless of the OS/browser color-scheme preference.
+  await page.addInitScript(() => {
+    window.localStorage.setItem('openlinker.theme', 'light');
+  });
+}
+
+async function login(page) {
+  await page.goto(`${BASE}/login`, { waitUntil: 'domcontentloaded' });
+  await page.getByPlaceholder('Enter your username').fill('operator');
+  await page.getByPlaceholder('Enter your password').fill('infakt-e2e-pw');
+  await page.getByRole('button', { name: 'Sign in' }).click();
+  await page.waitForURL((u) => !u.pathname.startsWith('/login'), { timeout: 15000 });
+}
+
+async function shot(page, name) {
+  await page.waitForTimeout(700);
+  await page.screenshot({ path: resolve(SHOTS, `${name}.png`), fullPage: true });
+  console.log('captured', name);
+}
+
+async function pickConnectionIfNeeded(page) {
+  const picker = page.getByLabel(/Invoicing connection/i).first();
+  if (await picker.count()) {
+    // Select by connection id (option value) — the fragile label-text/regex
+    // match previously fell through to selectOption({index:1}), silently
+    // picking the WRONG provider (Subiekt) instead of inFakt.
+    if (CONNECTION_ID) {
+      await picker.selectOption({ value: CONNECTION_ID });
+    } else {
+      await picker.selectOption({ label: CONN_NAME }).catch(() => picker.selectOption({ index: 1 }));
+    }
+    await page.waitForTimeout(800);
+  }
+}
+
+async function waitForAccepted(page, deadlineMs) {
+  const start = Date.now();
+  while (Date.now() - start < deadlineMs) {
+    // A full reload drops the client-side connection-picker selection —
+    // re-pick it every time or the panel falls back to "Select a
+    // connection…" and the reg-card never renders at all (looked like a
+    // false "rejected" before this fix).
+    await page.reload({ waitUntil: 'networkidle' });
+    await pickConnectionIfNeeded(page);
+    const accepted = await page.locator('.reg-card--success').count();
+    if (accepted > 0) return true;
+    const rejected = await page.locator('.reg-card--error').count();
+    if (rejected > 0) return false;
+    await page.waitForTimeout(5000);
+  }
+  return false;
+}
+
+const browser = await chromium.launch();
+const page = await browser.newPage({ viewport: { width: 1440, height: 900 } });
+try {
+  await forceLightTheme(page);
+  await login(page);
+
+  // 1. Order detail — not-issued state.
+  await page.goto(`${BASE}/orders/${ORDER_ID}`, { waitUntil: 'networkidle' });
+  await pickConnectionIfNeeded(page);
+  await shot(page, '10-order-detail-not-issued');
+
+  // 2. Issue the invoice. Shoot BEFORE any reload — the mutation's own
+  // query-invalidation updates the panel in place, and a reload here would
+  // just drop the connection-picker selection for no benefit.
+  const issueBtn = page.getByRole('button', { name: /Issue invoice/i }).first();
+  if (await issueBtn.count()) {
+    await issueBtn.click();
+    await page.waitForTimeout(3000);
+  }
+  await shot(page, '11-invoice-issued-submitted');
+  const pendingCard = await page.locator('.reg-card--info').count();
+  console.log('pending reg-card visible:', pendingCard > 0);
+
+  // 3. Poll until KSeF clears (accepted) or rejects.
+  const accepted = await waitForAccepted(page, CLEARANCE_POLL_MS);
+  await shot(page, accepted ? '12-invoice-accepted-cleared' : '12-invoice-rejected');
+  if (!accepted) {
+    console.log('KSeF did not reach accepted within the poll window — skipping correction step.');
+  }
+
+  // 4. Issue a KOR correction (only if accepted) — still on the order page,
+  // where the "Issue correction" button actually lives (no PDF link exists
+  // for inFakt today, so there is no separate "view invoice" affordance to
+  // detour through first).
+  if (accepted) {
+    const correctionBtn = page.getByRole('button', { name: /Issue correction/i }).first();
+    if (await correctionBtn.count()) {
+      await correctionBtn.click();
+      await page.waitForTimeout(500);
+      await shot(page, '14-correction-modal-empty');
+
+      await page.getByLabel(/Line number 1/i).fill('1');
+      await page.getByLabel(/New qty, line 1/i).fill('1');
+      await page.getByLabel(/New price, line 1/i).fill('99.99');
+      await shot(page, '15-correction-modal-filled');
+
+      await page.getByRole('button', { name: /Issue KOR/i }).click();
+      await page.waitForTimeout(4000);
+      await shot(page, '16-correction-issued');
+    }
+  }
+
+  // 5. Invoices list — both the original and (if issued) the correction visible.
+  // Filtered to our connection so the shared dev DB's unrelated rows (other
+  // providers' test fixtures) don't clutter a screenshot meant for the tutorial.
+  const invoicesListUrl = CONNECTION_ID
+    ? `${BASE}/invoices?connectionId=${CONNECTION_ID}`
+    : `${BASE}/invoices`;
+  await page.goto(invoicesListUrl, { waitUntil: 'networkidle' });
+  await shot(page, '17-invoices-list');
+
+  // 6. Full invoice detail page (screen 06 parity) — reached by clicking the
+  // row for our order, the only navigation path (no PDF link on the panel).
+  const invoiceRow = page.getByText(ORDER_ID.slice(0, 24)).first();
+  if (await invoiceRow.count()) {
+    await invoiceRow.click();
+    await page.waitForTimeout(1200);
+    await shot(page, '13-invoice-detail-page');
+  }
+
+  console.log('DONE');
+} catch (err) {
+  console.error('INFAKT_INVOICE_ERROR', err.message);
+  await page.screenshot({ path: resolve(SHOTS, 'error-invoice.png'), fullPage: true }).catch(() => {});
+  process.exitCode = 1;
+} finally {
+  await browser.close();
+}
diff --git a/apps/web/src/app/routes/route-lazy.test.ts b/apps/web/src/app/routes/route-lazy.test.ts
index 481e71fd8..3a94f1466 100644
--- a/apps/web/src/app/routes/route-lazy.test.ts
+++ b/apps/web/src/app/routes/route-lazy.test.ts
@@ -50,20 +50,21 @@ const lazyRoutes = collectLazyRoutes([
  * route reverted to eager `element:` form, which is exactly the regression
  * the parameterized test below is meant to catch.
  *
- * Today's breakdown (46 total):
+ * Today's breakdown (49 total):
  *   - 36 authenticated children (under `coreChildren`, counting per-children-node
  *     because grouped routes like orders/customers/inventory expose multiple
  *     lazy nodes — includes `/dev/ui` design-system page (#775), `/shipments` (#770),
  *     `/users` user-management page (#1125), and `/invoices/:invoiceId` detail (#1240))
  *   - 3 guest routes (forgot-password, reset-password, register — login stays eager)
- *   - 9 plugin routes (allegro callback + setup, prestashop setup, dpd setup,
- *     woocommerce setup, erli setup, subiekt setup (#1199), ksef setup, inpost setup)
+ *   - 10 plugin routes (allegro callback + setup, prestashop setup, dpd setup,
+ *     woocommerce setup, erli setup, subiekt setup (#1199), ksef setup, inpost setup,
+ *     infakt setup (#1282))
  *
  * Routes that are intentionally eager (no page module to defer):
  *   - login (first-paint optimization — see `login.route.tsx`)
  *   - prompt-templates-legacy-redirects (inline `<Navigate>` element)
  */
-const EXPECTED_LAZY_ROUTE_COUNT = 48;
+const EXPECTED_LAZY_ROUTE_COUNT = 49;
 
 describe('route lazy contract', () => {
   it(`the registered route tree contains exactly ${EXPECTED_LAZY_ROUTE_COUNT} lazy routes`, () => {
diff --git a/apps/web/src/features/connections/components/EditConnectionForm.tsx b/apps/web/src/features/connections/components/EditConnectionForm.tsx
index 9e386dbbb..344e90719 100644
--- a/apps/web/src/features/connections/components/EditConnectionForm.tsx
+++ b/apps/web/src/features/connections/components/EditConnectionForm.tsx
@@ -50,7 +50,8 @@ type StructuredField =
   | 'sellerCountryIso2'
   | 'contextIdentifier'
   | 'inpostEnvironment'
-  | 'inpostOrganizationId';
+  | 'inpostOrganizationId'
+  | 'infaktPaymentMethod';
 
 function readString(config: Record<string, unknown>, key: string): string {
   const value = config[key];
@@ -104,6 +105,16 @@ function readInpostEnvironment(config: Record<string, unknown>): '' | 'sandbox'
   return value === 'sandbox' || value === 'production' ? value : '';
 }
 
+/**
+ * Read the Infakt default payment method out of `config.defaultPaymentMethod`
+ * (#1303). Absent keys hydrate to `'cash'` — the adapter's own fallback — so
+ * the select (and the disclosure summary reading it) always reflects what
+ * will actually be sent, never a blank/unset state.
+ */
+function readInfaktPaymentMethod(config: Record<string, unknown>): 'cash' | 'transfer' {
+  return config.defaultPaymentMethod === 'transfer' ? 'transfer' : 'cash';
+}
+
 /**
  * Read the InPost sender address out of `config.senderAddress` (#771). Returns
  * a fully-populated form shape — empty-string fields where the operator hasn't
@@ -333,6 +344,8 @@ export function EditConnectionForm({ connection }: EditConnectionFormProps): Rea
       inpostEnvironment: readInpostEnvironment(connection.config),
       inpostOrganizationId: readString(connection.config, 'organizationId'),
       inpostSenderAddress: readInpostSenderAddress(connection.config),
+      // Infakt default payment method (#1303) — `config.defaultPaymentMethod`.
+      infaktPaymentMethod: readInfaktPaymentMethod(connection.config),
     },
     resolver: zodResolver(editConnectionSchema),
   });
diff --git a/apps/web/src/features/connections/components/edit-connection.schema.ts b/apps/web/src/features/connections/components/edit-connection.schema.ts
index e31b336cd..e3b04f7b2 100644
--- a/apps/web/src/features/connections/components/edit-connection.schema.ts
+++ b/apps/web/src/features/connections/components/edit-connection.schema.ts
@@ -236,6 +236,9 @@ export const editConnectionSchema = z
     // flat `config.sellerNip`). All optional client-side so the operator can save
     // incremental progress; the server is the strict gate.
     ksefEnvironment: z.union([z.enum(['test', 'demo', 'prod']), z.literal('')]).optional(),
+    // Infakt-only structured field surfacing `config.defaultPaymentMethod`
+    // (#1303). Empty allowed for unset — the adapter falls back to `'cash'`.
+    infaktPaymentMethod: z.union([z.enum(['cash', 'transfer']), z.literal('')]).optional(),
     // NIP normalization mirrors the setup wizard (`ksef-setup.schema.ts`): strip
     // dashes/spaces the operator may paste, then enforce 10 digits. Without this
     // parity a value saved with separators on create fails the edit-schema check.
@@ -364,6 +367,11 @@ export interface StructuredConfigPatch {
   subiektCapabilities?: Record<string, boolean>;
   /** KSeF environment — `config.env` (#1152). Empty string clears the key. */
   ksefEnvironment?: string;
+  /**
+   * Infakt default payment method — `config.defaultPaymentMethod` (#1303).
+   * Empty string clears the key (adapter falls back to `'cash'`).
+   */
+  infaktPaymentMethod?: string;
   /**
    * KSeF seller-profile sub-fields (#1223). Each maps onto a leaf of the nested
    * `config.seller.{nip,name,address}` shape the adapter's `resolveSeller`
@@ -589,6 +597,16 @@ export function mergeStructuredIntoConfig(
       }
     }
   }
+  // Infakt default payment method (#1303) — `config.defaultPaymentMethod`.
+  // The form field is named `infaktPaymentMethod` to avoid colliding with a
+  // future generic `paymentMethod` field on another platform.
+  if (structured.infaktPaymentMethod !== undefined) {
+    if (structured.infaktPaymentMethod.length === 0) {
+      delete next.defaultPaymentMethod;
+    } else {
+      next.defaultPaymentMethod = structured.infaktPaymentMethod;
+    }
+  }
   return next;
 }
 
diff --git a/apps/web/src/features/connections/components/infakt-setup-form.test.tsx b/apps/web/src/features/connections/components/infakt-setup-form.test.tsx
new file mode 100644
index 000000000..211f159ee
--- /dev/null
+++ b/apps/web/src/features/connections/components/infakt-setup-form.test.tsx
@@ -0,0 +1,254 @@
+/**
+ * InfaktSetupForm Tests
+ *
+ * Coverage for the single-step inFakt setup wizard. Tests form validation,
+ * submission via the generic create-connection mutation, and the post-create
+ * "Test connection" flow that surfaces a ConnectionTestResult. Mirrors
+ * `erli-setup-form.test.tsx`.
+ */
+import { cleanup, fireEvent, screen, waitFor } from '@testing-library/react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import {
+  createMockApiClient,
+  findToastTitle,
+  renderWithProviders,
+} from '../../../test/test-utils';
+import { InfaktSetupForm } from './infakt-setup-form';
+
+describe('InfaktSetupForm', () => {
+  afterEach(cleanup);
+
+  it('renders the required form fields', () => {
+    renderWithProviders(<InfaktSetupForm />);
+    expect(screen.getByLabelText('Connection name')).toBeInTheDocument();
+    expect(screen.getByLabelText('API key')).toBeInTheDocument();
+    expect(screen.getByLabelText('Base URL (optional)')).toBeInTheDocument();
+    expect(screen.getByLabelText('Default payment method')).toBeInTheDocument();
+  });
+
+  it('defaults the payment method to cash', () => {
+    renderWithProviders(<InfaktSetupForm />);
+    expect(screen.getByLabelText('Default payment method')).toHaveValue('cash');
+  });
+
+  it('requires connection name to be non-empty', async () => {
+    renderWithProviders(<InfaktSetupForm />);
+    fireEvent.click(screen.getByRole('button', { name: 'Connect inFakt' }));
+
+    await waitFor(() => {
+      expect(screen.getAllByText('Connection name is required')[0]).toBeInTheDocument();
+    });
+  });
+
+  it('requires the API key to be non-empty', async () => {
+    renderWithProviders(<InfaktSetupForm />);
+    fireEvent.change(screen.getByLabelText('Connection name'), {
+      target: { value: 'My inFakt Account' },
+    });
+    fireEvent.click(screen.getByRole('button', { name: 'Connect inFakt' }));
+
+    await waitFor(() => {
+      expect(screen.getAllByText('API key is required')[0]).toBeInTheDocument();
+    });
+  });
+
+  it('rejects a non-HTTPS base URL override', async () => {
+    renderWithProviders(<InfaktSetupForm />);
+    fireEvent.change(screen.getByLabelText('Connection name'), {
+      target: { value: 'My inFakt Account' },
+    });
+    fireEvent.change(screen.getByLabelText('API key'), {
+      target: { value: 'sk_test_123' },
+    });
+    fireEvent.change(screen.getByLabelText('Base URL (optional)'), {
+      target: { value: 'http://api.infakt.pl' },
+    });
+    fireEvent.click(screen.getByRole('button', { name: 'Connect inFakt' }));
+
+    await waitFor(() => {
+      expect(screen.getAllByText('Base URL must use HTTPS')[0]).toBeInTheDocument();
+    });
+  });
+
+  it('submits the API key and a cash-default config when no base URL is given', async () => {
+    const create = vi.fn().mockResolvedValue({ id: 'conn-1', name: 'My inFakt Account' });
+    const apiClient = createMockApiClient({ connections: { create } });
+
+    renderWithProviders(<InfaktSetupForm />, { apiClient });
+
+    fireEvent.change(screen.getByLabelText('Connection name'), {
+      target: { value: 'My inFakt Account' },
+    });
+    fireEvent.change(screen.getByLabelText('API key'), {
+      target: { value: 'sk_test_123' },
+    });
+    fireEvent.click(screen.getByRole('button', { name: 'Connect inFakt' }));
+
+    await waitFor(() => {
+      expect(create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'My inFakt Account',
+          platformType: 'infakt',
+          adapterKey: 'infakt.accounting.v1',
+          config: { defaultPaymentMethod: 'cash' },
+          credentials: { apiKey: 'sk_test_123' },
+        }),
+      );
+    });
+    expect(await findToastTitle('Connection created')).toBeInTheDocument();
+  });
+
+  it('includes baseUrl in config when supplied', async () => {
+    const create = vi.fn().mockResolvedValue({ id: 'conn-1', name: 'My inFakt Account' });
+    const apiClient = createMockApiClient({ connections: { create } });
+
+    renderWithProviders(<InfaktSetupForm />, { apiClient });
+
+    fireEvent.change(screen.getByLabelText('Connection name'), {
+      target: { value: 'My inFakt Account' },
+    });
+    fireEvent.change(screen.getByLabelText('API key'), {
+      target: { value: 'sk_test_123' },
+    });
+    fireEvent.change(screen.getByLabelText('Base URL (optional)'), {
+      target: { value: 'https://sandbox.infakt.pl' },
+    });
+    fireEvent.click(screen.getByRole('button', { name: 'Connect inFakt' }));
+
+    await waitFor(() => {
+      expect(create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          config: { defaultPaymentMethod: 'cash', baseUrl: 'https://sandbox.infakt.pl' },
+        }),
+      );
+    });
+  });
+
+  it('submits transfer when selected in the payment method field', async () => {
+    const create = vi.fn().mockResolvedValue({ id: 'conn-1', name: 'My inFakt Account' });
+    const apiClient = createMockApiClient({ connections: { create } });
+
+    renderWithProviders(<InfaktSetupForm />, { apiClient });
+
+    fireEvent.change(screen.getByLabelText('Connection name'), {
+      target: { value: 'My inFakt Account' },
+    });
+    fireEvent.change(screen.getByLabelText('API key'), {
+      target: { value: 'sk_test_123' },
+    });
+    fireEvent.change(screen.getByLabelText('Default payment method'), {
+      target: { value: 'transfer' },
+    });
+    fireEvent.click(screen.getByRole('button', { name: 'Connect inFakt' }));
+
+    await waitFor(() => {
+      expect(create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          config: { defaultPaymentMethod: 'transfer' },
+        }),
+      );
+    });
+  });
+
+  it('surfaces the test-connection result after a successful create', async () => {
+    const create = vi.fn().mockResolvedValue({ id: 'conn-1', name: 'My inFakt Account' });
+    const test = vi
+      .fn()
+      .mockResolvedValue({ success: true, status: 200, message: 'OK', latencyMs: 42 });
+    const apiClient = createMockApiClient({ connections: { create, test } });
+
+    renderWithProviders(<InfaktSetupForm />, { apiClient });
+
+    fireEvent.change(screen.getByLabelText('Connection name'), {
+      target: { value: 'My inFakt Account' },
+    });
+    fireEvent.change(screen.getByLabelText('API key'), {
+      target: { value: 'sk_test_123' },
+    });
+    fireEvent.click(screen.getByRole('button', { name: 'Connect inFakt' }));
+
+    // After create, the test affordance replaces the connect button.
+    const testButton = await screen.findByRole('button', { name: 'Test connection' });
+    fireEvent.click(testButton);
+
+    await waitFor(() => {
+      expect(test).toHaveBeenCalledWith('conn-1');
+    });
+    expect(await screen.findByText('Connection test passed')).toBeInTheDocument();
+  });
+
+  it('surfaces a failing test-connection result', async () => {
+    const create = vi.fn().mockResolvedValue({ id: 'conn-1', name: 'My inFakt Account' });
+    const test = vi
+      .fn()
+      .mockResolvedValue({ success: false, status: 401, message: 'Unauthorized', latencyMs: 10 });
+    const apiClient = createMockApiClient({ connections: { create, test } });
+
+    renderWithProviders(<InfaktSetupForm />, { apiClient });
+
+    fireEvent.change(screen.getByLabelText('Connection name'), {
+      target: { value: 'My inFakt Account' },
+    });
+    fireEvent.change(screen.getByLabelText('API key'), {
+      target: { value: 'sk_test_123' },
+    });
+    fireEvent.click(screen.getByRole('button', { name: 'Connect inFakt' }));
+
+    const testButton = await screen.findByRole('button', { name: 'Test connection' });
+    fireEvent.click(testButton);
+
+    expect(await screen.findByText('Connection test failed')).toBeInTheDocument();
+    expect(screen.getByText(/Unauthorized/)).toBeInTheDocument();
+  });
+
+  it('surfaces the "Unable to test connection" alert when the test request rejects', async () => {
+    const create = vi.fn().mockResolvedValue({ id: 'conn-1', name: 'My inFakt Account' });
+    const test = vi.fn().mockRejectedValue(new Error('Network unreachable'));
+    const apiClient = createMockApiClient({ connections: { create, test } });
+
+    renderWithProviders(<InfaktSetupForm />, { apiClient });
+
+    fireEvent.change(screen.getByLabelText('Connection name'), {
+      target: { value: 'My inFakt Account' },
+    });
+    fireEvent.change(screen.getByLabelText('API key'), {
+      target: { value: 'sk_test_123' },
+    });
+    fireEvent.click(screen.getByRole('button', { name: 'Connect inFakt' }));
+
+    const testButton = await screen.findByRole('button', { name: 'Test connection' });
+    fireEvent.click(testButton);
+
+    expect(await screen.findByText('Unable to test connection')).toBeInTheDocument();
+    expect(screen.getByText(/Network unreachable/)).toBeInTheDocument();
+    expect(screen.queryByText('Connection test passed')).not.toBeInTheDocument();
+    expect(screen.queryByText('Connection test failed')).not.toBeInTheDocument();
+  });
+
+  it('disables the submit button during the create mutation', async () => {
+    const create = vi
+      .fn()
+      .mockImplementation(
+        () =>
+          new Promise((resolve) =>
+            setTimeout(() => resolve({ id: 'conn-1', name: 'My inFakt Account' }), 100),
+          ),
+      );
+    const apiClient = createMockApiClient({ connections: { create } });
+
+    renderWithProviders(<InfaktSetupForm />, { apiClient });
+
+    fireEvent.change(screen.getByLabelText('Connection name'), {
+      target: { value: 'My inFakt Account' },
+    });
+    fireEvent.change(screen.getByLabelText('API key'), {
+      target: { value: 'sk_test_123' },
+    });
+    fireEvent.click(screen.getByRole('button', { name: 'Connect inFakt' }));
+
+    await waitFor(() => {
+      const button = screen.getByRole('button', { name: /Connecting|Connect inFakt/ });
+      expect(button).toBeDisabled();
+    });
+  });
+});
diff --git a/apps/web/src/features/connections/components/infakt-setup-form.tsx b/apps/web/src/features/connections/components/infakt-setup-form.tsx
new file mode 100644
index 000000000..62d4e5e8b
--- /dev/null
+++ b/apps/web/src/features/connections/components/infakt-setup-form.tsx
@@ -0,0 +1,214 @@
+/**
+ * Infakt Setup Form
+ *
+ * Single-step wizard for creating an inFakt connection. Collects:
+ *   - Connection name
+ *   - inFakt API key (the only credential)
+ *   - Optional advanced base URL override (config) — sandbox vs. production
+ *   - Default payment method sent on every issued invoice/correction (#1303)
+ *
+ * Mirrors `ErliSetupForm`: one credential, no capabilities step (capabilities
+ * default silently to the adapter manifest's supported set on the omitted
+ * path). After a successful create the form surfaces a "Test connection"
+ * affordance that calls the generic `/connections/:id/test` endpoint and
+ * renders the `ConnectionTestResult`. Abandon-prevention triggers a native
+ * confirm dialog when the form is dirty and the tab is closed.
+ *
+ * @module features/connections/components
+ */
+import { useEffect, useState, type ReactElement } from 'react';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { useForm } from 'react-hook-form';
+import { useNavigate } from 'react-router-dom';
+import { useCreateConnectionMutation } from '../hooks/use-create-connection-mutation';
+import { useTestConnectionMutation } from '../hooks/use-test-connection-mutation';
+import type { ConnectionTestResult } from '../api/connections.types';
+import {
+  INFAKT_SETUP_DEFAULT_VALUES,
+  infaktSetupSchema,
+  toCreateConnectionInput,
+  type InfaktSetupFormSubmission,
+  type InfaktSetupFormValues,
+} from './infakt-setup.schema';
+import { Alert } from '../../../shared/ui/alert';
+import { BackLink } from '../../../shared/ui/back-link';
+import { Button } from '../../../shared/ui/button';
+import { FormErrorSummary } from '../../../shared/ui/form-error-summary';
+import { FormField } from '../../../shared/ui/form-field';
+import { Input } from '../../../shared/ui/input';
+import { Select } from '../../../shared/ui/select';
+import { useToast } from '../../../shared/ui/toast-provider';
+
+export function InfaktSetupForm(): ReactElement {
+  const createConnection = useCreateConnectionMutation();
+  const testConnection = useTestConnectionMutation();
+  const { showToast } = useToast();
+  const navigate = useNavigate();
+  const [createdConnectionId, setCreatedConnectionId] = useState<string | null>(null);
+  const [testResult, setTestResult] = useState<ConnectionTestResult | null>(null);
+
+  const form = useForm<InfaktSetupFormValues, undefined, InfaktSetupFormSubmission>({
+    defaultValues: INFAKT_SETUP_DEFAULT_VALUES,
+    resolver: zodResolver(infaktSetupSchema),
+    mode: 'onBlur',
+  });
+
+  // Abandon-prevention.
+  useEffect(() => {
+    function handleBeforeUnload(event: BeforeUnloadEvent): void {
+      if (!form.formState.isDirty || createdConnectionId !== null) return;
+      event.preventDefault();
+      event.returnValue = '';
+    }
+    window.addEventListener('beforeunload', handleBeforeUnload);
+    return () => window.removeEventListener('beforeunload', handleBeforeUnload);
+  }, [form.formState.isDirty, createdConnectionId]);
+
+  const validationMessages = Object.values(form.formState.errors).flatMap((error) =>
+    error?.message ? [String(error.message)] : [],
+  );
+
+  const onSubmit = form.handleSubmit(async (values) => {
+    try {
+      const created = await createConnection.mutateAsync(toCreateConnectionInput(values));
+      form.reset(values, { keepValues: true, keepDirty: false });
+      setCreatedConnectionId(created.id);
+      showToast({
+        tone: 'success',
+        title: 'Connection created',
+        description: `inFakt connection "${created.name}" was created.`,
+      });
+    } catch {
+      return;
+    }
+  });
+
+  const onTest = async (): Promise<void> => {
+    if (!createdConnectionId) return;
+    // Clear any prior result first: otherwise a re-test that rejects would render
+    // a stale resolved-result Alert alongside the "unable to test" error Alert.
+    setTestResult(null);
+    try {
+      const result = await testConnection.mutateAsync(createdConnectionId);
+      setTestResult(result);
+    } catch {
+      // surfaced via testConnection.error
+    }
+  };
+
+  return (
+    <form className="wizard-card" onSubmit={(event) => void onSubmit(event)} noValidate>
+      <BackLink to="/connections/new" label="Connections" className="wizard-card__back" />
+
+      {form.formState.submitCount > 0 && validationMessages.length > 0 ? (
+        <FormErrorSummary errors={validationMessages} />
+      ) : null}
+      {createConnection.error ? (
+        <Alert tone="error" title="Unable to create connection">
+          {createConnection.error.message}
+        </Alert>
+      ) : null}
+
+      <Alert tone="info" title="Before you start">
+        In your inFakt account settings, generate an <strong>API key</strong>. OpenLinker uses
+        it to issue invoices and read KSeF clearance status through inFakt's native
+        integration. The key is stored securely on the server and only shown once.
+      </Alert>
+
+      <FormField
+        label="Connection name"
+        name="name"
+        error={form.formState.errors.name?.message}
+        description="A label to identify this inFakt account in OpenLinker."
+      >
+        <Input
+          {...form.register('name')}
+          placeholder="My inFakt Account"
+          autoComplete="off"
+          invalid={Boolean(form.formState.errors.name)}
+        />
+      </FormField>
+
+      <FormField
+        label="API key"
+        name="apiKey"
+        error={form.formState.errors.apiKey?.message}
+        description="Your inFakt API key — generated in your inFakt account settings."
+      >
+        <Input
+          {...form.register('apiKey')}
+          type="password"
+          placeholder="••••••••••••••••••••••••••••••••"
+          autoComplete="off"
+          invalid={Boolean(form.formState.errors.apiKey)}
+        />
+      </FormField>
+
+      <FormField
+        label="Base URL (optional)"
+        name="baseUrl"
+        error={form.formState.errors.baseUrl?.message}
+        description="Advanced — override the default inFakt API base URL for sandbox testing. Must use HTTPS. Leave blank to use production."
+      >
+        <Input
+          {...form.register('baseUrl')}
+          className="mono-text"
+          placeholder="https://api.infakt.pl"
+          autoComplete="off"
+          invalid={Boolean(form.formState.errors.baseUrl)}
+        />
+      </FormField>
+
+      <FormField
+        label="Default payment method"
+        name="defaultPaymentMethod"
+        error={form.formState.errors.defaultPaymentMethod?.message}
+        description={
+          '"Transfer" 422s on inFakt unless a bank account is configured on the seller’s ' +
+          'inFakt account. Leave "Cash" unless you have confirmed that prerequisite.'
+        }
+      >
+        <Select
+          {...form.register('defaultPaymentMethod')}
+          invalid={Boolean(form.formState.errors.defaultPaymentMethod)}
+        >
+          <option value="cash">Cash</option>
+          <option value="transfer">Transfer</option>
+        </Select>
+      </FormField>
+
+      {createdConnectionId ? (
+        <>
+          {testResult ? (
+            <Alert
+              tone={testResult.success ? 'success' : 'error'}
+              title={testResult.success ? 'Connection test passed' : 'Connection test failed'}
+            >
+              {testResult.message}
+              {typeof testResult.latencyMs === 'number' ? ` (${testResult.latencyMs}ms)` : null}
+            </Alert>
+          ) : null}
+          {testConnection.error ? (
+            <Alert tone="error" title="Unable to test connection">
+              {testConnection.error.message}
+            </Alert>
+          ) : null}
+          <div className="form-actions">
+            <Button type="button" onClick={() => void onTest()} disabled={testConnection.isPending}>
+              {testConnection.isPending ? 'Testing…' : 'Test connection'}
+            </Button>
+            <Button tone="secondary" type="button" onClick={() => void navigate('/connections')}>
+              Done
+            </Button>
+          </div>
+        </>
+      ) : (
+        <div className="form-actions">
+          <Button type="submit" disabled={createConnection.isPending}>
+            {createConnection.isPending ? 'Connecting…' : 'Connect inFakt'}
+          </Button>
+        </div>
+      )}
+    </form>
+  );
+}
diff --git a/apps/web/src/features/connections/components/infakt-setup.schema.ts b/apps/web/src/features/connections/components/infakt-setup.schema.ts
new file mode 100644
index 000000000..ee1f94deb
--- /dev/null
+++ b/apps/web/src/features/connections/components/infakt-setup.schema.ts
@@ -0,0 +1,72 @@
+/**
+ * Infakt Setup Form Schema
+ *
+ * Zod schema + form → API payload mapping for the guided inFakt connection
+ * wizard. inFakt is a Polish accounting platform authenticated with a single
+ * API key (#1280/#1282). The form collects a connection name, the required
+ * `apiKey` credential, and an optional advanced `baseUrl` config override
+ * (sandbox vs. production). Mirrors `erli-setup.schema.ts`.
+ *
+ * @module features/connections/components
+ */
+import { z } from 'zod';
+import type { CreateConnectionInput } from '../api/connections.types';
+
+export const INFAKT_ADAPTER_KEY = 'infakt.accounting.v1';
+
+// Mirrors the BE config DTO posture (optional https-only base URL override).
+const isHttps = (value: string): boolean => value.startsWith('https://');
+
+// Mirrors the BE `InfaktPaymentMethodValues` enum (#1303) — kept as a plain
+// literal here rather than a cross-package import since FE and BE are
+// separate deployables (see other structured sections, e.g. dpd-setup-form's
+// `environment` select).
+export const INFAKT_PAYMENT_METHOD_VALUES = ['cash', 'transfer'] as const;
+
+export const infaktSetupSchema = z.object({
+  name: z.string().trim().min(1, 'Connection name is required'),
+  apiKey: z.string().trim().min(1, 'API key is required'),
+  baseUrl: z
+    .union([
+      z
+        .string()
+        .trim()
+        .url('Base URL must be a valid URL (e.g. https://api.infakt.pl)')
+        .refine(isHttps, 'Base URL must use HTTPS'),
+      z.literal(''),
+    ])
+    .optional(),
+  defaultPaymentMethod: z.enum(INFAKT_PAYMENT_METHOD_VALUES),
+});
+
+export type InfaktSetupFormValues = z.input<typeof infaktSetupSchema>;
+export type InfaktSetupFormSubmission = z.output<typeof infaktSetupSchema>;
+
+export const INFAKT_SETUP_DEFAULT_VALUES: InfaktSetupFormValues = {
+  name: '',
+  apiKey: '',
+  baseUrl: '',
+  // Cash is fiscal-safe by default — transfer 422s on inFakt unless a bank
+  // account is configured (see the help copy below and on the edit section).
+  // Matches the adapter's own fallback in infakt-invoicing.adapter.ts.
+  defaultPaymentMethod: 'cash',
+};
+
+export function toCreateConnectionInput(values: InfaktSetupFormSubmission): CreateConnectionInput {
+  const config: Record<string, unknown> = { defaultPaymentMethod: values.defaultPaymentMethod };
+  if (values.baseUrl && values.baseUrl.length > 0) {
+    config.baseUrl = values.baseUrl;
+  }
+
+  return {
+    name: values.name,
+    platformType: 'infakt',
+    adapterKey: INFAKT_ADAPTER_KEY,
+    credentials: { apiKey: values.apiKey },
+    config,
+    // enabledCapabilities is OMITTED on purpose: on the omitted path
+    // `ConnectionService.create` defaults to the adapter manifest's supported
+    // set, so the inFakt connection lands with the capabilities the
+    // registered `infakt.accounting.v1` adapter actually delivers (Invoicing).
+  };
+}
diff --git a/apps/web/src/features/invoicing/hooks/use-invoice-rendered-document-download.ts b/apps/web/src/features/invoicing/hooks/use-invoice-rendered-document-download.ts
new file mode 100644
index 000000000..19f723e6f
--- /dev/null
+++ b/apps/web/src/features/invoicing/hooks/use-invoice-rendered-document-download.ts
@@ -0,0 +1,82 @@
+/**
+ * useInvoiceRenderedDocumentDownload
+ *
+ * One-shot action (NOT a TanStack mutation) that fetches the provider's
+ * server-rendered document (`kind=rendered` — e.g. Infakt's PDF, #1321) via
+ * `apiClient.invoicing.downloadDocument(id, 'rendered')` and triggers a
+ * browser download. Mirrors `useKsefUpoDownload`'s shape exactly; kept as a
+ * separate hook (rather than generalizing `useKsefUpoDownload`) because that
+ * hook is scoped to the dedicated `/upo` route, while this one goes through
+ * the neutral `/document?kind=rendered` route any provider can serve.
+ *
+ * Neutral: keyed on the internal `invoice.id`, never on platform type (ADR-026).
+ * Lives in `features/invoicing/hooks/` so it can use `useApiClient` freely;
+ * per-provider `invoiceDetailSection` slots import it from the
+ * `features/invoicing` barrel (dep direction: plugins/* → features/invoicing
+ * is explicitly allowed).
+ *
+ * @module features/invoicing/hooks
+ */
+import { useCallback, useState } from 'react';
+import { useApiClient } from '../../../app/api/api-client-provider';
+
+const EXTENSION_BY_MIME: Readonly<Record<string, string>> = {
+  'application/pdf': 'pdf',
+  'text/html': 'html',
+};
+
+function extensionForBlob(blob: Blob): string {
+  const mime = blob.type.toLowerCase().split(';', 1)[0]?.trim() ?? '';
+  return EXTENSION_BY_MIME[mime] ?? 'bin';
+}
+
+/**
+ * Trigger a browser download for an already-fetched blob via an in-memory
+ * object URL + a programmatic `<a download>` click. Defers `revokeObjectURL`
+ * past the current tick — some engines cancel the in-flight download if the
+ * URL is revoked synchronously after `click()`.
+ */
+function triggerBlobDownload(blob: Blob, filename: string): void {
+  const objectUrl = URL.createObjectURL(blob);
+  const anchor = document.createElement('a');
+  anchor.href = objectUrl;
+  anchor.download = filename;
+  document.body.appendChild(anchor);
+  anchor.click();
+  anchor.remove();
+  setTimeout(() => URL.revokeObjectURL(objectUrl), 0);
+}
+
+interface UseInvoiceRenderedDocumentDownload {
+  /** Fetch + trigger the browser download. Resolves `true` on success, `false`
+   *  when the fetch failed (the error is also exposed via `error`). */
+  download: (invoiceId: string) => Promise<boolean>;
+  isDownloading: boolean;
+  error: Error | null;
+}
+
+export function useInvoiceRenderedDocumentDownload(): UseInvoiceRenderedDocumentDownload {
+  const apiClient = useApiClient();
+  const [isDownloading, setIsDownloading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const download = useCallback(
+    async (invoiceId: string): Promise<boolean> => {
+      setIsDownloading(true);
+      setError(null);
+      try {
+        const blob = await apiClient.invoicing.downloadDocument(invoiceId, 'rendered');
+        triggerBlobDownload(blob, `ol-invoice-${invoiceId}.${extensionForBlob(blob)}`);
+        return true;
+      } catch (caught) {
+        setError(caught instanceof Error ? caught : new Error(String(caught)));
+        return false;
+      } finally {
+        setIsDownloading(false);
+      }
+    },
+    [apiClient],
+  );
+
+  return { download, isDownloading, error };
+}
diff --git a/apps/web/src/features/invoicing/index.ts b/apps/web/src/features/invoicing/index.ts
index ca5afc3fc..73bac2952 100644
--- a/apps/web/src/features/invoicing/index.ts
+++ b/apps/web/src/features/invoicing/index.ts
@@ -10,9 +10,10 @@
  * `resolveIssueErrorMessage`, `DocumentTypeSelect`, and `DOCUMENT_TYPE_LABEL_FALLBACK`
  * stay internal (only used by the panel itself or tests that deep-import them).
  *
- * Exception: `RegulatoryStatusBadge` is exported so per-provider
- * `invoiceDetailSection` slot components (e.g. `plugins/ksef`) can reuse
- * the neutral badge without duplicating the tone/label mapping.
+ * Exception: `RegulatoryStatusBadge` and `regCardToneFor` are exported so
+ * per-provider `invoiceDetailSection` slot components (KSeF, Subiekt,
+ * inFakt) can reuse the neutral badge and `.reg-card` tone mapping without
+ * duplicating either.
  *
  * @module apps/web/src/features/invoicing
  */
@@ -21,6 +22,7 @@ export { InvoiceTimeline } from './components/invoice-timeline';
 export { InvoiceStatusBadge } from './components/invoice-status-badge';
 export type { InvoiceDisplayStatus } from './components/invoice-status-badge';
 export { RegulatoryStatusBadge } from './components/regulatory-status-badge';
+export { regCardToneFor, type RegCardTone } from './lib/derive-invoice-display';
 export { InvoicePdfLink } from './components/invoice-pdf-link';
 export { useOrderInvoiceQuery } from './hooks/use-order-invoice-query';
 export { useInvoiceQuery } from './hooks/use-invoice-query';
@@ -35,6 +37,7 @@ export { useKsefUpoPreview } from './hooks/use-ksef-upo-preview';
 export type { UpoPreviewKind } from './hooks/use-ksef-upo-preview';
 export { useKsefUpoDownload } from './hooks/use-ksef-upo-download';
 export { useKsefFa3 } from './hooks/use-ksef-fa3';
+export { useInvoiceRenderedDocumentDownload } from './hooks/use-invoice-rendered-document-download';
 export { invoicingQueryKeys } from './api/invoicing.query-keys';
 export { InvoiceStatusValues, RegulatoryStatusValues } from './api/invoicing.types';
 export type {
diff --git a/apps/web/src/features/invoicing/lib/derive-invoice-display.ts b/apps/web/src/features/invoicing/lib/derive-invoice-display.ts
index 553755f87..59f7b842f 100644
--- a/apps/web/src/features/invoicing/lib/derive-invoice-display.ts
+++ b/apps/web/src/features/invoicing/lib/derive-invoice-display.ts
@@ -18,11 +18,25 @@
  *
  * @module apps/web/src/features/invoicing/lib
  */
-import type { FailureCode, InvoiceRecord } from '../api/invoicing.types';
+import type { FailureCode, InvoiceRecord, RegulatoryStatus } from '../api/invoicing.types';
 import type { InvoiceDisplayStatus } from '../components/invoice-status-badge';
 
 type Translate = (key: string, fallback: string) => string;
 
+export type RegCardTone = 'reg-card--info' | 'reg-card--success' | 'reg-card--error' | '';
+
+/**
+ * Severity-stripe tone for the shared `.reg-card` treatment (#1282). Shared
+ * by every per-provider `invoiceDetailSection` slot (KSeF, Subiekt, inFakt)
+ * so the status→tone mapping lives in exactly one place.
+ */
+export function regCardToneFor(status: RegulatoryStatus): RegCardTone {
+  if (status === 'submitted') return 'reg-card--info';
+  if (status === 'accepted') return 'reg-card--success';
+  if (status === 'rejected') return 'reg-card--error';
+  return '';
+}
+
 /**
  * Maps an `InvoiceRecord | null` (null = invoice-absent) to the FE display
  * status. A `failed` row is split into `failed` (rejected) vs `in-doubt` off
diff --git a/apps/web/src/index.css b/apps/web/src/index.css
index bde5d7b4f..2aa4ad0c8 100644
--- a/apps/web/src/index.css
+++ b/apps/web/src/index.css
@@ -810,7 +810,8 @@ textarea::placeholder {
   color: var(--text-disabled);
 }
 
-textarea {
+textarea,
+.textarea {
   height: auto;
   min-height: 5rem;
   padding: var(--space-2) var(--space-3);
@@ -9774,6 +9775,72 @@ html[data-density='compact'] .status-badge {
   align-self: stretch;
 }
 
+/* ── Regulatory section card (#1282) ──────────────────────────────────
+   Tone wrapper a provider's `invoiceDetailSection` root class adopts
+   (KSeF, Subiekt, inFakt) so the region reads at a glance — severity
+   stripe reusing the existing --status-* tokens, no new colors. Additive
+   alongside each section's own root class (e.g. `invoice-detail-section`),
+   never a replacement, so pre-existing DOM-shape assertions keep passing. */
+.reg-card {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-2);
+  padding: var(--space-3);
+  border-radius: var(--radius-sm);
+  border: 1px solid var(--border-subtle);
+  border-left: 3px solid var(--border-subtle);
+  background: var(--bg-surface-muted);
+}
+.reg-card--info {
+  border-left-color: var(--status-info);
+  background: var(--status-info-soft);
+}
+.reg-card--success {
+  border-left-color: var(--status-success);
+  background: var(--status-success-soft);
+}
+.reg-card--error {
+  border-left-color: var(--status-error);
+  background: var(--status-error-soft);
+}
+.reg-card__header {
+  display: flex;
+  align-items: center;
+  gap: var(--space-2);
+  font-size: 0.875rem;
+  font-weight: 600;
+  color: var(--text-primary);
+}
+.reg-card__progress {
+  height: 3px;
+  border-radius: 2px;
+  background: linear-gradient(
+    100deg,
+    var(--status-info-soft) 0%,
+    var(--status-info) 50%,
+    var(--status-info-soft) 100%
+  );
+  background-size: 200% 100%;
+  animation: invoice-skeleton-shimmer 1.4s ease-in-out infinite;
+}
+@media (prefers-reduced-motion: reduce) {
+  .reg-card__progress {
+    animation: none;
+    background: var(--status-info);
+  }
+}
+.reg-card__summary {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: var(--space-3);
+  flex-wrap: wrap;
+}
+.reg-card__note {
+  font-size: 0.75rem;
+  margin: 0;
+}
+
 /* ─ Invoice Timeline ─ */
 .invoice-timeline {
   display: flex;
@@ -9985,6 +10052,31 @@ html[data-density='compact'] .status-badge {
   margin-top: var(--space-3);
 }
 
+/* ─ Infakt invoice correction dialog (#1282) ─ */
+.infakt-correction__head {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: var(--space-2);
+  border: 0;
+  padding: 0 0 var(--space-3);
+}
+.infakt-correction__reason {
+  margin-bottom: var(--space-4);
+}
+.infakt-correction__table-scroll {
+  overflow-x: auto;
+}
+.infakt-correction__col-qty {
+  min-width: 80px;
+}
+.infakt-correction__col-price {
+  min-width: 100px;
+}
+.infakt-correction__note {
+  margin-top: var(--space-3);
+}
+
 /* ─ Correction trigger in order invoice panel (issued state) ─ */
 .order-invoice-panel__correction {
   margin-top: var(--space-3);
@@ -10128,6 +10220,58 @@ html[data-density='compact'] .status-badge {
 }
 .ksef-fa3-view__lineitems tbody tr:last-child td { border-bottom: none; }
 
+/* ── Inline Disclosure (#1303) ───────────────────────────────────────
+ * Native <details>/<summary> "collapsed value + Change affordance"
+ * pattern. First use: Infakt's default-payment-method field, which
+ * should read as an inline fact ("Payment method for invoice: Transfer")
+ * rather than a permanently-open form control most operators never touch.
+ */
+.inline-disclosure {
+  border: 1px dashed var(--accent-primary-border);
+  background: var(--accent-primary-soft);
+  border-radius: var(--radius-md);
+  padding: var(--space-3) var(--space-4);
+}
+
+.inline-disclosure__summary {
+  cursor: pointer;
+  list-style: none;
+  font-size: 0.85rem;
+  line-height: 1.5;
+  color: var(--text-primary);
+}
+
+.inline-disclosure__summary::-webkit-details-marker {
+  display: none;
+}
+
+.inline-disclosure__summary:focus-visible {
+  outline: none;
+  box-shadow: var(--shadow-focus);
+  border-radius: var(--radius-sm);
+}
+
+.inline-disclosure__label {
+  color: var(--text-secondary);
+}
+
+.inline-disclosure__value {
+  font-family: var(--font-mono);
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+.inline-disclosure__cta {
+  color: var(--accent-primary);
+  text-decoration: underline;
+  text-decoration-thickness: 1px;
+  text-underline-offset: 2px;
+  font-weight: 600;
+}
+
+.inline-disclosure__panel {
+  margin-top: var(--space-3);
+}
 
 /* ── Demo Mode (#1127) ─────────────────────────────────────────── */
 
diff --git a/apps/web/src/pages/connections/infakt-setup-page.tsx b/apps/web/src/pages/connections/infakt-setup-page.tsx
new file mode 100644
index 000000000..670d0c165
--- /dev/null
+++ b/apps/web/src/pages/connections/infakt-setup-page.tsx
@@ -0,0 +1,26 @@
+/**
+ * Infakt Setup Page
+ *
+ * Page wrapper for the guided inFakt connection wizard.
+ */
+import type { ReactElement } from 'react';
+import { InfaktSetupForm } from '../../features/connections/components/infakt-setup-form';
+import { PageLayout } from '../../shared/ui/page-layout';
+
+export function InfaktSetupPage(): ReactElement {
+  return (
+    <PageLayout
+      eyebrow="Integrations"
+      title="Connect inFakt"
+      description="Provide your inFakt API key. OpenLinker uses it to issue invoices and read KSeF clearance status through inFakt's native e-invoicing integration."
+      summary={
+        <div className="toolbar__group">
+          <span className="toolbar-chip">API key</span>
+          <span className="toolbar-chip">Guided setup</span>
+        </div>
+      }
+    >
+      <InfaktSetupForm />
+    </PageLayout>
+  );
+}
diff --git a/apps/web/src/plugins/index.ts b/apps/web/src/plugins/index.ts
index 13e50f807..1184d82bc 100644
--- a/apps/web/src/plugins/index.ts
+++ b/apps/web/src/plugins/index.ts
@@ -44,6 +44,7 @@ import { allegroPlugin } from './allegro';
 import { assertUniquePluginInvariants } from './assert-unique-plugin-invariants';
 import { dpdPlugin } from './dpd';
 import { erliPlugin } from './erli';
+import { infaktPlugin } from './infakt';
 import { inpostPlugin } from './inpost';
 import { ksefPlugin } from './ksef';
 import { prestashopPlugin } from './prestashop';
@@ -59,6 +60,7 @@ export const plugins: readonly OpenLinkerPlugin[] = [
   erliPlugin,
   subiektPlugin,
   ksefPlugin,
+  infaktPlugin,
 ];
 
 assertUniquePluginInvariants(plugins);
diff --git a/apps/web/src/plugins/infakt/components/infakt-credentials-panel.test.tsx b/apps/web/src/plugins/infakt/components/infakt-credentials-panel.test.tsx
new file mode 100644
index 000000000..dac952906
--- /dev/null
+++ b/apps/web/src/plugins/infakt/components/infakt-credentials-panel.test.tsx
@@ -0,0 +1,81 @@
+/**
+ * InfaktCredentialsPanel Tests
+ *
+ * Coverage for the rotate-API-key flow for inFakt connections. inFakt carries
+ * a single `apiKey` credential, so the panel rotates one field. Mirrors
+ * `erli-credentials-panel.test.tsx`.
+ */
+import { cleanup, fireEvent, screen, waitFor } from '@testing-library/react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import {
+  createMockApiClient,
+  findToastTitle,
+  renderWithProviders,
+  sampleConnection,
+} from '../../../test/test-utils';
+import { InfaktCredentialsPanel } from './infakt-credentials-panel';
+
+const infaktConnection = { ...sampleConnection, platformType: 'infakt' };
+
+describe('InfaktCredentialsPanel', () => {
+  afterEach(cleanup);
+
+  it('renders the rotate affordance for a credentials-backed connection', () => {
+    renderWithProviders(<InfaktCredentialsPanel connection={infaktConnection} />);
+    expect(screen.getByText('Rotate API key')).toBeInTheDocument();
+  });
+
+  it('falls back to the env-var disabled input when credentialsBacked=false', () => {
+    const envBacked = { ...infaktConnection, credentialsBacked: false };
+    renderWithProviders(<InfaktCredentialsPanel connection={envBacked} />);
+    expect(
+      screen.getByDisplayValue('Environment variable (not editable via UI)'),
+    ).toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: /rotate/i })).not.toBeInTheDocument();
+  });
+
+  it('sends the new apiKey and surfaces a success toast', async () => {
+    const updateCredentials = vi.fn().mockResolvedValue(undefined);
+    const apiClient = createMockApiClient({ connections: { updateCredentials } });
+    renderWithProviders(<InfaktCredentialsPanel connection={infaktConnection} />, { apiClient });
+
+    fireEvent.click(screen.getByText('Rotate API key'));
+    fireEvent.change(screen.getByPlaceholderText('New API key'), {
+      target: { value: 'sk_new_456' },
+    });
+    fireEvent.click(screen.getByRole('button', { name: 'Save new API key' }));
+
+    await waitFor(() => {
+      expect(updateCredentials).toHaveBeenCalledWith(infaktConnection.id, { apiKey: 'sk_new_456' });
+    });
+    expect(await findToastTitle('Credentials rotated')).toBeInTheDocument();
+  });
+
+  it('disables save while the field is empty', () => {
+    renderWithProviders(<InfaktCredentialsPanel connection={infaktConnection} />);
+    fireEvent.click(screen.getByText('Rotate API key'));
+    expect(screen.getByRole('button', { name: 'Save new API key' })).toBeDisabled();
+
+    fireEvent.change(screen.getByPlaceholderText('New API key'), {
+      target: { value: 'sk_new_456' },
+    });
+    expect(screen.getByRole('button', { name: 'Save new API key' })).toBeEnabled();
+  });
+
+  it('collapses the form after a successful save', async () => {
+    const updateCredentials = vi.fn().mockResolvedValue(undefined);
+    const apiClient = createMockApiClient({ connections: { updateCredentials } });
+    renderWithProviders(<InfaktCredentialsPanel connection={infaktConnection} />, { apiClient });
+
+    fireEvent.click(screen.getByText('Rotate API key'));
+    fireEvent.change(screen.getByPlaceholderText('New API key'), {
+      target: { value: 'sk_new_456' },
+    });
+    fireEvent.click(screen.getByRole('button', { name: 'Save new API key' }));
+
+    await waitFor(() => {
+      expect(screen.getByText('Rotate API key')).toBeInTheDocument();
+      expect(screen.queryByPlaceholderText('New API key')).not.toBeInTheDocument();
+    });
+  });
+});
diff --git a/apps/web/src/plugins/infakt/components/infakt-credentials-panel.tsx b/apps/web/src/plugins/infakt/components/infakt-credentials-panel.tsx
new file mode 100644
index 000000000..6d419e79f
--- /dev/null
+++ b/apps/web/src/plugins/infakt/components/infakt-credentials-panel.tsx
@@ -0,0 +1,102 @@
+/**
+ * Infakt Credentials Panel
+ *
+ * Plugin-owned credentials affordance for inFakt connections — rotates the
+ * stored API key in place via PUT /credentials. Owns its own toggle state,
+ * mutation, and toast feedback; the parent `EditConnectionForm` renders this
+ * only when the plugin contributes it. When the credential is env-backed
+ * (`credentialsBacked === false`) the panel shows a read-only affordance
+ * instead. Mirrors `ErliCredentialsPanel` (single `apiKey`, no auth-type
+ * enum).
+ *
+ * @module plugins/infakt/components
+ */
+import { useState, type FormEvent, type ReactElement } from 'react';
+import type { Connection } from '../../../features/connections';
+import { useUpdateConnectionCredentialsMutation } 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';
+
+export function InfaktCredentialsPanel({ connection }: { connection: Connection }): ReactElement {
+  const [showRotate, setShowRotate] = useState(false);
+  const [apiKey, setApiKey] = useState('');
+  const rotate = useUpdateConnectionCredentialsMutation();
+  const { showToast } = useToast();
+
+  if (!connection.credentialsBacked) {
+    return (
+      <FormField label="API Key" name="credentials">
+        <Input value="Environment variable (not editable via UI)" disabled />
+      </FormField>
+    );
+  }
+
+  const canSubmit = apiKey.trim().length > 0;
+
+  const onRotate = async (event: FormEvent): Promise<void> => {
+    event.preventDefault();
+    if (!canSubmit) return;
+    try {
+      await rotate.mutateAsync({
+        connectionId: connection.id,
+        credentials: { apiKey: apiKey.trim() },
+      });
+      showToast({
+        tone: 'success',
+        title: 'Credentials rotated',
+        description: 'The new inFakt API key is now in use.',
+      });
+      setApiKey('');
+      setShowRotate(false);
+    } catch {
+      // surfaced via rotate.error
+    }
+  };
+
+  return (
+    <FormField
+      label="API Key"
+      name="credentials"
+      description="Stored securely on the server. Rotate to replace the key without restarting the API."
+    >
+      {showRotate ? (
+        <div className="form-grid">
+          {rotate.error ? <Alert tone="error">{rotate.error.message}</Alert> : null}
+          <Input
+            type="password"
+            autoComplete="off"
+            placeholder="New API key"
+            value={apiKey}
+            onChange={(event) => setApiKey(event.target.value)}
+          />
+          <div className="form-actions">
+            <Button
+              type="button"
+              onClick={(event) => void onRotate(event)}
+              disabled={rotate.isPending || !canSubmit}
+            >
+              {rotate.isPending ? 'Rotating...' : 'Save new API key'}
+            </Button>
+            <Button
+              tone="secondary"
+              type="button"
+              onClick={() => {
+                setShowRotate(false);
+                setApiKey('');
+              }}
+            >
+              Cancel
+            </Button>
+          </div>
+        </div>
+      ) : (
+        <Button tone="secondary" type="button" onClick={() => setShowRotate(true)}>
+          Rotate API key
+        </Button>
+      )}
+    </FormField>
+  );
+}
diff --git a/apps/web/src/plugins/infakt/components/infakt-invoice-correction-flow.test.tsx b/apps/web/src/plugins/infakt/components/infakt-invoice-correction-flow.test.tsx
new file mode 100644
index 000000000..fb7ab4ab4
--- /dev/null
+++ b/apps/web/src/plugins/infakt/components/infakt-invoice-correction-flow.test.tsx
@@ -0,0 +1,250 @@
+/**
+ * InfaktInvoiceCorrectionFlow tests (#1282)
+ *
+ * @module plugins/infakt/components
+ */
+import { cleanup, fireEvent, screen, waitFor } from '@testing-library/react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import {
+  createMockApiClient,
+  renderWithProviders,
+  sampleConnection,
+} from '../../../test/test-utils';
+import type { InvoiceRecord } from '../../../features/invoicing/api/invoicing.types';
+import { InfaktInvoiceCorrectionFlow } from './infakt-invoice-correction-flow';
+
+const infaktConnection = { ...sampleConnection, platformType: 'infakt' };
+
+function makeInvoice(overrides: Partial<InvoiceRecord> = {}): InvoiceRecord {
+  return {
+    id: 'ol_invoice_test',
+    connectionId: infaktConnection.id,
+    orderId: 'ol_order_test',
+    providerType: 'infakt',
+    documentType: 'invoice',
+    status: 'issued',
+    providerInvoiceId: 'infakt-101',
+    providerInvoiceNumber: 'FV 101/inFakt/2026',
+    regulatoryStatus: 'accepted',
+    clearanceReference: '5260001246-20260625-A1B2-3D',
+    pdfUrl: null,
+    failureMode: null,
+    failureCode: null,
+    failureReason: null,
+    issuedAt: '2026-06-25T10:00:00.000Z',
+    createdAt: '2026-06-25T09:59:00.000Z',
+    updatedAt: '2026-06-25T10:00:00.000Z',
+    ...overrides,
+  };
+}
+
+afterEach(() => cleanup());
+
+describe('InfaktInvoiceCorrectionFlow', () => {
+  it('renders the form header and invoice reference', async () => {
+    renderWithProviders(
+      <InfaktInvoiceCorrectionFlow
+        invoice={makeInvoice()}
+        connection={infaktConnection}
+        onClose={vi.fn()}
+        onCorrectionIssued={vi.fn()}
+      />,
+    );
+    expect(await screen.findByRole('heading', { name: /Issue KOR correction/i })).toBeDefined();
+    expect(await screen.findByText(/FV 101\/inFakt\/2026/i)).toBeDefined();
+  });
+
+  it('renders the reason textarea', async () => {
+    renderWithProviders(
+      <InfaktInvoiceCorrectionFlow
+        invoice={makeInvoice()}
+        connection={infaktConnection}
+        onClose={vi.fn()}
+        onCorrectionIssued={vi.fn()}
+      />,
+    );
+    expect(await screen.findByLabelText(/Reason for correction/i)).toBeDefined();
+  });
+
+  it('starts with one empty line row', async () => {
+    renderWithProviders(
+      <InfaktInvoiceCorrectionFlow
+        invoice={makeInvoice()}
+        connection={infaktConnection}
+        onClose={vi.fn()}
+        onCorrectionIssued={vi.fn()}
+      />,
+    );
+    const lineInputs = await screen.findAllByLabelText(/Line number/i);
+    expect(lineInputs).toHaveLength(1);
+  });
+
+  it('adds a line row on "+ Add line" click', async () => {
+    renderWithProviders(
+      <InfaktInvoiceCorrectionFlow
+        invoice={makeInvoice()}
+        connection={infaktConnection}
+        onClose={vi.fn()}
+        onCorrectionIssued={vi.fn()}
+      />,
+    );
+    const addBtn = await screen.findByText(/Add line/i);
+    fireEvent.click(addBtn);
+    const lineInputs = await screen.findAllByLabelText(/Line number/i);
+    expect(lineInputs).toHaveLength(2);
+  });
+
+  it('removes a line row when Remove is clicked', async () => {
+    renderWithProviders(
+      <InfaktInvoiceCorrectionFlow
+        invoice={makeInvoice()}
+        connection={infaktConnection}
+        onClose={vi.fn()}
+        onCorrectionIssued={vi.fn()}
+      />,
+    );
+    fireEvent.click(await screen.findByText(/Add line/i));
+    let lineInputs = await screen.findAllByLabelText(/Line number/i);
+    expect(lineInputs).toHaveLength(2);
+
+    const removeBtns = await screen.findAllByRole('button', { name: /Remove line/i });
+    fireEvent.click(removeBtns[0]);
+
+    lineInputs = await screen.findAllByLabelText(/Line number/i);
+    expect(lineInputs).toHaveLength(1);
+  });
+
+  it('calls onClose when Cancel is clicked', async () => {
+    const onClose = vi.fn();
+    renderWithProviders(
+      <InfaktInvoiceCorrectionFlow
+        invoice={makeInvoice()}
+        connection={infaktConnection}
+        onClose={onClose}
+        onCorrectionIssued={vi.fn()}
+      />,
+    );
+    fireEvent.click(await screen.findByText(/Cancel/i));
+    expect(onClose).toHaveBeenCalledOnce();
+  });
+
+  it('blocks submit when no line has a line number and shows error', async () => {
+    const issueCorrection = vi.fn();
+    renderWithProviders(
+      <InfaktInvoiceCorrectionFlow
+        invoice={makeInvoice()}
+        connection={infaktConnection}
+        onClose={vi.fn()}
+        onCorrectionIssued={vi.fn()}
+      />,
+      { apiClient: createMockApiClient({ invoicing: { issueCorrection } }) },
+    );
+
+    fireEvent.click(await screen.findByRole('button', { name: /Issue KOR/i }));
+
+    expect(await screen.findByRole('alert')).toBeDefined();
+    expect(await screen.findByText(/at least one line/i)).toBeDefined();
+    expect(issueCorrection).not.toHaveBeenCalled();
+  });
+
+  it('submits issueCorrection with reason, line data and idempotencyKey on form submit', async () => {
+    const correctionInvoice = makeInvoice({ id: 'ol_invoice_correction' });
+    const issueCorrection = vi.fn().mockResolvedValue(correctionInvoice);
+    const onCorrectionIssued = vi.fn();
+    const onClose = vi.fn();
+
+    renderWithProviders(
+      <InfaktInvoiceCorrectionFlow
+        invoice={makeInvoice()}
+        connection={infaktConnection}
+        onClose={onClose}
+        onCorrectionIssued={onCorrectionIssued}
+      />,
+      { apiClient: createMockApiClient({ invoicing: { issueCorrection } }) },
+    );
+
+    const reasonInput = await screen.findByLabelText(/Reason for correction/i);
+    fireEvent.change(reasonInput, { target: { value: 'Partial return' } });
+
+    const lineInput = await screen.findByLabelText(/Line number 1/i);
+    fireEvent.change(lineInput, { target: { value: '1' } });
+    const qtyInput = await screen.findByLabelText(/New qty, line 1/i);
+    fireEvent.change(qtyInput, { target: { value: '0' } });
+    const priceInput = await screen.findByLabelText(/New price, line 1/i);
+    fireEvent.change(priceInput, { target: { value: '34.84' } });
+
+    fireEvent.click(await screen.findByRole('button', { name: /Issue KOR/i }));
+
+    await waitFor(() => {
+      expect(issueCorrection).toHaveBeenCalledWith(
+        'ol_invoice_test',
+        expect.objectContaining({
+          reason: 'Partial return',
+          lines: [{ originalLineNumber: 1, newQuantity: 0, newUnitPriceGross: 34.84 }],
+          idempotencyKey: expect.stringMatching(/^infakt-corr-/),
+        }),
+      );
+    });
+
+    await waitFor(() => expect(onCorrectionIssued).toHaveBeenCalledWith('ol_invoice_correction'));
+    await waitFor(() => expect(onClose).toHaveBeenCalledOnce());
+  });
+
+  it('does not include empty line rows in the submission', async () => {
+    const issueCorrection = vi.fn().mockResolvedValue(makeInvoice({ id: 'ol_invoice_cor2' }));
+
+    renderWithProviders(
+      <InfaktInvoiceCorrectionFlow
+        invoice={makeInvoice()}
+        connection={infaktConnection}
+        onClose={vi.fn()}
+        onCorrectionIssued={vi.fn()}
+      />,
+      { apiClient: createMockApiClient({ invoicing: { issueCorrection } }) },
+    );
+
+    // Add a second line but leave it empty
+    fireEvent.click(await screen.findByText(/Add line/i));
+
+    // Only fill line 1 — line number plus a delta, so it's a valid (non-no-op) row
+    const lineInputs = await screen.findAllByLabelText(/Line number/i);
+    fireEvent.change(lineInputs[0], { target: { value: '2' } });
+    const qtyInputs = await screen.findAllByLabelText(/New qty, line/i);
+    fireEvent.change(qtyInputs[0], { target: { value: '3' } });
+
+    fireEvent.click(await screen.findByRole('button', { name: /Issue KOR/i }));
+
+    await waitFor(() => {
+      const call = issueCorrection.mock.calls[0] as [
+        string,
+        { lines: { originalLineNumber: number }[] },
+      ];
+      expect(call[1].lines).toHaveLength(1);
+      expect(call[1].lines[0].originalLineNumber).toBe(2);
+    });
+  });
+
+  it('blocks submit when a filled line has neither new quantity nor new price', async () => {
+    const issueCorrection = vi.fn();
+
+    renderWithProviders(
+      <InfaktInvoiceCorrectionFlow
+        invoice={makeInvoice()}
+        connection={infaktConnection}
+        onClose={vi.fn()}
+        onCorrectionIssued={vi.fn()}
+      />,
+      { apiClient: createMockApiClient({ invoicing: { issueCorrection } }) },
+    );
+
+    const lineInputs = await screen.findAllByLabelText(/Line number/i);
+    fireEvent.change(lineInputs[0], { target: { value: '1' } });
+
+    fireEvent.click(await screen.findByRole('button', { name: /Issue KOR/i }));
+
+    expect(
+      await screen.findByText(/Each line must specify a new quantity and\/or a new price/i),
+    ).toBeInTheDocument();
+    expect(issueCorrection).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/web/src/plugins/infakt/components/infakt-invoice-correction-flow.tsx b/apps/web/src/plugins/infakt/components/infakt-invoice-correction-flow.tsx
new file mode 100644
index 000000000..9be002dcc
--- /dev/null
+++ b/apps/web/src/plugins/infakt/components/infakt-invoice-correction-flow.tsx
@@ -0,0 +1,308 @@
+/**
+ * InfaktInvoiceCorrectionFlow (#1282)
+ *
+ * Per-provider `invoiceCorrectionFlow` slot for inFakt. Issues a KOR (faktura
+ * korygująca) via `POST /invoices/:invoiceId/correct` — the same generic
+ * capability-gated endpoint KSeF uses (backed by `InfaktInvoicingAdapter`
+ * implementing `CorrectionIssuer`, PR #1292). The operator supplies:
+ *   - an optional free-text reason;
+ *   - per-line new quantity and/or new unit price gross.
+ *
+ * The form starts with ONE empty row and an "Add line" affordance for
+ * multi-line corrections. Near-1:1 port of `KsefInvoiceCorrectionFlow` — same
+ * line-row model, same generic `useIssueCorrectionMutation` hook, same
+ * `InvoiceCorrectionFlowProps` slot contract. The host dialog owns the outer
+ * chrome; this component is content-only — call `onClose` to close the
+ * dialog.
+ *
+ * @module plugins/infakt/components
+ */
+import { type ReactElement, useRef, useState } from 'react';
+import { useTranslation } from '../../../shared/i18n';
+import { Button } from '../../../shared/ui/button';
+import { useToast } from '../../../shared/ui/toast-provider';
+import type { InvoiceCorrectionFlowProps } from '../../../shared/plugins/plugin.types';
+import {
+  useIssueCorrectionMutation,
+  type CorrectionLineInput,
+} from '../../../features/invoicing';
+
+interface LineRow {
+  originalLineNumber: string;
+  newQuantity: string;
+  newUnitPriceGross: string;
+}
+
+function emptyRow(): LineRow {
+  return { originalLineNumber: '', newQuantity: '', newUnitPriceGross: '' };
+}
+
+/**
+ * Returns `null` when a filled-in row changes neither quantity nor price — a
+ * no-op line the backend `CorrectionLineDto` rejects (at least one delta is
+ * required per line).
+ */
+function parseLineRows(rows: LineRow[]): CorrectionLineInput[] | null {
+  const filled = rows.filter((r) => r.originalLineNumber.trim() !== '');
+  const parsed: CorrectionLineInput[] = [];
+  for (const r of filled) {
+    const lineNum = parseInt(r.originalLineNumber, 10);
+    const qty = r.newQuantity.trim() !== '' ? parseFloat(r.newQuantity) : undefined;
+    const price = r.newUnitPriceGross.trim() !== '' ? parseFloat(r.newUnitPriceGross) : undefined;
+    const hasQty = qty !== undefined && !Number.isNaN(qty);
+    const hasPrice = price !== undefined && !Number.isNaN(price);
+    if (!hasQty && !hasPrice) {
+      return null;
+    }
+    parsed.push({
+      originalLineNumber: lineNum,
+      ...(hasQty ? { newQuantity: qty } : {}),
+      ...(hasPrice ? { newUnitPriceGross: price } : {}),
+    });
+  }
+  return parsed;
+}
+
+export function InfaktInvoiceCorrectionFlow({
+  invoice,
+  onClose,
+  onCorrectionIssued,
+}: InvoiceCorrectionFlowProps): ReactElement {
+  const { t } = useTranslation();
+  const { showToast } = useToast();
+  const mutation = useIssueCorrectionMutation();
+
+  // Per-mount stable idempotency key — prevents duplicate KOR issuance on timeout/retry.
+  const idempotencyKeyRef = useRef(
+    `infakt-corr-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`,
+  );
+
+  const [reason, setReason] = useState('');
+  const [lines, setLines] = useState<LineRow[]>([emptyRow()]);
+  const [linesError, setLinesError] = useState<string | null>(null);
+
+  function updateLine(index: number, field: keyof LineRow, value: string): void {
+    setLines((prev) => prev.map((r, i) => (i === index ? { ...r, [field]: value } : r)));
+  }
+
+  function addLine(): void {
+    setLines((prev) => [...prev, emptyRow()]);
+  }
+
+  function removeLine(index: number): void {
+    setLines((prev) => (prev.length > 1 ? prev.filter((_, i) => i !== index) : prev));
+  }
+
+  function handleSubmit(): void {
+    const parsedLines = parseLineRows(lines);
+    if (parsedLines === null) {
+      setLinesError(
+        t(
+          'infakt.correction.lineDeltaRequired',
+          'Each line must specify a new quantity and/or a new price.',
+        ),
+      );
+      return;
+    }
+    if (parsedLines.length === 0) {
+      setLinesError(
+        t(
+          'infakt.correction.linesRequired',
+          'At least one line with a line number is required.',
+        ),
+      );
+      return;
+    }
+    setLinesError(null);
+    mutation.mutate(
+      {
+        invoiceId: invoice.id,
+        input: {
+          reason: reason.trim() !== '' ? reason.trim() : undefined,
+          lines: parsedLines,
+          idempotencyKey: idempotencyKeyRef.current,
+        },
+      },
+      {
+        onSuccess: (correctionInvoice) => {
+          showToast({
+            tone: 'success',
+            title: t('infakt.correction.issued', 'KOR issued'),
+            description: t(
+              'infakt.correction.issuedBody',
+              'The correcting document was submitted to KSeF via inFakt.',
+            ),
+          });
+          onCorrectionIssued(correctionInvoice.id);
+          onClose();
+        },
+        onError: (error) => {
+          showToast({
+            tone: 'error',
+            title: t('infakt.correction.failed', 'KOR failed'),
+            description: error.message,
+          });
+        },
+      },
+    );
+  }
+
+  const isSubmitting = mutation.isPending;
+
+  return (
+    <div className="infakt-correction">
+      {/* Header */}
+      <div className="infakt-correction__head">
+        <h3>{t('infakt.correction.title', 'Issue KOR correction')}</h3>
+        <span className="section-card__provider">
+          {t('infakt.correction.providerTag', 'inFakt · slot')}
+        </span>
+      </div>
+
+      {/* Original invoice reference */}
+      <div className="infakt-correction__orig">
+        <span>
+          {t('infakt.correction.correcting', 'Correcting')}{' '}
+          <strong>{invoice.providerInvoiceNumber ?? invoice.id}</strong>
+        </span>
+        {invoice.clearanceReference ? (
+          <span>
+            {t('infakt.correction.ksefRef', 'KSeF')}{' '}
+            <strong className="mono-text">
+              {invoice.clearanceReference.slice(0, 14)}…
+            </strong>
+          </span>
+        ) : null}
+        {invoice.issuedAt ? (
+          <span>
+            {t('infakt.correction.issuedOn', 'Issued')}{' '}
+            <strong className="mono-text">
+              {invoice.issuedAt.slice(0, 10)}
+            </strong>
+          </span>
+        ) : null}
+      </div>
+
+      {/* Reason */}
+      <div className="field infakt-correction__reason">
+        <label htmlFor="infakt-reason">
+          {t('infakt.correction.reasonLabel', 'Reason for correction')}
+        </label>
+        <textarea
+          id="infakt-reason"
+          className="textarea"
+          placeholder={t(
+            'infakt.correction.reasonPlaceholder',
+            'e.g. Partial return of the order',
+          )}
+          value={reason}
+          onChange={(e) => setReason(e.target.value)}
+          disabled={isSubmitting}
+          rows={3}
+        />
+      </div>
+
+      {/* Line items */}
+      {linesError ? (
+        <p className="error-text" role="alert">
+          {linesError}
+        </p>
+      ) : null}
+      <div className="infakt-correction__table-scroll">
+        <table className="data-table">
+          <thead>
+            <tr>
+              <th>{t('infakt.correction.col.lp', 'Lp')}</th>
+              <th className="infakt-correction__col-qty">
+                {t('infakt.correction.col.newQty', 'New qty')}
+              </th>
+              <th className="infakt-correction__col-price">
+                {t('infakt.correction.col.newPrice', 'New price')}
+              </th>
+              <th aria-label={t('infakt.correction.col.remove', 'Remove')} />
+            </tr>
+          </thead>
+          <tbody>
+            {lines.map((row, i) => (
+              <tr key={i}>
+                <td>
+                  <input
+                    type="number"
+                    className="input input--w-lp"
+                    value={row.originalLineNumber}
+                    onChange={(e) => updateLine(i, 'originalLineNumber', e.target.value)}
+                    placeholder="1"
+                    min={1}
+                    step={1}
+                    aria-label={`${t('infakt.correction.lineNum', 'Line number')} ${i + 1}`}
+                    disabled={isSubmitting}
+                  />
+                </td>
+                <td>
+                  <input
+                    type="number"
+                    className="input input--w-qty"
+                    value={row.newQuantity}
+                    onChange={(e) => updateLine(i, 'newQuantity', e.target.value)}
+                    placeholder="—"
+                    min={0}
+                    step="any"
+                    aria-label={`${t('infakt.correction.newQty', 'New qty, line')} ${i + 1}`}
+                    disabled={isSubmitting}
+                  />
+                </td>
+                <td>
+                  <input
+                    type="number"
+                    className="input input--w-price"
+                    value={row.newUnitPriceGross}
+                    onChange={(e) => updateLine(i, 'newUnitPriceGross', e.target.value)}
+                    placeholder="—"
+                    min={0}
+                    step="any"
+                    aria-label={`${t('infakt.correction.newPrice', 'New price, line')} ${i + 1}`}
+                    disabled={isSubmitting}
+                  />
+                </td>
+                <td>
+                  <Button
+                    tone="secondary"
+                    onClick={() => removeLine(i)}
+                    disabled={lines.length === 1 || isSubmitting}
+                    aria-label={`${t('infakt.correction.removeLine', 'Remove line')} ${i + 1}`}
+                  >
+                    ✕
+                  </Button>
+                </td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      </div>
+
+      <Button tone="secondary" onClick={addLine} disabled={isSubmitting}>
+        {t('infakt.correction.addLine', '+ Add line')}
+      </Button>
+
+      <p className="infakt-correction__note">
+        {t(
+          'infakt.correction.note',
+          'A KOR document corrects quantity and/or price per line. inFakt submits it to KSeF; OpenLinker reconciles the status automatically.',
+        )}
+      </p>
+
+      {/* Actions */}
+      <div className="wizard__actions">
+        <span className="wizard__spacer" />
+        <Button tone="secondary" onClick={onClose} disabled={isSubmitting}>
+          {t('infakt.correction.cancel', 'Cancel')}
+        </Button>
+        <Button tone="primary" onClick={handleSubmit} disabled={isSubmitting}>
+          {isSubmitting
+            ? t('infakt.correction.submitting', 'Issuing…')
+            : t('infakt.correction.submit', 'Issue KOR')}
+        </Button>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/web/src/plugins/infakt/components/infakt-invoice-detail-section.test.tsx b/apps/web/src/plugins/infakt/components/infakt-invoice-detail-section.test.tsx
new file mode 100644
index 000000000..72dd2256c
--- /dev/null
+++ b/apps/web/src/plugins/infakt/components/infakt-invoice-detail-section.test.tsx
@@ -0,0 +1,149 @@
+/**
+ * InfaktInvoiceDetailSection tests (#1282)
+ *
+ * @module plugins/infakt/components
+ */
+import { cleanup, fireEvent, screen, waitFor } from '@testing-library/react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { createMockApiClient, renderWithProviders, sampleConnection } from '../../../test/test-utils';
+import type { InvoiceRecord } from '../../../features/invoicing/api/invoicing.types';
+import { InfaktInvoiceDetailSection } from './infakt-invoice-detail-section';
+
+const infaktConnection = { ...sampleConnection, platformType: 'infakt' };
+
+function makeInvoice(overrides: Partial<InvoiceRecord> = {}): InvoiceRecord {
+  return {
+    id: 'ol_invoice_test',
+    connectionId: infaktConnection.id,
+    orderId: 'ol_order_test',
+    providerType: 'infakt',
+    documentType: 'invoice',
+    status: 'issued',
+    providerInvoiceId: 'infakt-101',
+    providerInvoiceNumber: 'FV 101/TEST/2026',
+    regulatoryStatus: 'not-applicable',
+    clearanceReference: null,
+    pdfUrl: null,
+    failureMode: null,
+    failureCode: null,
+    failureReason: null,
+    issuedAt: '2026-06-25T10:00:00.000Z',
+    createdAt: '2026-06-25T09:59:00.000Z',
+    updatedAt: '2026-06-25T10:00:00.000Z',
+    ...overrides,
+  };
+}
+
+afterEach(() => cleanup());
+
+describe('InfaktInvoiceDetailSection', () => {
+  it('renders nothing when regulatoryStatus is not-applicable', () => {
+    renderWithProviders(
+      <InfaktInvoiceDetailSection invoice={makeInvoice()} connection={infaktConnection} />,
+    );
+    expect(document.querySelector('.invoice-detail-section')).not.toBeInTheDocument();
+  });
+
+  it('renders the pending state with a progress indicator when submitted', async () => {
+    renderWithProviders(
+      <InfaktInvoiceDetailSection
+        invoice={makeInvoice({ regulatoryStatus: 'submitted' })}
+        connection={infaktConnection}
+      />,
+    );
+    expect(await screen.findByText(/submitting this invoice to KSeF/i)).toBeInTheDocument();
+    expect(document.querySelector('.reg-card--info')).toBeInTheDocument();
+    expect(document.querySelector('.reg-card__progress')).toBeInTheDocument();
+  });
+
+  it('renders the clearance reference chip when accepted', async () => {
+    renderWithProviders(
+      <InfaktInvoiceDetailSection
+        invoice={makeInvoice({
+          regulatoryStatus: 'accepted',
+          clearanceReference: '5260001246-20260625-A1B2-3D',
+        })}
+        connection={infaktConnection}
+      />,
+    );
+    expect(await screen.findByText('5260001246-20260625-A1B2-3D')).toBeInTheDocument();
+    expect(document.querySelector('.reg-card--success')).toBeInTheDocument();
+  });
+
+  it('falls back to providerInvoiceNumber when clearanceReference is absent on accepted', async () => {
+    renderWithProviders(
+      <InfaktInvoiceDetailSection
+        invoice={makeInvoice({
+          regulatoryStatus: 'accepted',
+          clearanceReference: null,
+          providerInvoiceNumber: 'FV 101/TEST/2026',
+        })}
+        connection={infaktConnection}
+      />,
+    );
+    expect(await screen.findByText('FV 101/TEST/2026')).toBeInTheDocument();
+  });
+
+  it('shows the pending fallback when accepted but no reference at all', async () => {
+    renderWithProviders(
+      <InfaktInvoiceDetailSection
+        invoice={makeInvoice({
+          regulatoryStatus: 'accepted',
+          clearanceReference: null,
+          providerInvoiceNumber: null,
+        })}
+        connection={infaktConnection}
+      />,
+    );
+    expect(await screen.findByText(/KSeF number pending/i)).toBeInTheDocument();
+  });
+
+  it('renders the failure reason when rejected', async () => {
+    renderWithProviders(
+      <InfaktInvoiceDetailSection
+        invoice={makeInvoice({
+          regulatoryStatus: 'rejected',
+          failureReason: 'Invalid buyer NIP format on line 2',
+        })}
+        connection={infaktConnection}
+      />,
+    );
+    expect(await screen.findByText('Invalid buyer NIP format on line 2')).toBeInTheDocument();
+    expect(document.querySelector('.reg-card--error')).toBeInTheDocument();
+  });
+
+  it('renders a fallback rejection message when no failureReason is set', async () => {
+    renderWithProviders(
+      <InfaktInvoiceDetailSection
+        invoice={makeInvoice({ regulatoryStatus: 'rejected', failureReason: null })}
+        connection={infaktConnection}
+      />,
+    );
+    expect(await screen.findByText('KSeF rejected this invoice.')).toBeInTheDocument();
+  });
+
+  it('calls downloadDocument with kind=rendered when Download PDF is clicked', async () => {
+    URL.createObjectURL = vi.fn(() => 'blob:mock');
+    URL.revokeObjectURL = vi.fn();
+    const downloadDocument = vi
+      .fn()
+      .mockResolvedValue(new Blob(['%PDF'], { type: 'application/pdf' }));
+    const apiClient = createMockApiClient({ invoicing: { downloadDocument } });
+
+    renderWithProviders(
+      <InfaktInvoiceDetailSection
+        invoice={makeInvoice({
+          regulatoryStatus: 'accepted',
+          clearanceReference: '5260001246-20260625-A1B2-3D',
+        })}
+        connection={infaktConnection}
+      />,
+      { apiClient },
+    );
+
+    fireEvent.click(screen.getByRole('button', { name: 'Download PDF' }));
+    await waitFor(() =>
+      expect(downloadDocument).toHaveBeenCalledWith('ol_invoice_test', 'rendered'),
+    );
+  });
+});
diff --git a/apps/web/src/plugins/infakt/components/infakt-invoice-detail-section.tsx b/apps/web/src/plugins/infakt/components/infakt-invoice-detail-section.tsx
new file mode 100644
index 000000000..8fbf7a296
--- /dev/null
+++ b/apps/web/src/plugins/infakt/components/infakt-invoice-detail-section.tsx
@@ -0,0 +1,106 @@
+/**
+ * Infakt Invoice Detail Section
+ *
+ * Per-provider `invoiceDetailSection` slot for inFakt connections (#1282).
+ * inFakt submits invoices to KSeF on OpenLinker's behalf and reports back
+ * clearance status — OpenLinker only reads the neutral `regulatoryStatus`,
+ * it never talks to KSeF directly for this provider. inFakt exposes no
+ * UPO/FA3 document endpoints of its own, but it does render a PDF of the
+ * invoice server-side (#1321) — the "Download PDF" action below hits the
+ * neutral `RegulatoryDocumentReader`-backed `/document?kind=rendered` route.
+ *
+ * Uses the shared `.reg-card` severity-stripe treatment (#1282) directly —
+ * inFakt ships with the redesigned look from day one.
+ *
+ * @module plugins/infakt/components
+ */
+import type { ReactElement } from 'react';
+import { useTranslation } from '../../../shared/i18n';
+import { CopyableId } from '../../../shared/ui/copyable-id';
+import { Button } from '../../../shared/ui/button';
+import { useToast } from '../../../shared/ui/toast-provider';
+import type { InvoiceDetailSectionProps } from '../../../shared/plugins/plugin.types';
+import {
+  RegulatoryStatusBadge,
+  regCardToneFor,
+  useInvoiceRenderedDocumentDownload,
+} from '../../../features/invoicing';
+
+export function InfaktInvoiceDetailSection({
+  invoice,
+}: InvoiceDetailSectionProps): ReactElement | null {
+  const { t } = useTranslation();
+  const pdfDownload = useInvoiceRenderedDocumentDownload();
+  const { showToast } = useToast();
+
+  if (invoice.regulatoryStatus === 'not-applicable') {
+    return null;
+  }
+
+  const ksefNumber = invoice.clearanceReference ?? invoice.providerInvoiceNumber ?? null;
+
+  async function handleDownloadPdf(): Promise<void> {
+    const ok = await pdfDownload.download(invoice.id);
+    if (!ok) {
+      showToast({
+        tone: 'error',
+        title: t('infakt.invoice.detail.pdfDownloadFailed', 'PDF download failed'),
+        description:
+          pdfDownload.error?.message ??
+          t('infakt.invoice.detail.pdfDownloadFailedDesc', 'Could not fetch the invoice PDF.'),
+      });
+    }
+  }
+
+  return (
+    <section className={`invoice-detail-section reg-card ${regCardToneFor(invoice.regulatoryStatus)}`.trim()}>
+      <div className="reg-card__header">
+        <h4 className="invoice-detail-section__title">
+          {t('infakt.invoice.detail.title', 'KSeF clearance (via inFakt)')}
+        </h4>
+        <RegulatoryStatusBadge status={invoice.regulatoryStatus} />
+      </div>
+
+      {invoice.regulatoryStatus === 'submitted' ? (
+        <>
+          <p className="text-muted reg-card__note">
+            {t(
+              'infakt.invoice.detail.pending',
+              'inFakt is submitting this invoice to KSeF. Clearance usually completes within a minute or two.',
+            )}
+          </p>
+          <div className="reg-card__progress" aria-hidden="true" />
+        </>
+      ) : null}
+
+      {invoice.regulatoryStatus === 'accepted' ? (
+        <div className="reg-card__summary">
+          {ksefNumber ? (
+            <CopyableId id={ksefNumber} label={ksefNumber} />
+          ) : (
+            <span className="text-muted">
+              {t('infakt.invoice.detail.numberPending', 'KSeF number pending')}
+            </span>
+          )}
+          <Button
+            tone="ghost"
+            className="button--sm"
+            onClick={() => void handleDownloadPdf()}
+            disabled={pdfDownload.isDownloading}
+          >
+            {pdfDownload.isDownloading
+              ? t('infakt.invoice.detail.pdfDownloading', 'Downloading…')
+              : t('infakt.invoice.detail.pdfDownload', 'Download PDF')}
+          </Button>
+        </div>
+      ) : null}
+
+      {invoice.regulatoryStatus === 'rejected' ? (
+        <p className="text-muted reg-card__note">
+          {invoice.failureReason ??
+            t('infakt.invoice.detail.rejectedFallback', 'KSeF rejected this invoice.')}
+        </p>
+      ) : null}
+    </section>
+  );
+}
diff --git a/apps/web/src/plugins/infakt/components/infakt-structured-section.test.tsx b/apps/web/src/plugins/infakt/components/infakt-structured-section.test.tsx
new file mode 100644
index 000000000..daa8a2b1c
--- /dev/null
+++ b/apps/web/src/plugins/infakt/components/infakt-structured-section.test.tsx
@@ -0,0 +1,208 @@
+/**
+ * InfaktStructuredSection Tests
+ *
+ * Coverage for the baseUrl editor field and default-payment-method select
+ * (#1303) shown in EditConnectionForm for inFakt connections. Tests
+ * propagation to JSON config via syncStructuredToJson callback. Mirrors
+ * `woocommerce-structured-section.test.tsx`.
+ */
+/* eslint-disable @typescript-eslint/no-explicit-any -- test component mocking requires flexible types */
+import type { ReactElement } from 'react';
+import { cleanup, fireEvent, screen } from '@testing-library/react';
+import { useForm } from 'react-hook-form';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { renderWithProviders } from '../../../test/test-utils';
+import { InfaktStructuredSection } from './infakt-structured-section';
+
+describe('InfaktStructuredSection', () => {
+  afterEach(cleanup);
+
+  it('renders the baseUrl field for editing', () => {
+    const TestComponent = (): ReactElement => {
+      const form = useForm<any>({
+        defaultValues: { baseUrl: 'https://api.infakt.pl' },
+      });
+      return (
+        <InfaktStructuredSection
+          connection={{ id: '1' } as any}
+          form={form as any}
+          configIsParseable={true}
+          syncStructuredToJson={vi.fn()}
+        />
+      );
+    };
+    renderWithProviders(<TestComponent />);
+    expect(screen.getByDisplayValue('https://api.infakt.pl')).toBeInTheDocument();
+  });
+
+  it('calls syncStructuredToJson with the baseUrl config key when the value changes', () => {
+    const syncStructuredToJson = vi.fn();
+    const TestComponent = (): ReactElement => {
+      const form = useForm<any>({
+        defaultValues: { baseUrl: 'https://api.infakt.pl' },
+      });
+      return (
+        <InfaktStructuredSection
+          connection={{ id: '1' } as any}
+          form={form as any}
+          configIsParseable={true}
+          syncStructuredToJson={syncStructuredToJson}
+        />
+      );
+    };
+    renderWithProviders(<TestComponent />);
+
+    const input = screen.getByDisplayValue('https://api.infakt.pl');
+    fireEvent.change(input, { target: { value: 'https://sandbox.infakt.pl' } });
+
+    expect(syncStructuredToJson).toHaveBeenCalledWith('baseUrl', 'https://sandbox.infakt.pl');
+  });
+
+  it('disables input when configIsParseable is false', () => {
+    const TestComponent = (): ReactElement => {
+      const form = useForm<any>({
+        defaultValues: { baseUrl: 'https://api.infakt.pl' },
+      });
+      return (
+        <InfaktStructuredSection
+          connection={{ id: '1' } as any}
+          form={form as any}
+          configIsParseable={false}
+          syncStructuredToJson={vi.fn()}
+        />
+      );
+    };
+    renderWithProviders(<TestComponent />);
+
+    const input = screen.getByDisplayValue('https://api.infakt.pl');
+    expect(input).toBeDisabled();
+  });
+
+  it('shows form error message when baseUrl has a validation error', () => {
+    const TestComponent = (): ReactElement => {
+      const form = useForm<any>({
+        defaultValues: { baseUrl: '' },
+      });
+      form.formState.errors.baseUrl = {
+        message: 'Base URL must use HTTPS',
+        type: 'manual',
+      };
+      return (
+        <InfaktStructuredSection
+          connection={{ id: '1' } as any}
+          form={form as any}
+          configIsParseable={true}
+          syncStructuredToJson={vi.fn()}
+        />
+      );
+    };
+    renderWithProviders(<TestComponent />);
+
+    expect(screen.getByText('Base URL must use HTTPS')).toBeInTheDocument();
+  });
+
+  it('shows the effective payment method in the collapsed disclosure summary (#1303)', () => {
+    const TestComponent = (): ReactElement => {
+      const form = useForm<any>({
+        defaultValues: { baseUrl: '', infaktPaymentMethod: 'transfer' },
+      });
+      return (
+        <InfaktStructuredSection
+          connection={{ id: '1' } as any}
+          form={form as any}
+          configIsParseable={true}
+          syncStructuredToJson={vi.fn()}
+        />
+      );
+    };
+    renderWithProviders(<TestComponent />);
+    expect(screen.getByText('Payment method for invoice:')).toBeInTheDocument();
+    expect(screen.getByText('Transfer', { selector: '.inline-disclosure__value' })).toBeInTheDocument();
+    expect(screen.getByLabelText('Default payment method')).not.toBeVisible();
+  });
+
+  it('defaults the collapsed summary to Cash when no value is set', () => {
+    const TestComponent = (): ReactElement => {
+      const form = useForm<any>({
+        defaultValues: { baseUrl: '', infaktPaymentMethod: '' },
+      });
+      return (
+        <InfaktStructuredSection
+          connection={{ id: '1' } as any}
+          form={form as any}
+          configIsParseable={true}
+          syncStructuredToJson={vi.fn()}
+        />
+      );
+    };
+    renderWithProviders(<TestComponent />);
+    expect(screen.getByText('Cash', { selector: '.inline-disclosure__value' })).toBeInTheDocument();
+  });
+
+  it('renders the default payment method select once expanded (#1303)', () => {
+    const TestComponent = (): ReactElement => {
+      const form = useForm<any>({
+        defaultValues: { baseUrl: '', infaktPaymentMethod: 'cash' },
+      });
+      return (
+        <InfaktStructuredSection
+          connection={{ id: '1' } as any}
+          form={form as any}
+          configIsParseable={true}
+          syncStructuredToJson={vi.fn()}
+        />
+      );
+    };
+    renderWithProviders(<TestComponent />);
+
+    fireEvent.click(screen.getByText('Payment method for invoice:'));
+
+    expect(screen.getByLabelText('Default payment method')).toHaveValue('cash');
+  });
+
+  it('calls syncStructuredToJson with the infaktPaymentMethod config key when the selection changes', () => {
+    const syncStructuredToJson = vi.fn();
+    const TestComponent = (): ReactElement => {
+      const form = useForm<any>({
+        defaultValues: { baseUrl: '', infaktPaymentMethod: 'cash' },
+      });
+      return (
+        <InfaktStructuredSection
+          connection={{ id: '1' } as any}
+          form={form as any}
+          configIsParseable={true}
+          syncStructuredToJson={syncStructuredToJson}
+        />
+      );
+    };
+    renderWithProviders(<TestComponent />);
+
+    fireEvent.click(screen.getByText('Payment method for invoice:'));
+    fireEvent.change(screen.getByLabelText('Default payment method'), {
+      target: { value: 'transfer' },
+    });
+
+    expect(syncStructuredToJson).toHaveBeenCalledWith('infaktPaymentMethod', 'transfer');
+  });
+
+  it('disables the payment method select when configIsParseable is false', () => {
+    const TestComponent = (): ReactElement => {
+      const form = useForm<any>({
+        defaultValues: { baseUrl: '', infaktPaymentMethod: 'cash' },
+      });
+      return (
+        <InfaktStructuredSection
+          connection={{ id: '1' } as any}
+          form={form as any}
+          configIsParseable={false}
+          syncStructuredToJson={vi.fn()}
+        />
+      );
+    };
+    renderWithProviders(<TestComponent />);
+
+    fireEvent.click(screen.getByText('Payment method for invoice:'));
+
+    expect(screen.getByLabelText('Default payment method')).toBeDisabled();
+  });
+});
diff --git a/apps/web/src/plugins/infakt/components/infakt-structured-section.tsx b/apps/web/src/plugins/infakt/components/infakt-structured-section.tsx
new file mode 100644
index 000000000..13b00aaf8
--- /dev/null
+++ b/apps/web/src/plugins/infakt/components/infakt-structured-section.tsx
@@ -0,0 +1,84 @@
+/**
+ * Infakt Structured Section
+ *
+ * Plugin-owned structured-config inputs rendered inside `EditConnectionForm`
+ * when the connection's `platformType` is `'infakt'`. Carries:
+ *
+ *   - Base URL (`config.baseUrl`) — used to point an existing connection at
+ *     inFakt's sandbox environment instead of production.
+ *   - Default payment method (`config.defaultPaymentMethod`, #1303) — sent
+ *     on every issued invoice/correction. Empty selection means "no
+ *     override", the adapter falls back to `'cash'`. Tucked behind an
+ *     `InlineDisclosure` — most operators never touch it, so it reads as an
+ *     inline fact ("Payment method for invoice: Cash") rather than a
+ *     permanently-open control competing with Base URL for attention.
+ *
+ * Credentials (the API key) are NOT edited here — they live in the
+ * write-only `InfaktCredentialsPanel`.
+ *
+ * @module plugins/infakt/components
+ */
+import type { ReactElement } from 'react';
+import { FormField } from '../../../shared/ui/form-field';
+import { InlineDisclosure } from '../../../shared/ui/inline-disclosure';
+import { Input } from '../../../shared/ui/input';
+import { Select } from '../../../shared/ui/select';
+import type { StructuredConfigSectionProps } from '../../../shared/plugins';
+
+const PAYMENT_METHOD_LABELS: Record<'cash' | 'transfer', string> = {
+  cash: 'Cash',
+  transfer: 'Transfer',
+};
+
+export function InfaktStructuredSection({
+  form,
+  configIsParseable,
+  syncStructuredToJson,
+}: StructuredConfigSectionProps): ReactElement {
+  const paymentMethod = form.watch('infaktPaymentMethod') ?? '';
+  // Mirrors the adapter's own fallback (`config.defaultPaymentMethod ?? 'cash'`)
+  // so the collapsed summary always reflects what will actually be sent.
+  const effectiveLabel = PAYMENT_METHOD_LABELS[paymentMethod === 'transfer' ? 'transfer' : 'cash'];
+
+  return (
+    <>
+      <FormField
+        label="Base URL (optional)"
+        name="baseUrl"
+        error={form.formState.errors.baseUrl?.message}
+        description="Advanced — override the default inFakt API base URL for sandbox testing. Leave blank to use production."
+      >
+        <Input
+          value={form.watch('baseUrl') ?? ''}
+          onChange={(event) => syncStructuredToJson('baseUrl', event.target.value)}
+          placeholder="https://api.infakt.pl"
+          className="mono-text"
+          autoComplete="off"
+          disabled={!configIsParseable}
+          invalid={Boolean(form.formState.errors.baseUrl)}
+        />
+      </FormField>
+      <InlineDisclosure label="Payment method for invoice:" value={effectiveLabel}>
+        <FormField
+          label="Default payment method"
+          name="infaktPaymentMethod"
+          error={form.formState.errors.infaktPaymentMethod?.message}
+          description={
+            '"Transfer" 422s on inFakt unless a bank account is configured on the seller’s ' +
+            'inFakt account. Leave "Cash" unless you have confirmed that prerequisite.'
+          }
+        >
+          <Select
+            value={paymentMethod}
+            onChange={(event) => syncStructuredToJson('infaktPaymentMethod', event.target.value)}
+            disabled={!configIsParseable}
+            invalid={Boolean(form.formState.errors.infaktPaymentMethod)}
+          >
+            <option value="cash">{PAYMENT_METHOD_LABELS.cash}</option>
+            <option value="transfer">{PAYMENT_METHOD_LABELS.transfer}</option>
+          </Select>
+        </FormField>
+      </InlineDisclosure>
+    </>
+  );
+}
diff --git a/apps/web/src/plugins/infakt/index.ts b/apps/web/src/plugins/infakt/index.ts
new file mode 100644
index 000000000..1b7f18a2d
--- /dev/null
+++ b/apps/web/src/plugins/infakt/index.ts
@@ -0,0 +1,49 @@
+/**
+ * inFakt plugin
+ *
+ * Unified contribution (#1282, epic #1279) for inFakt — a Polish accounting
+ * SaaS that submits invoices to KSeF on OpenLinker's behalf and reports back
+ * clearance status. inFakt carries the neutral `Invoicing` capability
+ * (ADR-026, backend #1292/#1293); this plugin contributes:
+ *
+ *   - the guided setup route (build-time) + setup card (platform-side)
+ *   - the structured-config edit section (sandbox baseUrl override)
+ *   - the write-only credentials panel (single API key rotation)
+ *   - the per-provider invoice detail section (KSeF number + clearance status)
+ *   - the per-provider invoice correction flow (KOR)
+ *
+ * Per ADR-026, the FE never reasons about inFakt specifics through
+ * `platformType === 'infakt'` string-matching in shared components — every
+ * platform-specific affordance is resolved through the registry via
+ * `usePlatform('infakt')`.
+ *
+ * @module plugins/infakt
+ */
+import type { OpenLinkerPlugin } from '../../shared/plugins';
+import { definePlugin } from '../define-plugin';
+import { InfaktCredentialsPanel } from './components/infakt-credentials-panel';
+import { InfaktInvoiceCorrectionFlow } from './components/infakt-invoice-correction-flow';
+import { InfaktInvoiceDetailSection } from './components/infakt-invoice-detail-section';
+import { InfaktStructuredSection } from './components/infakt-structured-section';
+import { infaktSetupRoute } from './infakt-setup.route';
+
+export const infaktPlugin: OpenLinkerPlugin = definePlugin({
+  id: 'infakt',
+  platformType: 'infakt',
+  build: {
+    routes: [infaktSetupRoute],
+  },
+  platform: {
+    displayName: 'inFakt',
+    setupCard: {
+      title: 'inFakt',
+      description: 'Polish accounting platform with native KSeF integration',
+      to: '/connections/new/infakt',
+      badge: 'API key',
+    },
+    StructuredConfigSection: InfaktStructuredSection,
+    CredentialsPanel: InfaktCredentialsPanel,
+    invoiceDetailSection: InfaktInvoiceDetailSection,
+    invoiceCorrectionFlow: InfaktInvoiceCorrectionFlow,
+  },
+});
diff --git a/apps/web/src/plugins/infakt/infakt-setup.route.tsx b/apps/web/src/plugins/infakt/infakt-setup.route.tsx
new file mode 100644
index 000000000..212c826de
--- /dev/null
+++ b/apps/web/src/plugins/infakt/infakt-setup.route.tsx
@@ -0,0 +1,16 @@
+/**
+ * Route: `/connections/new/infakt` — guided inFakt wizard.
+ *
+ * @module plugins/infakt
+ */
+import type { RouteObject } from 'react-router-dom';
+import type { RouteCrumbHandle } from '../../app/nav-registry.types';
+
+export const infaktSetupRoute: RouteObject = {
+  path: 'connections/new/infakt',
+  handle: { crumb: { group: 'Platform', title: 'Connect inFakt' } } satisfies RouteCrumbHandle,
+  lazy: async () => {
+    const { InfaktSetupPage } = await import('../../pages/connections/infakt-setup-page');
+    return { Component: InfaktSetupPage };
+  },
+};
diff --git a/apps/web/src/plugins/ksef/components/ksef-invoice-detail-section.tsx b/apps/web/src/plugins/ksef/components/ksef-invoice-detail-section.tsx
index b973de211..fa963abb3 100644
--- a/apps/web/src/plugins/ksef/components/ksef-invoice-detail-section.tsx
+++ b/apps/web/src/plugins/ksef/components/ksef-invoice-detail-section.tsx
@@ -21,6 +21,7 @@ import type { ReactElement } from 'react';
 import type { InvoiceDetailSectionProps } from '../../../shared/plugins';
 import {
   RegulatoryStatusBadge,
+  regCardToneFor,
   useKsefUpoDownload,
   useKsefUpoPreview,
   useKsefFa3,
@@ -127,7 +128,11 @@ export function KsefInvoiceDetailSection({
 
   return (
     <>
-      <section className="invoice-detail-section invoice-detail-section--ksef">
+      <section
+        className={`invoice-detail-section invoice-detail-section--ksef reg-card ${regCardToneFor(
+          invoice.regulatoryStatus,
+        )}`.trim()}
+      >
         <h4 className="invoice-detail-section__title">
           {t('invoice.ksef.sectionTitle', 'KSeF · National e-Invoicing System')}
         </h4>
diff --git a/apps/web/src/plugins/subiekt/components/subiekt-invoice-detail-section.tsx b/apps/web/src/plugins/subiekt/components/subiekt-invoice-detail-section.tsx
index d6b87548a..9a46382b2 100644
--- a/apps/web/src/plugins/subiekt/components/subiekt-invoice-detail-section.tsx
+++ b/apps/web/src/plugins/subiekt/components/subiekt-invoice-detail-section.tsx
@@ -13,6 +13,7 @@ import { useTranslation } from '../../../shared/i18n';
 import type { InvoiceDetailSectionProps } from '../../../shared/plugins/plugin.types';
 import {
   RegulatoryStatusBadge,
+  regCardToneFor,
   type RegulatoryStatus,
 } from '../../../features/invoicing';
 
@@ -29,7 +30,9 @@ export function SubiektInvoiceDetailSection({
   if (!hasRegulatoryData && !hasPdf) return null;
 
   return (
-    <section className="detail-section">
+    <section
+      className={`detail-section reg-card ${regCardToneFor(invoice.regulatoryStatus)}`.trim()}
+    >
       <h2 className="detail-section__title">
         {t('subiekt.invoice.detail.title', 'Regulatory status')}
       </h2>
diff --git a/apps/web/src/shared/plugins/plugin.types.ts b/apps/web/src/shared/plugins/plugin.types.ts
index e16c60129..2f8736443 100644
--- a/apps/web/src/shared/plugins/plugin.types.ts
+++ b/apps/web/src/shared/plugins/plugin.types.ts
@@ -361,7 +361,8 @@ export interface InvoiceDetailSectionProps {
  */
 export interface InvoiceCorrectionFlowProps {
   invoice: InvoiceRecord;
-  connection: Connection;
+  /** Optional: only KSeF, Subiekt, and inFakt implementers ignore it today. */
+  connection?: Connection;
   onClose: () => void;
   onCorrectionIssued: (correctionInvoiceId: string) => void;
 }
diff --git a/apps/web/src/shared/ui/index.ts b/apps/web/src/shared/ui/index.ts
index e63670467..fdc24c138 100644
--- a/apps/web/src/shared/ui/index.ts
+++ b/apps/web/src/shared/ui/index.ts
@@ -76,3 +76,7 @@ export { BulkActionBar } from './bulk-action-bar';
 export type { BulkActionBarProps } from './bulk-action-bar';
 export { CheckboxCell } from './checkbox-cell';
 export type { CheckboxCellProps } from './checkbox-cell';
+
+// ── Disclosure (#1303) ───────────────────────────────────────────────
+export { InlineDisclosure } from './inline-disclosure';
+export type { InlineDisclosureProps } from './inline-disclosure';
diff --git a/apps/web/src/shared/ui/inline-disclosure.test.tsx b/apps/web/src/shared/ui/inline-disclosure.test.tsx
new file mode 100644
index 000000000..8147dc0e6
--- /dev/null
+++ b/apps/web/src/shared/ui/inline-disclosure.test.tsx
@@ -0,0 +1,57 @@
+import { describe, expect, it } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { InlineDisclosure } from './inline-disclosure';
+
+describe('InlineDisclosure', () => {
+  it('renders the label, value, and Change affordance in the collapsed summary', () => {
+    render(
+      <InlineDisclosure label="Payment method for invoice:" value="Transfer">
+        <p>panel content</p>
+      </InlineDisclosure>,
+    );
+    expect(screen.getByText('Payment method for invoice:')).toBeInTheDocument();
+    expect(screen.getByText('Transfer')).toBeInTheDocument();
+    expect(screen.getByText('Change →')).toBeInTheDocument();
+  });
+
+  it('hides the panel content until expanded', () => {
+    render(
+      <InlineDisclosure label="Payment method for invoice:" value="Transfer">
+        <p>panel content</p>
+      </InlineDisclosure>,
+    );
+    expect(screen.getByText('panel content')).not.toBeVisible();
+  });
+
+  it('reveals the panel content when the summary is clicked', async () => {
+    const user = userEvent.setup();
+    render(
+      <InlineDisclosure label="Payment method for invoice:" value="Transfer">
+        <p>panel content</p>
+      </InlineDisclosure>,
+    );
+
+    await user.click(screen.getByText('Payment method for invoice:'));
+
+    expect(screen.getByText('panel content')).toBeVisible();
+  });
+
+  it('renders open by default when defaultOpen is true', () => {
+    render(
+      <InlineDisclosure label="Payment method for invoice:" value="Transfer" defaultOpen>
+        <p>panel content</p>
+      </InlineDisclosure>,
+    );
+    expect(screen.getByText('panel content')).toBeVisible();
+  });
+
+  it('uses a custom changeLabel when provided', () => {
+    render(
+      <InlineDisclosure label="Payment method for invoice:" value="Transfer" changeLabel="Edit">
+        <p>panel content</p>
+      </InlineDisclosure>,
+    );
+    expect(screen.getByText('Edit →')).toBeInTheDocument();
+  });
+});
diff --git a/apps/web/src/shared/ui/inline-disclosure.tsx b/apps/web/src/shared/ui/inline-disclosure.tsx
new file mode 100644
index 000000000..d6cbe827c
--- /dev/null
+++ b/apps/web/src/shared/ui/inline-disclosure.tsx
@@ -0,0 +1,43 @@
+/**
+ * Inline Disclosure
+ *
+ * Generic "collapsed value with a Change affordance" pattern built on the
+ * native `<details>`/`<summary>` elements (per the UI Library Policy:
+ * prefer native HTML when it covers the use case — no headless library or
+ * custom keyboard handling needed for a disclosure). Shows a label + current
+ * value inline; clicking reveals the panel (typically a form control to
+ * change the value). First consumer: Infakt's default-payment-method field
+ * (#1303) in the connection wizard and edit screen.
+ *
+ * @module shared/ui
+ */
+import type { ReactElement, ReactNode } from 'react';
+
+export interface InlineDisclosureProps {
+  label: string;
+  value: string;
+  children: ReactNode;
+  changeLabel?: string;
+  defaultOpen?: boolean;
+  className?: string;
+}
+
+export function InlineDisclosure({
+  label,
+  value,
+  children,
+  changeLabel = 'Change',
+  defaultOpen = false,
+  className,
+}: InlineDisclosureProps): ReactElement {
+  return (
+    <details className={['inline-disclosure', className].filter(Boolean).join(' ')} open={defaultOpen}>
+      <summary className="inline-disclosure__summary">
+        <span className="inline-disclosure__label">{label}</span>{' '}
+        <span className="inline-disclosure__value">{value}</span>{' '}
+        <span className="inline-disclosure__cta">{changeLabel} →</span>
+      </summary>
+      <div className="inline-disclosure__panel">{children}</div>
+    </details>
+  );
+}
diff --git a/docs/plans/implementation-plan-infakt-fe-plugin.md b/docs/plans/implementation-plan-infakt-fe-plugin.md
new file mode 100644
index 000000000..e84c63218
--- /dev/null
+++ b/docs/plans/implementation-plan-infakt-fe-plugin.md
@@ -0,0 +1,678 @@
+# Implementation Plan: inFakt FE Plugin + Invoice-Section Host Redesign
+
+**Date**: 2026-07-01
+**Status**: Draft
+**Estimated Effort**: 2-3 days
+
+---
+
+## 1. Task Summary
+
+**Objective**: Ship the inFakt frontend plugin (guided connection setup, credentials rotation,
+invoice detail region, KOR correction flow) and, alongside it, a visual redesign of the shared
+`OrderInvoicePanel` regulatory-section host chrome that all three invoicing providers
+(KSeF, Subiekt, inFakt) render into.
+
+**Context**: The inFakt backend (epic #1279) is code-complete on two open PRs — #1292
+(`InfaktInvoicingAdapter` implementing `InvoicingPort` + `RegulatoryStatusReader` +
+`CorrectionIssuer`, hardening + unit tests) and #1293 (plugin registration + webhook
+ingestion, stacked on #1292, still draft). Issue #1282 tracks the FE half and has already
+been updated (this session) to include the correction-flow scope item that was missing from
+the original spec. A design-review mockup was built and approved by the user
+(https://claude.ai/code/artifact/2c542a0c-0719-4db1-b9d0-c962be23dadb, 7 screens) covering
+every screen/state for both pieces of work — this plan turns that approved mockup into an
+execution-ready implementation.
+
+**Classification**: Frontend (`apps/web`). No CORE, Integration, or Infrastructure changes —
+the backend capability surface (`InvoicingPort`, `RegulatoryStatusReader`, `CorrectionIssuer`,
+`POST /invoices/:invoiceId/correct`, `PUT /connections/:id/credentials`) already exists and is
+generic/capability-gated.
+
+---
+
+## 2. Scope & Non-Goals
+
+### In Scope
+
+- New `infakt` plugin under `apps/web/src/plugins/infakt/` (descriptor, invoice-detail-section,
+  correction-flow, structured-config section).
+- Guided single-step connection setup form + page + route
+  (`features/connections/components/infakt-setup-form.tsx` + schema,
+  `pages/connections/infakt-setup-page.tsx`, `plugins/infakt/infakt-setup.route.tsx`) — mirrors
+  the Erli pattern (single `apiKey` credential + optional `baseUrl` config override), **not**
+  the generic inline `CreateConnectionForm` the original issue #1282 text implied (see
+  §7 Alternatives).
+- `InfaktCredentialsPanel` (post-create key rotation) — near-identical port of
+  `ErliCredentialsPanel`.
+- `InfaktStructuredSection` (post-create `baseUrl` edit in `EditConnectionForm`) — near-identical
+  port of `WoocommerceStructuredSection`'s single-field shape.
+- `InfaktInvoiceDetailSection` (regulatory-status region: not-applicable / submitted /
+  accepted / rejected) — reuses the neutral `RegulatoryStatusBadge`; no `cleared` label per the
+  verified `RegulatoryStatusValues` contract (terminal success is `accepted` only, see §4).
+- `InfaktInvoiceCorrectionFlow` (KOR modal) — near-1:1 port of `KsefInvoiceCorrectionFlow`'s
+  line-row model, since both ride the same generic `useIssueCorrectionMutation` +
+  `POST /invoices/:invoiceId/correct` contract.
+- Registration in `apps/web/src/plugins/index.ts`.
+- Two Playwright evidence scripts (`apps/web/e2e/infakt-connection.mjs`,
+  `apps/web/e2e/infakt-invoice.mjs`) run once locally against the real inFakt sandbox, producing
+  `libs/integrations/infakt/docs/assets/*.png` screenshots committed to the branch and posted inline in a PR
+  comment — proof that connecting inFakt and issuing/clearing/correcting a real invoice through
+  OpenLinker actually works end to end, not just that the UI renders (see §6 Phase 4).
+- Redesign of the shared `.invoice-panel__inline-alert` / raw `.slot-row` host chrome in
+  `OrderInvoicePanel` (`features/invoicing/components/order-invoice-panel.tsx`) and the
+  KSeF/Subiekt detail sections' outer chrome, into the "reg-card" treatment validated in
+  mockup screen 07 (severity-stripe card, icon header, progress bar for pending, grouped
+  actions + copyable chip for accepted, proper `Alert`-style callout for rejected). Reuses
+  only existing OKLCH status tokens — no new colors.
+
+### Out of Scope
+
+- Any backend change. #1292/#1293 already ship the full capability surface this plugin
+  consumes.
+- `WebhookProvisioningPort` UI — inFakt's webhook is BE-only per #1293's PR description
+  ("No `WebhookProvisioningPort` … webhook setup is UI-only, per issue scope" — meaning no FE
+  work needed either way).
+- i18n string migration — new strings use `t(key, fallback)` per the existing no-op i18n seam
+  convention; no catalog entries are added (matches every other plugin today).
+- Changing `RegulatoryStatusValues` / adding a `cleared`-distinct UI state — confirmed no
+  provider emits `cleared` today; out of scope for this plan (see §4, §5 Assumptions).
+- A full visual overhaul of unrelated shared UI primitives — the redesign is scoped to the
+  invoice regulatory-section chrome only (§ In Scope), not a broader design-system pass (per
+  saved user feedback: apply incrementally, don't big-bang redesign unprompted).
+
+### Constraints
+
+- Must not introduce a new GitHub issue's worth of backend work — this is FE-only.
+- Branch/PR: single branch `1282-infakt-fe-plugin` (this worktree), single PR closing #1282.
+  The host-panel redesign rides in the same PR (see §7 Alternatives for why a separate issue
+  was filed but not a separate PR).
+- Must pass `pnpm --filter @openlinker/web lint`, `type-check`, `test` before commit.
+
+---
+
+## 3. Architecture Mapping
+
+**Target Layer**: Frontend only — `plugins/`, `features/connections/`, `features/invoicing/`,
+`pages/connections/`.
+
+**Capabilities Involved** (backend, already shipped): `Invoicing` (base port),
+`RegulatoryStatusReader`, `CorrectionIssuer` — all resolved server-side; the FE never
+capability-checks directly, it renders based on neutral `InvoiceRecord.regulatoryStatus` and
+the presence of the plugin's `invoiceCorrectionFlow` / `invoiceDetailSection` slots.
+
+**Existing Services/Hooks Reused** (zero new hooks needed):
+- `useCreateConnectionMutation`, `useTestConnectionMutation`, `useUpdateConnectionCredentialsMutation`
+  (`features/connections`)
+- `useIssueCorrectionMutation`, `RegulatoryStatusBadge` (`features/invoicing` public barrel)
+- `usePlatform` / `usePlatforms` (`shared/plugins`)
+- `definePlugin` (`plugins/define-plugin`)
+
+**New Components Required**:
+- `plugins/infakt/index.ts` (descriptor)
+- `plugins/infakt/infakt-setup.route.tsx`
+- `plugins/infakt/components/infakt-structured-section.tsx`
+- `plugins/infakt/components/infakt-credentials-panel.tsx`
+- `plugins/infakt/components/infakt-invoice-detail-section.tsx`
+- `plugins/infakt/components/infakt-invoice-correction-flow.tsx`
+- `features/connections/components/infakt-setup-form.tsx`
+- `features/connections/components/infakt-setup.schema.ts`
+- `pages/connections/infakt-setup-page.tsx`
+- (redesign) modifications to `features/invoicing/components/order-invoice-panel.tsx` and a new
+  shared `reg-card` CSS block in `index.css`; light edits to `ksef-invoice-detail-section.tsx`
+  and `subiekt-invoice-detail-section.tsx` outer `<section>` wrappers to adopt the new class.
+
+**Core vs Integration Justification**: N/A — no CORE or Integration change. All contract
+surfaces (`InvoiceRecord`, `RegulatoryStatus`, `POST /invoices/:invoiceId/correct`,
+`PUT /connections/:id/credentials`) are pre-existing and generic.
+
+---
+
+## 4. External / Domain Research
+
+### Backend contract (verified against `1280-infakt-plugin-hardening-tests` branch, PR #1292)
+
+- `InfaktCredentials = { apiKey: string }`, `InfaktConnectionConfig = { baseUrl?: string }`
+  (`libs/integrations/infakt/src/domain/types/infakt-connection.types.ts`) — confirms issue
+  #1282's field list is accurate and minimal.
+- `InfaktInvoicingAdapter implements InvoicingPort, RegulatoryStatusReader, CorrectionIssuer` —
+  `issueCorrection` is real, confirming the correction-flow scope item added to #1282 this
+  session is backed by working code, not speculative.
+- adapterKey: `infakt.accounting.v1` (per epic #1279 / PR #1293 description).
+
+### Neutral invoicing contract (verified against `apps/web/src/features/invoicing/api/invoicing.types.ts`, current main)
+
+- `RegulatoryStatusValues = ['not-applicable', 'submitted', 'cleared', 'accepted', 'rejected']`
+  but the file's own doc-comment states: *"Terminal success is `accepted`… `cleared` is
+  reserved for split-clearance regimes and no current provider emits it, so the FE never
+  renders a `cleared` success label."* This **corrects** one of the mockup's open design
+  questions (mockup screen 04 flagged uncertainty between `cleared` vs `accepted`) — the
+  answer is: **only `accepted` gets the success/UPO-style treatment; `cleared` needs no
+  distinct UI in this plan.**
+- `InvoiceRecord` has no seller/buyer/line-item fields — confirmed by the mockup agent's own
+  research; `InfaktInvoiceDetailSection` renders only from `clearanceReference`,
+  `providerInvoiceNumber`, `regulatoryStatus`, `failureReason`.
+- `POST /invoices/:invoiceId/correct` body: `{ reason?, lines: [{ originalLineNumber,
+  newQuantity?, newUnitPriceGross? }], idempotencyKey? }` — identical shape KSeF already uses;
+  `InfaktInvoiceCorrectionFlow` needs no new types.
+
+### Internal patterns (verified by reading current-main source, this session)
+
+- **Setup flow**: every FE plugin with a non-OAuth single/few-credential shape (Erli is the
+  closest analog to inFakt: one `apiKey` + optional `baseUrl`) ships a guided route
+  (`plugins/<name>/<name>-setup.route.tsx`) → page (`pages/connections/<name>-setup-page.tsx`)
+  → form (`features/connections/components/<name>-setup-form.tsx` + `.schema.ts`). The
+  `PlatformPicker` component (`features/connections/components/platform-picker.tsx`) always
+  navigates via `setupCard.to` to that dedicated route — there is **no** inline generic-form
+  path for a plugin with a `setupCard` (the generic `CreateConnectionForm`'s raw-JSON path is
+  reserved for platforms with no plugin at all, or the `/connections/new/advanced` escape
+  hatch). This is a **correction to issue #1282's original text**, which implied wiring
+  `StructuredConfigSection` into the generic create form — the actual codebase convention is
+  the guided-form pattern. Erli's `ErliSetupForm` (`features/connections/components/erli-setup-form.tsx`)
+  + `erli-setup.schema.ts` are the reference implementation to port almost verbatim.
+- **Credentials rotation**: `ErliCredentialsPanel` is the exact single-`apiKey` analog (KSeF's
+  panel additionally rotates an `authType` enum, which inFakt doesn't have).
+- **Post-create structured-edit**: `WoocommerceStructuredSection`'s single-field `siteUrl`
+  shape is the closest analog for editing `baseUrl` after creation via `EditConnectionForm`
+  (Erli deliberately skips this and falls back to raw JSON — inFakt keeps it per #1282's
+  explicit ask, and the field count is the same as WooCommerce's, so the precedent is sound).
+- **Invoice detail section**: `SubiektInvoiceDetailSection` is the simpler analog (badge + KV
+  rows, no dialog); `KsefInvoiceDetailSection` shows the same shape plus UPO/FA(3) dialogs that
+  inFakt does not need (inFakt has no UPO/FA3 endpoints — it only reports KSeF status +
+  `clearanceReference`, matching Subiekt's posture more closely than KSeF's). **Decision**:
+  base `InfaktInvoiceDetailSection` on `SubiektInvoiceDetailSection`'s structure (badge + KV,
+  no dialogs), not KSeF's.
+- **Correction flow**: `KsefInvoiceCorrectionFlow` (`plugins/ksef/components/ksef-invoice-correction-flow.tsx`)
+  is the exact contract match (`InvoiceCorrectionFlowProps`, `useIssueCorrectionMutation`,
+  same line-row model) — port near-verbatim, only the section title / copy changes.
+  `SubiektInvoiceCorrectionFlow` exists too and is worth a quick diff-check during
+  implementation in case it diverged from KSeF's in a way worth adopting, but KSeF is the
+  primary reference since the mockup was built against it.
+- **`OrderInvoicePanel` current host chrome** (verified by reading the full current
+  implementation): it is **already more polished than the mockup's "before" baseline assumed**
+  — it has `InvoiceStatusBadge` + `RegulatoryStatusBadge` in the header, a real
+  `.invoice-panel__inline-alert` component for `failed`/`in-doubt` (colored bar + bold title +
+  body), and a proper KV block for `issued`. The redesign's real value-add is: (a) a dedicated
+  card treatment for the *provider's own* `invoiceDetailSection` slot content (today it's a
+  bare `<section>` inside the KV block, mockup's "after" wraps it in a severity-stripe card),
+  and (b) consistent iconography + a progress bar for the `submitted`/pending window. Plan
+  scope is narrowed accordingly — see Phase 2 below.
+
+---
+
+## 5. Questions & Assumptions
+
+### Open Questions
+
+- Setup-card icon/monogram and its color (mockup open item #1/#2) — no existing plugin uses an
+  icon badge on its setup card (KSeF, Erli, WooCommerce all use title + `badge` chip only).
+  **Default**: drop the invented "iF" monogram, match the established title+badge-chip
+  convention exactly (no icon) unless the user says otherwise.
+- Whether the host-panel redesign should also touch `not-issued` / `pending` / `issuing` /
+  `failed` / `in-doubt` panel states beyond the provider-slot card, or stay narrowly scoped to
+  the provider `invoiceDetailSection` region. **Default**: narrow scope — only the provider
+  slot's card wrapper + its internal submitted/accepted/rejected states change; the panel's
+  own `not-issued`/`pending`/`issuing`/`failed`/`in-doubt` states (which are already
+  well-designed per §4) are left untouched in this plan.
+
+### Assumptions
+
+- `cleared` needs no distinct UI (confirmed in §4 — safe default, not a guess).
+- inFakt has no PDF/UPO/FA3-equivalent document to surface — only `clearanceReference` /
+  `providerInvoiceNumber` / `failureReason`. If this turns out wrong once #1292/#1293 merge
+  and a real sandbox response is inspected, `InfaktInvoiceDetailSection` is a single small
+  component to extend later — not a blocking assumption.
+- The host-panel redesign is CSS/markup-only — no new props on `InvoiceDetailSectionProps` /
+  `InvoiceCorrectionFlowProps` are needed. The card wrapper can be added by `OrderInvoicePanel`
+  around the slot's rendered output without changing the slot contract, since the slot already
+  renders a self-contained `<section>` (see `SubiektInvoiceDetailSection`) — the host can wrap
+  that section in a `.reg-card` div, or the redesign can standardize each section's own root
+  class name to `reg-card` directly. **Decision**: change the section components' own root
+  class (KSeF, Subiekt, inFakt all switch to `reg-card` + a `--tone` modifier) rather than
+  double-wrapping from the host, since the section owns its own semantic content (title, rows)
+  and is best positioned to know its own severity tone.
+
+### Documentation Gaps
+
+- None — `docs/frontend-architecture.md` § Platform Plugins fully documents the slot contract;
+  the guided-setup-route pattern isn't written down as a named convention anywhere, it only
+  exists as consistent precedent across 6+ plugins. Worth a follow-up doc note, out of scope
+  for this plan.
+
+---
+
+## 6. Proposed Implementation Plan
+
+### Phase 1: inFakt plugin — connection lifecycle
+
+**Goal**: An operator can create, view, and rotate credentials for an inFakt connection.
+
+**Steps**:
+
+1. **Setup schema**
+   - **File**: `apps/web/src/features/connections/components/infakt-setup.schema.ts`
+   - **Action**: Port `erli-setup.schema.ts` verbatim, renaming `ERLI_ADAPTER_KEY` →
+     `INFAKT_ADAPTER_KEY = 'infakt.accounting.v1'`, `platformType: 'infakt'`. Keep the same
+     `name` / `apiKey` / `baseUrl` (https-only, optional) Zod shape.
+   - **Acceptance**: `infaktSetupSchema` exports match Erli's shape 1:1 minus naming.
+
+2. **Setup form**
+   - **File**: `apps/web/src/features/connections/components/infakt-setup-form.tsx`
+   - **Action**: Port `erli-setup-form.tsx` verbatim, swap copy ("inFakt" / "API key from your
+     inFakt account settings" instead of "Shop API key" / seller-panel copy), swap the
+     `BackLink` target stays `/connections/new`, swap toast copy.
+   - **Acceptance**: form renders name/apiKey/baseUrl fields, submit creates the connection via
+     `useCreateConnectionMutation`, shows "Test connection" affordance after create (reuses
+     `useTestConnectionMutation` — no changes needed there).
+
+3. **Setup page + route**
+   - **Files**: `apps/web/src/pages/connections/infakt-setup-page.tsx`,
+     `apps/web/src/plugins/infakt/infakt-setup.route.tsx`
+   - **Action**: Port `erli-setup-page.tsx` / `erli-setup.route.tsx` verbatim with inFakt copy
+     and path `connections/new/infakt`.
+   - **Acceptance**: navigating to `/connections/new/infakt` renders the page with the form.
+
+4. **Credentials panel**
+   - **File**: `apps/web/src/plugins/infakt/components/infakt-credentials-panel.tsx`
+   - **Action**: Port `ErliCredentialsPanel` verbatim (single `apiKey` rotate, same
+     `credentialsBacked` fallback).
+   - **Acceptance**: matches `erli-credentials-panel.test.tsx`'s five assertions when ported
+     to an `infakt-credentials-panel.test.tsx` (see Phase 4).
+
+5. **Structured config section (post-create `baseUrl` edit)**
+   - **File**: `apps/web/src/plugins/infakt/components/infakt-structured-section.tsx`
+   - **Action**: Port `WoocommerceStructuredSection`'s single-field pattern, one `FormField`
+     for `baseUrl` bound via `syncStructuredToJson('baseUrl', value)`, helper text explaining
+     sandbox vs. production (per issue #1282's original ask).
+   - **Acceptance**: editing an existing inFakt connection's `baseUrl` in `EditConnectionForm`
+     round-trips through `configText` JSON correctly (mirror
+     `woocommerce-structured-section.test.tsx`'s assertions).
+
+### Phase 2: inFakt plugin — invoice surfacing
+
+**Goal**: Regulatory status and KOR corrections are visible/actionable on an inFakt-issued
+invoice, using the redesigned host chrome.
+
+**Steps**:
+
+6. **Redesign the provider-slot host chrome** (do this before wiring inFakt's own section, so
+   inFakt is born with the new look and KSeF/Subiekt get it as a drive-by improvement)
+   - **Files**:
+     - `apps/web/src/index.css` — new bounded section `/* ── Regulatory section card (#1282) ── */`
+       adding `.reg-card`, `.reg-card--info` / `.reg-card--success` / `.reg-card--error`
+       (severity-stripe via `border-left` + existing `--status-*` tokens, no new colors),
+       `.reg-card__header` (icon + title row), `.reg-card__progress` (indeterminate bar for
+       `submitted`), `.reg-card__summary` (accepted: reference chip + grouped actions).
+     - `apps/web/src/plugins/ksef/components/ksef-invoice-detail-section.tsx` — change the root
+       `<section className="invoice-detail-section invoice-detail-section--ksef">` to also
+       carry `reg-card reg-card--{tone}` (tone derived from `regulatoryStatus`: `submitted` →
+       info, `accepted` → success, `rejected` → error, `not-applicable`/other → no card, keep
+       returning `null`).
+     - `apps/web/src/plugins/subiekt/components/subiekt-invoice-detail-section.tsx` — same
+       root-class change.
+   - **Acceptance**: existing KSeF/Subiekt detail-section tests still pass unchanged (class
+     name is additive, not a DOM restructure) — run
+     `pnpm --filter @openlinker/web test ksef-invoice-detail-section subiekt-invoice-detail-section`
+     to confirm no visual-only test asserts the old class name exclusively.
+   - **Risk**: if any existing test asserts `container.querySelector('.invoice-detail-section')`
+     exactly, keep that class alongside the new one (additive) rather than replacing it — see
+     §8 Risks.
+
+7. **Invoice detail section**
+   - **File**: `apps/web/src/plugins/infakt/components/infakt-invoice-detail-section.tsx`
+   - **Action**: Base on `SubiektInvoiceDetailSection`'s structure (badge + KV rows, no
+     dialogs), applying the new `reg-card` root class from step 6 directly (inFakt ships with
+     the redesigned look from day one — no "before" version to migrate). Render:
+     - `not-applicable` → return `null` (no card)
+     - `submitted` → `reg-card--info`, `RegulatoryStatusBadge`, progress bar, "Pending KSeF
+       clearance…" copy
+     - `accepted` → `reg-card--success`, `RegulatoryStatusBadge`, KV row with
+       `clearanceReference` (copyable — reuse existing copy-to-clipboard affordance if one
+       exists in `shared/ui`, else a plain `<code>` + a small "Copy" button using
+       `navigator.clipboard.writeText`)
+     - `rejected` → `reg-card--error`, `RegulatoryStatusBadge`, `failureReason` text
+   - **Acceptance**: matches mockup screen 04's four states exactly; unit test covers all four
+     `regulatoryStatus` values plus the `not-applicable` no-render case.
+
+8. **Correction flow**
+   - **File**: `apps/web/src/plugins/infakt/components/infakt-invoice-correction-flow.tsx`
+   - **Action**: Port `KsefInvoiceCorrectionFlow` near-verbatim (per the issue #1282 update
+     made this session) — same line-row model (`originalLineNumber` / `newQuantity` /
+     `newUnitPriceGross`), one empty row + "Add line", reuses
+     `useIssueCorrectionMutation` from `features/invoicing`. Swap only the dialog title/copy
+     to inFakt-specific wording.
+   - **Acceptance**: matches `ksef-invoice-correction-flow.test.tsx`'s assertions 1:1 when
+     ported (empty-row start, add-line, validation, submit success/error).
+
+### Phase 3: Registration
+
+**Steps**:
+
+9. **Plugin descriptor**
+   - **File**: `apps/web/src/plugins/infakt/index.ts`
+   - **Action**:
+     ```typescript
+     export const infaktPlugin: OpenLinkerPlugin = definePlugin({
+       id: 'infakt',
+       platformType: 'infakt',
+       build: { routes: [infaktSetupRoute] },
+       platform: {
+         displayName: 'inFakt',
+         setupCard: {
+           title: 'inFakt',
+           description: 'Polish accounting platform with native KSeF integration',
+           to: '/connections/new/infakt',
+           badge: 'API key',
+         },
+         StructuredConfigSection: InfaktStructuredSection,
+         CredentialsPanel: InfaktCredentialsPanel,
+         invoiceDetailSection: InfaktInvoiceDetailSection,
+         invoiceCorrectionFlow: InfaktInvoiceCorrectionFlow,
+       },
+     });
+     ```
+   - **Acceptance**: `assertUniquePluginInvariants` passes with the new entry (no id/platformType
+     collision — trivially true, `infakt` is new).
+
+10. **Barrel registration**
+    - **File**: `apps/web/src/plugins/index.ts`
+    - **Action**: add `import { infaktPlugin } from './infakt';` and append to the `plugins`
+      array (position: after `subiektPlugin`, before `ksefPlugin`, keeping the existing
+      invoicing-providers-last-ish grouping — exact order doesn't affect correctness, only
+      setup-card display order).
+    - **Acceptance**: `/connections/new` shows the inFakt card; `pnpm --filter @openlinker/web test`
+      green (covers the module-load duplicate-id/platformType assertion).
+
+### Phase 4: E2E Playwright verification + screenshot evidence
+
+**Goal**: Prove, with real browser screenshots against a running local stack + the real inFakt
+sandbox, that an operator can connect inFakt and issue a real invoice through OpenLinker end to
+end (OL → `InfaktInvoicingAdapter` → inFakt sandbox API → KSeF) — not just that the components
+render. Follows the exact precedent already established for Subiekt/Erli
+(`apps/web/e2e/subiekt-invoice.mjs`, `apps/web/e2e/subiekt-proofs.mjs`): plain Playwright `.mjs`
+scripts (not `*.spec.ts` — these are one-off evidence-capture walkthroughs, not part of `pnpm test`),
+run manually against `pnpm --filter @openlinker/web preview` (port 4173), saving screenshots to
+`libs/integrations/infakt/docs/assets/` and committing them to the PR branch (the established convention — see
+`docs/assets/subiekt/*.png`, already tracked in git).
+
+**Presentation requirement (these screenshots get reused verbatim in the operator-facing setup
+guide later, so they must be clean, not just functional)**:
+- **Never let a real secret render in cleartext.** The API-key field is `type="password"`, so
+  the input itself already renders masked dots on screen — the script must NOT temporarily
+  switch it to `type="text"` to "show" the key for the screenshot, and must not print the raw
+  key to stdout/logs. The credentials-panel's masked-key display (last 4 chars) is the only
+  place a fragment of the real key may be visible, which is the same posture every other
+  provider's docs already use.
+- **No placeholder junk in frame.** Use a realistic connection name (e.g. "inFakt — Production"
+  or "inFakt Sandbox", not "test test 123" / "asdf"), a real-looking order (an actual seeded
+  order from the dev stack, not a manually-typed dummy), and let toasts/alerts resolve to their
+  final state before the shot (`shot()`'s existing `waitForTimeout` already does this — don't
+  skip it to go faster). If the sandbox API key itself is a throwaway sandbox credential (not a
+  production secret), that's fine to type into the form — the concern is the *rendered pixels*,
+  not the credential's sensitivity tier.
+- Review each `libs/integrations/infakt/docs/assets/*.png` by eye before committing — if any frame looks like a
+  debug/dev artifact (raw JSON dump, console error toast, `localhost:3000` visibly in a URL bar
+  that shouldn't be there, lorem-ipsum text), redo that step rather than shipping it as-is.
+
+**Steps**:
+
+11. **Connection walkthrough script**
+    - **File**: `apps/web/e2e/infakt-connection.mjs`
+    - **Action**: Port `subiekt-invoice.mjs`'s login/shot helper pattern. Drive: `/connections/new`
+      → click inFakt card → fill a realistic name + real sandbox API key (from environment/local
+      secrets — **never hardcode the sandbox key in the script or commit it**; read via
+      `process.env.INFAKT_SANDBOX_API_KEY`) → submit → "Test connection" → connection list showing
+      the new `infakt` connection. Capture one screenshot per step into
+      `libs/integrations/infakt/docs/assets/{00..05}-*.png`. Per the presentation requirement above: the API-key
+      field stays masked throughout, and the connection-list shot only ever shows the panel's
+      standard masked/last-4-chars rendering — never the full key.
+    - **Acceptance**: running the script against a local `pnpm --filter @openlinker/web preview`
+      + `pnpm start:dev:api` stack with real sandbox credentials produces a green "Connection test
+      passed" screenshot, with no cleartext secret visible in any frame.
+
+12. **Invoice issuance walkthrough script**
+    - **File**: `apps/web/e2e/infakt-invoice.mjs`
+    - **Action**: Port `subiekt-invoice.mjs`'s `issueFlow` near-verbatim: open a real ingested
+      order → invoice panel not-issued state → click "Issue invoice" → wait for the real
+      OL → inFakt → KSeF round-trip → capture the `submitted` reg-card, then poll/reload until
+      `regulatoryStatus` flips to `accepted` (KSeF clearance in sandbox is ~90s per the earlier
+      feasibility POC finding) and capture the `accepted` reg-card with the clearance reference
+      chip. Also drive "Issue correction" once on the accepted invoice to capture the KOR modal
+      states + the resulting corrected-document row on `/invoices`.
+    - **Acceptance**: screenshots exist proving (a) invoice issued, (b) KSeF clearance reached
+      `accepted` through the real sandbox (not mocked), (c) a correction was issued successfully.
+      This is the concrete "we can issue an invoice through OpenLinker and inFakt" confirmation
+      the user asked for.
+
+13. **Screenshot evidence in the PR**
+    - **Action**: After both scripts run successfully and `libs/integrations/infakt/docs/assets/*.png` are
+      committed to the branch, post a PR comment (via `gh pr comment`) embedding the screenshots
+      as markdown images referencing
+      `https://raw.githubusercontent.com/openlinker-project/openlinker/1282-infakt-fe-plugin/libs/integrations/infakt/docs/assets/{name}.png`
+      — the same raw-content-URL technique the repo already relies on for rendering
+      `docs/assets/*` images works here too, because the files are committed to the PR's own
+      branch, so the images render inline in the GitHub comment UI with no external upload step.
+      Structure the comment as a short walkthrough: setup → issue → clearance → correction, one
+      image per step with a one-line caption.
+    - **Acceptance**: the PR has a comment with inline-rendered screenshots covering the full
+      connect → issue → clear → correct flow.
+
+### Implementation Details
+
+**New Components**: listed in §3 above — all `apps/web`, no domain/application/infrastructure
+layers touched (this is a pure-FE plan).
+
+**Configuration Changes**: none (no new env vars — inFakt's `baseUrl` is a per-connection
+config field, not a build-time var).
+
+**Database Migrations**: none.
+
+**Events**: none emitted or consumed — this is synchronous CRUD + query/mutation hooks only.
+
+**Error Handling**: reuses existing `ApiError` normalization (`useCreateConnectionMutation`,
+`useUpdateConnectionCredentialsMutation`, `useIssueCorrectionMutation` all already surface
+`.error` for the form/panel to render via `Alert`). No new error types.
+
+---
+
+## 7. Alternatives Considered
+
+### Alternative 1: Wire `StructuredConfigSection` into the generic `CreateConnectionForm` (issue #1282's literal text)
+
+- **Description**: Skip the guided setup route/page/form and rely on the generic
+  `/connections/new` inline form (raw JSON config + credentials JSON) with inFakt's
+  `StructuredConfigSection` swapped in.
+- **Why Rejected**: Verified against the actual `CreateConnectionForm` + `PlatformPicker`
+  source: every plugin with a `setupCard` unconditionally navigates to its own dedicated route
+  via `setupCard.to` — there is no live code path where `StructuredConfigSection` renders
+  inside the generic form for a plugin that also has a `setupCard`. Issue #1282's text
+  described a shape that doesn't match any existing plugin's actual wiring. Following the
+  guided-route pattern (Erli is the near-identical analog: one credential + optional advanced
+  URL) is both correct and less work per-field than reproducing the generic form's raw-JSON UX.
+- **Trade-offs**: none of substance — the guided-form approach is strictly better UX
+  (dedicated instructional copy, inline "Test connection" affordance) and is what every
+  comparable plugin already does.
+
+### Alternative 2: Open a separate PR (and possibly a separate issue) for the host-panel redesign
+
+- **Description**: File a standalone issue + PR for the `reg-card` redesign, keep the inFakt
+  plugin PR narrowly scoped to #1282.
+- **Why Rejected**: The redesign's only realistic motivation right now is "inFakt's new
+  section should look like the approved mockup" — splitting it into a separate PR would mean
+  either (a) inFakt ships with the *old* bare-section look first and gets restyled later
+  (churn, two review passes on the same lines), or (b) the redesign PR has to land first and
+  block inFakt for no benefit. Per the user's saved preference (single PR for plan +
+  implementation; apply UI-redesign direction incrementally as related work touches each
+  component — not as a big-bang), bundling the two is more consistent with how this specific
+  redesign was scoped: as *inFakt's* section design, generalized to its two existing siblings
+  as a drive-by improvement since they share one CSS class contract.
+- **Trade-offs**: the PR diff is slightly larger (touches 2 existing provider sections instead
+  of 0) and a reviewer sees an unrelated-looking CSS section in an "inFakt plugin" PR — mitigated
+  by a clear PR description section explaining the redesign is additive/non-breaking and
+  why it's bundled.
+
+---
+
+## 8. Validation & Risks
+
+### Architecture Compliance
+
+- ✅ No CORE/Integration/Infrastructure changes — pure `apps/web` work.
+- ✅ Dependency direction respected: `plugins/infakt/*` imports only `features/invoicing`,
+  `features/connections` (public barrels) and `shared/*`; the setup form itself lives in
+  `features/connections/components/` per the established convention (pages deep-import it,
+  which is a documented, accepted gap — see `docs/frontend-architecture.md` § Feature Public
+  Surface, "Out of scope today").
+- ✅ No plugin does `platformType === 'infakt'` string comparison anywhere outside
+  `plugins/infakt/` — all cross-cutting logic stays capability/slot-driven.
+
+### Naming Conventions
+
+- ✅ Components: `kebab-case.tsx` files, `PascalCase` exports (`InfaktCredentialsPanel`, etc.)
+- ✅ Hooks: none new.
+- ✅ Route module: `infakt-setup.route.tsx`.
+- ✅ Tests: `*.test.tsx` colocated.
+
+### Existing Patterns
+
+- ✅ Guided setup flow matches Erli precedent exactly.
+- ✅ Credentials panel matches Erli precedent exactly.
+- ✅ Structured section matches WooCommerce precedent exactly.
+- ✅ Correction flow matches KSeF precedent exactly (mandated by the shared backend contract).
+
+### Risks
+
+- **Redesign regresses existing KSeF/Subiekt visual tests**: mitigated by making the class
+  change additive (keep old class, add new) rather than a replace, and running the existing
+  test suites for both sections before considering Phase 2 Step 6 done (see acceptance
+  criteria in Step 6).
+- **`baseUrl` sandbox-override semantics unclear to operators**: mitigated by the helper text
+  specified in Phase 1 Step 5 (explicit "leave blank for production" copy), matching Erli's
+  and Woo's existing helper-text conventions.
+- **inFakt sandbox response shape for `clearanceReference` diverges from assumption**: low
+  risk (assumption documented in §5, cheap to fix — one component, no contract change needed)
+  since the neutral `InvoiceRecord` shape is already fixed regardless of provider.
+
+### Edge Cases
+
+- Connection with `credentialsBacked: false` (env-var-backed) → `InfaktCredentialsPanel` falls
+  back to the disabled read-only input, matching Erli's tested behavior exactly.
+- Multiple active inFakt connections → already handled by `OrderInvoicePanel`'s existing
+  connection-picker logic (`selectInvoicingConnections`), no inFakt-specific change needed.
+- `regulatoryStatus === 'cleared'` (never emitted today per §4) → `InfaktInvoiceDetailSection`
+  should not crash if it ever appears; treat as a no-card/no-render fallback identical to
+  `not-applicable` (safe default, matches the "FE never renders a cleared label" contract).
+
+### Backward Compatibility
+
+- ✅ No breaking changes — additive plugin registration, additive CSS classes, no changes to
+  `InvoiceDetailSectionProps` / `InvoiceCorrectionFlowProps` / any exported type.
+
+---
+
+## 9. Testing Strategy & Acceptance Criteria
+
+### Unit Tests
+
+- `apps/web/src/features/connections/components/infakt-setup-form.test.tsx` — port
+  `erli-setup-form`'s test suite shape if one exists (check during implementation; if Erli's
+  form has no dedicated test file, write one covering: renders fields, submit calls
+  `createConnection.mutateAsync` with the right payload, shows test-connection affordance
+  after create).
+- `apps/web/src/features/connections/components/infakt-setup.schema.test.ts` (if Erli's schema
+  has one — port it) — validates `apiKey` required, `baseUrl` optional/https-only.
+- `apps/web/src/plugins/infakt/components/infakt-credentials-panel.test.tsx` — port
+  `erli-credentials-panel.test.tsx`'s 5 cases verbatim (renders rotate affordance, env-backed
+  fallback, sends new apiKey + toast, disables save while empty, collapses after success).
+- `apps/web/src/plugins/infakt/components/infakt-structured-section.test.tsx` — port
+  `woocommerce-structured-section.test.tsx`'s applicable cases (renders field, propagates via
+  `syncStructuredToJson`, disables when `!configIsParseable`, shows validation error).
+- `apps/web/src/plugins/infakt/components/infakt-invoice-detail-section.test.tsx` — new: one
+  case per `RegulatoryStatus` value (`not-applicable` → null, `submitted` → pending copy +
+  progress bar, `accepted` → clearance reference chip, `rejected` → failure reason visible).
+- `apps/web/src/plugins/infakt/components/infakt-invoice-correction-flow.test.tsx` — port
+  `ksef-invoice-correction-flow.test.tsx`'s cases verbatim.
+- `apps/web/src/plugins/index.test.ts` (existing suite, if present covering plugin count/ids) —
+  update expected count / add `infakt` to any hardcoded id list.
+- Redesign regression: re-run `ksef-invoice-detail-section.test.tsx` and
+  `subiekt-invoice-detail-section.test.tsx` unmodified — must stay green after the additive
+  class change.
+
+### Integration Tests
+
+- None needed — no backend/API changes; existing `apps/api` int-specs for
+  `/connections`, `/invoices/*` already cover the generic endpoints this plugin calls.
+
+### E2E Verification (Phase 4)
+
+- `apps/web/e2e/infakt-connection.mjs` and `apps/web/e2e/infakt-invoice.mjs` — manual-run
+  Playwright walkthroughs (not part of `pnpm test` / CI), run once against a live local stack
+  + the real inFakt sandbox before opening the PR. Produces `libs/integrations/infakt/docs/assets/*.png`,
+  committed to the branch, then posted as an inline-image PR comment (§6 Phase 4 Step 13).
+  This is the one part of the plan that requires real external sandbox credentials and a
+  running `pnpm start:dev:api` + `pnpm --filter @openlinker/web preview` stack — everything
+  else in this plan is verified by `pnpm test` alone.
+
+### Mocking Strategy
+
+- All tests use `createMockApiClient()` / `renderWithProviders()` from
+  `apps/web/src/test/test-utils.tsx` per the existing convention — no real network calls, no
+  new mocking infrastructure needed.
+
+### Acceptance Criteria
+
+- [ ] `pnpm --filter @openlinker/web lint` passes
+- [ ] `pnpm --filter @openlinker/web type-check` passes
+- [ ] `pnpm --filter @openlinker/web test` passes (all new + all existing invoicing/connections
+  suites)
+- [ ] `/connections/new` shows the inFakt card (title "inFakt", badge "API key", no icon)
+- [ ] Selecting the inFakt card navigates to `/connections/new/infakt` and shows the guided form
+- [ ] Empty API key on submit shows a validation error, no request sent
+- [ ] Successful create shows the connection in the list with `infakt` platformType, offers
+  "Test connection"
+- [ ] Editing an existing inFakt connection shows the masked-key credentials panel + rotate,
+  and the `baseUrl` structured field
+- [ ] An inFakt invoice with `regulatoryStatus: 'submitted'` shows the info-tone reg-card with
+  a progress indicator
+- [ ] An inFakt invoice with `regulatoryStatus: 'accepted'` shows the success-tone reg-card
+  with a copyable `clearanceReference`
+- [ ] An inFakt invoice with `regulatoryStatus: 'rejected'` shows the error-tone reg-card with
+  `failureReason` visible
+- [ ] "Issue correction" opens the KOR modal with one empty line row + "Add line"; missing
+  line number blocks submit; success closes the dialog + refetches the invoice
+- [ ] KSeF and Subiekt invoice-detail-section existing tests remain green after the redesign
+- [ ] `libs/integrations/infakt/docs/assets/*.png` exist proving a real sandbox connection + issuance + KSeF
+  clearance (`accepted`) + a correction, captured via `infakt-connection.mjs` / `infakt-invoice.mjs`
+- [ ] The PR has a comment with those screenshots rendered inline (raw.githubusercontent.com
+  image links against the PR branch)
+
+---
+
+## 10. Alignment Checklist
+
+- [x] Follows hexagonal architecture (N/A — pure FE, no layer violations introduced)
+- [x] Respects CORE vs Integration boundaries (no CORE/Integration touched)
+- [x] Uses existing patterns (Erli setup flow, WooCommerce structured section, KSeF/Subiekt
+  detail sections and correction flow — all ported, not invented)
+- [x] Idempotency considered (correction submit reuses the existing idempotency-keyed mutation;
+  no new mutating flow introduced)
+- [ ] Event-driven patterns used where applicable — N/A, no events in this slice
+- [ ] Rate limits & retries addressed — N/A, no new external calls (all via existing generic
+  connection/invoice endpoints)
+- [x] Error handling comprehensive (reuses existing `ApiError` + `Alert` patterns throughout)
+- [x] Testing strategy complete (§9)
+- [x] Naming conventions followed (§8)
+- [x] File structure matches standards (§3, §6)
+- [x] Plan is execution-ready
+- [x] Plan is saved as markdown file
+
+---
+
+## Related Documentation
+
+- [Frontend Architecture](../frontend-architecture.md)
+- [Engineering Standards](../engineering-standards.md)
+- [Testing Guide](../testing-guide.md)
+- [Code Review Guide](../code-review-guide.md)
+- Mockup artifact: https://claude.ai/code/artifact/2c542a0c-0719-4db1-b9d0-c962be23dadb
+- Issue #1282 (FE plugin, correction-flow scope added 2026-07-01)
+- PR #1292 (backend hardening), PR #1293 (backend registration + webhook, draft)
diff --git a/docs/plans/implementation-plan-infakt-pdf-download.md b/docs/plans/implementation-plan-infakt-pdf-download.md
new file mode 100644
index 000000000..a38949b95
--- /dev/null
+++ b/docs/plans/implementation-plan-infakt-pdf-download.md
@@ -0,0 +1,82 @@
+# Implementation Plan — Infakt real PDF download (#1321)
+
+## 1. Task
+
+Fix `InfaktInvoicingAdapter`'s always-null `pdfUrl` by implementing the existing
+`RegulatoryDocumentReader` sub-capability against Infakt's real PDF endpoint
+(`GET /invoices/{uuid}/pdf.json?document_type=original&invoice_type={kind}`,
+verified live against the sandbox). Wire the FE Infakt invoice detail section to
+the already-existing `GET /invoices/:invoiceId/document?kind=rendered` route.
+
+**Layer**: Integration (Infakt adapter) + Frontend (Infakt plugin detail section).
+**Non-goals**: no new sub-capability, no new controller route (the `/document`
+route + `isRegulatoryDocumentReader` dispatch already exist and are unchanged),
+no operator-configurable `document_type` (hardcode `'original'` for v1), no
+change to Subiekt's `pdfUrl` usage (out of scope — Subiekt is FE-only today and
+untouched by this fix).
+
+## 2. Decision: keep `InvoiceRecord.pdfUrl`
+
+Subiekt's FE detail section (`apps/web/src/plugins/subiekt/components/subiekt-invoice-detail-section.tsx`)
+still reads `invoice.pdfUrl` for its own (separate, unverified) PDF link. Removing
+the field core-wide would break that component's types for no benefit to this
+issue's scope. **Decision: keep `pdfUrl` on `InvoiceRecord`, but stop Infakt from
+populating it with a nonexistent field** — pass `null` explicitly at the 3 call
+sites, with a comment explaining Infakt's real PDF path is now
+`RegulatoryDocumentReader.getRegulatoryDocument(record, 'rendered')`, not this
+field. Also drop the dead `print_url` field from the Infakt DTO type (never read).
+
+## 3. Backend changes
+
+1. `libs/integrations/infakt/src/infrastructure/http/infakt-http-client.interface.ts`
+   — add `getBinary(path, query?): Promise<{ data: Uint8Array; contentType: string }>`.
+2. `libs/integrations/infakt/src/infrastructure/http/infakt-http-client.ts`
+   — implement `getBinary` via `fetch` + a capped streaming read (mirrors
+   `KsefHttpClient.readBinaryBodyCapped`'s 10 MB cap — same defense-in-depth
+   rationale: never fully buffer a mendacious/oversized body).
+3. `libs/integrations/infakt/src/domain/types/infakt.types.ts` — remove the dead
+   `pdf_url` / `print_url` fields from `InfaktInvoice`.
+4. `libs/integrations/infakt/src/infrastructure/adapters/infakt-invoicing.adapter.ts`
+   — add `RegulatoryDocumentReader` to the `implements` clause; implement
+   `getRegulatoryDocument(record, kind)`: throws `UnsupportedRegulatoryDocumentKindError`
+   for any kind other than `'rendered'` (Infakt has no UPO/confirmation of its
+   own — it submits to KSeF natively and OL never touches that document), else
+   calls `getBinary('invoices/{providerInvoiceId}/pdf.json', { document_type: 'original', invoice_type: toInfaktInvoiceType(record.documentType) })`.
+   Replace the 3 `invoice.pdf_url ?? null` call sites with `null` + explanatory comment.
+5. Unit tests: `infakt-invoicing.adapter.spec.ts` — new `getRegulatoryDocument`
+   describe block (happy path returns bytes+contentType; unsupported kind throws).
+   `infakt-http-client.spec.ts` — new `getBinary` test (happy path + oversized-body cap).
+
+## 4. Frontend changes
+
+1. `apps/web/src/features/invoicing/hooks/use-invoice-rendered-document-download.ts`
+   (new) — mirrors `useKsefUpoDownload`'s shape (`{ download, isDownloading, error }`),
+   calling `apiClient.invoicing.downloadDocument(invoiceId, 'rendered')` (already
+   exists on the API client — no client change needed) and triggering a browser
+   download. Neutral (kind-agnostic naming) so any future `rendered`-only
+   provider can reuse it, not just Infakt.
+2. Export it from `features/invoicing/index.ts` barrel.
+3. `apps/web/src/plugins/infakt/components/infakt-invoice-detail-section.tsx`
+   — add a "Download PDF" button gated on `invoice.regulatoryStatus === 'accepted'`
+   (mirrors KSeF's UPO-availability gating), wired to the new hook. Update the
+   file's header comment (currently says Infakt "exposes no UPO/FA3 document
+   endpoints of its own" — still true for confirmation/source, but no longer
+   true for a rendered PDF).
+4. Tests: `infakt-invoice-detail-section.test.tsx` — new case asserting the
+   download button appears when accepted and calls the mocked API client.
+
+## 5. Validation
+
+- `pnpm --filter @openlinker/integrations-infakt test`
+- `pnpm --filter @openlinker/web test -- infakt-invoice-detail-section`
+- `pnpm lint && pnpm type-check` (scoped packages first, full run before PR)
+- Manual: re-verify against the sandbox that `GET /invoices/{uuid}/pdf.json?document_type=original&invoice_type=vat` still returns a valid PDF (already done ad hoc in this session).
+
+## Pre-implement gate: skipped
+
+This is a self-contained fix reusing an existing, unmodified capability
+(`RegulatoryDocumentReader`), an existing, unmodified controller route
+(`GET /invoices/:invoiceId/document`), and an existing, unmodified FE API
+client method (`downloadDocument`). No new port, DI token, ORM entity, or
+contract-surface change is introduced, so there is no reuse-collision or
+contract-break surface for `/pre-implement` to catch.
diff --git a/libs/integrations/infakt/docs/assets/00-platform-picker.png b/libs/integrations/infakt/docs/assets/00-platform-picker.png
new file mode 100644
index 000000000..4379bf123
Binary files /dev/null and b/libs/integrations/infakt/docs/assets/00-platform-picker.png differ
diff --git a/libs/integrations/infakt/docs/assets/01-infakt-wizard-empty.png b/libs/integrations/infakt/docs/assets/01-infakt-wizard-empty.png
new file mode 100644
index 000000000..b3655f420
Binary files /dev/null and b/libs/integrations/infakt/docs/assets/01-infakt-wizard-empty.png differ
diff --git a/libs/integrations/infakt/docs/assets/02-infakt-wizard-filled.png b/libs/integrations/infakt/docs/assets/02-infakt-wizard-filled.png
new file mode 100644
index 000000000..59bc79bd5
Binary files /dev/null and b/libs/integrations/infakt/docs/assets/02-infakt-wizard-filled.png differ
diff --git a/libs/integrations/infakt/docs/assets/03-infakt-connection-created.png b/libs/integrations/infakt/docs/assets/03-infakt-connection-created.png
new file mode 100644
index 000000000..f89b9c621
Binary files /dev/null and b/libs/integrations/infakt/docs/assets/03-infakt-connection-created.png differ
diff --git a/libs/integrations/infakt/docs/assets/04-infakt-connection-test-ok.png b/libs/integrations/infakt/docs/assets/04-infakt-connection-test-ok.png
new file mode 100644
index 000000000..ea39b70f1
Binary files /dev/null and b/libs/integrations/infakt/docs/assets/04-infakt-connection-test-ok.png differ
diff --git a/libs/integrations/infakt/docs/assets/05-connections-list-with-infakt.png b/libs/integrations/infakt/docs/assets/05-connections-list-with-infakt.png
new file mode 100644
index 000000000..0a9b9b8ba
Binary files /dev/null and b/libs/integrations/infakt/docs/assets/05-connections-list-with-infakt.png differ
diff --git a/libs/integrations/infakt/docs/assets/08-orders-list.png b/libs/integrations/infakt/docs/assets/08-orders-list.png
new file mode 100644
index 000000000..50848ba5f
Binary files /dev/null and b/libs/integrations/infakt/docs/assets/08-orders-list.png differ
diff --git a/libs/integrations/infakt/docs/assets/10-order-detail-not-issued.png b/libs/integrations/infakt/docs/assets/10-order-detail-not-issued.png
new file mode 100644
index 000000000..d487bf340
Binary files /dev/null and b/libs/integrations/infakt/docs/assets/10-order-detail-not-issued.png differ
diff --git a/libs/integrations/infakt/docs/assets/11-invoice-issued-submitted.png b/libs/integrations/infakt/docs/assets/11-invoice-issued-submitted.png
new file mode 100644
index 000000000..ee1539c0e
Binary files /dev/null and b/libs/integrations/infakt/docs/assets/11-invoice-issued-submitted.png differ
diff --git a/libs/integrations/infakt/docs/assets/12-invoice-accepted-cleared.png b/libs/integrations/infakt/docs/assets/12-invoice-accepted-cleared.png
new file mode 100644
index 000000000..e8bc6aeed
Binary files /dev/null and b/libs/integrations/infakt/docs/assets/12-invoice-accepted-cleared.png differ
diff --git a/libs/integrations/infakt/docs/assets/13-invoice-detail-page.png b/libs/integrations/infakt/docs/assets/13-invoice-detail-page.png
new file mode 100644
index 000000000..47aaac3a4
Binary files /dev/null and b/libs/integrations/infakt/docs/assets/13-invoice-detail-page.png differ
diff --git a/libs/integrations/infakt/docs/assets/14-correction-modal-empty.png b/libs/integrations/infakt/docs/assets/14-correction-modal-empty.png
new file mode 100644
index 000000000..c2738b7e3
Binary files /dev/null and b/libs/integrations/infakt/docs/assets/14-correction-modal-empty.png differ
diff --git a/libs/integrations/infakt/docs/assets/15-correction-modal-filled.png b/libs/integrations/infakt/docs/assets/15-correction-modal-filled.png
new file mode 100644
index 000000000..208fbbf75
Binary files /dev/null and b/libs/integrations/infakt/docs/assets/15-correction-modal-filled.png differ
diff --git a/libs/integrations/infakt/docs/assets/16-correction-issued.png b/libs/integrations/infakt/docs/assets/16-correction-issued.png
new file mode 100644
index 000000000..7e198183e
Binary files /dev/null and b/libs/integrations/infakt/docs/assets/16-correction-issued.png differ
diff --git a/libs/integrations/infakt/docs/assets/17-invoices-list.png b/libs/integrations/infakt/docs/assets/17-invoices-list.png
new file mode 100644
index 000000000..9e7d072c7
Binary files /dev/null and b/libs/integrations/infakt/docs/assets/17-invoices-list.png differ
diff --git a/libs/integrations/infakt/docs/assets/if1-infakt-dashboard-login.png b/libs/integrations/infakt/docs/assets/if1-infakt-dashboard-login.png
new file mode 100644
index 000000000..a127b51e1
Binary files /dev/null and b/libs/integrations/infakt/docs/assets/if1-infakt-dashboard-login.png differ
diff --git a/libs/integrations/infakt/docs/assets/if2-infakt-api-key-page.png b/libs/integrations/infakt/docs/assets/if2-infakt-api-key-page.png
new file mode 100644
index 000000000..37c16f1fe
Binary files /dev/null and b/libs/integrations/infakt/docs/assets/if2-infakt-api-key-page.png differ
diff --git a/libs/integrations/infakt/docs/assets/if3-infakt-webhooks-list.png b/libs/integrations/infakt/docs/assets/if3-infakt-webhooks-list.png
new file mode 100644
index 000000000..8d17d8e26
Binary files /dev/null and b/libs/integrations/infakt/docs/assets/if3-infakt-webhooks-list.png differ
diff --git a/libs/integrations/infakt/docs/assets/if4-infakt-webhook-form.png b/libs/integrations/infakt/docs/assets/if4-infakt-webhook-form.png
new file mode 100644
index 000000000..2ed21d899
Binary files /dev/null and b/libs/integrations/infakt/docs/assets/if4-infakt-webhook-form.png differ
diff --git a/libs/integrations/infakt/docs/assets/if5-infakt-invoice-confirmed.png b/libs/integrations/infakt/docs/assets/if5-infakt-invoice-confirmed.png
new file mode 100644
index 000000000..8c9fa7952
Binary files /dev/null and b/libs/integrations/infakt/docs/assets/if5-infakt-invoice-confirmed.png differ
diff --git a/libs/integrations/infakt/src/domain/types/infakt.types.ts b/libs/integrations/infakt/src/domain/types/infakt.types.ts
index 3a9f39f30..53ff00e20 100644
--- a/libs/integrations/infakt/src/domain/types/infakt.types.ts
+++ b/libs/integrations/infakt/src/domain/types/infakt.types.ts
@@ -72,8 +72,6 @@ export interface InfaktInvoice {
   client_id: number | null;
   client_uuid: string | null;
   services: InfaktInvoiceService[];
-  print_url: string | null;
-  pdf_url: string | null;
 }
 
 /** One line item on an Infakt invoice. */
diff --git a/libs/integrations/infakt/src/infrastructure/adapters/__tests__/infakt-invoicing.adapter.spec.ts b/libs/integrations/infakt/src/infrastructure/adapters/__tests__/infakt-invoicing.adapter.spec.ts
index afb5778fd..c5f9ba592 100644
--- a/libs/integrations/infakt/src/infrastructure/adapters/__tests__/infakt-invoicing.adapter.spec.ts
+++ b/libs/integrations/infakt/src/infrastructure/adapters/__tests__/infakt-invoicing.adapter.spec.ts
@@ -11,7 +11,11 @@
  * @module libs/integrations/infakt/src/infrastructure/adapters/__tests__
  */
 import type { LoggerPort } from '@openlinker/shared/logging';
-import { BuyerProfile, InvoiceRecord } from '@openlinker/core/invoicing';
+import {
+  BuyerProfile,
+  InvoiceRecord,
+  UnsupportedRegulatoryDocumentKindError,
+} from '@openlinker/core/invoicing';
 import type { IssueInvoiceCommand, IssueCorrectionCommand } from '@openlinker/core/invoicing';
 import { InfaktInvoicingAdapter, INFAKT_PROVIDER_TYPE } from '../infakt-invoicing.adapter';
 import { InfaktApiError } from '../../../domain/exceptions/infakt-api.error';
@@ -74,8 +78,6 @@ function invoiceFixture(overrides: Partial<InfaktInvoice> = {}): InfaktInvoice {
         group: null,
       },
     ],
-    print_url: null,
-    pdf_url: 'https://infakt.pl/inv-uuid-1.pdf',
     ...overrides,
   };
 }
@@ -259,7 +261,9 @@ describe('InfaktInvoicingAdapter', () => {
       expect(record.providerInvoiceNumber).toBe('FV/1/2026');
       expect(record.status).toBe('issued');
       expect(record.idempotencyKey).toBe('idem-1');
-      expect(record.pdfUrl).toBe('https://infakt.pl/inv-uuid-1.pdf');
+      // Infakt's invoice resource carries no `pdf_url` field (#1321) — the
+      // real PDF is served via `RegulatoryDocumentReader.getRegulatoryDocument`.
+      expect(record.pdfUrl).toBeNull();
       // KSeF submission is inline now — the record reflects the send_to_ksef
       // response, not the (necessarily stale, pre-submission) invoice payload.
       expect(record.regulatoryStatus).toBe('submitted');
@@ -618,4 +622,68 @@ describe('InfaktInvoicingAdapter', () => {
       });
     });
   });
+
+  describe('getRegulatoryDocument', () => {
+    function recordFixture(): InvoiceRecord {
+      const now = new Date('2026-07-01T12:00:00Z');
+      return new InvoiceRecord(
+        'record-1',
+        'conn-1',
+        'order-1',
+        INFAKT_PROVIDER_TYPE,
+        'invoice',
+        'issued',
+        'inv-uuid-1',
+        'FV/1/2026',
+        'accepted',
+        'ksef-number-1',
+        'idem-1',
+        null,
+        now,
+        null,
+        now,
+        now,
+      );
+    }
+
+    it('should fetch the PDF via the dedicated pdf.json endpoint (happy path)', async () => {
+      const pdfBytes = new Uint8Array([0x25, 0x50, 0x44, 0x46]); // "%PDF"
+      http.seedBinary('invoices/inv-uuid-1/pdf.json', {
+        data: pdfBytes,
+        contentType: 'application/pdf',
+      });
+
+      const document = await adapter.getRegulatoryDocument(recordFixture(), 'rendered');
+
+      expect(document.content).toBe(pdfBytes);
+      expect(document.contentType).toBe('application/pdf');
+      const call = http.calls.find(
+        (c) => c.method === 'GET_BINARY' && c.path === 'invoices/inv-uuid-1/pdf.json',
+      );
+      expect(call?.query).toEqual({ document_type: 'original', invoice_type: 'vat' });
+    });
+
+    it('should default to application/pdf when Infakt reports no content type', async () => {
+      http.seedBinary('invoices/inv-uuid-1/pdf.json', {
+        data: new Uint8Array([1, 2, 3]),
+        contentType: '',
+      });
+
+      const document = await adapter.getRegulatoryDocument(recordFixture(), 'rendered');
+
+      expect(document.contentType).toBe('application/pdf');
+    });
+
+    it('should throw UnsupportedRegulatoryDocumentKindError for confirmation (Infakt has no UPO of its own)', async () => {
+      await expect(
+        adapter.getRegulatoryDocument(recordFixture(), 'confirmation'),
+      ).rejects.toBeInstanceOf(UnsupportedRegulatoryDocumentKindError);
+    });
+
+    it('should throw UnsupportedRegulatoryDocumentKindError for source', async () => {
+      await expect(
+        adapter.getRegulatoryDocument(recordFixture(), 'source'),
+      ).rejects.toBeInstanceOf(UnsupportedRegulatoryDocumentKindError);
+    });
+  });
 });
diff --git a/libs/integrations/infakt/src/infrastructure/adapters/infakt-invoicing.adapter.ts b/libs/integrations/infakt/src/infrastructure/adapters/infakt-invoicing.adapter.ts
index 2d8dad180..f2c02c8e5 100644
--- a/libs/integrations/infakt/src/infrastructure/adapters/infakt-invoicing.adapter.ts
+++ b/libs/integrations/infakt/src/infrastructure/adapters/infakt-invoicing.adapter.ts
@@ -28,12 +28,15 @@ import type {
   IssueInvoiceResult,
   InvoicingPort,
   RegulatoryClearanceResult,
+  RegulatoryDocument,
+  RegulatoryDocumentKind,
+  RegulatoryDocumentReader,
   RegulatoryStatus,
   RegulatoryStatusReader,
   UpsertCustomerCommand,
   UpsertCustomerResult,
 } from '@openlinker/core/invoicing';
-import { InvoiceRecord } from '@openlinker/core/invoicing';
+import { InvoiceRecord, UnsupportedRegulatoryDocumentKindError } from '@openlinker/core/invoicing';
 import type { IInfaktHttpClient } from '../http/infakt-http-client.interface';
 import { InfaktApiError } from '../../domain/exceptions/infakt-api.error';
 import type {
@@ -167,7 +170,7 @@ function fromGroszy(amountGroszy: number): number {
 }
 
 export class InfaktInvoicingAdapter
-  implements InvoicingPort, RegulatoryStatusReader, CorrectionIssuer
+  implements InvoicingPort, RegulatoryStatusReader, CorrectionIssuer, RegulatoryDocumentReader
 {
   constructor(
     private readonly connectionId: string,
@@ -286,7 +289,11 @@ export class InfaktInvoicingAdapter
       toRegulatoryStatus(ksefResult.status),
       ksefResult.ksef_number,
       idempotencyKey ?? null,
-      invoice.pdf_url ?? null,
+      // Infakt's invoice resource carries no `pdf_url` field (verified live
+      // against the sandbox, #1321) — the real PDF path is
+      // `RegulatoryDocumentReader.getRegulatoryDocument(record, 'rendered')`
+      // below, which hits the dedicated `pdf.json` endpoint.
+      null,
       now,
       null,
       now,
@@ -328,7 +335,11 @@ export class InfaktInvoicingAdapter
           toRegulatoryStatus(invoice.ksef_data?.status ?? null),
           invoice.ksef_data?.ksef_number ?? null,
           null,
-          invoice.pdf_url ?? null,
+          // Infakt's invoice resource carries no `pdf_url` field (verified live
+          // against the sandbox, #1321) — the real PDF path is
+          // `RegulatoryDocumentReader.getRegulatoryDocument(record, 'rendered')`
+          // below, which hits the dedicated `pdf.json` endpoint.
+          null,
           invoice.invoice_date ? new Date(invoice.invoice_date) : now,
           null,
           now,
@@ -453,7 +464,11 @@ export class InfaktInvoicingAdapter
       toRegulatoryStatus(ksefResult.status),
       ksefResult.ksef_number,
       idempotencyKey ?? null,
-      invoice.pdf_url ?? null,
+      // Infakt's invoice resource carries no `pdf_url` field (verified live
+      // against the sandbox, #1321) — the real PDF path is
+      // `RegulatoryDocumentReader.getRegulatoryDocument(record, 'rendered')`
+      // below, which hits the dedicated `pdf.json` endpoint.
+      null,
       now,
       null,
       now,
@@ -474,6 +489,34 @@ export class InfaktInvoicingAdapter
     );
   }
 
+  /**
+   * `RegulatoryDocumentReader.getRegulatoryDocument` (#1321) — fetch the
+   * invoice PDF as neutral bytes. Infakt has no `pdf_url` field on the
+   * invoice resource (verified live against the sandbox); the real path is
+   * the dedicated `GET /invoices/{uuid}/pdf.json` endpoint, which returns the
+   * PDF binary directly. Infakt submits to KSeF natively and OL never builds
+   * or holds a KSeF confirmation (UPO) for this provider, so only `rendered`
+   * is supported — `confirmation`/`source` are soft 409s via
+   * `UnsupportedRegulatoryDocumentKindError`, mirroring KSeF's own adapter
+   * rejecting `rendered` the other way around.
+   */
+  async getRegulatoryDocument(
+    record: InvoiceRecord,
+    kind: RegulatoryDocumentKind = 'confirmation',
+  ): Promise<RegulatoryDocument> {
+    if (kind !== 'rendered') {
+      throw new UnsupportedRegulatoryDocumentKindError(kind);
+    }
+    const response = await this.http.getBinary(`invoices/${record.providerInvoiceId}/pdf.json`, {
+      document_type: 'original',
+      invoice_type: toInfaktInvoiceType(record.documentType),
+    });
+    return {
+      content: response.data,
+      contentType: response.contentType.length > 0 ? response.contentType : 'application/pdf',
+    };
+  }
+
   // --- helpers ---
 
   private async resolveClientId(cmd: IssueInvoiceCommand): Promise<number> {
diff --git a/libs/integrations/infakt/src/infrastructure/http/__tests__/infakt-http-client.spec.ts b/libs/integrations/infakt/src/infrastructure/http/__tests__/infakt-http-client.spec.ts
index 0ecfb0361..1077afd64 100644
--- a/libs/integrations/infakt/src/infrastructure/http/__tests__/infakt-http-client.spec.ts
+++ b/libs/integrations/infakt/src/infrastructure/http/__tests__/infakt-http-client.spec.ts
@@ -19,6 +19,30 @@ function fakeResponse(status: number, body: string): Response {
   } as unknown as Response;
 }
 
+/** Fake `Response` exposing a streaming `.body.getReader()` for `getBinary`. */
+function fakeBinaryResponse(status: number, contentType: string, chunks: Uint8Array[]): Response {
+  let index = 0;
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    text: (): Promise<string> => Promise.resolve(''),
+    headers: { get: (name: string): string | null => (name === 'content-type' ? contentType : null) },
+    body: {
+      getReader: () => ({
+        read: (): Promise<{ done: boolean; value?: Uint8Array }> => {
+          if (index < chunks.length) {
+            const value = chunks[index];
+            index += 1;
+            return Promise.resolve({ done: false, value });
+          }
+          return Promise.resolve({ done: true });
+        },
+        cancel: (): Promise<void> => Promise.resolve(),
+      }),
+    },
+  } as unknown as Response;
+}
+
 function fakeLogger(): jest.Mocked<LoggerPort> {
   return {
     log: jest.fn(),
@@ -152,4 +176,36 @@ describe('InfaktHttpClient', () => {
       expect(logger.warn).toHaveBeenCalled();
     });
   });
+
+  describe('getBinary', () => {
+    it('should stream the response body and report the content type (happy path)', async () => {
+      const chunk1 = new Uint8Array([0x25, 0x50, 0x44, 0x46]); // "%PDF"
+      const chunk2 = new Uint8Array([0x2d, 0x31, 0x2e, 0x34]); // "-1.4"
+      fetchMock.mockResolvedValue(fakeBinaryResponse(200, 'application/pdf', [chunk1, chunk2]));
+
+      const result = await client.getBinary('invoices/abc/pdf.json', { document_type: 'original' });
+
+      expect(result.contentType).toBe('application/pdf');
+      expect(Array.from(result.data)).toEqual([...chunk1, ...chunk2]);
+      const [url] = fetchMock.mock.calls[0] as [string];
+      expect(url).toBe(`${INFAKT_DEFAULT_BASE_URL}/invoices/abc/pdf.json?document_type=original`);
+    });
+
+    it('should throw InfaktApiError on a non-2xx response', async () => {
+      fetchMock.mockResolvedValue(fakeResponse(404, '{"error":"not found"}'));
+      await expect(client.getBinary('invoices/missing/pdf.json')).rejects.toBeInstanceOf(
+        InfaktApiError,
+      );
+    });
+
+    it('should cap the response and throw InfaktApiError past the byte cap', async () => {
+      // Exceeds the client's 10 MB streaming cap in a single oversized chunk.
+      const oversized = new Uint8Array(10 * 1024 * 1024 + 1);
+      fetchMock.mockResolvedValue(fakeBinaryResponse(200, 'application/pdf', [oversized]));
+
+      await expect(client.getBinary('invoices/huge/pdf.json')).rejects.toMatchObject({
+        statusCode: 200,
+      });
+    });
+  });
 });
diff --git a/libs/integrations/infakt/src/infrastructure/http/infakt-http-client.interface.ts b/libs/integrations/infakt/src/infrastructure/http/infakt-http-client.interface.ts
index 24eba0e19..1bbeeca78 100644
--- a/libs/integrations/infakt/src/infrastructure/http/infakt-http-client.interface.ts
+++ b/libs/integrations/infakt/src/infrastructure/http/infakt-http-client.interface.ts
@@ -12,7 +12,15 @@
  *
  * @module libs/integrations/infakt/src/infrastructure/http
  */
+/** Raw bytes + provider-reported content type for a binary (non-JSON) response. */
+export interface InfaktBinaryResponse {
+  data: Uint8Array;
+  contentType: string;
+}
+
 export interface IInfaktHttpClient {
   get<T>(path: string, query?: Record<string, string>): Promise<T>;
   post<T>(path: string, body: unknown): Promise<T>;
+  /** Fetch a binary response (e.g. a PDF) rather than parsing JSON. */
+  getBinary(path: string, query?: Record<string, string>): Promise<InfaktBinaryResponse>;
 }
diff --git a/libs/integrations/infakt/src/infrastructure/http/infakt-http-client.ts b/libs/integrations/infakt/src/infrastructure/http/infakt-http-client.ts
index 069f229e0..77bb09caf 100644
--- a/libs/integrations/infakt/src/infrastructure/http/infakt-http-client.ts
+++ b/libs/integrations/infakt/src/infrastructure/http/infakt-http-client.ts
@@ -10,7 +10,7 @@
  */
 import type { LoggerPort } from '@openlinker/shared/logging';
 import { InfaktApiError } from '../../domain/exceptions/infakt-api.error';
-import type { IInfaktHttpClient } from './infakt-http-client.interface';
+import type { IInfaktHttpClient, InfaktBinaryResponse } from './infakt-http-client.interface';
 
 export interface InfaktHttpClientConfig {
   apiKey: string;
@@ -19,6 +19,14 @@ export interface InfaktHttpClientConfig {
 
 export const INFAKT_DEFAULT_BASE_URL = 'https://api.infakt.pl/api/v3';
 
+/**
+ * Cap on a binary response body (e.g. an invoice PDF). Mirrors the KSeF HTTP
+ * client's `MAX_BINARY_RESPONSE_BYTES` — the running total is enforced as
+ * chunks stream in, so an oversized or mendacious `Content-Length` can't
+ * drive an unbounded buffered read into memory.
+ */
+const MAX_BINARY_RESPONSE_BYTES = 10 * 1024 * 1024;
+
 export class InfaktHttpClient implements IInfaktHttpClient {
   private readonly baseUrl: string;
 
@@ -45,6 +53,53 @@ export class InfaktHttpClient implements IInfaktHttpClient {
     return this.parse<T>(res, 'POST', path);
   }
 
+  async getBinary(path: string, query?: Record<string, string>): Promise<InfaktBinaryResponse> {
+    const url = this.buildUrl(path, query);
+    const res = await fetch(url, { headers: this.headers() });
+    if (!res.ok) {
+      const text = await res.text();
+      this.logger.warn(`Infakt API GET ${path} → ${res.status}`);
+      throw new InfaktApiError(
+        `Infakt API GET ${path} failed with status ${res.status}`,
+        res.status,
+        text,
+      );
+    }
+    const data = await this.readBinaryBodyCapped(res, url);
+    return { data, contentType: res.headers.get('content-type') ?? '' };
+  }
+
+  private async readBinaryBodyCapped(res: Response, url: string): Promise<Uint8Array> {
+    const body = res.body;
+    if (!body) {
+      return new Uint8Array(0);
+    }
+    const reader = body.getReader();
+    const chunks: Uint8Array[] = [];
+    let total = 0;
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > MAX_BINARY_RESPONSE_BYTES) {
+        await reader.cancel();
+        throw new InfaktApiError(
+          `Infakt binary response for ${url} exceeds the ${MAX_BINARY_RESPONSE_BYTES}-byte cap`,
+          res.status,
+          null,
+        );
+      }
+      chunks.push(value);
+    }
+    const bytes = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return bytes;
+  }
+
   private buildUrl(path: string, query?: Record<string, string>): string {
     const base = `${this.baseUrl}/${path.replace(/^\//, '')}`;
     if (!query || Object.keys(query).length === 0) return base;
diff --git a/libs/integrations/infakt/src/testing/fake-infakt-http-client.ts b/libs/integrations/infakt/src/testing/fake-infakt-http-client.ts
index 5acc16841..3d54c1bcd 100644
--- a/libs/integrations/infakt/src/testing/fake-infakt-http-client.ts
+++ b/libs/integrations/infakt/src/testing/fake-infakt-http-client.ts
@@ -10,10 +10,15 @@
  *
  * @module libs/integrations/infakt/src/testing
  */
-import type { IInfaktHttpClient } from '../infrastructure/http/infakt-http-client.interface';
+import type {
+  IInfaktHttpClient,
+  InfaktBinaryResponse,
+} from '../infrastructure/http/infakt-http-client.interface';
+
+type CallMethod = 'GET' | 'POST' | 'GET_BINARY';
 
 interface RecordedCall {
-  method: 'GET' | 'POST';
+  method: CallMethod;
   path: string;
   query?: Record<string, string>;
   body?: unknown;
@@ -31,8 +36,14 @@ export class FakeInfaktHttpClient implements IInfaktHttpClient {
     return this;
   }
 
-  /** Seed a rejection (e.g. `InfaktApiError`) for `GET path` / `POST path`. */
-  seedError(method: 'GET' | 'POST', path: string, error: Error): this {
+  /** Seed a successful binary response for `getBinary(path)`. */
+  seedBinary(path: string, value: InfaktBinaryResponse): this {
+    this.responses.set(this.key('GET_BINARY', path), { kind: 'resolve', value });
+    return this;
+  }
+
+  /** Seed a rejection (e.g. `InfaktApiError`) for `GET path` / `POST path` / `getBinary(path)`. */
+  seedError(method: CallMethod, path: string, error: Error): this {
     this.responses.set(this.key(method, path), { kind: 'reject', error });
     return this;
   }
@@ -52,7 +63,12 @@ export class FakeInfaktHttpClient implements IInfaktHttpClient {
     return this.resolve<T>('POST', path);
   }
 
-  private resolve<T>(method: 'GET' | 'POST', path: string): Promise<T> {
+  getBinary(path: string, query?: Record<string, string>): Promise<InfaktBinaryResponse> {
+    this.calls.push({ method: 'GET_BINARY', path, query });
+    return this.resolve<InfaktBinaryResponse>('GET_BINARY', path);
+  }
+
+  private resolve<T>(method: CallMethod, path: string): Promise<T> {
     const seeded = this.responses.get(this.key(method, path));
     if (!seeded) {
       return Promise.reject(
@@ -62,7 +78,7 @@ export class FakeInfaktHttpClient implements IInfaktHttpClient {
     return seeded.kind === 'resolve' ? Promise.resolve(seeded.value as T) : Promise.reject(seeded.error);
   }
 
-  private key(method: 'GET' | 'POST', path: string): string {
+  private key(method: CallMethod, path: string): string {
     return `${method} ${path}`;
   }
 }