refactor: expose tbank-sync public api and guard its boundary (WealthLedger/backend#118 )

2026-10-28 12:28:12 +03:00
40 changed files with 616 additions and 983 deletions
@@ -1,30 +1,5 @@
 # Changelog

-## [2.4.0](https://git.personal.ksv741.ru/WealthLedger/backend/compare/v2.3.1...v2.4.0) (2026-11-01)
-
-### Features
-
-* extend account list portfolio summary ([#138](https://git.personal.ksv741.ru/WealthLedger/backend/issues/138)) ([97fc41f](https://git.personal.ksv741.ru/WealthLedger/backend/commit/97fc41fa295a7a943a27171fa41cdaf286632956))
-* **portfolio:** store and publish instrument sector and issuer (WealthLedger/main[#48](https://git.personal.ksv741.ru/WealthLedger/backend/issues/48)) ([#148](https://git.personal.ksv741.ru/WealthLedger/backend/issues/148)) ([17432df](https://git.personal.ksv741.ru/WealthLedger/backend/commit/17432dfee3d7d06841caea4419a062e2a4bfc82c))
-
-### Bug Fixes
-
-* count brokerage cash once and skip short-position return percent (WealthLedger/backend[#140](https://git.personal.ksv741.ru/WealthLedger/backend/issues/140)) ([f2843e3](https://git.personal.ksv741.ru/WealthLedger/backend/commit/f2843e30bda5442158ec145cc63a5491506bb60f))
-* reset portfolio value points inflated by double-counted cash (WealthLedger/backend[#140](https://git.personal.ksv741.ru/WealthLedger/backend/issues/140)) ([2325b63](https://git.personal.ksv741.ru/WealthLedger/backend/commit/2325b638839240bf5d6d4f7e6e1f8eaa82d4d7fd))
-* scope income and ledger sync to requested intervals (WealthLedger/backend[#57](https://git.personal.ksv741.ru/WealthLedger/backend/issues/57)) ([#147](https://git.personal.ksv741.ru/WealthLedger/backend/issues/147)) ([5e84e1e](https://git.personal.ksv741.ru/WealthLedger/backend/commit/5e84e1e5f1943b5af1992a3a946194b27fc1a1d5))
-* use available Debian packages in image build ([#129](https://git.personal.ksv741.ru/WealthLedger/backend/issues/129)) ([a250142](https://git.personal.ksv741.ru/WealthLedger/backend/commit/a250142a86e07ec7047e642afa16492fa4987f9a))
-
-### Refactoring
-
-* expose tbank-sync public api and guard its boundary (WealthLedger/backend[#118](https://git.personal.ksv741.ru/WealthLedger/backend/issues/118)) ([#143](https://git.personal.ksv741.ru/WealthLedger/backend/issues/143)) ([5295945](https://git.personal.ksv741.ru/WealthLedger/backend/commit/5295945ab237a6e94aa64d7bb54bfd04554ca9f9))
-* publish typed problem detail codes (WealthLedger/backend[#117](https://git.personal.ksv741.ru/WealthLedger/backend/issues/117)) ([#144](https://git.personal.ksv741.ru/WealthLedger/backend/issues/144)) ([d37fa2c](https://git.personal.ksv741.ru/WealthLedger/backend/commit/d37fa2c9034e90e9d22d4022c45fc36c22dd2ab3))
-* remove tbank-sync operations import cycle (WealthLedger/backend[#116](https://git.personal.ksv741.ru/WealthLedger/backend/issues/116)) ([#142](https://git.personal.ksv741.ru/WealthLedger/backend/issues/142)) ([22668da](https://git.personal.ksv741.ru/WealthLedger/backend/commit/22668da3fa0666bdd22737913379c99d4cf01993))
-
-### Tests
-
-* cover portfolio publish rollback and claim fence (WealthLedger/backend[#105](https://git.personal.ksv741.ru/WealthLedger/backend/issues/105)) ([#146](https://git.personal.ksv741.ru/WealthLedger/backend/issues/146)) ([e350146](https://git.personal.ksv741.ru/WealthLedger/backend/commit/e350146749293f2eaf8060f7626ff3c1cd8edf2c))
-* replace operations sync delays with explicit barriers (WealthLedger/backend[#104](https://git.personal.ksv741.ru/WealthLedger/backend/issues/104)) ([#145](https://git.personal.ksv741.ru/WealthLedger/backend/issues/145)) ([99b137e](https://git.personal.ksv741.ru/WealthLedger/backend/commit/99b137ed0b39ab73b6a28d1a494d2d98bf8fa380))
-
 ## [2.3.1](https://git.personal.ksv741.ru/WealthLedger/backend/compare/v2.3.0...v2.3.1) (2026-10-24)

 ### Bug Fixes
@@ -92,8 +92,11 @@
    }
  },
  "src/modules/investments/investment-sync-plan.ts": {
+    "sonarjs/cognitive-complexity": {
+      "count": 1
+    },
    "sonarjs/no-nested-conditional": {
-      "count": 3
+      "count": 4
    }
  },
  "src/modules/investments/operations/application/brokerage-operations.service.ts": {
@@ -56,7 +56,6 @@ export default defineConfig(
        'after',
        { overrides: { '?': 'before', ':': 'before' } },
      ],
-      'import-x/no-cycle': 'error',
      'import-x/no-duplicates': ['error', { 'prefer-inline': true }],
    },
  },
@@ -1,12 +1,12 @@
 {
  "name": "wealth-ledger-backend",
-  "version": "2.4.0",
+  "version": "2.3.1",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "wealth-ledger-backend",
-      "version": "2.4.0",
+      "version": "2.3.1",
      "license": "UNLICENSED",
      "dependencies": {
        "@grpc/grpc-js": "1.14.6",
@@ -1,6 +1,6 @@
 {
  "name": "wealth-ledger-backend",
-  "version": "2.4.0",
+  "version": "2.3.1",
  "description": "",
  "author": "",
  "private": true,
@@ -1,11 +0,0 @@
-CREATE TABLE "TbankInstrumentClassification" (
-    "provider" TEXT NOT NULL,
-    "instrumentKey" TEXT NOT NULL,
-    "sector" TEXT,
-    "sectorFetchedAt" DATETIME,
-    "assetUid" TEXT,
-    "brandUid" TEXT,
-    "brandName" TEXT,
-    "brandFetchedAt" DATETIME,
-    PRIMARY KEY ("provider","instrumentKey")
-);
@@ -186,20 +186,6 @@ model TbankInstrumentLookup {
  @@id([provider, identifierType, identifier])
 }

-// Public per-instrument classification; no holdings or credentials.
-model TbankInstrumentClassification {
-  provider        String
-  instrumentKey   String
-  sector          String?
-  sectorFetchedAt DateTime?
-  assetUid        String?
-  brandUid        String?
-  brandName       String?
-  brandFetchedAt  DateTime?
-
-  @@id([provider, instrumentKey])
-}
-
 // Source records contain no holdings, personal estimates or credentials errors.
 model TbankInstrumentSource {
  provider String
@@ -1,7 +1,7 @@
 import { Injectable, ServiceUnavailableException } from '@nestjs/common';
 import { constants as httpStatus } from 'node:http2';

-export enum MoexErrorCode { Unavailable = 'MOEX_UNAVAILABLE' }
+enum MoexErrorCode { Unavailable = 'MOEX_UNAVAILABLE' }

 const MIN_PRICE_PERCENT_EXCLUSIVE = 0;
 const FIRST_PAGE_OFFSET = 0;
@@ -4,7 +4,7 @@ import { LRUCache } from 'lru-cache';

 import { ISO_DATE_LENGTH, ISO_DATE_START } from '../../common/time';

-export enum NcrErrorCode { Unavailable = 'NCR_UNAVAILABLE' }
+enum NcrErrorCode { Unavailable = 'NCR_UNAVAILABLE' }

 const EXPECTED_REGISTRY_TABLES = 1;
 const RATING_COLUMN = 2;
@@ -236,16 +236,6 @@ describe('TbankClient metadata retries', () => {
    jest.useRealTimers();
  });

-  it.each([
-    ['bondBy', (client: TbankClient, optIn: boolean) => client.getBond('token', 'uid', undefined, optIn)],
-    ['etfBy', (client: TbankClient, optIn: boolean) => client.getEtf('token', 'uid', undefined, optIn)],
-    ['getAssetBy', (client: TbankClient, optIn: boolean) => optIn ? client.getAssetBrand('token', 'uid') : client.getAssetDescription('token', 'uid')],
-  ])('%s reports NOT_FOUND only for classification lookups', async (_method, invoke) => {
-    requestRpc.mockRejectedValue({ code: status.NOT_FOUND });
-    await expect(invoke(client, false)).rejects.toBeInstanceOf(ServiceUnavailableException);
-    await expect(invoke(client, true)).rejects.toBeInstanceOf(NotFoundException);
-  });
-
  it.each([
    status.UNAVAILABLE,
    status.DEADLINE_EXCEEDED,
@@ -375,29 +375,18 @@ export class TbankClient {
    ).then((response) => response.instruments ?? []);
  }

-  getBond(token: string, uid: string, idType = InstrumentIdType.Uid, notFound = false): Promise<null | TbankBond> {
+  getBond(token: string, uid: string): Promise<null | TbankBond> {
    return this.call<{ instrument?: TbankBond }>(
      token,
      this.sparseInstruments,
      'bondBy',
      {
-        idType,
+        idType: InstrumentIdType.Uid,
        id: uid,
      },
-      notFound,
    ).then((response) => response.instrument ?? null);
  }

-  getEtf(
-    token: string,
-    id: string,
-    idType = InstrumentIdType.Uid,
-    notFound = false,
-  ): Promise<null | Pick<TbankShare, 'assetUid' | 'figi' | 'sector' | 'uid'>> {
-    return this.call<{ instrument?: TbankShare }>(token, this.sparseInstruments, 'etfBy', { idType, id }, notFound)
-      .then((response) => response.instrument ?? null);
-  }
-
  getBondCoupons(
    token: string,
    uid: string,
@@ -416,25 +405,18 @@ export class TbankClient {
    ).then((response) => response.events ?? []);
  }

-  getShare(token: string, uid: string, idType = InstrumentIdType.Uid, notFound = false): Promise<null | TbankShare> {
+  getShare(token: string, uid: string): Promise<null | TbankShare> {
    return this.call<{ instrument?: TbankShare }>(
      token,
      this.instruments,
      'shareBy',
      {
-        idType,
+        idType: InstrumentIdType.Uid,
        id: uid,
      },
-      notFound,
    ).then((response) => response.instrument ?? null);
  }

-  getAssetBrand(token: string, assetUid: string): Promise<null | { assetUid?: string; brand?: { name?: string; uid?: string } }> {
-    return this.call<{ asset?: { brand?: { name?: string; uid?: string }; uid?: string } }>(
-      token, this.instruments, 'getAssetBy', { id: assetUid }, true,
-    ).then((response) => response.asset ? { assetUid: response.asset.uid, brand: response.asset.brand } : null);
-  }
-
  getAssetDescription(token: string, assetUid: string): Promise<null | string> {
    return this.call<{ asset?: { description?: string } }>(
      token,
@@ -532,7 +514,6 @@ export class TbankClient {
    client: TbankClientService,
    method: string,
    request: object,
-    notFound = false,
  ): Promise<Response> {
    const metadataCall = method === 'getInstrumentBy';
    for (let attempts = FIRST_ATTEMPT; attempts <= RPC_MAX_ATTEMPTS; attempts += ATTEMPT_INCREMENT) {
@@ -595,7 +576,7 @@ export class TbankClient {
        }
        if (
          grpcCode === status.NOT_FOUND &&
-          (notFound || method === 'shareBy' || metadataCall)
+          (method === 'shareBy' || metadataCall)
        ) {
          throw new NotFoundException();
        }
@@ -8,7 +8,7 @@ import {
  utcDate,
 } from '../investment-calendar';

-export enum IncomeErrorCode { InvalidPeriod = 'INVALID_INCOME_PERIOD' }
+enum IncomeErrorCode { InvalidPeriod = 'INVALID_INCOME_PERIOD' }

 const MONDAY_WEEKDAY_INDEX = 1;
 const INCLUSIVE_DAY_OFFSET = 1;
@@ -22,8 +22,6 @@ const row = (
  isin: null,
  ticker: null,
  logoName: null,
-  sector: null,
-  issuer: null,
 });
 const portfolio = (positions: PortfolioPositionDto[]): PortfolioDto => ({
  positions,
@@ -1,16 +1,196 @@
-import { accountHistory, ledgerRange } from './investment-sync-plan';
+import {
+  accountHistory,
+  ledgerRange,
+  planInvestmentScreen,
+} from './investment-sync-plan';

-// Missing opening dates must not silently narrow the reported history boundary.
-describe('account history boundaries', () => {
+describe('screen dependency and history planning', () => {
  const now = new Date('2026-09-25T12:00:00Z');
-  const accounts = [{ accountId: 'a', openedOn: null }];
-
-  it('retains the unknown opening boundary for history and instrument ledger', () => {
-    expect(accountHistory(accounts, now)[0].from.toISOString()).toBe(
+  const context = {
+    membershipKnown: true,
+    accounts: [{ accountId: 'a', openedOn: '2020-01-01' }],
+    instruments: [
+      {
+        uid: 'uid',
+        type: 'STOCK' as const,
+        historyFrom: new Date('2020-01-01Z'),
+      },
+    ],
+  };
+  it('prioritizes discovery, the selected period, then history; Moscow dates are converted once', () => {
+    const plan = planInvestmentScreen(
+      {
+        screen: 'income',
+        accountId: 'a',
+        from: '2024-02-01',
+        to: '2024-02-29',
+      },
+      context,
+      now,
+    );
+    expect(plan.sources[0].kind).toBe('membership');
+    const selected = plan.sources.filter(
+      (source) => source.kind === 'operations' && source.priority === 'screen',
+    );
+    // The single selected range is chunked into month-aligned intervals.
+    expect(selected).toHaveLength(2);
+    expect(
+      selected.every(
+        (source) =>
+          source.from != null &&
+          source.from.toISOString() >= '2024-01-31T21:00:00.000Z' &&
+          source.to != null &&
+          source.to.toISOString() <= '2024-02-29T21:00:00.000Z',
+      ),
+    ).toBe(true);
+    expect(
+      selected.some(
+        (source) => source.from?.toISOString() === '2024-01-31T21:00:00.000Z',
+      ),
+    ).toBe(true);
+    expect(
+      selected.some(
+        (source) => source.to?.toISOString() === '2024-02-29T21:00:00.000Z',
+      ),
+    ).toBe(true);
+    expect(plan.unavailable).toEqual([]);
+    const firstHistory = plan.sources.findIndex(
+      (source) => source.priority === 'history',
+    );
+    expect(
+      plan.sources
+        .slice(firstHistory)
+        .every((source) => source.priority === 'history'),
+    ).toBe(true);
+  });
+  it('force contains only shown dependencies and retains instrument reconciliation predicates', () => {
+    const plan = planInvestmentScreen(
+      {
+        screen: 'stock',
+        instrumentUid: 'uid',
+        from: '2026-01-01',
+        to: '2026-02-01',
+        candlePeriod: 'year',
+      },
+      context,
+      now,
+      true,
+    );
+    expect(plan.sources.map((source) => source.kind)).toEqual(
+      expect.arrayContaining([
+        'membership',
+        'portfolio',
+        'operations',
+        'metadata',
+        'quote',
+        'company',
+        'calendar',
+        'candles',
+      ]),
+    );
+    expect(plan.sources.every((source) => source.priority !== 'history')).toBe(
+      true,
+    );
+    expect(
+      plan.sources
+        .filter((source) => source.kind === 'operations')
+        .every((source) => source.instrumentUid === 'uid'),
+    ).toBe(true);
+    const accounts = planInvestmentScreen(
+      { screen: 'accounts' },
+      context,
+      now,
+      true,
+    );
+    expect(
+      accounts.sources.some((source) => source.kind === 'operations'),
+    ).toBe(false);
+  });
+  it('never invents an account or candle history boundary; discovery gates unknown membership', () => {
+    const unknown = {
+      ...context,
+      accounts: [{ accountId: 'a', openedOn: null }],
+      instruments: [],
+    };
+    expect(accountHistory(unknown.accounts, now)[0].from.toISOString()).toBe(
      '1970-01-01T00:00:00.000Z',
    );
    expect(
-      ledgerRange(undefined, undefined, 'uid', accounts, now).from.toISOString(),
+      ledgerRange(
+        undefined,
+        undefined,
+        'uid',
+        unknown.accounts,
+        now,
+      ).from.toISOString(),
    ).toBe('1970-01-01T00:00:00.000Z');
+    const plan = planInvestmentScreen(
+      { screen: 'bond', instrumentUid: 'uid', candlePeriod: 'all' },
+      unknown,
+      now,
+    );
+    expect(plan.sources.some((source) => source.kind === 'candles')).toBe(
+      false,
+    );
+    expect(plan.unavailable[0].reason).toBe('history_start_unavailable');
+    expect(
+      planInvestmentScreen(
+        { screen: 'account' },
+        { ...context, membershipKnown: false },
+        now,
+      ).sources,
+    ).toEqual([{ kind: 'membership', priority: 'discovery' }]);
+  });
+  it('keeps UTC event days separate from Moscow instrument calendar days at year rollover', () => {
+    const rollover = new Date('2026-12-31T22:00:00Z');
+    const events = planInvestmentScreen(
+      { screen: 'events' },
+      context,
+      rollover,
+      true,
+    );
+    expect(
+      events.sources.find((source) => source.kind === 'calendar')?.from,
+    ).toEqual(new Date('2026-12-31Z'));
+    const stock = planInvestmentScreen(
+      { screen: 'stock', instrumentUid: 'uid' },
+      context,
+      rollover,
+      true,
+    );
+    expect(
+      stock.sources.find((source) => source.kind === 'calendar'),
+    ).toMatchObject({
+      from: new Date('2022-01-01Z'),
+      to: new Date('2028-01-01Z'),
+    });
+    expect(rollover.toISOString()).toBe('2026-12-31T22:00:00.000Z');
+  });
+
+  it('keeps search queries separate and events scoped to their inclusive period', () => {
+    const search = planInvestmentScreen(
+      { screen: 'stocks', query: ' sber ' },
+      context,
+      now,
+      true,
+    );
+    expect(
+      search.sources.find((source) => source.kind === 'catalog')?.query,
+    ).toBe('SBER');
+    const events = planInvestmentScreen(
+      { screen: 'events', from: '2026-10-01', to: '2026-10-31' },
+      context,
+      now,
+      true,
+    );
+    expect(
+      events.sources.find((source) => source.kind === 'calendar'),
+    ).toMatchObject({
+      from: new Date('2026-10-01Z'),
+      to: new Date('2026-10-31Z'),
+    });
+    expect(events.sources.some((source) => source.kind === 'operations')).toBe(
+      false,
+    );
  });
 });
@@ -1,11 +1,267 @@
-import type { OperationInterval } from './operations/domain/operations-sync-plan';
+import { ISO_DATE_LENGTH, ISO_DATE_START } from '../../common/time';
+import { planIncomePeriod } from './income/income.api';
+import { dateOnlyBounds, moscowDate } from './investment-calendar';
+import {
+  type OperationInterval,
+  operationIntervals,
+} from './operations/domain/operations-sync-plan';

+const FORECAST_YEARS = 1;
 const JANUARY_INDEX = 0;
 const FIRST_DAY_OF_MONTH = 1;
 const EXCLUSIVE_END_OFFSET_MS = 1;
 const NO_END_OFFSET_MS = 0;

+export type InvestmentScreen = {
+  accountId?: string;
+  candlePeriod?: 'all' | 'halfYear' | 'month' | 'year';
+  candleRange?: { from: Date; to: Date };
+  from?: string;
+  instrumentUid?: string;
+  query?: string;
+  screen:
+    | 'account' |
+    'accounts' |
+    'bond' |
+    'bonds' |
+    'events' |
+    'income' |
+    'operations' |
+    'stock' |
+    'stocks';
+  to?: string;
+};
+const defaultEventDays = 30;
+const incomeHistoryYears = 5;
+const candleMonths = { month: 1, halfYear: 6, year: 12 };
+
 type Account = { accountId: string; openedOn: null | string };
+type Instrument = {
+  historyFrom: Date | null;
+  type: 'BOND' | 'STOCK';
+  uid: string;
+};
+type Source = {
+  accountId?: string;
+  from?: Date;
+  instrumentType?: 'BOND' | 'STOCK';
+  instrumentUid?: string;
+  kind:
+    | 'calendar' |
+    'candles' |
+    'catalog' |
+    'company' |
+    'membership' |
+    'metadata' |
+    'metrics' |
+    'operations' |
+    'portfolio' |
+    'quote';
+  priority: 'discovery' | 'history' | 'screen';
+  query?: string;
+  to?: Date;
+};
+
+// Expands screen scope, never credentials or arbitrary caller-supplied jobs.
+// Owners execute their own sources and expand instruments after discovery.
+export function planInvestmentScreen(
+  screen: InvestmentScreen,
+  context: {
+    accounts: Account[];
+    instruments: Instrument[];
+    membershipKnown: boolean;
+  },
+  now: Date,
+  force = false,
+) {
+  const sources: Source[] = [{ kind: 'membership', priority: 'discovery' }];
+  const accounts = context.accounts.filter(
+    (account) =>
+      !screen.accountId ||
+      screen.accountId === 'all' ||
+      account.accountId === screen.accountId,
+  );
+  const unavailable: { reason: string; resourceKey: string }[] = [];
+  const operations = (from: Date, to: Date, instrumentUid?: string) => {
+    const targets = accounts.flatMap((account) =>
+      from < to
+        ? [
+            {
+              accountId: account.accountId,
+              from,
+              to,
+              ...(instrumentUid ? { instrumentUid } : {}),
+            },
+          ]
+        : [],
+    );
+    sources.push(
+      ...operationIntervals(targets).map((range) => ({
+        ...range,
+        kind: 'operations' as const,
+        priority: 'screen' as const,
+      })),
+    );
+  };
+  const portfolio = () =>
+    sources.push(
+      ...accounts.map(({ accountId }) => ({
+        kind: 'portfolio' as const,
+        accountId,
+        priority: 'screen' as const,
+      })),
+    );
+  if (!context.membershipKnown) return { sources, unavailable, now };
+  if (
+    ['account', 'accounts', 'bond', 'events', 'stock'].includes(screen.screen)
+  ) {
+    portfolio();
+  }
+  if (
+    screen.screen === 'operations' ||
+    screen.screen === 'stock' ||
+    screen.screen === 'bond'
+  ) {
+    const range = ledgerRange(
+      screen.from,
+      screen.to,
+      screen.instrumentUid,
+      accounts,
+      now,
+    );
+    operations(range.from, range.to, force ? screen.instrumentUid : undefined);
+  }
+  if (screen.screen === 'account' || screen.screen === 'income') {
+    const period = planIncomePeriod(
+      screen.screen === 'income' ? screen.from : undefined,
+      screen.screen === 'income' ? screen.to : undefined,
+    );
+    const bounds = dateOnlyBounds(period.selected, now);
+    operations(bounds.from, bounds.to);
+    if (screen.screen === 'account') {
+      const range = ledgerRange(
+        screen.from,
+        screen.to,
+        undefined,
+        accounts,
+        now,
+      );
+      operations(range.from, range.to);
+    }
+  }
+  if (screen.screen === 'stocks' || screen.screen === 'bonds') {
+    sources.push({
+      kind: 'catalog',
+      instrumentType: screen.screen === 'stocks' ? 'STOCK' : 'BOND',
+      query: screen.query?.trim().toUpperCase() ?? '',
+      priority: 'screen',
+    });
+  }
+  const instruments = context.instruments.filter(
+    (instrument) =>
+      !screen.instrumentUid || instrument.uid === screen.instrumentUid,
+  );
+  if (
+    screen.instrumentUid &&
+    !instruments.length &&
+    (screen.screen === 'stock' || screen.screen === 'bond')
+  ) {
+    instruments.push({
+      uid: screen.instrumentUid,
+      type: screen.screen === 'stock' ? 'STOCK' : 'BOND',
+      historyFrom: null,
+    });
+  }
+  for (const instrument of instruments) {
+    const identity = {
+      instrumentUid: instrument.uid,
+      instrumentType: instrument.type,
+    };
+    sources.push({ ...identity, kind: 'metadata', priority: 'screen' });
+    if (['bond', 'bonds', 'stock', 'stocks'].includes(screen.screen)) {
+      sources.push({ ...identity, kind: 'quote', priority: 'screen' });
+    }
+    if (screen.screen === 'stock' || screen.screen === 'bond') {
+      sources.push({
+        ...identity,
+        kind: screen.screen === 'stock' ? 'company' : 'metrics',
+        priority: 'screen',
+      });
+      const from = new Date(now);
+      const period = screen.candlePeriod ?? 'month';
+      if (period !== 'all') {
+        // eslint-disable-next-line security/detect-object-injection -- The period belongs to the validated candle-period union.
+        from.setUTCMonth(from.getUTCMonth() - candleMonths[period]);
+      }
+      const range =
+        screen.candleRange ??
+        (period === 'all'
+          ? instrument.historyFrom
+            ? { from: instrument.historyFrom, to: now }
+            : null
+          : { from, to: now });
+      if (range) {
+        sources.push({
+          ...identity,
+          kind: 'candles',
+          ...range,
+          priority: 'screen',
+        });
+      } else {
+        unavailable.push({
+          resourceKey: `candles/${instrument.uid}/all`,
+          reason: 'history_start_unavailable',
+        });
+      }
+    }
+    if (['account', 'bond', 'events', 'stock'].includes(screen.screen)) {
+      const day =
+        screen.screen === 'stock' || screen.screen === 'bond'
+          ? moscowDate(now)
+          : now.toISOString().slice(ISO_DATE_START, ISO_DATE_LENGTH);
+      const from =
+        screen.screen === 'events' && screen.from
+          ? new Date(`${screen.from}T00:00:00Z`)
+          : new Date(`${day}T00:00:00Z`);
+      const to =
+        screen.screen === 'events' && screen.to
+          ? new Date(`${screen.to}T00:00:00Z`)
+          : new Date(from);
+      if (
+        !(screen.screen === 'events' && screen.to) &&
+        screen.screen !== 'stock' &&
+        screen.screen !== 'bond'
+      ) {
+        to.setUTCDate(to.getUTCDate() + defaultEventDays);
+      }
+      if (screen.screen === 'stock' || screen.screen === 'bond') {
+        from.setUTCFullYear(from.getUTCFullYear() - incomeHistoryYears);
+        to.setUTCFullYear(to.getUTCFullYear() + FORECAST_YEARS);
+      }
+      sources.push({
+        ...identity,
+        kind: 'calendar',
+        from,
+        to,
+        priority: 'screen',
+      });
+    }
+  }
+  if (!force && !['bonds', 'stocks'].includes(screen.screen)) {
+    sources.push(
+      ...accountHistory(accounts, now).map((range) => ({
+        ...range,
+        kind: 'operations' as const,
+        priority: 'history' as const,
+      })),
+    );
+  }
+  const priorities = { discovery: 0, screen: 1, history: 2 };
+  sources.sort(
+    (left, right) => priorities[left.priority] - priorities[right.priority],
+  );
+  return { sources, unavailable, now };
+}

 export function accountHistory(
  accounts: Account[],
@@ -1,10 +0,0 @@
-export const operationCategories = [
-  'trade',
-  'income',
-  'tax',
-  'fee',
-  'transfer',
-  'other',
-] as const;
-
-export type OperationCategory = (typeof operationCategories)[number];
@@ -6,11 +6,13 @@ import { MILLISECONDS_PER_SECOND } from '../../../../common/time';
 import { isTbankErrorCode, TbankErrorCode } from '../../../../integrations/tbank/tbank-error-code';
 import { TbankOperationState } from '../../../../integrations/tbank/tbank-protocol';
 import { TbankAccessService, TbankClient } from '../../../../integrations/tbank/tbank.api';
+import { accountHistory } from '../../investment-sync-plan';
 import {
  type OperationInterval,
  operationIntervals,
  operationsSyncPriority,
  planOperationRead,
+  uncoveredOperationIntervals,
 } from '../domain/operations-sync-plan';
 import {
  BrokerageOperationsRepository,
@@ -46,6 +48,7 @@ export class BrokerageOperationsSyncService {
    intervals: OperationInterval[],
    options: {
      force?: boolean;
+      history?: boolean;
      movingEnd?: boolean;
      observe?: boolean;
      revision?: string;
@@ -96,6 +99,30 @@ export class BrokerageOperationsSyncService {
            connection.revision,
          )
        : null;
+    if (!options.observe && !options.force && options.history) {
+      const accountIds = new Set(
+        intervals.map((interval) => interval.accountId),
+      );
+      const history = accountHistory(
+        connection.accounts.filter((account) =>
+          accountIds.has(account.accountId),
+        ),
+        now,
+      );
+      const missing = planOperationRead(history, coverage, now, {
+        movingEnd: true,
+      }).load;
+      const remaining = uncoveredOperationIntervals(missing, targets);
+      if (remaining.length) {
+        await this.request(
+          userId,
+          remaining,
+          false,
+          'history',
+          connection.revision,
+        );
+      }
+    }
    return { plan, handle };
  }

@@ -6,12 +6,17 @@ import {
  InstrumentMetadataService,
  metadataKey,
  TbankAccessService,
+  TbankMembershipService,
  type TbankOperationItem,
  tbankSourceTtlMs,
 } from '../../../../integrations/tbank/tbank.api';
 import { dateOnlyBounds, DateOnlyRange } from '../../investment-calendar';
 import { investmentResourceMeta } from '../../investment-resource.mapper';
-import { accountHistory, ledgerRange } from '../../investment-sync-plan';
+import {
+  accountHistory,
+  ledgerRange,
+  planInvestmentScreen,
+} from '../../investment-sync-plan';
 import {
  hourlyAttempt,
  TbankSyncRepository,
@@ -32,6 +37,7 @@ import {
 } from '../presentation/brokerage-operation.dto';
 import { BrokerageOperationsSyncService } from './brokerage-operations-sync.service';

+const EXCLUSIVE_END_OFFSET_MS = 1;
 const FIRST_RESULT_OFFSET = 0;
 const MISSING_MEMBERSHIP_REVISION = 0;
 const STALE_FRESHNESS_MS = 0;
@@ -55,6 +61,7 @@ export class BrokerageOperationsService {
    private readonly metadata: InstrumentMetadataService,
    private readonly repository: BrokerageOperationsRepository,
    private readonly sync: BrokerageOperationsSyncService,
+    private readonly membership: TbankMembershipService,
    private readonly config: ConfigService,
    private readonly hourlySync: TbankSyncRepository,
  ) {}
@@ -110,14 +117,35 @@ export class BrokerageOperationsService {
      cursor,
    };
    if (cursor) await this.repository.readPage(readInput);
-    const intervals = selected.flatMap((account) =>
-      from < to ? [{ accountId: account.accountId, from, to }] : [],
+    const screen = planInvestmentScreen(
+      {
+        screen: 'operations',
+        accountId,
+        from: from.toISOString(),
+        to: new Date(to.valueOf() - EXCLUSIVE_END_OFFSET_MS).toISOString(),
+      },
+      {
+        accounts: selected,
+        instruments: [],
+        membershipKnown: Boolean(connection.membershipAt),
+      },
+      now,
+    );
+    const intervals = screen.sources.flatMap((source) =>
+      source.kind === 'operations' &&
+      source.priority === 'screen' &&
+      source.accountId &&
+      source.from &&
+      source.to
+        ? [{ accountId: source.accountId, from: source.from, to: source.to }]
+        : [],
    );
    // The ledger only starts the first-time load of missing intervals; the
    // mutable tail belongs to the hourly walk and membership is not rechecked.
    if (intervals.length) {
      await this.sync.readPlan(userId, intervals, {
        movingEnd,
+        history: true,
        revision: connection.revision,
      });
    }
@@ -378,19 +406,32 @@ export class BrokerageOperationsService {
      periods: ranges,
    };
    let saved = await this.repository.readPage(input);
-    if (!observe) {
-      const targets = (saved?.connection.accounts ?? []).flatMap((account) =>
-        (saved?.periods ?? []).map((period) => ({
+    const schedule = async () => {
+      const current = await this.access.local(userId, accountId);
+      if (current.revision !== connection.revision) return;
+      const snapshot = await this.repository.readPage(input);
+      if (!snapshot?.connection.membershipAt) return;
+      const targets = snapshot.connection.accounts.flatMap((account) =>
+        (snapshot.periods ?? []).map((period) => ({
          accountId: account.accountId,
          ...period,
        })),
      );
      if (targets.length) {
        await this.sync.readPlan(userId, targets, {
-          movingEnd: saved?.periods?.some((period) => period.movingEnd),
+          movingEnd: snapshot.periods?.some((period) => period.movingEnd),
+          history: true,
          revision: connection.revision,
        });
      }
+    };
+    if (!observe) {
+      const discovery = await this.membership.request(
+        userId,
+        connection.revision,
+      );
+      if (discovery) void discovery.done.then(schedule).catch(() => undefined);
+      else await schedule();
      saved = await this.repository.readPage(input);
    }
    const now = new Date();
@@ -3,8 +3,10 @@ import { MILLISECONDS_PER_SECOND } from '../../../../common/time';
 import { decimal } from '../../../../integrations/tbank/decimal';
 import { TbankOperationType } from '../../../../integrations/tbank/tbank-protocol';
 import { TbankMoney, TbankOperationItem } from '../../../../integrations/tbank/tbank.api';
-import { type OperationCategory } from '../../operation-category';
-import { BrokerageOperationDto } from '../presentation/brokerage-operation.dto';
+import {
+  BrokerageOperationDto,
+  OperationCategory,
+} from '../presentation/brokerage-operation.dto';

 const MISSING_TIMESTAMP_COMPONENT = 0;

@@ -5,3 +5,4 @@ export type { OperationInterval } from './domain/operations-sync-plan';

 // Public cross-module surface. Nest providers are exported by the matching module.
 export { BrokerageOperationDto } from './presentation/brokerage-operation.dto';
+export { operationCategories } from './presentation/brokerage-operation.dto';
@@ -16,7 +16,6 @@ import {
 import { MoneyDto } from '../../../../common/money.dto';
 import { AccountReferenceDto } from '../../account-reference.dto';
 import { InvestmentResourceMetaDto } from '../../investment-resource.dto';
-import { operationCategories, type OperationCategory } from '../../operation-category';

 const MIN_OPERATIONS_PAGE_SIZE = 1;

@@ -24,6 +23,16 @@ const MAX_CURSOR_LENGTH = 4096;
 const MAX_OPERATIONS_PAGE_SIZE = 1000;
 export const DEFAULT_OPERATIONS_PAGE_SIZE = 100;

+export const operationCategories = [
+  'trade',
+  'income',
+  'tax',
+  'fee',
+  'transfer',
+  'other',
+] as const;
+export type OperationCategory = (typeof operationCategories)[number];
+
 export class BrokerageOperationsQueryDto {
  @ApiPropertyOptional({
    format: 'uuid',
@@ -6,10 +6,9 @@ import { PortfolioDto } from '../presentation/portfolio.dto';
 import { PortfolioService } from './portfolio.service';

 describe('persistent portfolio projection', () => {
-  const access = { local: jest.fn(), tokenForAttempt: jest.fn(), rejectMembershipToken: jest.fn() };
+  const access = { local: jest.fn(), tokenForAttempt: jest.fn() };
  const tbank = { getPortfolio: jest.fn(), getPositions: jest.fn() };
  const metadata = { savedMany: jest.fn(), request: jest.fn() };
-  const classification = { refresh: jest.fn() };
  const repository = {
    read: jest.fn(),
    reserve: jest.fn(),
@@ -24,7 +23,6 @@ describe('persistent portfolio projection', () => {
      access as never,
      tbank as never,
      metadata as never,
-      classification as never,
      repository as never,
      { request: jest.fn().mockResolvedValue(null) } as never,
      { event: jest.fn() } as never,
@@ -36,7 +34,6 @@ describe('persistent portfolio projection', () => {
      accounts: [{ accountId: 'a' }, { accountId: 'b' }],
    });
    access.tokenForAttempt.mockResolvedValue('synthetic');
-    access.rejectMembershipToken.mockResolvedValue(undefined);
    repository.reserve.mockResolvedValue(null);
    repository.read.mockResolvedValue({
      membershipAt,
@@ -47,37 +44,6 @@ describe('persistent portfolio projection', () => {
    repository.publish.mockResolvedValue(true);
    metadata.savedMany.mockResolvedValue(new Map());
    metadata.request.mockResolvedValue(null);
-    classification.refresh.mockResolvedValue(new Map());
-  });
-  it('refreshes classification before publishing and passes the hourly walk time', async () => {
-    const walkStartedAt = new Date('2026-10-31T12:00:00Z');
-    const position = { instrumentType: 'share', instrumentUid: 'uid', figi: 'figi', quantity: { units: '1' } };
-    repository.reserve.mockResolvedValue({ launch: true, work: { id: 'work', attemptId: 'attempt' } });
-    tbank.getPortfolio.mockResolvedValue({ positions: [position] });
-    tbank.getPositions.mockResolvedValue({ money: [] });
-    classification.refresh.mockResolvedValue(new Map([[JSON.stringify(['uid', 'figi']), {
-      sector: 'Energy', issuer: { id: 'issuer', name: 'Issuer' },
-    }]]));
-    const handle = await service.request('user', 'private', 'a', true, walkStartedAt);
-    assert(handle);
-    await handle.done;
-    expect(classification.refresh).toHaveBeenCalledWith('synthetic', [position], walkStartedAt);
-    expect(classification.refresh.mock.invocationCallOrder[0]).toBeLessThan(repository.publish.mock.invocationCallOrder[0]);
-    const snapshot = (repository.publish.mock.calls as [unknown, string, PortfolioDto][])[0][2];
-    expect(snapshot.positions[0]).toEqual(expect.objectContaining({
-      sector: 'Energy', issuer: { id: 'issuer', name: 'Issuer' },
-    }));
-  });
-  it('rejects an invalid classification token without publishing the snapshot', async () => {
-    repository.reserve.mockResolvedValue({ launch: true, work: { id: 'work', attemptId: 'attempt' } });
-    tbank.getPortfolio.mockResolvedValue({ positions: [] });
-    tbank.getPositions.mockResolvedValue({ money: [] });
-    classification.refresh.mockRejectedValue(new Error('INVALID_TBANK_TOKEN'));
-    const handle = await service.request('user', 'private', 'a');
-    assert(handle);
-    await handle.done;
-    expect(repository.publish).not.toHaveBeenCalled();
-    expect(access.rejectMembershipToken).toHaveBeenCalled();
  });
  it('normalizes exact signed money, order, UID metadata and unknown types without metadata RPC', async () => {
    repository.reserve.mockResolvedValueOnce({
@@ -30,7 +30,6 @@ import {
 } from '../infrastructure/portfolio.repository';
 import { mapPortfolio } from '../infrastructure/tbank-portfolio.mapper';
 import { PortfolioDto } from '../presentation/portfolio.dto';
-import { type Classification, PositionClassificationService } from './position-classification.service';

 const MISSING_DATA_REVISION = 0;
 const NO_ACCOUNTS = 0;
@@ -47,7 +46,6 @@ export class PortfolioService {
    private readonly access: TbankAccessService,
    private readonly tbank: TbankClient,
    private readonly metadata: InstrumentMetadataService,
-    private readonly classification: PositionClassificationService,
    private readonly repository: PortfolioRepository,
    private readonly membership: TbankMembershipService,
    private readonly logger: StructuredLogger,
@@ -90,11 +88,6 @@ export class PortfolioService {
          snapshot: account.portfolio
            ? {
                ...(account.portfolio.payload as unknown as PortfolioDto),
-                positions: (account.portfolio.payload as unknown as PortfolioDto).positions.map((position) => ({
-                  ...position,
-                  sector: position.sector ?? null,
-                  issuer: position.issuer ?? null,
-                })),
                lastSuccessfulAt: account.portfolio.fetchedAt.toISOString(),
                isStale:
                  Date.now() - account.portfolio.fetchedAt.valueOf() >=
@@ -238,8 +231,8 @@ export class PortfolioService {
    };
  }

-  request(userId: string, revision: string, accountId: string, force = false, walkStartedAt?: Date) {
-    return this.queueSnapshot(userId, revision, accountId, force, walkStartedAt);
+  request(userId: string, revision: string, accountId: string, force = false) {
+    return this.queueSnapshot(userId, revision, accountId, force);
  }

  private queueSnapshot(
@@ -247,7 +240,6 @@ export class PortfolioService {
    revision: string,
    accountId: string,
    force = false,
-    walkStartedAt = new Date(),
  ) {
    const reserved = this.reservations.then(async () => {
      const requested = await this.repository.reserve(
@@ -276,11 +268,9 @@ export class PortfolioService {
              this.tbank.getPortfolio(token, accountId),
              this.tbank.getPositions(token, accountId),
            ]);
-            const classifications = await this.classification.refresh(token, portfolio.positions ?? [], walkStartedAt);
            const snapshot = await this.normalize(
              portfolio.positions ?? [],
              positions.money ?? [],
-              classifications,
            );
            const published = await this.repository.publish(
              attempt,
@@ -319,10 +309,9 @@ export class PortfolioService {
  private async normalize(
    upstream: NonNullable<TbankPortfolio['positions']>,
    money: TbankMoney[],
-    classifications: ReadonlyMap<string, Classification>,
  ): Promise<PortfolioDto> {
    const lastSuccessfulAt = new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
    const savedMetadata = await this.metadata.savedMany(upstream);
-    return mapPortfolio(upstream, money, savedMetadata, lastSuccessfulAt, classifications);
+    return mapPortfolio(upstream, money, savedMetadata, lastSuccessfulAt);
  }
 }
@@ -1,172 +0,0 @@
-import { NotFoundException } from '@nestjs/common';
-
-jest.mock('../../../../prisma/prisma.service', () => ({ PrismaService: class {} }));
-import { TbankErrorCode } from '../../../../integrations/tbank/tbank-error-code';
-import { InstrumentIdType } from '../../../../integrations/tbank/tbank-protocol';
-import { PositionClassificationService } from './position-classification.service';
-
-describe('PositionClassificationService', () => {
-  const position = { instrumentType: 'share', instrumentUid: 'uid', figi: 'figi', quantity: { units: 1 } };
-  const saved = { sector: 'Old', sectorFetchedAt: new Date('2026-10-30T12:00:00Z'), assetUid: 'asset', brandUid: 'brand', brandName: 'Old brand', brandFetchedAt: new Date('2026-10-30T12:00:00Z') };
-  const tbank = { getShare: jest.fn(), getAssetBrand: jest.fn(), getBond: jest.fn(), getEtf: jest.fn() };
-  const repository = { read: jest.fn(), save: jest.fn() };
-  const logger = { event: jest.fn() };
-  const service = new PositionClassificationService(tbank as never, repository as never, logger as never);
-
-  beforeEach(() => {
-    jest.resetAllMocks();
-    repository.read.mockResolvedValue(saved);
-    repository.save.mockImplementation((_key: string, update: Record<string, unknown>) => Promise.resolve({ ...saved, ...update }));
-    tbank.getAssetBrand.mockResolvedValue({ assetUid: 'asset', brand: { uid: 'new-brand', name: 'New brand' } });
-  });
-
-  it('does not fetch a value at 23:59, and refreshes it at 24:00', async () => {
-    await service.refresh('token', [position], new Date('2026-10-31T11:59:00Z'));
-    expect(tbank.getShare).not.toHaveBeenCalled();
-    tbank.getShare.mockResolvedValue({ uid: 'uid', figi: 'figi', sector: ' Tech ', assetUid: 'asset' });
-    const result = await service.refresh('token', [position], new Date('2026-10-31T12:00:00Z'));
-    expect(result.values().next().value).toEqual({ sector: 'Tech', issuer: { id: 'new-brand', name: 'New brand' } });
-    expect(repository.save).toHaveBeenCalledWith(expect.any(String), {
-      sector: 'Tech', sectorFetchedAt: new Date('2026-10-31T12:00:00Z'),
-      brandUid: 'new-brand', brandName: 'New brand', brandFetchedAt: new Date('2026-10-31T12:00:00Z'),
-    });
-  });
-
-  it('accepts a matching FIGI after UID NOT_FOUND', async () => {
-    tbank.getShare.mockRejectedValueOnce(new NotFoundException()).mockResolvedValueOnce({ uid: 'different', figi: 'figi', sector: 'Energy', assetUid: 'asset' });
-    const result = await service.refresh('token', [position], new Date('2026-10-31T12:00:00Z'));
-    expect(tbank.getShare).toHaveBeenNthCalledWith(2, 'token', 'figi', InstrumentIdType.Figi, true);
-    expect(result.values().next().value?.sector).toBe('Energy');
-  });
-
-  it('preserves saved values on mismatched instrument and returns refreshed values on database failure', async () => {
-    tbank.getShare.mockResolvedValue({ uid: 'wrong', sector: 'Energy' });
-    const result = await service.refresh('token', [position], new Date('2026-10-31T12:00:00Z'));
-    expect(result.values().next().value?.sector).toBe('Old');
-    repository.save.mockRejectedValue(new Error('db unavailable'));
-    tbank.getShare.mockResolvedValue({ uid: 'uid', sector: 'Energy', assetUid: 'asset' });
-    const fallback = await service.refresh('token', [position], new Date('2026-10-31T12:00:00Z'));
-    expect(fallback.values().next().value?.sector).toBe('Energy');
-    expect(logger.event).toHaveBeenCalled();
-  });
-
-  it('does not retain an issuer from a previous asset when the asset changes', async () => {
-    repository.read.mockResolvedValue({ ...saved, brandFetchedAt: new Date('2026-10-31T12:00:00Z') });
-    tbank.getShare.mockResolvedValue({ uid: 'uid', sector: 'Energy', assetUid: 'other' });
-    tbank.getAssetBrand.mockResolvedValue({ assetUid: 'other', brand: { uid: 'other-brand', name: 'Other brand' } });
-    const result = await service.refresh('token', [position], new Date('2026-10-31T12:00:00Z'));
-    expect(tbank.getAssetBrand).toHaveBeenCalledWith('token', 'other');
-    expect(result.values().next().value?.issuer).toEqual({ id: 'other-brand', name: 'Other brand' });
-  });
-
-  it('does not restart the brand clock when the brand fetch fails after an asset change', async () => {
-    repository.read.mockResolvedValue({ ...saved, brandFetchedAt: new Date('2026-10-31T12:00:00Z') });
-    tbank.getShare.mockResolvedValue({ uid: 'uid', sector: 'Energy', assetUid: 'other' });
-    tbank.getAssetBrand.mockRejectedValue(new Error('upstream unavailable'));
-    const result = await service.refresh('token', [position], new Date('2026-10-31T12:00:00Z'));
-    expect(result.values().next().value?.issuer).toBeNull();
-    expect(repository.save).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
-      assetUid: 'other', brandUid: null, brandName: null, brandFetchedAt: null,
-    }));
-  });
-
-  it('does not return the previous asset brand when saving a changed asset fails', async () => {
-    repository.save.mockRejectedValue(new Error('db unavailable'));
-    tbank.getShare.mockResolvedValue({ uid: 'uid', sector: 'Energy', assetUid: 'other' });
-    tbank.getAssetBrand.mockRejectedValue(new Error('upstream unavailable'));
-    const result = await service.refresh('token', [position], new Date('2026-10-31T12:00:00Z'));
-    expect(result.values().next().value).toEqual({ sector: 'Energy', issuer: null });
-    expect(repository.save).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
-      assetUid: 'other', brandUid: null, brandName: null, brandFetchedAt: null,
-    }));
-    expect(logger.event).toHaveBeenCalled();
-  });
-
-  it('records a fetched brand as null when a fresh instrument has no asset_uid', async () => {
-    repository.read.mockResolvedValue(null);
-    tbank.getShare.mockResolvedValue({ uid: 'uid', sector: 'Energy' });
-    await service.refresh('token', [position], new Date('2026-10-31T12:00:00Z'));
-    expect(repository.save).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
-      brandUid: null, brandName: null, brandFetchedAt: new Date('2026-10-31T12:00:00Z'),
-    }));
-  });
-
-  it('treats a NOT_FOUND answer as fetched and does not refetch it an hour later', async () => {
-    tbank.getShare.mockRejectedValue(new NotFoundException());
-    await service.refresh('token', [position], new Date('2026-10-31T12:00:00Z'));
-    expect(repository.save).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
-      sector: null, sectorFetchedAt: new Date('2026-10-31T12:00:00Z'),
-    }));
-    repository.read.mockResolvedValue({ ...saved, sector: null, sectorFetchedAt: new Date('2026-10-31T12:00:00Z'), assetUid: null, brandUid: null, brandName: null, brandFetchedAt: new Date('2026-10-31T12:00:00Z') });
-    tbank.getShare.mockClear();
-    await service.refresh('token', [position], new Date('2026-10-31T13:00:00Z'));
-    expect(tbank.getShare).not.toHaveBeenCalled();
-  });
-
-  it('records a missing brand and restarts its clock when NOT_FOUND has no saved asset UID', async () => {
-    repository.read.mockResolvedValue(null);
-    tbank.getShare.mockRejectedValue(new NotFoundException());
-    const startedAt = new Date('2026-10-31T12:00:00Z');
-    const result = await service.refresh('token', [position], startedAt);
-    expect(result.values().next().value).toEqual({ sector: null, issuer: null });
-    expect(repository.save).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
-      brandUid: null, brandName: null, brandFetchedAt: startedAt,
-    }));
-    expect(tbank.getAssetBrand).not.toHaveBeenCalled();
-  });
-
-  it('does not leak one refresh call\'s invalid token into another call', async () => {
-    tbank.getShare.mockRejectedValueOnce(new Error(TbankErrorCode.InvalidToken))
-      .mockResolvedValueOnce({ uid: 'uid', figi: 'figi', sector: 'Energy', assetUid: 'asset' });
-    await expect(service.refresh('first', [position], new Date('2026-10-31T12:00:00Z'))).rejects.toThrow();
-    const result = await service.refresh('second', [position], new Date('2026-10-31T12:00:00Z'));
-    expect(result.values().next().value?.sector).toBe('Energy');
-  });
-
-  it('propagates an invalid token before publishing a classification', async () => {
-    tbank.getShare.mockRejectedValue(new Error(TbankErrorCode.InvalidToken));
-    const result = service.refresh('token', [position], new Date('2026-10-31T12:00:00Z'));
-    await expect(result).rejects.toThrow(TbankErrorCode.InvalidToken);
-    expect(repository.save).not.toHaveBeenCalled();
-  });
-
-  it('leaves a fresh brand untouched when the sector refresh finds the same asset', async () => {
-    repository.read.mockResolvedValue({ ...saved, brandFetchedAt: new Date('2026-10-31T12:00:00Z') });
-    tbank.getShare.mockResolvedValue({ uid: 'uid', sector: 'Energy', assetUid: 'asset' });
-    await service.refresh('token', [position], new Date('2026-10-31T12:00:00Z'));
-    expect(tbank.getAssetBrand).not.toHaveBeenCalled();
-  });
-
-  it('skips unsupported types, zero-quantity positions, and shares a brand lookup across instruments', async () => {
-    repository.read.mockResolvedValue(null);
-    tbank.getShare.mockResolvedValue({ uid: 'uid', sector: 'Energy', assetUid: 'asset' });
-    tbank.getBond.mockResolvedValue({ uid: 'bond', sector: 'Energy', assetUid: 'asset' });
-    const result = await service.refresh('token', [
-      { instrumentType: 'currency', instrumentUid: 'cash', figi: 'cash', quantity: { units: 1 } },
-      { instrumentType: 'share', instrumentUid: 'empty', figi: 'empty', quantity: {} },
-      { instrumentType: 'Share', instrumentUid: 'upper', figi: 'upper', quantity: { units: 1 } },
-      position,
-      { instrumentType: 'bond', instrumentUid: 'bond', figi: 'bond-figi', quantity: { units: 1 } },
-    ], new Date('2026-10-31T12:00:00Z'));
-    expect(result.size).toBe(3);
-    expect(tbank.getAssetBrand).toHaveBeenCalledTimes(1);
-    expect(tbank.getEtf).not.toHaveBeenCalled();
-  });
-
-  it('skips duplicate instrument keys and retries a failed asset lookup for another instrument in the same walk', async () => {
-    repository.read.mockResolvedValue(null);
-    tbank.getShare.mockResolvedValue({ uid: 'uid', sector: 'Energy', assetUid: 'asset' });
-    tbank.getBond.mockResolvedValue({ uid: 'bond', sector: 'Energy', assetUid: 'asset' });
-    tbank.getAssetBrand.mockRejectedValueOnce(new Error('upstream unavailable'))
-      .mockResolvedValueOnce({ assetUid: 'asset', brand: { uid: 'new-brand', name: 'New brand' } });
-    const result = await service.refresh('token', [position, position,
-      { instrumentType: 'bond', instrumentUid: 'bond', figi: 'bond-figi', quantity: { units: 1 } },
-    ], new Date('2026-10-31T12:00:00Z'));
-    expect(result.size).toBe(2);
-    expect(tbank.getShare).toHaveBeenCalledTimes(1);
-    expect(tbank.getAssetBrand).toHaveBeenCalledTimes(2);
-    expect([...result.values()].map(({ issuer }) => issuer)).toEqual([
-      null, { id: 'new-brand', name: 'New brand' },
-    ]);
-  });
-});
@@ -1,184 +0,0 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
-
-import { isZero } from '../../../../common/decimal';
-import { StructuredLogger } from '../../../../common/logging/structured-logger.service';
-import { MILLISECONDS_PER_DAY } from '../../../../common/time';
-import { decimal } from '../../../../integrations/tbank/decimal';
-import { isTbankErrorCode, TbankErrorCode } from '../../../../integrations/tbank/tbank-error-code';
-import { InstrumentIdType } from '../../../../integrations/tbank/tbank-protocol';
-import { metadataKey, TbankClient, type TbankPortfolio } from '../../../../integrations/tbank/tbank.api';
-import { PositionClassificationRepository } from '../infrastructure/position-classification.repository';
-
-export type Classification = { issuer: null | { id: string; name: string }; sector: null | string };
-type Position = NonNullable<TbankPortfolio['positions']>[number];
-type Instrument = { assetUid?: string; figi?: string; sector?: string; uid?: string };
-type Row = NonNullable<Awaited<ReturnType<PositionClassificationRepository['read']>>>;
-type Update = Parameters<PositionClassificationRepository['save']>[1];
-
-@Injectable()
-export class PositionClassificationService {
-  constructor(
-    private readonly tbank: TbankClient,
-    private readonly repository: PositionClassificationRepository,
-    private readonly logger: StructuredLogger,
-  ) {}
-
-  async refresh(token: string, positions: Position[], walkStartedAt: Date): Promise<Map<string, Classification>> {
-    const result = new Map<string, Classification>();
-    const inFlight = new Map<string, Promise<unknown>>();
-    for (const position of positions) {
-      if (!['bond', 'etf', 'share'].includes((position.instrumentType ?? '').toLowerCase())) continue;
-      if (isZero(decimal(position.quantity ?? {}))) continue;
-      const key = metadataKey(position);
-      if (result.has(key)) continue;
-      result.set(key, await this.refreshOne(token, position, key, walkStartedAt, inFlight));
-    }
-    return result;
-  }
-
-  private async refreshOne(token: string, position: Position, key: string, startedAt: Date,
-    inFlight: Map<string, Promise<unknown>>): Promise<Classification> {
-    let saved: null | Row = null;
-    const update: Update = {};
-    try {
-      saved = await this.repository.read(key);
-      const due = (at: Date | null | undefined) => !at || startedAt.valueOf() - at.valueOf() >= MILLISECONDS_PER_DAY;
-      const sectorDue = due(saved?.sectorFetchedAt);
-      const brandDue = due(saved?.brandFetchedAt);
-      let assetUid = saved?.assetUid ?? null;
-      let instrumentFresh = false;
-      if (sectorDue || (brandDue && !saved?.assetUid)) {
-        const instrument = await this.refreshInstrument(token, position, sectorDue, assetUid, update, startedAt);
-        assetUid = instrument.assetUid;
-        instrumentFresh = instrument.fresh;
-      }
-      const assetChanged = 'assetUid' in update && update.assetUid !== saved?.assetUid;
-      if (assetChanged) {
-        update.brandUid = null;
-        update.brandName = null;
-        update.brandFetchedAt = null;
-      }
-      if (brandDue || assetChanged) {
-        await this.refreshBrand(token, assetUid, update, startedAt, inFlight, instrumentFresh);
-      }
-      if (Object.keys(update).length) saved = await this.repository.save(key, update);
-    } catch (error) {
-      if (this.invalidToken(error)) throw error;
-      this.failed(error);
-    }
-    const current = { ...saved, ...update };
-    return {
-      issuer: current.brandUid && current.brandName ? { id: current.brandUid, name: current.brandName } : null,
-      sector: current.sector ?? null,
-    };
-  }
-
-  private async refreshInstrument(token: string, position: Position, sectorDue: boolean, savedUid: null | string,
-    update: Update, startedAt: Date): Promise<{ assetUid: null | string; fresh: boolean }> {
-    try {
-      const lookup = await this.instrument(token, position);
-      if (lookup && !this.matches(lookup)) return { assetUid: savedUid, fresh: false };
-      if (lookup) return { assetUid: this.acceptInstrument(lookup.found, savedUid, sectorDue, update, startedAt), fresh: true };
-      if (sectorDue) this.clearSector(update, startedAt);
-    } catch (error) {
-      if (this.invalidToken(error)) throw error;
-      if (error instanceof NotFoundException) {
-        if (sectorDue) this.clearSector(update, startedAt);
-      } else this.failed(error);
-    }
-    return { assetUid: savedUid, fresh: false };
-  }
-
-  private clearSector(update: Update, startedAt: Date) {
-    update.sector = null;
-    update.sectorFetchedAt = startedAt;
-  }
-
-  private acceptInstrument(found: Instrument, savedUid: null | string, sectorDue: boolean, update: Update, startedAt: Date) {
-    const assetUid = found.assetUid?.trim() || null;
-    if (assetUid !== savedUid) update.assetUid = assetUid;
-    if (sectorDue) this.setSector(update, found.sector, startedAt);
-    return assetUid;
-  }
-
-  private setSector(update: Update, sector: string | undefined, startedAt: Date) {
-    update.sector = sector?.trim() || null;
-    update.sectorFetchedAt = startedAt;
-  }
-
-  private async refreshBrand(token: string, assetUid: null | string, update: Update, startedAt: Date,
-    inFlight: Map<string, Promise<unknown>>, instrumentFresh: boolean) {
-    if (!assetUid) {
-      if (instrumentFresh || 'assetUid' in update || 'sectorFetchedAt' in update) this.clearBrand(update, startedAt);
-      return;
-    }
-    try {
-      const asset = await this.dedupe(inFlight, assetUid, () => this.tbank.getAssetBrand(token, assetUid));
-      if (asset && asset.assetUid !== assetUid) return;
-      const uid = asset?.brand?.uid?.trim() || null;
-      const name = asset?.brand?.name?.trim() || null;
-      update.brandUid = uid && name ? uid : null;
-      update.brandName = uid && name ? name : null;
-      update.brandFetchedAt = startedAt;
-    } catch (error) {
-      if (this.invalidToken(error)) throw error;
-      if (error instanceof NotFoundException) this.clearBrand(update, startedAt);
-      else this.failed(error);
-    }
-  }
-
-  private clearBrand(update: Update, startedAt: Date) {
-    update.brandUid = null;
-    update.brandName = null;
-    update.brandFetchedAt = startedAt;
-  }
-
-  private matches(lookup: { found: Instrument; id: string; idType: InstrumentIdType }) {
-    return (lookup.idType === InstrumentIdType.Uid ? lookup.found.uid : lookup.found.figi) === lookup.id;
-  }
-
-  private invalidToken(error: unknown) {
-    return error instanceof Error && isTbankErrorCode(error.message, TbankErrorCode.InvalidToken);
-  }
-
-  private async instrument(token: string, position: Position) {
-    const type = (position.instrumentType ?? '').toLowerCase();
-    const lookup = (id: string, idType: InstrumentIdType) => {
-      switch (type) {
-        case 'bond': return this.tbank.getBond(token, id, idType, true);
-        case 'share': return this.tbank.getShare(token, id, idType, true);
-        default: return this.tbank.getEtf(token, id, idType, true);
-      }
-    };
-    const uid = position.instrumentUid?.trim();
-    const figi = position.figi?.trim();
-    if (uid) {
-      try {
-        const found = await lookup(uid, InstrumentIdType.Uid);
-        if (found) return { found, id: uid, idType: InstrumentIdType.Uid };
-      } catch (error) {
-        if (!(error instanceof NotFoundException)) throw error;
-      }
-    }
-    if (figi) {
-      const found = await lookup(figi, InstrumentIdType.Figi);
-      return found ? { found, id: figi, idType: InstrumentIdType.Figi } : null;
-    }
-    return null;
-  }
-
-  private dedupe<T>(map: Map<string, Promise<unknown>>, key: string, run: () => Promise<T>): Promise<T> {
-    const pending = map.get(key);
-    if (pending) return pending as Promise<T>;
-    const promise = run().catch((error: unknown) => {
-      map.delete(key);
-      throw error;
-    });
-    map.set(key, promise);
-    return promise;
-  }
-
-  private failed(error: unknown) {
-    this.logger.event('warn', 'portfolio.classification.failed', { code: error instanceof Error ? error.name : 'Unknown' });
-  }
-}
@@ -14,8 +14,6 @@ const position = (
  isin: null,
  ticker: null,
  logoName: null,
-  sector: null,
-  issuer: null,
  absoluteReturn: null,
  averagePurchasePrice: null,
 });
@@ -1,29 +0,0 @@
-import { Injectable } from '@nestjs/common';
-
-import { PrismaService } from '../../../../prisma/prisma.service';
-
-@Injectable()
-export class PositionClassificationRepository {
-  constructor(private readonly prisma: PrismaService) {}
-
-  read(key: string) {
-    return this.prisma.tbankInstrumentClassification.findUnique({
-      where: { provider_instrumentKey: { provider: 'tbank', instrumentKey: key } },
-    });
-  }
-
-  save(key: string, data: {
-    assetUid?: null | string;
-    brandFetchedAt?: Date | null;
-    brandName?: null | string;
-    brandUid?: null | string;
-    sector?: null | string;
-    sectorFetchedAt?: Date;
-  }) {
-    return this.prisma.tbankInstrumentClassification.upsert({
-      where: { provider_instrumentKey: { provider: 'tbank', instrumentKey: key } },
-      create: { provider: 'tbank', instrumentKey: key, ...data },
-      update: data,
-    });
-  }
-}
@@ -1,5 +1,4 @@
 import type { Money } from '../../../../common/money.types';
-import type { Classification } from '../application/position-classification.service';
 import type { PortfolioDto, PortfolioPositionDto } from '../presentation/portfolio.dto';

 import {
@@ -36,10 +35,9 @@ function mapPortfolio(
  cash: TbankMoney[],
  metadata: ReadonlyMap<string, { data?: null | TbankInstrument }>,
  lastSuccessfulAt: string,
-  classification: ReadonlyMap<string, Classification> = new Map(),
 ): PortfolioDto {
  const positions = upstream
-    .map((position) => mapPosition(position, metadata.get(metadataKey(position))?.data ?? null, classification.get(metadataKey(position))))
+    .map((position) => mapPosition(position, metadata.get(metadataKey(position))?.data ?? null))
    .filter((position): position is PortfolioPositionDto => position !== null);
  const balances = new Map<string, ReturnType<typeof decimal>>();
  for (const value of cash) {
@@ -65,7 +63,6 @@ function mapPortfolio(
 function mapPosition(
  position: NonNullable<TbankPortfolio['positions']>[number],
  metadata: null | TbankInstrument,
-  classification?: Classification,
 ): null | PortfolioPositionDto {
  const quantity = decimal(position.quantity ?? {});
  if (isZero(quantity)) return null;
@@ -99,8 +96,6 @@ function mapPosition(
    isin: metadata?.isin?.trim() || null,
    ticker: metadata?.ticker?.trim() || null,
    logoName: metadata?.brand?.logoName?.trim() || null,
-    sector: classification?.sector ?? null,
-    issuer: classification?.issuer ?? null,
  };
 }

@@ -5,10 +5,8 @@ import { AuthModule } from '../../auth/auth.module';
 import { TbankSyncRepositoryModule } from '../tbank-sync/tbank-sync-repository.module';
 import { ForecastService } from './application/forecast.service';
 import { PortfolioService } from './application/portfolio.service';
-import { PositionClassificationService } from './application/position-classification.service';
 import { ForecastRepository } from './infrastructure/forecast.repository';
 import { PortfolioRepository } from './infrastructure/portfolio.repository';
-import { PositionClassificationRepository } from './infrastructure/position-classification.repository';
 import { PortfolioController } from './presentation/portfolio.controller';

@Module({
@@ -17,8 +15,6 @@ import { PortfolioController } from './presentation/portfolio.controller';
  providers: [
    PortfolioService,
    PortfolioRepository,
-    PositionClassificationService,
-    PositionClassificationRepository,
    ForecastService,
    ForecastRepository,
  ],
@@ -4,14 +4,6 @@ import { MoneyDto } from '../../../../common/money.dto';
 import { AccountReferenceDto } from '../../account-reference.dto';
 import { InvestmentResourceMetaDto } from '../../investment-resource.dto';

-export class PortfolioIssuerDto {
-  @ApiProperty()
-  declare id: string;
-
-  @ApiProperty()
-  declare name: string;
-}
-
 export class PortfolioPositionDto {
  @ApiPropertyOptional({ type: String, nullable: true })
  instrumentUid?: null | string;
@@ -60,12 +52,6 @@ export class PortfolioPositionDto {

  @ApiProperty({ type: String, nullable: true })
  declare logoName: null | string;
-
-  @ApiProperty({ type: String, nullable: true })
-  declare sector: null | string;
-
-  @ApiProperty({ type: PortfolioIssuerDto, nullable: true })
-  declare issuer: null | PortfolioIssuerDto;
 }

 export class PortfolioStructureCategoryDto {
@@ -132,7 +132,6 @@ export class TbankHourlyScheduler implements OnModuleDestroy, OnModuleInit {
  // upstream call inside one. The attempt outcome is derived from durable
  // step rows by the repository, never from walk-local state.
  private async walk(attempt: TbankSyncAttempt) {
-    const walkStartedAt = new Date();
    this.active.add(attempt.attemptId);
    try {
      const { userId, revision } = attempt;
@@ -156,7 +155,6 @@ export class TbankHourlyScheduler implements OnModuleDestroy, OnModuleInit {
        accounts,
        dispatch,
        dispatchProblems,
-        walkStartedAt,
      );
      await this.waitWorks(userId, children.map((child) => child.id));
      for (const account of accounts) {
@@ -241,7 +239,6 @@ export class TbankHourlyScheduler implements OnModuleDestroy, OnModuleInit {
    accounts: Accounts,
    dispatch: DispatchStep,
    dispatchProblems: HourlySection[],
-    walkStartedAt: Date,
  ) {
    for (const account of accounts) {
      await this.dispatchPortfolio(
@@ -250,7 +247,6 @@ export class TbankHourlyScheduler implements OnModuleDestroy, OnModuleInit {
        account.accountId,
        dispatch,
        dispatchProblems,
-        walkStartedAt,
      );
    }
    for (const account of accounts) {
@@ -278,11 +274,10 @@ export class TbankHourlyScheduler implements OnModuleDestroy, OnModuleInit {
    accountId: string,
    dispatch: DispatchStep,
    dispatchProblems: HourlySection[],
-    walkStartedAt: Date,
  ) {
    try {
      const work = await this.withBound(
-        this.portfolio.request(userId, revision, accountId, true, walkStartedAt),
+        this.portfolio.request(userId, revision, accountId, true),
      );
      if (work && work !== BOUND_EXPIRED) {
        await dispatch({ accountId, id: work.id, section: 'portfolio' });
@@ -23,7 +23,7 @@ import {

 import { MAX_INSTRUMENT_QUERY_LENGTH, MIN_INSTRUMENT_QUERY_LENGTH } from '../instrument-query';
 import { InvestmentAttemptProblemDto } from '../investment-resource.dto';
-import { operationCategories } from '../operation-category';
+import { operationCategories } from '../operations/operations.api';

 const MIN_ACCOUNT_ID_LENGTH = 1;
 const MIN_SYNC_PAGE_SIZE = 1;
@@ -32,7 +32,7 @@ import {
  UpcomingEventsQueryDto,
 } from './upcoming-events.dto';

-export enum EventsErrorCode { InvalidPeriod = 'INVALID_EVENTS_PERIOD' }
+enum EventsErrorCode { InvalidPeriod = 'INVALID_EVENTS_PERIOD' }

 const FIRST_BATCH_OFFSET = 0;

@@ -1,38 +1,12 @@
 import { INestApplication } from '@nestjs/common';
 import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';

-import { HttpErrorCode } from './common/error-code';
-import { MoexErrorCode } from './integrations/moex/moex.client';
-import { NcrErrorCode } from './integrations/ncr/ncr-ratings.client';
-import { TbankErrorCode } from './integrations/tbank/tbank-error-code';
-import { AuthErrorCode } from './modules/auth/application/auth-error-code';
-import { BankErrorCode } from './modules/banking/bank-cards/application/bank-card-input';
-import { IncomeErrorCode } from './modules/investments/income/income-period';
-import { InstrumentErrorCode } from './modules/investments/instruments/domain/instrument-error-code';
-import { OperationErrorCode } from './modules/investments/operations/domain/operation-error-code';
-import { EventsErrorCode } from './modules/investments/upcoming-events/upcoming-events.service';
-
 export const API_PREFIX = 'api/v1';

 // Nest Swagger cannot express additionalProperties on a class, so closed request
 // bodies are restored here after generation; the runtime allowlist stays in the controller.
 const CLOSED_SCHEMAS = ['StockScreenerCriteriaDto'];

-// Every code HttpExceptionFilter can emit. Assembled at the composition root so
-// common/ProblemDetailsDto does not depend on modules.
-export const PROBLEM_CODES = [
-  ...Object.values(HttpErrorCode),
-  ...Object.values(AuthErrorCode),
-  ...Object.values(OperationErrorCode),
-  ...Object.values(InstrumentErrorCode),
-  ...Object.values(TbankErrorCode),
-  ...Object.values(BankErrorCode),
-  ...Object.values(MoexErrorCode),
-  ...Object.values(NcrErrorCode),
-  ...Object.values(EventsErrorCode),
-  ...Object.values(IncomeErrorCode),
-];
-
 export function createOpenApiDocument(app: INestApplication) {
  const document = SwaggerModule.createDocument(
    app,
@@ -44,8 +18,5 @@ export function createOpenApiDocument(app: INestApplication) {
      schema.additionalProperties = false;
    }
  }
-  const problem = schemas.ProblemDetailsDto;
-  const problemCode = problem && 'properties' in problem ? problem.properties?.code : undefined;
-  if (problemCode && !('$ref' in problemCode)) problemCode.enum = PROBLEM_CODES;
  return document;
 }
@@ -121,55 +121,6 @@ describe('OpenAPI contract (integration)', () => {
    expect(analytics.properties).not.toHaveProperty('yearComparison');
  });

-  it('publishes every emitted problem detail code as a named enum', () => {
-    const schemas = createOpenApiDocument(app).components?.schemas;
-    const expectedCodes = [
-      'BAD_REQUEST',
-      'INTERNAL_SERVER_ERROR',
-      'NOT_FOUND',
-      'UNAUTHORIZED',
-      'UNSUPPORTED_MEDIA_TYPE',
-      'VALIDATION_ERROR',
-      'EMAIL_ALREADY_REGISTERED',
-      'INVALID_CREDENTIALS',
-      'INVALID_OPERATIONS_CURSOR',
-      'BOND_HISTORY_START_UNAVAILABLE',
-      'BOND_TICKER_AMBIGUOUS',
-      'STOCK_HISTORY_START_UNAVAILABLE',
-      'STOCK_TICKER_AMBIGUOUS',
-      'INVALID_TBANK_TOKEN',
-      'TBANK_NOT_CONNECTED',
-      'TBANK_UNAVAILABLE',
-      'BANK_CARD_ARCHIVED',
-      'BANK_DEPENDENT_REFUNDS',
-      'BANK_DUPLICATE_CATEGORY',
-      'BANK_IMMUTABLE_OPERATION',
-      'BANK_INTENT_CONFLICT',
-      'BANK_INVALID_DATE',
-      'BANK_INVALID_INPUT',
-      'BANK_INVALID_MONEY',
-      'BANK_INVALID_REFUND',
-      'BANK_NOT_FOUND',
-      'BANK_OPENING_DATE_CONFLICT',
-      'BANK_OPERATION_DELETED',
-      'BANK_REFUND_LIMIT',
-      'BANK_VERSION_CONFLICT',
-      'BANK_WRITE_CONFLICT',
-      'MOEX_UNAVAILABLE',
-      'NCR_UNAVAILABLE',
-      'INVALID_EVENTS_PERIOD',
-      'INVALID_INCOME_PERIOD',
-    ];
-
-    const problem = schemas?.ProblemDetailsDto;
-    assert(problem && !('$ref' in problem));
-    const codeSchema = problem.properties?.code;
-    assert(codeSchema && !('$ref' in codeSchema));
-    expect(codeSchema.type).toBe('string');
-    expect(codeSchema.enum).toEqual(expect.arrayContaining(expectedCodes));
-    expect(codeSchema.enum).toHaveLength(expectedCodes.length);
-  });
-
  it('generates the runtime contract without server startup or deployment configuration', async () => {
    const schemas = createOpenApiDocument(app).components?.schemas;
    expect(schemas?.StockScreenerCriteriaDto).toMatchObject({
@@ -297,58 +297,6 @@ describe('local income completeness and exact money (SQLite)', () => {
    expect(result.data?.calculatedAt).toBe('2025-02-01T00:00:00.000Z');
    expect(upstream.getOperationsByCursor).not.toHaveBeenCalled();
  });
-  it('ordinary covered income reads local data without membership or operations RPC', async () => {
-    await prisma.tbankConnection.update({
-      where: { userId: 'income-owner' },
-      data: { membershipAt: new Date('2020-01-01Z') },
-    });
-    const response = await get('a', undefined, false).expect(200);
-    const result = response.body as IncomeAnalyticsResourceDto;
-    expect(result.data).not.toBeNull();
-    expect(result.meta.completeness).toBe('complete');
-    expect(upstream.getOpenAccounts).not.toHaveBeenCalled();
-    expect(upstream.getOperationsByCursor).not.toHaveBeenCalled();
-  });
-  it('cold income imports only the missing requested interval', async () => {
-    await prisma.tbankConnection.update({
-      where: { userId: 'income-owner' },
-      data: { membershipAt: new Date('2020-01-01Z') },
-    });
-    let release: () => void = () => {
-      throw new Error('Upstream not initialized');
-    };
-    const blocked = new Promise<{ hasNext: boolean; items: never[] }>((resolve) => {
-      release = () => resolve({ hasNext: false, items: [] });
-    });
-    upstream.getOperationsByCursor.mockReturnValue(blocked);
-    const first = await get('a', 'from=2025-02-01&to=2025-02-28', false).expect(200);
-    const cold = first.body as IncomeAnalyticsResourceDto;
-    release();
-    expect(cold.data).toBeNull();
-    expect(cold.meta.completeness).toBe('incomplete');
-    let result: IncomeAnalyticsResourceDto = cold;
-    for (let attempt = 0; attempt < 100; attempt++) {
-      const response = await get('a', 'from=2025-02-01&to=2025-02-28').expect(200);
-      result = response.body as IncomeAnalyticsResourceDto;
-      if (result.meta.completeness === 'complete') break;
-      await new Promise((resolve) => setTimeout(resolve, 10));
-    }
-    expect(result.data).not.toBeNull();
-    expect(result.meta.completeness).toBe('complete');
-    expect(upstream.getOpenAccounts).not.toHaveBeenCalled();
-    expect(upstream.getOperationsByCursor.mock.calls).toEqual([
-      ['synthetic', expect.objectContaining({
-        accountId: 'a',
-        from: { seconds: '1738357199' },
-        to: { seconds: '1738368001' },
-      })],
-      ['synthetic', expect.objectContaining({
-        accountId: 'a',
-        from: { seconds: '1738367999' },
-        to: { seconds: '1740776401' },
-      })],
-    ]);
-  });
  it('returns while a cold upstream is blocked and validates access/period before scheduling', async () => {
    await get('absent', undefined, false).expect(404);
    await get('a', 'from=2025-02-31&to=2025-03-01', false).expect(400);
@@ -113,50 +113,6 @@ describe('persistent ledger HTTP and cursor (SQLite)', () => {
      }
    }
  });
-  it.each([
-    'from=2099-01-01',
-    'from=2025-03-01&to=2025-02-01',
-  ])('empty ledger range %s returns 200 without upstream RPC', async (query) => {
-    const response = await request(app.getHttpServer())
-      .get(`/api/v1/brokerage-accounts/a/operations?${query}`)
-      .set('Authorization', auth())
-      .expect(200);
-    const result = response.body as BrokerageOperationsResourceDto;
-    expect(result.data?.items).toEqual([]);
-    expect(upstream.getOperationsByCursor).not.toHaveBeenCalled();
-  });
-  it('cold ledger imports only the missing requested interval', async () => {
-    upstream.getOperationsByCursor.mockResolvedValue({
-      hasNext: false,
-      items: [],
-    });
-    await put().expect(200);
-    await request(app.getHttpServer())
-      .get('/api/v1/brokerage-accounts/a/operations?from=2025-02-01&to=2025-02-28')
-      .set('Authorization', auth())
-      .expect(200);
-    let complete = false;
-    for (let attempt = 0; attempt < 100; attempt++) {
-      const response = await request(app.getHttpServer())
-        .get('/api/v1/brokerage-accounts/a/operations?from=2025-02-01&to=2025-02-28&sync=observe')
-        .set('Authorization', auth())
-        .expect(200);
-      const result = response.body as BrokerageOperationsResourceDto;
-      complete = result.meta.completeness === 'complete';
-      if (complete) break;
-      await delay(10);
-    }
-    expect(complete).toBe(true);
-    expect(upstream.getOperationsByCursor).toHaveBeenCalledTimes(1);
-    expect(upstream.getOperationsByCursor).toHaveBeenCalledWith(
-      'synthetic',
-      expect.objectContaining({
-        accountId: 'a',
-        from: { seconds: '1738367999' },
-        to: { seconds: '1740787201' },
-      }),
-    );
-  });
  it('reads ordered pages with identical IDs/timestamps across accounts and no upstream RPC, including after reopen', async () => {
    let cursor: null | string = null;
    const ids: string[] = [];
@@ -453,7 +409,7 @@ describe('persistent ledger HTTP and cursor (SQLite)', () => {
    const result = (await get('sync=observe', 'a').expect(200))
      .body as BrokerageOperationsResourceDto;
    expect(result.meta.coverage?.historyBoundary).toBe('unknown');
-    expect(result.meta.coverage?.historyState).toBe('missing');
+    expect(result.meta.coverage?.historyState).toBe('loading');
  }, 30_000);

  it('returns cold missing while upstream is blocked, then confirms an empty interval; observe never retries failure', async () => {
@@ -76,7 +76,7 @@ describe('Request-driven operations synchronization (SQLite)', () => {
        where: { id },
      });
      if (work.state === expected) return work;
-      await delay(2); // Backoff between exact DB-state polls; not a timing barrier.
+      await delay(2);
    }
    throw new Error(`Sync did not reach ${expected}`);
  }
@@ -113,7 +113,6 @@ describe('Request-driven operations synchronization (SQLite)', () => {
    });
    service = createService();
  });
-  afterEach(() => jest.restoreAllMocks());
  afterAll(async () => prisma.$disconnect());

  it.each([[false, 1], [true, 1], [false, 2], [true, 2]] as const)(
@@ -187,17 +186,13 @@ describe('Request-driven operations synchronization (SQLite)', () => {

  it('publishes the forced visible period before unrelated pending history and retains it if history fails', async () => {
    const gate = deferred<TbankOperationsByCursorResponse>();
-    const started = deferred<void>();
    const march = {
      ...january,
      from: new Date('2026-03-01Z'),
      to: new Date('2026-04-01Z'),
    };
    upstream.getOperationsByCursor
-      .mockImplementationOnce(() => {
-        started.resolve();
-        return gate.promise;
-      })
+      .mockReturnValueOnce(gate.promise)
      .mockImplementation((_token, request) => {
        if (Number(request.from?.seconds) + 1 === march.from.valueOf() / 1000) {
          return Promise.resolve({
@@ -210,9 +205,7 @@ describe('Request-driven operations synchronization (SQLite)', () => {
    const history = requiredHandle(
      await service.request('owner', [february, march], false, 'history'),
    );
-    // RPC starts after reserve/claim commits and pending reads the history plan.
-    // Waiting for state=running alone would not ensure that pending was read.
-    await started.promise;
+    await delay(5);
    const screen = requiredHandle(
      await service.request('owner', [march], true),
    );
@@ -232,12 +225,8 @@ describe('Request-driven operations synchronization (SQLite)', () => {

  it('moves a newly visible interval ahead of pending backfill and records an unknown requested floor', async () => {
    const gate = deferred<TbankOperationsByCursorResponse>();
-    const started = deferred<void>();
    upstream.getOperationsByCursor
-      .mockImplementationOnce(() => {
-        started.resolve();
-        return gate.promise;
-      })
+      .mockReturnValueOnce(gate.promise)
      .mockResolvedValue({ hasNext: false, items: [] });
    const march = {
      ...january,
@@ -252,7 +241,7 @@ describe('Request-driven operations synchronization (SQLite)', () => {
        'history',
      ),
    );
-    await started.promise;
+    await delay(5);
    await service.request('owner', [march], false);
    gate.resolve({ hasNext: false, items: [] });
    await state(history, 'complete');
@@ -482,7 +471,7 @@ describe('Request-driven operations synchronization (SQLite)', () => {
        expect(saved.state).toBe(
          checkpoint === 'after-publish' ? 'complete' : 'running',
        );
-        await delay(10); // Bounded pause; absence of a recovery RPC cannot be awaited.
+        await delay(10);
        expect(upstream.getOperationsByCursor).not.toHaveBeenCalled();
        if (checkpoint === 'after-publish') {
          // eslint-disable-next-line jest/no-conditional-expect -- The parameterized fixture chooses the scenario; each branch asserts its outcome and the test also asserts common invariants.
@@ -515,17 +504,13 @@ describe('Request-driven operations synchronization (SQLite)', () => {

  it('joins a request bridging active groups and keeps both original handles observable', async () => {
    const blocked = deferred<typeof complete>();
-    const started = deferred<void>();
    upstream.getOperationsByCursor
-      .mockImplementationOnce(() => {
-        started.resolve();
-        return blocked.promise;
-      })
+      .mockReturnValueOnce(blocked.promise)
      .mockResolvedValue({ hasNext: false, items: [] });
    const early = { ...january, to: new Date('2026-01-10Z') };
    const late = { ...january, from: new Date('2026-01-20Z') };
    const first = requiredHandle(await service.request('owner', [early], true));
-    await started.promise;
+    await delay(5);
    const second = requiredHandle(await service.request('owner', [late], true));
    const merged = requiredHandle(
      await service.request('owner', [january], true),
@@ -541,28 +526,25 @@ describe('Request-driven operations synchronization (SQLite)', () => {

  it('extends an overlapping atomic group without rereading its intersection or publishing a partial result', async () => {
    const first = deferred<typeof complete>();
-    const started = deferred<void>();
    const remainder = deferred<typeof complete>();
-    const remainderStarted = deferred<void>();
    const early = { ...january, to: new Date('2026-01-20Z') };
    const late = { ...january, from: new Date('2026-01-10Z') };
    upstream.getOperationsByCursor
-      .mockImplementationOnce(() => {
-        started.resolve();
-        return first.promise;
-      })
-      .mockImplementationOnce(() => {
-        remainderStarted.resolve();
-        return remainder.promise;
-      });
+      .mockReturnValueOnce(first.promise)
+      .mockReturnValueOnce(remainder.promise);
    const handle = requiredHandle(
      await service.request('owner', [early], true),
    );
-    await started.promise;
-    expect(upstream.getOperationsByCursor).toHaveBeenCalledTimes(1);
+    await delay(5);
    expect(await service.request('owner', [late], true)).toBe(handle);
    first.resolve({ hasNext: false, items: [] });
-    await remainderStarted.promise;
+    for (
+      let index = 0;
+      index < 500 && upstream.getOperationsByCursor.mock.calls.length < 2;
+      index += 1
+    ) {
+      await delay(2);
+    }
    expect(upstream.getOperationsByCursor).toHaveBeenCalledTimes(2);
    expect(upstream.getOperationsByCursor.mock.calls[1][1].from).toEqual({
      seconds: String(early.to.valueOf() / 1000 - 1),
@@ -579,17 +561,13 @@ describe('Request-driven operations synchronization (SQLite)', () => {
      items: never[];
      nextCursor: string;
    }>();
-    const started = deferred<void>();
    upstream.getOperationsByCursor
-      .mockImplementationOnce(() => {
-        started.resolve();
-        return first.promise;
-      })
+      .mockReturnValueOnce(first.promise)
      .mockResolvedValue({ hasNext: false, items: [] });
    const history = requiredHandle(
      await service.request('owner', [january], false, 'history'),
    );
-    await started.promise;
+    await delay(5);
    const screen = requiredHandle(
      await service.request('owner', [february], true),
    );
@@ -605,17 +583,19 @@ describe('Request-driven operations synchronization (SQLite)', () => {

  it('keeps published initial windows on recovery and restarts only the unfinished month', async () => {
    const blocked = deferred<typeof complete>();
-    const blockedStarted = deferred<void>();
    upstream.getOperationsByCursor
      .mockResolvedValueOnce(complete)
-      .mockImplementationOnce(() => {
-        blockedStarted.resolve();
-        return blocked.promise;
-      });
+      .mockReturnValueOnce(blocked.promise);
    const handle = requiredHandle(
      await service.request('owner', [january, february], false),
    );
-    await blockedStarted.promise;
+    for (
+      let index = 0;
+      index < 500 && upstream.getOperationsByCursor.mock.calls.length < 2;
+      index += 1
+    ) {
+      await delay(2);
+    }
    expect(await prisma.tbankOperation.count()).toBe(1);
    const before = await prisma.tbankOperationCoverage.findMany();
    expect(before).toHaveLength(1);
@@ -636,15 +616,8 @@ describe('Request-driven operations synchronization (SQLite)', () => {
        })
      ).fetchedAt,
    ).toEqual(before[0].fetchedAt);
-    const stalePage = deferred<Promise<boolean>>();
-    const stagePage = repository.stagePage.bind(repository);
-    jest.spyOn(repository, 'stagePage').mockImplementation((...args) => {
-      const result = stagePage(...args);
-      stalePage.resolve(result);
-      return result;
-    });
    blocked.resolve(complete);
-    expect(await stalePage.promise).toBe(false);
+    await delay(10);
    expect(await prisma.tbankOperation.count()).toBe(1);
    expect(await prisma.tbankOperationCoverage.count()).toBe(2);
  });
@@ -678,11 +651,7 @@ describe('Request-driven operations synchronization (SQLite)', () => {

  it('coalesces twenty requests, observes without RPC and completes only after the last page', async () => {
    const blocked = deferred<typeof complete>();
-    const started = deferred<void>();
-    upstream.getOperationsByCursor.mockImplementationOnce(() => {
-      started.resolve();
-      return blocked.promise;
-    });
+    upstream.getOperationsByCursor.mockReturnValueOnce(blocked.promise);
    const handles = await Promise.all(
      Array.from({ length: 20 }, () =>
        service.request('owner', [january], true),
@@ -690,7 +659,7 @@ describe('Request-driven operations synchronization (SQLite)', () => {
    );
    expect(new Set(handles).size).toBe(1);
    const handle = requiredHandle(handles[0]);
-    await started.promise;
+    await delay(5);
    expect(upstream.getOperationsByCursor).toHaveBeenCalledTimes(1);
    expect((await service.observe('owner', handle)).state).toBe('running');
    expect(await prisma.tbankOperation.count()).toBe(0);
@@ -730,7 +699,6 @@ describe('Request-driven operations synchronization (SQLite)', () => {
    expect(await prisma.tbankOperationCoverage.findMany()).toEqual(oldCoverage);
    const calls = upstream.getOperationsByCursor.mock.calls.length;
    await service.observe('owner', handle);
-    // Bounded pause; absence of a background retry cannot be awaited.
    await delay(10);
    expect(upstream.getOperationsByCursor).toHaveBeenCalledTimes(calls);
    upstream.getOperationsByCursor
@@ -745,29 +713,29 @@ describe('Request-driven operations synchronization (SQLite)', () => {

  it('starts an unfinished interval from page one after a new run request and ignores late old pages', async () => {
    const blocked = deferred<typeof complete>();
-    const blockedStarted = deferred<void>();
    upstream.getOperationsByCursor
      .mockResolvedValueOnce({
        hasNext: true,
        nextCursor: 'provider-cursor',
        items: [operation()],
      })
-      .mockImplementationOnce(() => {
-        blockedStarted.resolve();
-        return blocked.promise;
-      });
+      .mockReturnValueOnce(blocked.promise);
    const handle = requiredHandle(
      await service.request('owner', [january], true),
    );
-    await blockedStarted.promise;
+    for (
+      let index = 0;
+      index < 500 && upstream.getOperationsByCursor.mock.calls.length < 2;
+      index += 1
+    ) {
+      await delay(2);
+    }
+    expect(upstream.getOperationsByCursor).toHaveBeenCalledTimes(2);
    const before = await prisma.tbankSyncWork.findUniqueOrThrow({
      where: { id: handle },
    });
-    expect(await prisma.tbankSyncStage.count()).toBeGreaterThan(0);
-
    service = createService();
    await service.observe('owner', handle);
-    // Bounded pause; absence of work adoption by observe cannot be awaited.
    await delay(5);
    expect(upstream.getOperationsByCursor).toHaveBeenCalledTimes(2);
    upstream.getOperationsByCursor.mockResolvedValueOnce({
@@ -784,15 +752,8 @@ describe('Request-driven operations synchronization (SQLite)', () => {
    expect(
      upstream.getOperationsByCursor.mock.calls[2][1].cursor,
    ).toBeUndefined();
-    const stalePage = deferred<Promise<boolean>>();
-    const stagePage = repository.stagePage.bind(repository);
-    jest.spyOn(repository, 'stagePage').mockImplementation((...args) => {
-      const result = stagePage(...args);
-      stalePage.resolve(result);
-      return result;
-    });
    blocked.resolve(complete);
-    expect(await stalePage.promise).toBe(false);
+    await delay(10);
    expect((await prisma.tbankOperation.findFirstOrThrow()).payload).toEqual(
      operation('30'),
    );
@@ -1,9 +1,6 @@
 import { ConfigService } from '@nestjs/config';
 import assert from 'node:assert/strict';

-import type { Prisma } from '../generated/prisma/client';
-import type { PortfolioDto } from '../src/modules/investments/portfolio/presentation/portfolio.dto';
-
 import { PortfolioRepository } from '../src/modules/investments/portfolio/infrastructure/portfolio.repository';
 import { PrismaService } from '../src/prisma/prisma.service';

@@ -19,41 +16,9 @@ describe('portfolio publication (SQLite)', () => {
    totalsByCurrency: [],
    positions: [],
    cashBalances: [],
-    structure: { currencies: [], unvaluedCategories: [] },
-  } satisfies PortfolioDto;
+    structure: {},
+  } as never;
  const accountId = 'account';
-  const valuedSnapshot = {
-    ...snapshot,
-    totalsByCurrency: [
-      { currency: 'RUB', value: '200' },
-      { currency: 'USD', value: '10' },
-    ],
-  } satisfies PortfolioDto;
-  const createRunningAttempt = () =>
-    prisma.tbankSyncWork.create({
-      data: {
-        id: 'live',
-        userId: 'owner',
-        revision: 'current',
-        scopeKey: `portfolio:${accountId}`,
-        intent: {},
-        state: 'running',
-        attemptId: 'live-attempt',
-        processRunId: 'run',
-        priority: 1,
-        progress: {},
-      },
-    });
-  const interceptTransaction = (intercept: (tx: Prisma.TransactionClient) => void) => {
-    const transaction = prisma.$transaction.bind(prisma);
-    jest.spyOn(prisma, '$transaction').mockImplementation(
-      (callback: (tx: Prisma.TransactionClient) => Promise<unknown>) =>
-        transaction((tx) => {
-          intercept(tx);
-          return callback(tx);
-        }),
-    );
-  };

  beforeAll(async () => {
    await prisma.$connect();
@@ -62,9 +27,7 @@ describe('portfolio publication (SQLite)', () => {
    });
  });
  afterAll(async () => prisma.$disconnect());
-  afterEach(() => jest.restoreAllMocks());
  beforeEach(async () => {
-    await prisma.tbankPortfolioValueHistory.deleteMany();
    await prisma.tbankConnection.deleteMany();
    await prisma.tbankConnection.create({
      data: {
@@ -85,7 +48,20 @@ describe('portfolio publication (SQLite)', () => {
  });

  it('publishes the same snapshot for the running attempt of the current revision', async () => {
-    await createRunningAttempt();
+    await prisma.tbankSyncWork.create({
+      data: {
+        id: 'live',
+        userId: 'owner',
+        revision: 'current',
+        scopeKey: `portfolio:${accountId}`,
+        intent: {},
+        state: 'running',
+        attemptId: 'live-attempt',
+        processRunId: 'run',
+        priority: 1,
+        progress: {},
+      },
+    });
    const published = await repository.publish(
      { id: 'live', attemptId: 'live-attempt', userId: 'owner', revision: 'current' },
      accountId,
@@ -94,99 +70,4 @@ describe('portfolio publication (SQLite)', () => {
    assert.equal(published, true);
    expect(await prisma.tbankPortfolio.count()).toBe(1);
  });
-
-  it('rolls back the snapshot, first value point and claim when the second point fails', async () => {
-    const previousFetchedAt = new Date('2025-12-31T00:00:00.000Z');
-    const previousCapturedAt = new Date('2025-12-31T01:00:00.000Z');
-    await prisma.tbankPortfolio.create({
-      data: {
-        userId: 'owner',
-        revision: 'current',
-        accountId,
-        payload: snapshot,
-        fetchedAt: previousFetchedAt,
-      },
-    });
-    await prisma.tbankPortfolioValueHistory.create({
-      data: {
-        userId: 'owner',
-        accountId,
-        points: {
-          create: {
-            attemptId: 'previous-attempt',
-            currency: 'RUB',
-            value: '100',
-            capturedAt: previousCapturedAt,
-          },
-        },
-      },
-    });
-    await createRunningAttempt();
-    interceptTransaction((tx) => {
-      const upsert = tx.tbankPortfolioValuePoint.upsert.bind(tx.tbankPortfolioValuePoint);
-      jest
-        .spyOn(tx.tbankPortfolioValuePoint, 'upsert')
-        .mockImplementationOnce((args) => upsert(args))
-        .mockRejectedValueOnce(new Error('injected second point failure'));
-    });
-
-    await expect(
-      repository.publish(
-        { id: 'live', attemptId: 'live-attempt', userId: 'owner', revision: 'current' },
-        accountId,
-        valuedSnapshot,
-      ),
-    ).rejects.toThrow('injected second point failure');
-
-    expect(
-      await prisma.tbankPortfolio.findUnique({
-        where: { userId_revision_accountId: { userId: 'owner', revision: 'current', accountId } },
-      }),
-    ).toMatchObject({ payload: snapshot, fetchedAt: previousFetchedAt, dataRevision: 1 });
-    expect(
-      await prisma.tbankPortfolioValuePoint.findMany({
-        select: { attemptId: true, value: true, capturedAt: true },
-      }),
-    ).toEqual([
-      { attemptId: 'previous-attempt', value: '100', capturedAt: previousCapturedAt },
-    ]);
-    expect(await prisma.tbankSyncWork.findUniqueOrThrow({ where: { id: 'live' } }))
-      .toMatchObject({ state: 'running', attemptId: 'live-attempt' });
-  });
-
-  it.each(['stale attempt', 'complete work', 'invalid token'] as const)(
-    'does not publish for %s',
-    async (scenario) => {
-      await createRunningAttempt();
-      if (scenario === 'complete work') {
-        await prisma.tbankSyncWork.update({
-          where: { id: 'live' },
-          data: { state: 'complete' },
-        });
-      }
-      if (scenario === 'invalid token') {
-        await prisma.tbankConnection.update({
-          where: { userId: 'owner' },
-          data: { invalidToken: true },
-        });
-      }
-
-      await expect(
-        repository.publish(
-          {
-            id: 'live',
-            attemptId: scenario === 'stale attempt' ? 'stale-attempt' : 'live-attempt',
-            userId: 'owner',
-            revision: 'current',
-          },
-          accountId,
-          valuedSnapshot,
-        ),
-      ).resolves.toBe(false);
-
-      expect(await prisma.tbankPortfolio.count()).toBe(0);
-      expect(await prisma.tbankPortfolioValueHistory.count()).toBe(0);
-      expect(await prisma.tbankPortfolioValuePoint.count()).toBe(0);
-    },
-  );
 });
@@ -298,8 +298,6 @@ describe('T-Bank value history persistence and visibility (SQLite)', () => {
            isin: null,
            ticker: null,
            logoName: null,
-            sector: null,
-            issuer: null,
          },
        ],
        cashBalances: [{ currency: 'USD', value: '50' }],