Merge branch 'develop' into test/72-slim-sqlite-regression

test: slim sqlite runner regression workload (WealthLedger/backend#72 )
2026-10-14 08:13:34 +03:00 · 2026-10-13 23:46:20 +03:00
85 changed files with 2891 additions and 3728 deletions
@@ -89,9 +89,4 @@ Commits и PR titles — Conventional Commits с parser-recognized Issue referen
 `spec:`. Каждый commit содержит одну задачу. Исключения release и правила
 ссылки — в Engineering Workflow из AGENTS. Root другого checkout не управляет этим repo.
 Прямой push в `main`, force-push и перенос опубликованных тегов не входят в
-обычную работу. PR сливается squash или rebase-merge; merge-коммит не
-используется. `main` обновляется только fast-forward из `develop`, поэтому
-`origin/main` всегда предок `origin/develop`:
-`git merge-base --is-ancestor origin/main origin/develop`. Срочный fix —
-обычная ветка `fix/*` от `develop`; пути hotfix от `main` нет.
-Перед релизом прочитай местный README, раздел «Релизы».
+обычную работу. Перед release/hotfix прочитай местный README, раздел «Релизы».
@@ -28,8 +28,9 @@ jobs:
          docker version
          docker buildx version
      - run: npm ci
+      - run: npx --no-install prisma generate
      - run: npm run verify
-      - run: node test/sqlite.cjs --all
+      - run: npm run test:e2e
      - name: Login with dedicated Nexus writer
        env:
          REGISTRY_USERNAME: ${{ secrets.NEXUS_USERNAME }}
@@ -4,7 +4,7 @@ on:
  push:
    branches: [develop, main]
  pull_request:
-    types: [opened, synchronize, reopened, edited]
+    types: [opened, synchronize, reopened]
  schedule:
    - cron: '47 5 * * *'

@@ -34,17 +34,12 @@ jobs:
          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
        run: |
          printf '%s\n' "$PR_TITLE" | npm run commitlint -- --strict
-          if [[ "$PR_TITLE" =~ ^chore\(release\):\ [0-9]+\.[0-9]+\.[0-9]+$ ]]; then
-            npm run commitlint -- --strict --from "$HEAD_SHA^" --to "$HEAD_SHA"
-          else
-            npm run commitlint -- --strict --from "$BASE_SHA" --to "$HEAD_SHA"
-          fi
+          npm run commitlint -- --strict --from "$BASE_SHA" --to "$HEAD_SHA"

  security:
    needs: commits
    if: >-
      !cancelled() &&
-      gitea.event.action != 'edited' &&
      (needs.commits.result == 'success' || needs.commits.result == 'skipped')
    timeout-minutes: 15
    runs-on: ubuntu-latest
@@ -72,8 +67,7 @@ jobs:
  verify:
    needs: [commits, security]
    if: >-
-      !cancelled() && gitea.event.action != 'edited' &&
-      needs.security.result == 'success' &&
+      !cancelled() && needs.security.result == 'success' &&
      gitea.event_name != 'schedule'
    timeout-minutes: 45
    runs-on: ubuntu-latest
@@ -87,10 +81,12 @@ jobs:
        with:
          node-version-file: .nvmrc
      - run: npm ci
+      - name: Generate Prisma client before typechecks
+        run: npx --no-install prisma generate
      - name: Run all backend gates
        run: npm run verify
      - name: Run isolated SQLite and runtime OpenAPI suites
-        run: node test/sqlite.cjs --all
+        run: npm run test:e2e
      - name: Analyze develop with SonarQube
        if: gitea.event_name == 'push' && gitea.ref == 'refs/heads/develop'
        # v2.3.0: same Docker-based scanner used for SonarQube 9.9.
@@ -1 +1 @@
-24.22.1
+24.21.0
@@ -1,134 +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
-
-* 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))
-
-## [2.3.0](https://git.personal.ksv741.ru/WealthLedger/backend/compare/v2.2.0...v2.3.0) (2026-10-24)
-
-### Features
-
-* log unhandled errors and pretty dev output (WealthLedger/backend[#120](https://git.personal.ksv741.ru/WealthLedger/backend/issues/120)) ([#126](https://git.personal.ksv741.ru/WealthLedger/backend/issues/126)) ([966a1f7](https://git.personal.ksv741.ru/WealthLedger/backend/commit/966a1f793aa2087cce3e47750e0017f78315bd64))
-
-### Bug Fixes
-
-* persist refresh cookie across browser restarts (WealthLedger/backend[#123](https://git.personal.ksv741.ru/WealthLedger/backend/issues/123)) ([d1f6969](https://git.personal.ksv741.ru/WealthLedger/backend/commit/d1f6969dc7c22ae3cf7396bccdbf0cea2f61db2e))
-
-### Maintenance
-
-* **deps:** update non-major dependencies [#11](https://git.personal.ksv741.ru/WealthLedger/backend/issues/11) ([449cfcd](https://git.personal.ksv741.ru/WealthLedger/backend/commit/449cfcd6c5a91307012bb3a640c8255ba243cbf5))
-
-## [2.2.0](https://git.personal.ksv741.ru/WealthLedger/backend/compare/v2.1.0...v2.2.0) (2026-10-18)
-
-### Features
-
-* unify income payment cards and drop period comparisons (WealthLedger/main[#33](https://git.personal.ksv741.ru/WealthLedger/backend/issues/33)) ([#83](https://git.personal.ksv741.ru/WealthLedger/backend/issues/83)) ([31b0e15](https://git.personal.ksv741.ru/WealthLedger/backend/commit/31b0e1557978019a9293e5fd3efeee319194cddd))
-
-### Bug Fixes
-
-* align password policy to 8-72 printable ASCII on register (WealthLedger/backend[#60](https://git.personal.ksv741.ru/WealthLedger/backend/issues/60)) ([#109](https://git.personal.ksv741.ru/WealthLedger/backend/issues/109)) ([e03fad6](https://git.personal.ksv741.ru/WealthLedger/backend/commit/e03fad622bfec0fa7e42d536f65e361d319a1ac9))
-* restore screener OpenAPI constraints (WealthLedger/backend[#70](https://git.personal.ksv741.ru/WealthLedger/backend/issues/70)) ([#95](https://git.personal.ksv741.ru/WealthLedger/backend/issues/95)) ([2ad3517](https://git.personal.ksv741.ru/WealthLedger/backend/commit/2ad3517d87bffa8af9285d72fd6f78b96b3eed9f))
-* separate T-Bank RPC network time from queue wait (WealthLedger/backend[#81](https://git.personal.ksv741.ru/WealthLedger/backend/issues/81)) ([#94](https://git.personal.ksv741.ru/WealthLedger/backend/issues/94)) ([0d7839c](https://git.personal.ksv741.ru/WealthLedger/backend/commit/0d7839cf79669768bba55f420ed43304545ac8d9))
-* skip hourly terms overlapped by a long walk (WealthLedger/backend[#54](https://git.personal.ksv741.ru/WealthLedger/backend/issues/54)) ([6975853](https://git.personal.ksv741.ru/WealthLedger/backend/commit/6975853656698b61781ca056f35c0d68e47ea32a))
-* surface durable hourly attempt in accounts and income meta (WealthLedger/backend[#58](https://git.personal.ksv741.ru/WealthLedger/backend/issues/58)) ([14bcb9d](https://git.personal.ksv741.ru/WealthLedger/backend/commit/14bcb9da5ff081710d672d140175d348a03a2fe5))
-* translate permanent invalid-token errors on online entrypoints (WealthLedger/backend[#59](https://git.personal.ksv741.ru/WealthLedger/backend/issues/59)) ([#110](https://git.personal.ksv741.ru/WealthLedger/backend/issues/110)) ([8a6f60d](https://git.personal.ksv741.ru/WealthLedger/backend/commit/8a6f60d9651fc7c474dd9b3690314505e18c4fa0))
-
-### Performance
-
-* batch bank operation page relations (WealthLedger/backend[#68](https://git.personal.ksv741.ru/WealthLedger/backend/issues/68)) ([285dd08](https://git.personal.ksv741.ru/WealthLedger/backend/commit/285dd08472d9acb66fab8d46d511d9ce607b110f))
-* start bond search prices with details (WealthLedger/backend[#71](https://git.personal.ksv741.ru/WealthLedger/backend/issues/71)) ([#89](https://git.personal.ksv741.ru/WealthLedger/backend/issues/89)) ([da2e1d0](https://git.personal.ksv741.ru/WealthLedger/backend/commit/da2e1d0781d23f4ab1c38e7bf3cad2e254d026d5))
-
-### Refactoring
-
-* extract shared public instrument projection ([#69](https://git.personal.ksv741.ru/WealthLedger/backend/issues/69)) ([#84](https://git.personal.ksv741.ru/WealthLedger/backend/issues/84)) ([9b7e5e1](https://git.personal.ksv741.ru/WealthLedger/backend/commit/9b7e5e1215b7c1c5320effb6ba5b2c2a8b0cd604))
-* remove unreachable catalog producer and sync orchestration (WealthLedger/backend[#62](https://git.personal.ksv741.ru/WealthLedger/backend/issues/62)) ([#98](https://git.personal.ksv741.ru/WealthLedger/backend/issues/98)) ([96d4de4](https://git.personal.ksv741.ru/WealthLedger/backend/commit/96d4de4195b105d64ac6ffaf8d3d8aab4142ece4))
-
-### CI
-
-* validate edited PR titles (WealthLedger/backend[#74](https://git.personal.ksv741.ru/WealthLedger/backend/issues/74)) ([bbb5aff](https://git.personal.ksv741.ru/WealthLedger/backend/commit/bbb5afff842720374feecfcd74eea83283e0b2ae))
-
-### Tests
-
-* await portfolio publication done instead of polling ticks (WealthLedger/backend[#63](https://git.personal.ksv741.ru/WealthLedger/backend/issues/63)) ([#103](https://git.personal.ksv741.ru/WealthLedger/backend/issues/103)) ([7023021](https://git.personal.ksv741.ru/WealthLedger/backend/commit/702302126b81335959be2e66b4b5ad38e5806b70))
-* cover auth token, cookie and expiry boundaries (WealthLedger/backend[#61](https://git.personal.ksv741.ru/WealthLedger/backend/issues/61)) ([#113](https://git.personal.ksv741.ru/WealthLedger/backend/issues/113)) ([32622c1](https://git.personal.ksv741.ru/WealthLedger/backend/commit/32622c1dad9649842d8cb78d8e964da33e5df459))
-* isolate HTTP suites from scheduler and bank-card case order (WealthLedger/backend[#65](https://git.personal.ksv741.ru/WealthLedger/backend/issues/65)) ([#100](https://git.personal.ksv741.ru/WealthLedger/backend/issues/100)) ([9e4f9d9](https://git.personal.ksv741.ru/WealthLedger/backend/commit/9e4f9d9cab12aa714449b99280894a521c3514b6))
-* replace late portfolio sleep with started and done barriers (WealthLedger/backend[#63](https://git.personal.ksv741.ru/WealthLedger/backend/issues/63)) ([#101](https://git.personal.ksv741.ru/WealthLedger/backend/issues/101)) ([7bc7d8d](https://git.personal.ksv741.ru/WealthLedger/backend/commit/7bc7d8ddecc6cb9f387d00be68f61eb99d57d6fc))
-* replace metadata sleeps with upstream start barriers (WealthLedger/backend[#63](https://git.personal.ksv741.ru/WealthLedger/backend/issues/63)) ([#102](https://git.personal.ksv741.ru/WealthLedger/backend/issues/102)) ([ec6d9a2](https://git.personal.ksv741.ru/WealthLedger/backend/commit/ec6d9a2639f1845674bf7ce5fc357f2f7b7f5dfb))
-* slim sqlite runner regression workload (WealthLedger/backend[#72](https://git.personal.ksv741.ru/WealthLedger/backend/issues/72)) ([1033d21](https://git.personal.ksv741.ru/WealthLedger/backend/commit/1033d2114e99232a90c5d5c321749a9c6e3fbff0))
-
-### Maintenance
-
-* adopt linear git model in backend docs ([#111](https://git.personal.ksv741.ru/WealthLedger/backend/issues/111)) ([4f485ab](https://git.personal.ksv741.ru/WealthLedger/backend/commit/4f485ab0e9f0f9d52ae446e51966525473948b0e))
-* align SQLite driver version (WealthLedger/backend[#67](https://git.personal.ksv741.ru/WealthLedger/backend/issues/67)) ([203cc72](https://git.personal.ksv741.ru/WealthLedger/backend/commit/203cc72cb2d1aac34f39c5ba528820b511666f17))
-* drop unused direct source-map-support dependency (WealthLedger/backend[#4](https://git.personal.ksv741.ru/WealthLedger/backend/issues/4)) ([#96](https://git.personal.ksv741.ru/WealthLedger/backend/issues/96)) ([c789e33](https://git.personal.ksv741.ru/WealthLedger/backend/commit/c789e33c41281f2fc3de8851f21ae897a81e2b5d))
-* make OpenAPI export atomic and add read-only check (WealthLedger/backend[#3](https://git.personal.ksv741.ru/WealthLedger/backend/issues/3)) ([#97](https://git.personal.ksv741.ru/WealthLedger/backend/issues/97)) ([a93f2d5](https://git.personal.ksv741.ru/WealthLedger/backend/commit/a93f2d55e7a31515ed1cc056cd57101f2b315405))
-* unify verification preparation (WealthLedger/backend[#66](https://git.personal.ksv741.ru/WealthLedger/backend/issues/66)) ([b90cedd](https://git.personal.ksv741.ru/WealthLedger/backend/commit/b90cedd580321fb560a4ad0d9f9f5ba03303248e))
-
-## [2.1.0](https://git.personal.ksv741.ru/WealthLedger/backend/compare/v2.0.0...v2.1.0) (2026-10-12)
-
-### Features
-
-* add hourly portfolio sync history ([0057925](https://git.personal.ksv741.ru/WealthLedger/backend/commit/0057925888dde874830149865fc5e13920ac5783))
-* add stock screener ([7d10ef8](https://git.personal.ksv741.ru/WealthLedger/backend/commit/7d10ef8adfce76ad2ed6368e1022fbd3f6847a23))
-* reconcile hourly investment resource states ([323b83b](https://git.personal.ksv741.ru/WealthLedger/backend/commit/323b83b5827d1191fbc14cfdf1d0e62f249fc78d))
-
-### Bug Fixes
-
-* align backend workflow rules (WealthLedger/main[#27](https://git.personal.ksv741.ru/WealthLedger/backend/issues/27)) ([c7d0600](https://git.personal.ksv741.ru/WealthLedger/backend/commit/c7d060023b612af9e1dd4c2a2fb2d5d1bf173784))
-* bound hourly step awaits by the per-step wait limit ([#56](https://git.personal.ksv741.ru/WealthLedger/backend/issues/56)) ([52fa3a3](https://git.personal.ksv741.ru/WealthLedger/backend/commit/52fa3a36baa5ab236a7ebd64ef1b4f447c91e129))
-* keep candle retries read-only ([947ffef](https://git.personal.ksv741.ru/WealthLedger/backend/commit/947ffefa9b8cad7f19355c187f2bd50c9739a822))
-* restore terminal hourly lifecycle after persistence failure ([#56](https://git.personal.ksv741.ru/WealthLedger/backend/issues/56)) ([fa57a20](https://git.personal.ksv741.ru/WealthLedger/backend/commit/fa57a201fdd8127774aee9af553da75a75add07c))
-* unblock backend dependency audit ([85858a1](https://git.personal.ksv741.ru/WealthLedger/backend/commit/85858a160f00dd428c80b8fa1824c1779245fdfe))
-
-### Documentation
-
-* clarify backend verification policy ([d7895f2](https://git.personal.ksv741.ru/WealthLedger/backend/commit/d7895f287ee802e7b13df7a2a4c6dba0b711e5a9))
-* pin backend workflow reference (WealthLedger/main[#27](https://git.personal.ksv741.ru/WealthLedger/backend/issues/27)) ([c5248db](https://git.personal.ksv741.ru/WealthLedger/backend/commit/c5248dbefc4b11a9f417bc835041a4294bd61047))
-
-### CI
-
-* skip checks on PR metadata edits ([0ad84ff](https://git.personal.ksv741.ru/WealthLedger/backend/commit/0ad84ff4f0b4712abc7e69dc299856f14af6eadd))
-
-### Tests
-
-* align all accounts metadata ([db375cb](https://git.personal.ksv741.ru/WealthLedger/backend/commit/db375cbee7d8f1eff48822b8e3c74898f40e8886))
-* align resource availability metadata ([bc631e7](https://git.personal.ksv741.ru/WealthLedger/backend/commit/bc631e72de0d9b0ff7b261b1ea644a73c2943d2a))
-* align upcoming events with local reads ([966b2a5](https://git.personal.ksv741.ru/WealthLedger/backend/commit/966b2a5836cdaf5b761e3c76568ff30a90ba1f4c))
-* extend ledger sqlite timeout ([4870d49](https://git.personal.ksv741.ru/WealthLedger/backend/commit/4870d4950303ad1de743e19b665b2fbdc05b781a))
-* increase ledger request timeout ([2facd86](https://git.personal.ksv741.ru/WealthLedger/backend/commit/2facd8675c74a97d92e0e8f44ed4a93aabb47674))
-
-### Maintenance
-
-* align backend engineering workflow (WealthLedger/main[#27](https://git.personal.ksv741.ru/WealthLedger/backend/issues/27)) ([a31e8d2](https://git.personal.ksv741.ru/WealthLedger/backend/commit/a31e8d2c4d85a21cdd5efdcc9f5fe503f210804b))
-* prune obsolete eslint suppressions ([a46a411](https://git.personal.ksv741.ru/WealthLedger/backend/commit/a46a4112cbcc72b1c3ff17cac4ac8bebcf579bca))
-
 ## [2.0.0](https://git.personal.ksv741.ru/WealthLedger/backend/compare/v1.0.0...v2.0.0) (2026-10-07)

 ### ⚠ BREAKING CHANGES
@@ -1,9 +1,9 @@
-FROM node:24.22.1-bookworm-slim AS base
+FROM node:24.21.0-bookworm-slim AS base
 WORKDIR /app

 FROM base AS dependencies
 # Native SQLite/bcrypt builds happen only here; compilers stay out of runtime.
-RUN apt-get update && apt-get install -y --no-install-recommends python3 make g++ ca-certificates openssl && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y --no-install-recommends python3=3.11.2-1+b1 make=4.3-4.1 g++=4:12.2.0-3 ca-certificates=20250419~deb12u1 openssl=3.0.20-1~deb12u2 && rm -rf /var/lib/apt/lists/*
 COPY package.json package-lock.json ./
 RUN npm ci
 COPY . .
@@ -11,7 +11,7 @@ RUN npx --no-install prisma generate

 FROM dependencies AS development
 # Nest watch uses ps to stop the previous process tree before restarting.
-RUN apt-get update && apt-get install -y --no-install-recommends procps && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y --no-install-recommends procps=2:4.0.2-3 && rm -rf /var/lib/apt/lists/*
 RUN mkdir /data && chown node:node /data && chown -R node:node /app
 USER node
 ENV NODE_ENV=development DATABASE_URL=file:/data/wealthledger.db
@@ -19,11 +19,10 @@ EXPOSE 3000
 CMD ["npm", "run", "start:dev"]

 FROM dependencies AS build
-# The client is already generated at the shared dependencies stage (same revision).
-RUN npx --no-install nest build && npm prune --omit=dev --omit=optional
+RUN npm run build && npm prune --omit=dev --omit=optional

 FROM base AS production
-RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates openssl && rm -rf /var/lib/apt/lists/* \
+RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates=20250419~deb12u1 openssl=3.0.20-1~deb12u2 && rm -rf /var/lib/apt/lists/* \
    && mkdir /data && chown node:node /data
 ARG VERSION
 ARG REVISION
@@ -14,7 +14,6 @@ cp .env.example .env
 nvm use --silent
 npm ci
 npx prisma migrate deploy
-npx prisma generate
 npm run start:dev
 ```

@@ -61,7 +60,7 @@ Compose topology принадлежит workspace, эксплуатационн
 npm run verify
 ```

-Он запускает генерацию Prisma client, zero-warning lint,
+Он запускает zero-warning lint,
 application/test typechecks, Jest с покрытием и build. `npm run lint:fix` — отдельная
 записывающая команда. `npm run test:cov` также доступен отдельно; общего числового
 threshold нет. `npm run test:e2e` отдельно проверяет функциональные HTTP suites
@@ -81,13 +80,11 @@ TypeScript 7 требует поддержки со стороны `ts-jest` и
 Единый `.gitea/workflows/verify.yml` запускает `commits → security → verify`
 последовательно на PR; на push в `develop`/`main` — `security → verify`.
 Рабочие ветки проверяются после открытия PR, без дублирующего push-запуска.
-Изменение заголовка PR повторяет только проверку Conventional Commits; `security`
-и `verify` на metadata-only событии не запускаются.
+Изменение заголовка PR тоже повторяет проверки Conventional Commits.
 Новый запуск отменяет устаревший для того же PR/ветки и типа события
 (требуется Gitea 1.26+). Ежедневно в 05:47 UTC выполняется только `security`.
-Job `verify` запускает `npm ci` и `npm run verify` (генерация Prisma client
-внутри gate, один Nest build), затем функциональный `node test/sqlite.cjs --all`
-на уже собранных артефактах. Используется только checkout
+Job `verify` запускает `npm ci`, генерацию Prisma client,
+`npm run verify` и функциональный `npm run test:e2e`. Используется только checkout
 backend и его зависимости; OpenAPI генерируется во время проверки, SHA записывается в лог.
 Успешный unit gate не заменяет SQLite/e2e; ошибка любой suite завершает job с FAIL.

@@ -218,10 +215,7 @@ nvm use --silent
 npm run openapi:generate
 ```

-Команда собирает backend и записывает `openapi.json` в корень репозитория
-атомарно: через временный файл и rename, без частичной записи при сбое.
-`npm run openapi:check` только сравнивает runtime schema с файлом и завершается
-с ошибкой при расхождении, не перезаписывая его.
+Команда собирает backend и записывает `openapi.json` в корень репозитория.
 Сервер и HTTP-порт не запускаются; Nest preview читает metadata без создания
 провайдеров и подключения к БД/T-Bank. Настроенный `.env` и реальные секреты
 не нужны. `openapi.json` исключён из Git и каждый раз создаётся из DTO/Swagger
@@ -258,10 +252,7 @@ breaking changes относительно предыдущего выпуска.
 проверяет уникальность DB, сохранность вымышленного внешнего файла, отказ migration
 и SIGINT/SIGTERM cleanup. Полный e2e набор остаётся в `npm run test:e2e`.
 Логи остаются в каталоге из вывода. Для одной suite:
-`node test/sqlite.cjs app.e2e-spec.ts`. Crash-регрессия в
-`tbank-operations-sync.e2e-spec.ts` загружает классы из `dist/`, поэтому перед
-адресным запуском этой suite выполните `npm run build`, иначе child/dist может
-расходиться с parent/src.
+`node test/sqlite.cjs app.e2e-spec.ts`.

 | Риск | Проверка реальной DB |
 | --- | --- |
@@ -307,57 +298,35 @@ Durability оставляет временные DB, логи и `result.json`
 Репозиторий выпускается независимо. `develop` — интеграция, `main` — принятые
 релизы. Обычная работа: issue-linked ветка от актуального `develop`, PR в `develop`;
 общие правила — в Engineering Workflow по ссылке из AGENTS.
-PR сливается squash или rebase-merge; merge-коммит не используется. `main`
-обновляется только fast-forward из `develop`, поэтому история линейна:
-
-```text
-<type>/<issue>-<slug> --squash--> develop --ff-only--> main --> tag vX.Y.Z
-```
-
-Инвариант: `origin/main` всегда предок `origin/develop`. Проверка:
-
-```bash
-git fetch -q origin
-git merge-base --is-ancestor origin/main origin/develop && echo ok || echo BROKEN
-```
-
+Обычные PR допускают squash; release и обратная синхронизация сохраняют историю.
 Commits и PR titles — Conventional Commits со ссылкой на Issue (кроме release),
 включая `spec:`. Версии вручную не повышай.

-1. Получи `main`, `develop` и теги: `git fetch origin --tags`. Проверь
-   инвариант. Создай `release/X.Y.Z` от проверенного `develop`;
-   `nvm use --silent`, `npm ci`.
+1. Получи `main`, `develop` и теги: `git fetch origin --tags`. Убедись, что
+   `develop` содержит последний релиз. Создай `release/<name>` от проверенного
+   `develop`; `nvm use --silent`, `npm ci`. Hotfix начинается от `main` в
+   `release/hotfix-<name>` и проходит тот же процесс.
 2. На чистой ветке выполни `npm run release:preview`, просмотри версию/changelog,
   затем `npm run release:prepare`. Команда создаёт `chore(release): X.Y.Z`,
   обновляет manifest/lockfile/CHANGELOG; тег и push не выполняет. Не обходи
   guards ветки, чистого дерева, отсутствующих тегов или уже подготовленной версии.
 3. Проверь diff и штатные gates этого репозитория. Отправь только release-ветку,
-   открой PR в **`develop`** с заголовком `chore(release): X.Y.Z`. После зелёных
-   `verify`, `security`, `commits` выполни fast-forward-only merge. Если
-   `develop` изменился, обнови release-ветку и повтори проверки кандидата.
-4. Открой PR `develop → main` с тем же заголовком и слей fast-forward-only.
-5. Получи удалённый `main`, сравни его HEAD с проверенным release SHA и версией
+   открой PR в `main` с заголовком `chore(release): X.Y.Z`. После зелёных
+   `verify`, `security`, `commits` выполни fast-forward-only merge. Если `main`
+   изменился, согласуй историю и повтори проверки кандидата.
+4. Получи удалённый `main`, сравни его HEAD с проверенным release SHA и версией
   manifest/lockfile. Создай аннотированный `vX.Y.Z` именно на этом SHA:
   `git tag -a vX.Y.Z <release-sha> -m "Release X.Y.Z"`, затем отправь только
   `git push origin refs/tags/vX.Y.Z`. Не запускай release-it повторно на `main`.
-Обратная синхронизация не нужна: release-коммит попал в `develop` на шаге 3.
-Опубликованные теги не перемещай. При сбое после merge создай отсутствующий тег
-без нового bump; до merge исправь и проверь существующий кандидат без
-повторного повышения версии.
-
-Freeze релиза не поддерживается: пока открыт релизный PR, `develop` не двигают.
-Срочный fix — обычная ветка `fix/*` от `develop` с последующим релизом;
-пути от `main` нет, он сделал бы `main` не-предком `develop`. Исключение
-требует явного решения: `release/hotfix-<name>` от `main`, PR в `main`, тег,
-затем merge `main → develop` для восстановления инварианта.
+5. Верни release-коммит через PR `main → develop` без squash/rebase; проверь,
+   что `develop` содержит тег. Опубликованные теги не перемещай. При сбое после
+   merge создай отсутствующий тег без нового bump; до merge исправь и проверь
+   существующий кандидат без повторного повышения версии.

 `feat:` повышает minor, `fix:`/`perf:` и прочие разрешённые типы — patch;
 `!`/`BREAKING CHANGE:` — major, включая версии до 1.0. `chore(release):`
 исключён из рекомендации и changelog. Конфигурация — `.release-it.json`.
 В Gitea для `main`/`develop` должны быть запрещены прямой/force push и обход
-администратором, включена блокировка устаревшей ветки, обязательны `verify`,
-`security`, `commits`; теги `v*` защищены. Линейность обеспечивают merge styles
-репозитория: merge-коммиты и rebase `--no-ff` выключены, доступны squash,
-rebase-merge и fast-forward-only; стиль по умолчанию — squash.
+администратором, обязательны `verify`, `security`, `commits`; теги `v*` защищены.
 Workflow сам не включает эти настройки. Отдельное review approval для одного
 владельца не требуется. Npm publishing, deploy и Gitea Releases не включены.
@@ -54,6 +54,9 @@
    }
  },
  "src/modules/investments/instruments/application/catalog-discovery.service.ts": {
+    "sonarjs/cognitive-complexity": {
+      "count": 1
+    },
    "sonarjs/no-nested-conditional": {
      "count": 1
    }
@@ -92,8 +95,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": {
@@ -136,8 +142,11 @@
    }
  },
  "src/modules/investments/tbank-sync/tbank-sync.service.ts": {
+    "sonarjs/cognitive-complexity": {
+      "count": 1
+    },
    "sonarjs/no-nested-conditional": {
-      "count": 6
+      "count": 7
    }
  },
  "test/bank-cards-durability.cjs": {
@@ -37,7 +37,7 @@ export default defineConfig(
    linterOptions: { reportUnusedDisableDirectives: 'error' },
    settings: {
      'import-x/resolver-next': [createTypeScriptImportResolver()],
-      'node': { tryExtensions: ['.ts', '.js', '.json', '.node'], version: '24.22.1' },
+      'node': { tryExtensions: ['.ts', '.js', '.json', '.node'], version: '24.21.0' },
    },
    rules: {
      'curly': ['error', 'multi-line'],
@@ -56,7 +56,6 @@ export default defineConfig(
        'after',
        { overrides: { '?': 'before', ':': 'before' } },
      ],
-      'import-x/no-cycle': 'error',
      'import-x/no-duplicates': ['error', { 'prefer-inline': true }],
    },
  },
@@ -212,24 +211,4 @@ export default defineConfig(
      '@typescript-eslint/no-unsafe-enum-comparison': 'error',
    },
  },
-  {
-    files: ['src/**/*.ts'],
-    ignores: [...tests, 'src/modules/investments/tbank-sync/**'],
-    rules: {
-      // Separate rule so it does not replace layer-specific no-restricted-imports configs.
-      'import-x/no-restricted-paths': ['error', {
-        zones: [{
-          target: './src',
-          from: './src/modules/investments/tbank-sync',
-          except: [
-            './tbank-sync.api.ts',
-            './tbank-sync.dto.ts',
-            './tbank-sync.module.ts',
-            './tbank-sync-repository.module.ts',
-          ],
-          message: 'Use tbank-sync.api for cross-module access.',
-        }],
-      }],
-    },
-  },
 );
@@ -1,21 +1,20 @@
 {
  "name": "wealth-ledger-backend",
-  "version": "2.4.0",
+  "version": "2.0.0",
  "description": "",
  "author": "",
  "private": true,
  "license": "UNLICENSED",
  "engines": {
-    "node": "v24.22.1"
+    "node": "v24.21.0"
  },
  "scripts": {
    "build": "prisma generate && nest build",
    "openapi:generate": "npm run build && node scripts/generate-openapi.cjs",
-    "openapi:check": "npm run build && node scripts/generate-openapi.cjs --check",
    "format": "npm run lint:fix",
    "start": "nest start",
    "start:dev": "NODE_ENV=development nest start --watch --path tsconfig.dev.json",
-    "start:debug": "NODE_ENV=development nest start --debug --watch --path tsconfig.dev.json",
+    "start:debug": "nest start --debug --watch --path tsconfig.dev.json",
    "start:prod": "node dist/src/main.js",
    "lint": "npm run lint:check",
    "lint:check": "eslint . --max-warnings=0",
@@ -32,24 +31,24 @@
    "test:container": "node test/container-smoke.cjs",
    "test:durability": "node test/bank-cards-durability.cjs",
    "test:openapi-contract": "npm run build && node test/sqlite.cjs openapi-contract.e2e-spec.ts",
-    "verify": "prisma generate && npm run lint && npm run test:lint && npm run typecheck:app && npm run typecheck:test && npm run test:cov -- --runInBand && nest build",
+    "verify": "npm run lint && npm run test:lint && npm run typecheck:app && npm run typecheck:test && npm run test:cov -- --runInBand && npm run build",
    "release:preview": "release-it --dry-run --ci",
    "release:prepare": "release-it --ci",
    "commitlint": "commitlint",
    "test:lint": "node --test test/eslint-config.cjs"
  },
  "dependencies": {
-    "@grpc/grpc-js": "1.14.6",
+    "@grpc/grpc-js": "1.14.5",
    "@grpc/proto-loader": "0.8.1",
-    "@nestjs/common": "12.2.0",
-    "@nestjs/config": "12.0.1",
-    "@nestjs/core": "12.2.0",
-    "@nestjs/jwt": "12.0.3",
+    "@nestjs/common": "12.0.1",
+    "@nestjs/config": "12.0.0",
+    "@nestjs/core": "12.0.1",
+    "@nestjs/jwt": "12.0.1",
    "@nestjs/passport": "12.0.0",
-    "@nestjs/platform-express": "12.2.0",
-    "@nestjs/swagger": "12.0.4",
-    "@prisma/adapter-better-sqlite3": "7.10.1",
-    "@prisma/client": "7.10.1",
+    "@nestjs/platform-express": "12.0.1",
+    "@nestjs/swagger": "12.0.1",
+    "@prisma/adapter-better-sqlite3": "7.10.0",
+    "@prisma/client": "7.10.0",
    "bcrypt": "6.0.0",
    "better-sqlite3": "12.11.1",
    "cheerio": "1.2.0",
@@ -57,77 +56,68 @@
    "class-validator": "0.15.1",
    "cookie-parser": "1.4.7",
    "dotenv": "17.4.2",
-    "lru-cache": "11.5.3",
-    "nestjs-pino": "5.3.1",
+    "lru-cache": "11.5.2",
+    "nestjs-pino": "5.1.0",
    "passport": "0.7.0",
    "passport-jwt": "4.0.1",
    "pino-http": "11.0.0",
-    "prisma": "7.10.1",
+    "prisma": "7.10.0",
    "reflect-metadata": "0.2.2",
    "rxjs": "7.8.2"
  },
  "devDependencies": {
-    "@commitlint/cli": "21.2.4",
-    "@commitlint/config-conventional": "21.2.4",
-    "@darraghor/eslint-plugin-nestjs-typed": "7.5.8",
+    "@commitlint/cli": "21.2.2",
+    "@commitlint/config-conventional": "21.2.2",
+    "@darraghor/eslint-plugin-nestjs-typed": "7.5.6",
    "@eslint/js": "10.0.1",
-    "@nestjs/cli": "12.0.10",
-    "@nestjs/schematics": "12.0.10",
-    "@nestjs/testing": "12.2.0",
-    "@release-it/conventional-changelog": "12.0.2",
+    "@nestjs/cli": "12.0.0",
+    "@nestjs/schematics": "12.0.1",
+    "@nestjs/testing": "12.0.1",
+    "@release-it/conventional-changelog": "12.0.0",
    "@stylistic/eslint-plugin": "5.10.0",
    "@types/bcrypt": "6.0.0",
    "@types/cookie-parser": "1.4.10",
    "@types/express": "5.0.6",
    "@types/jest": "30.0.0",
-    "@types/node": "24.19.2",
+    "@types/node": "24.13.4",
    "@types/passport-jwt": "4.0.1",
    "@types/supertest": "7.2.1",
-    "conventional-changelog-conventionalcommits": "10.4.1",
-    "eslint": "10.13.0",
+    "conventional-changelog-conventionalcommits": "10.4.0",
+    "eslint": "10.11.0",
    "eslint-import-resolver-typescript": "4.4.5",
    "eslint-plugin-import-x": "4.17.1",
-    "eslint-plugin-jest": "29.17.0",
-    "eslint-plugin-n": "18.5.0",
-    "eslint-plugin-perfectionist": "5.13.0",
+    "eslint-plugin-jest": "29.16.6",
+    "eslint-plugin-n": "18.4.0",
+    "eslint-plugin-perfectionist": "5.12.1",
    "eslint-plugin-regexp": "3.3.1",
-    "eslint-plugin-security": "4.2.0",
-    "eslint-plugin-sonarjs": "4.2.2",
-    "globals": "17.13.0",
-    "jest": "30.5.2",
-    "pino-pretty": "13.2.0",
-    "release-it": "21.1.1",
-    "supertest": "7.3.1",
-    "ts-jest": "29.4.15",
+    "eslint-plugin-security": "4.1.0",
+    "eslint-plugin-sonarjs": "4.2.1",
+    "globals": "17.12.0",
+    "jest": "30.5.1",
+    "release-it": "21.0.2",
+    "source-map-support": "0.5.21",
+    "supertest": "7.2.2",
+    "ts-jest": "29.4.12",
    "ts-loader": "9.6.2",
    "ts-node": "10.9.2",
    "tsconfig-paths": "4.2.0",
    "typescript": "6.0.3",
-    "typescript-eslint": "8.72.0"
+    "typescript-eslint": "8.70.1"
  },
  "overrides": {
    "proxy-addr": "2.0.8",
-    "express": {
-      "body-parser": "2.4.0"
-    },
    "@nestjs/platform-express": {
-      "multer": "2.5.0"
-    },
-    "ajv": {
-      "fast-uri": "3.1.9"
+      "multer": "2.4.0"
    },
    "@prisma/config@7.10.0": {
      "deepmerge-ts": "8.0.2"
    },
    "release-it": {
-      "basic-ftp": "6.2.3",
-      "undici": "7.30.1"
-    },
-    "socks": {
-      "ip-address": "10.7.4"
+      "basic-ftp": "6.2.1",
+      "undici": "7.29.1"
    },
    "prisma": {
-      "mysql2": "3.24.6"
+      "mysql2": "3.24.4"
    }
  },
  "jest": {
@@ -1,4 +0,0 @@
-- Points written before WealthLedger/backend#140 counted cash twice (cash balance
-- plus the mirroring CURRENCY position). Historical compositions and FX rates are
-- not stored, so the points cannot be recomputed exactly; history restarts here.
-DELETE FROM "TbankPortfolioValuePoint";
@@ -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,10 +1,5 @@
 const { randomBytes } = require('node:crypto');
-const { readFile, rename, rm, writeFile } = require('node:fs/promises');
-const { resolve } = require('node:path');
-
-// Relative to the working directory, as before: the contract test runs the script in a temporary directory.
-const target = resolve(process.cwd(), 'openapi.json');
-const checkOnly = process.argv.includes('--check');
+const { writeFile } = require('node:fs/promises');

 // Schema generation needs no deployment configuration or real credentials.
 Object.assign(process.env, {
@@ -24,48 +19,23 @@ const { NestFactory } = require('@nestjs/core');
 const { AppModule } = require('../dist/src/app.module.js');
 const { API_PREFIX, createOpenApiDocument } = require('../dist/src/openapi.js');

-async function render() {
+async function generate() {
  const app = await NestFactory.create(AppModule, {
    preview: true,
    logger: false,
  });
  try {
    app.setGlobalPrefix(API_PREFIX);
-    return JSON.stringify(createOpenApiDocument(app), null, 2) + '\n';
+    await writeFile(
+      'openapi.json',
+      JSON.stringify(createOpenApiDocument(app), null, 2) + '\n',
+    );
  } finally {
    await app.close();
  }
 }

-// Read-only: compares the runtime document with the committed artifact and never writes.
-async function check(content) {
-  const current = await readFile(target, 'utf8').catch(() => null);
-  if (current !== content) {
-    console.error(
-      'openapi.json is out of date with the runtime schema. Run `npm run openapi:generate`.',
-    );
-    process.exitCode = 1;
-    return;
-  }
-  console.log('openapi.json matches the runtime schema.');
-}
-
-// Atomic update: write a sibling temp file, then rename over the target, so a failed run never leaves partial output.
-async function update(content) {
-  const temp = `${target}.${process.pid}.tmp`;
-  try {
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- Operator-selected working directory and fixed artifact name; no request input.
-    await writeFile(temp, content);
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- Operator-selected working directory and fixed artifact name; no request input.
-    await rename(temp, target);
-  } finally {
-    await rm(temp, { force: true });
-  }
-}
-
-render()
-  .then((content) => (checkOnly ? check(content) : update(content)))
-  .catch((error) => {
-    console.error(error);
-    process.exitCode = 1;
-  });
+generate().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});
@@ -1,6 +1,6 @@
 import { BadRequestException, ValidationPipe } from '@nestjs/common';

-import { LoginDto, RegisterDto } from '../modules/auth/presentation/auth.dto';
+import { CredentialsDto } from '../modules/auth/presentation/auth.dto';
 import {
  CreateBankCardDto,
  UpdateBankCardDto,
@@ -11,7 +11,7 @@ describe('DTO validation', () => {
    forbidUnknownValues: true, transform: true, whitelist: true });

  it('requires credentials and normalizes a valid email', async () => {
-    const metadata = { type: 'body' as const, metatype: RegisterDto };
+    const metadata = { type: 'body' as const, metatype: CredentialsDto };
    await expect(pipe.transform({}, metadata)).rejects.toBeInstanceOf(
      BadRequestException,
    );
@@ -29,59 +29,6 @@ describe('DTO validation', () => {
    });
  });

-  // Test intent: register accepts 8..72 printable ASCII characters only (bcrypt
-  // reads 72 bytes, so non-ASCII could be silently truncated); login only caps
-  // bytes so accounts created under the older policy can still sign in.
-  describe('password policy', () => {
-    const register = { type: 'body' as const, metatype: RegisterDto };
-    const login = { type: 'body' as const, metatype: LoginDto };
-    const body = (password: string) => ({ email: 'user@example.com', password });
-    const accepts = (value: unknown, metadata: typeof login | typeof register) =>
-      pipe.transform(value, metadata).then(
-        () => true,
-        (error: unknown) => {
-          if (!(error instanceof BadRequestException)) throw error;
-          return false;
-        },
-      );
-
-    it.each([
-      ['7 chars', 'a'.repeat(7), false],
-      ['8 chars', 'a'.repeat(8), true],
-      ['72 chars', 'a'.repeat(72), true],
-      ['73 chars', 'a'.repeat(73), false],
-      ['all printable symbols and space', 'Aa1 !~"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}', true],
-      ['Cyrillic, 8+ chars', 'пароль-пароль', false],
-      ['emoji', 'passw😀rd', false],
-      ['tab', 'pass\tword1', false],
-      ['newline', 'password1\n', false],
-      ['DEL', 'password\x7f1', false],
-      ['non-string', 12345678, false],
-    ])('register: %s', async (_, password, accepted) => {
-      await expect(accepts(body(password as string), register)).resolves.toBe(accepted);
-    });
-
-    it('register keeps raw whitespace untouched', async () => {
-      const password = '  spaced pass  ';
-      await expect(pipe.transform(body(password), register)).resolves.toEqual(
-        body(password),
-      );
-    });
-
-    it.each([
-      ['legacy Cyrillic password', 'пароль-пароль', true],
-      ['short legacy password', 'short', true],
-      ['72 bytes', 'a'.repeat(72), true],
-      ['73 bytes', 'a'.repeat(73), false],
-      ['36 Cyrillic letters = 72 bytes', 'я'.repeat(36), true],
-      ['37 Cyrillic letters = 74 bytes', 'я'.repeat(37), false],
-      ['empty', '', false],
-      ['non-string', 12345678, false],
-    ])('login: %s', async (_, password, accepted) => {
-      await expect(accepts(body(password as string), login)).resolves.toBe(accepted);
-    });
-  });
-
  it('requires and validates nested money in a new card', async () => {
    const metadata = { type: 'body' as const, metatype: CreateBankCardDto };
    const card = {
@@ -1,29 +1,24 @@
-import { ArgumentsHost, BadRequestException } from '@nestjs/common';
+import { ArgumentsHost } from '@nestjs/common';

-import { StructuredLogger } from '../logging/structured-logger.service';
 import { HttpExceptionFilter } from './http-exception.filter';

 describe('HttpExceptionFilter', () => {
-  const setup = () => {
+  it('does not expose internal error details', () => {
    const status = jest.fn().mockReturnThis();
    const type = jest.fn().mockReturnThis();
    const json = jest.fn();
    const locals: Record<string, unknown> = {};
-    const logger = { event: jest.fn() };
-    const filter = new HttpExceptionFilter(logger as unknown as StructuredLogger);
+    const filter = new HttpExceptionFilter();
    const host = {
      switchToHttp: () => ({
        getResponse: () => ({ status, type, json, locals }),
      }),
    } as unknown as ArgumentsHost;
-    return { filter, host, status, type, json, locals, logger };
-  };

-  it('logs unhandled errors with name and stack frames but never the message', () => {
-    const { filter, host, status, type, json, locals, logger } = setup();
-    const error = new Error('operation failed\npassword: SYNTHETIC_AUDIT_SECRET');
-
-    filter.catch(error, host);
+    filter.catch(
+      new Error('operation failed\npassword: SYNTHETIC_AUDIT_SECRET'),
+      host,
+    );

    expect(status).toHaveBeenCalledWith(500);
    expect(type).toHaveBeenCalledWith('application/problem+json');
@@ -32,29 +27,6 @@ describe('HttpExceptionFilter', () => {
      code: 'INTERNAL_SERVER_ERROR',
    });
    expect(locals.publicErrorCode).toBe('INTERNAL_SERVER_ERROR');
-    expect(logger.event).toHaveBeenCalledTimes(1);
-    const [level, event, fields] = logger.event.mock.calls[0] as [string, string, Record<string, unknown>];
-    expect(level).toBe('error');
-    expect(event).toBe('http.request.unhandled');
-    expect(fields).toMatchObject({ code: 'INTERNAL_SERVER_ERROR', errorName: 'Error' });
-    expect(JSON.stringify(fields)).not.toContain('SYNTHETIC_AUDIT_SECRET');
-    expect(String(fields['errorStack']).split('\n').every((line) => line.startsWith('    at '))).toBe(true);
-  });
-
-  it('logs field pointers without values for validation errors', () => {
-    const { filter, host, status, logger, locals } = setup();
-    const exception = new BadRequestException({
-      message: [
-        { property: 'amount', constraints: { isPositive: 'amount must be positive' }, value: -42 },
-        { property: 'amount', constraints: { min: 'amount too small' }, value: -42 },
-      ],
-    });
-
-    filter.catch(exception, host);
-
-    expect(status).toHaveBeenCalledWith(400);
-    expect(locals.invalidFields).toBe('#/amount');
-    expect(logger.event).not.toHaveBeenCalled();
-    expect(JSON.stringify(locals)).not.toContain('-42');
+    expect(locals.errorStack).toBeUndefined();
  });
 });
@@ -10,12 +10,9 @@ import {
 } from '@nestjs/common';

 import { HttpErrorCode } from '../error-code';
-import { StructuredLogger } from '../logging/structured-logger.service';

@Catch()
 export class HttpExceptionFilter implements ExceptionFilter {
-  constructor(private readonly logger: StructuredLogger) {}
-
  catch(exception: unknown, host: ArgumentsHost): void {
    const context = host.switchToHttp();
    const response = context.getResponse<Response>();
@@ -34,18 +31,6 @@ export class HttpExceptionFilter implements ExceptionFilter {
      : this.codeFor(status, payload);
    response.locals ??= {};
    response.locals.publicErrorCode = code;
-    if (isValidation) {
-      response.locals.invalidFields = [
-        ...new Set(
-          this.validationErrors(
-            (payload as { message: ValidationError[] }).message,
-          ).map((error) => error.pointer),
-        ),
-      ].join(',');
-    }
-    if (!(exception instanceof HttpException)) {
-      this.logUnhandled(exception, code);
-    }
    response
      .status(status)
      .type('application/problem+json')
@@ -62,20 +47,6 @@ export class HttpExceptionFilter implements ExceptionFilter {
      });
  }

-  // ponytail: stack содержит текст message в первой строке; оставляем только кадры, message не пишем.
-  private logUnhandled(exception: unknown, code: string): void {
-    const error = exception instanceof Error ? exception : undefined;
-    const frames = (error?.stack ?? '')
-      .split('\n')
-      .filter((line) => line.startsWith('    at '))
-      .join('\n');
-    this.logger.event('error', 'http.request.unhandled', {
-      code,
-      errorName: error?.name ?? typeof exception,
-      errorStack: frames,
-    });
-  }
-
  private codeFor(status: number, payload: unknown): string {
    if (typeof payload === 'object' && payload !== null && 'code' in payload) {
      const code = (payload as { code?: unknown }).code;
@@ -24,7 +24,6 @@ function completion(request: Request, response: Response, value: { responseTime:
    status: response.statusCode,
    durationMs: Math.round(value.responseTime),
    ...(typeof response.locals.publicErrorCode === 'string' ? { code: response.locals.publicErrorCode } : {}),
-    ...(typeof response.locals.invalidFields === 'string' ? { invalidFields: response.locals.invalidFields } : {}),
  };
 }

@@ -32,10 +31,6 @@ export function loggingOptions(config: ConfigService<Environment, true>): Option
  return {
    level: config.getOrThrow('LOG_LEVEL'),
    messageKey: 'message',
-    // ponytail: development-only pretty output; production never loads pino-pretty.
-    ...(process.env['NODE_ENV'] === 'development'
-      ? { transport: { target: 'pino-pretty', options: { colorize: true, singleLine: true, messageKey: 'message' } } }
-      : {}),
    genReqId: (_request, response) => {
      const id = randomUUID();
      response.setHeader('X-Request-ID', id);
@@ -14,14 +14,10 @@ const allowedFields = new Set([
  'count',
  'durationMs',
  'environment',
-  'errorName',
-  'errorStack',
  'found',
  'grpcCode',
  'headersReceived',
-  'invalidFields',
  'method',
-  'networkMs',
  'operation',
  'queueWaitMs',
  'requestId',
@@ -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;
@@ -121,11 +121,19 @@ export class TbankAccessService {
    return work ? this.tokens.decrypt(work.connection.encryptedToken) : null;
  }

-  // Online reads: a permanent upstream auth refusal becomes 400/INVALID_TBANK_TOKEN here, once, for every caller.
-  async online<T>(
-    userId: string,
-    run: (connection: { revision: string; token: string }) => Promise<T>,
-  ): Promise<T> {
+  async onlineToken(userId: string) {
+    const connection = await this.prisma.tbankConnection.findUnique({
+      where: { userId },
+      select: { encryptedToken: true, invalidToken: true },
+    });
+    if (!connection) throw new ConflictException({ code: TbankErrorCode.NotConnected });
+    if (connection.invalidToken) {
+      throw new BadRequestException({ code: TbankErrorCode.InvalidToken });
+    }
+    return this.tokens.decrypt(connection.encryptedToken);
+  }
+
+  async current(userId: string): Promise<{ revision: string; token: string }> {
    const connection = await this.prisma.tbankConnection.findUnique({
      where: { userId },
      select: { encryptedToken: true, invalidToken: true, revision: true },
@@ -134,8 +142,7 @@ export class TbankAccessService {
    if (connection.invalidToken) {
      throw new BadRequestException({ code: TbankErrorCode.InvalidToken });
    }
-    const token = this.tokens.decrypt(connection.encryptedToken);
-    return this.tokens.translateInvalidToken(() => run({ revision: connection.revision, token }));
+    return { revision: connection.revision, token: this.tokens.decrypt(connection.encryptedToken) };
  }

  async publishMembership(
@@ -165,8 +165,6 @@ describe('TbankClient operations', () => {
        operation: 'getAccounts', grpcCode: status.DEADLINE_EXCEEDED,
        queueWaitMs: 0, channelState: 'CONNECTING', headersReceived: false,
      }));
-      const [, , fields] = logger.event.mock.calls.at(-1) as [string, string, { networkMs: unknown }];
-      expect(typeof fields.networkMs).toBe('number');
      expect(JSON.stringify(logger.event.mock.calls)).not.toContain('secret');
    } finally {
      jest.useRealTimers();
@@ -236,16 +234,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,
@@ -64,7 +64,6 @@ type TbankClientService = Client & Record<string, Unary<never, never>>;
 type RpcDiagnostics = {
  channelState?: string;
  headersReceived?: boolean;
-  networkMs?: number;
  queueWaitMs?: number;
  trackingId?: string;
 };
@@ -375,29 +374,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 +404,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 +513,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) {
@@ -544,13 +524,10 @@ export class TbankClient {
          throw new ServiceUnavailableException({ code: TbankErrorCode.Unavailable });
        }
        const response = await this.queue.run(() => {
-          const sentAt = performance.now();
-          diagnostics.queueWaitMs = Math.round(sentAt - startedAt);
+          diagnostics.queueWaitMs = Math.round(performance.now() - startedAt);
          return this.request<Response>(
            token, client, method, request, diagnostics,
-          ).finally(() => {
-            diagnostics.networkMs = Math.round(performance.now() - sentAt);
-          });
+          );
        });
        this.logger.event('debug', 'tbank.rpc.completed', {
          operation: method,
@@ -595,7 +572,7 @@ export class TbankClient {
        }
        if (
          grpcCode === status.NOT_FOUND &&
-          (notFound || method === 'shareBy' || metadataCall)
+          (method === 'shareBy' || metadataCall)
        ) {
          throw new NotFoundException();
        }
@@ -37,7 +37,7 @@ export function configureApp(app: INestApplication): void {
      exceptionFactory: (message) => new BadRequestException({ message }),
    }),
  );
-  app.useGlobalFilters(new HttpExceptionFilter(app.get(StructuredLogger)));
+  app.useGlobalFilters(new HttpExceptionFilter());
  app.enableShutdownHooks();
 }

@@ -17,7 +17,7 @@ import { AuthenticationResult, AuthUser, RefreshPayload } from './auth.types';
 const EXPECTED_ROTATED_SESSIONS = 1;

 const PASSWORD_HASH_ROUNDS = 12;
-export const REFRESH_TTL_MS = 604_800_000;
+const REFRESH_TTL_MS = 604_800_000;

 const ACCESS_TTL = '15m';
 const REFRESH_TTL = '7d';
@@ -22,9 +22,9 @@ import {

 import { ApiProblemResponses } from '../../../common/decorators/api-safe-error-response.decorator';
 import { HttpErrorCode } from '../../../common/error-code';
-import { AuthService, REFRESH_TTL_MS } from '../application/auth.service';
+import { AuthService } from '../application/auth.service';
 import { AccessPayload, AuthenticationResult } from '../application/auth.types';
-import { LoginDto, RegisterDto } from './auth.dto';
+import { CredentialsDto } from './auth.dto';
 import { JwtAuthGuard } from './jwt-auth.guard';

 const REFRESH_COOKIE = 'refresh_token';
@@ -56,7 +56,7 @@ export class AuthController {
  @HttpCode(HttpStatus.OK)
  @ApiOkResponse({ type: AuthenticationDto })
  async register(
-    @Body() credentials: RegisterDto,
+    @Body() credentials: CredentialsDto,
    @Res({ passthrough: true }) response: Response,
  ) {
    return this.respond(
@@ -69,7 +69,7 @@ export class AuthController {
  @HttpCode(HttpStatus.OK)
  @ApiOkResponse({ type: AuthenticationDto })
  async login(
-    @Body() credentials: LoginDto,
+    @Body() credentials: CredentialsDto,
    @Res({ passthrough: true }) response: Response,
  ) {
    return this.respond(
@@ -134,7 +134,6 @@ export class AuthController {
      sameSite: 'lax' as const,
      secure: process.env['NODE_ENV'] !== 'development',
      path: COOKIE_PATH,
-      maxAge: REFRESH_TTL_MS,
    };
  }
 }
@@ -1,9 +1,8 @@
 import { ApiProperty } from '@nestjs/swagger';
 import { Transform } from 'class-transformer';
 import {
-  IsNotEmpty,
  IsString,
-  Matches,
+  MinLength,
  Validate,
  ValidatorConstraint,
 } from 'class-validator';
@@ -14,10 +13,8 @@ const FIRST_CHARACTER_INDEX = 0;
 const MAX_EMAIL_LENGTH = 254;
 const ASCII_SPACE = 32;
 const ASCII_DELETE = 127;
-// bcrypt reads at most 72 bytes; printable ASCII keeps characters == bytes.
-const MIN_PASSWORD_LENGTH = 8;
+const MIN_PASSWORD_LENGTH = 12;
 const MAX_PASSWORD_BYTES = 72;
-const PASSWORD_PATTERN = `^[\\x20-\\x7E]{${MIN_PASSWORD_LENGTH},${MAX_PASSWORD_BYTES}}$`;

@ValidatorConstraint({ name: 'email' })
 class EmailConstraint {
@@ -43,9 +40,8 @@ class EmailConstraint {
  }
 }

-// Login stays lenient: accounts created under an older policy must still sign in.
-@ValidatorConstraint({ name: 'passwordMaxBytes' })
-class PasswordMaxBytesConstraint {
+@ValidatorConstraint({ name: 'passwordBytes' })
+class PasswordBytesConstraint {
  validate(value: unknown): boolean {
    return (
      typeof value === 'string' &&
@@ -54,11 +50,11 @@ class PasswordMaxBytesConstraint {
  }

  defaultMessage(): string {
-    return `must not exceed ${MAX_PASSWORD_BYTES} UTF-8 bytes`;
+    return 'must not exceed 72 UTF-8 bytes';
  }
 }

-class EmailDto {
+export class CredentialsDto {
  @ApiProperty({ example: 'user@example.com' })
  @IsString()
  @Transform(({ value }: { value: unknown }) =>
@@ -66,28 +62,14 @@ class EmailDto {
  )
  @Validate(EmailConstraint)
  declare email: string;
-}

-export class RegisterDto extends EmailDto {
  @ApiProperty({
-    description: `Raw password: ${MIN_PASSWORD_LENGTH}-${MAX_PASSWORD_BYTES} printable ASCII characters (letters, digits, symbols, space). Not trimmed or normalized.`,
-    pattern: PASSWORD_PATTERN,
+    minLength: MIN_PASSWORD_LENGTH,
+    maxLength: MAX_PASSWORD_BYTES,
    example: 'a secure password',
  })
  @IsString()
-  @Matches(new RegExp(PASSWORD_PATTERN), {
-    message: `must be ${MIN_PASSWORD_LENGTH}-${MAX_PASSWORD_BYTES} printable ASCII characters`,
-  })
-  declare password: string;
-}
-
-export class LoginDto extends EmailDto {
-  @ApiProperty({
-    description: `Raw password, at most ${MAX_PASSWORD_BYTES} UTF-8 bytes. Not trimmed or normalized.`,
-    example: 'a secure password',
-  })
-  @IsString()
-  @IsNotEmpty()
-  @Validate(PasswordMaxBytesConstraint)
+  @MinLength(MIN_PASSWORD_LENGTH)
+  @Validate(PasswordBytesConstraint)
  declare password: string;
 }
@@ -91,101 +91,6 @@ export class BankOperationsService {
    };
  }

-  private async pageViews(tx: Tx, rows: BankCardOperation[]) {
-    const userId = rows[0]?.userId;
-    if (!userId) return [];
-    const cardIds = new Set(
-      rows.flatMap((row) =>
-        [row.cardId, row.targetCardId].filter(
-          (id): id is string => id !== null,
-        ),
-      ),
-    );
-    const sourceIds = new Set(
-      rows.flatMap((row) => (row.originalExpenseId ? [row.originalExpenseId] : [])),
-    );
-    const [cards, sources] = await Promise.all([
-      tx.bankCard.findMany({ where: { userId, id: { in: [...cardIds] } } }),
-      tx.bankCardOperation.findMany({
-        where: { userId, id: { in: [...sourceIds] } },
-      }),
-    ]);
-    const categoryIds = new Set(
-      rows
-        .map(
-          (row) =>
-            sources.find((source) => source.id === row.originalExpenseId)
-              ?.categoryId ?? row.categoryId,
-        )
-        .filter((id): id is string => id !== null),
-    );
-    const expenseIds = new Set(
-      rows.flatMap((row) => {
-        const source = sources.find((item) => item.id === row.originalExpenseId);
-        return row.kind === BankOperationKind.Expense || source
-          ? [source?.id ?? row.id]
-          : [];
-      }),
-    );
-    const [categories, refunds] = await Promise.all([
-      tx.expenseCategory.findMany({
-        where: { userId, id: { in: [...categoryIds] } },
-      }),
-      tx.bankCardOperation.findMany({
-        where: {
-          userId,
-          originalExpenseId: { in: [...expenseIds] },
-          deletedAt: null,
-        },
-      }),
-    ]);
-    const cardsById = new Map(cards.map((card) => [card.id, card]));
-    const sourcesById = new Map(sources.map((source) => [source.id, source]));
-    const categoriesById = new Map(categories.map((category) => [category.id, category]));
-    return rows.map((row) => {
-      const card = cardsById.get(row.cardId) as { name: string };
-      const target = row.targetCardId ? cardsById.get(row.targetCardId) : null;
-      const source = row.originalExpenseId
-        ? sourcesById.get(row.originalExpenseId)
-        : null;
-      const categoryId = source?.categoryId ?? row.categoryId;
-      const relatedRefunds =
-        row.kind === BankOperationKind.Expense || source
-          ? refunds.filter(
-              (refund) =>
-                refund.originalExpenseId === (source?.id ?? row.id) &&
-                (!source || refund.id !== row.id),
-            )
-          : [];
-      return {
-        id: row.id,
-        kind: row.kind as BankOperationDto['kind'],
-        cardId: row.cardId,
-        cardName: card.name,
-        targetCardId: row.targetCardId,
-        targetCardName: target?.name ?? null,
-        categoryId,
-        categoryName: categoriesById.get(categoryId ?? '')?.name ?? null,
-        originalExpenseId: row.originalExpenseId,
-        amount: rubMoney(row.amountKopecks),
-        availableRefund:
-          row.kind === BankOperationKind.Expense || source
-            ? rubMoney(
-                (source?.amountKopecks ?? row.amountKopecks) -
-                relatedRefunds.reduce(
-                  (sum, refund) => sum + refund.amountKopecks,
-                  ZERO_KOPECKS,
-                ),
-              )
-            : null,
-        date: row.date,
-        description: row.description,
-        version: row.version,
-        createdAt: row.createdAt.toISOString(),
-      };
-    });
-  }
-
  private async validateOperation(
    tx: Tx,
    userId: string,
@@ -454,7 +359,9 @@ export class BankOperationsService {
        take: limit,
      });
      return {
-        items: await this.pageViews(tx, rows),
+        items: await Promise.all(
+          rows.map((row) => this.operationView(tx, row)),
+        ),
        total,
        page,
        hasNext: page * limit < total,
@@ -2,39 +2,12 @@ import { ApiProperty } from '@nestjs/swagger';

 import { MoneyDto } from '../../../common/money.dto';
 import { InvestmentResourceMetaDto } from '../investment-resource.dto';
-import { PortfolioStructureDto } from '../portfolio/portfolio.api';
 import { HourlySyncStatusDto } from '../tbank-sync/tbank-sync.dto';

-export class UnrealizedReturnDto {
-  @ApiProperty()
-  declare currency: string;
-
-  @ApiProperty({ example: '12.345678901' })
-  declare absolute: string;
-
-  @ApiProperty({ example: '100.00' })
-  declare costBasis: string;
-
-  @ApiProperty({ type: String, nullable: true, example: '12.34' })
-  declare percent: null | string;
-
-  @ApiProperty()
-  declare partial: boolean;
-}
-
 export class PortfolioSummaryDto {
  @ApiProperty({ type: MoneyDto, isArray: true })
  declare totalsByCurrency: MoneyDto[];

-  @ApiProperty({ type: MoneyDto, isArray: true })
-  declare cashBalances: MoneyDto[];
-
-  @ApiProperty({ type: PortfolioStructureDto })
-  declare structure: PortfolioStructureDto;
-
-  @ApiProperty({ type: UnrealizedReturnDto, isArray: true })
-  declare unrealizedReturnByCurrency: UnrealizedReturnDto[];
-
  @ApiProperty({
    type: 'integer',
    minimum: 0,
@@ -48,20 +21,6 @@ export class PortfolioSummaryDto {
    description: 'Number of non-zero bond positions, not the number of units.',
  })
  declare bondPositionCount: number;
-
-  @ApiProperty({
-    type: 'integer',
-    minimum: 0,
-    description: 'Number of non-zero fund positions, not the number of units.',
-  })
-  declare fundPositionCount: number;
-
-  @ApiProperty({
-    type: 'integer',
-    minimum: 0,
-    description: 'Number of all non-zero positions, not the number of units.',
-  })
-  declare totalPositionCount: number;
 }

 export class BrokerageAccountDto {
@@ -33,7 +33,6 @@ describe('saved brokerage account projection', () => {
  });

  it('keeps exact saved totals and independent missing summaries', async () => {
-    const structure = { currencies: [], unvaluedCategories: [] };
    portfolio.saved.mockResolvedValue({
      membership: meta,
      accounts: [
@@ -44,12 +43,10 @@ describe('saved brokerage account projection', () => {
          openedOn: null,
          meta,
          snapshot: {
-            cashBalances: [{ currency: 'RUB', value: '10.000000001' }],
-            structure,
            totalsByCurrency: [
              { currency: 'RUB', value: '100000000.000000001' },
            ],
-            positions: [{ type: 'STOCK', quantity: '1' }, { type: 'BOND', quantity: '2' }],
+            positions: [{ type: 'STOCK' }, { type: 'BOND' }],
          },
        },
        {
@@ -64,91 +61,15 @@ describe('saved brokerage account projection', () => {
    });
    const response = await service.list('owner');
    expect(response.data?.[0].portfolioSummary).toEqual({
-      cashBalances: [{ currency: 'RUB', value: '10.000000001' }],
-      structure,
      totalsByCurrency: [{ currency: 'RUB', value: '100000000.000000001' }],
      stockPositionCount: 1,
      bondPositionCount: 1,
-      fundPositionCount: 0,
-      totalPositionCount: 2,
-      unrealizedReturnByCurrency: [],
    });
    expect(response.data?.[1].portfolioSummary).toBeNull();
    expect(response.meta.availability).toBe('available');
    expect(response.meta.completeness).toBe('complete');
  });

-  it('returns an empty summary from an empty saved portfolio', async () => {
-    const structure = { currencies: [], unvaluedPositions: [], unknownValues: [] };
-    portfolio.saved.mockResolvedValueOnce({
-      membership: meta,
-      accounts: [{
-        id: 'empty', name: 'Empty', type: 'BROKERAGE', openedOn: null, meta,
-        snapshot: { cashBalances: [], structure, totalsByCurrency: [], positions: [] },
-      }],
-    });
-
-    expect((await service.list('owner')).data?.[0].portfolioSummary).toEqual({
-      cashBalances: [], structure, totalsByCurrency: [],
-      stockPositionCount: 0, bondPositionCount: 0,
-      fundPositionCount: 0, totalPositionCount: 0,
-      unrealizedReturnByCurrency: [],
-    });
-  });
-
-  it('calculates exact returns by currency, partial data, and zero cost basis', async () => {
-    portfolio.saved.mockResolvedValueOnce({
-      membership: meta,
-      accounts: [{
-        id: 'a', name: 'A', type: 'BROKERAGE', openedOn: null, meta,
-        snapshot: {
-          cashBalances: [], structure: {}, totalsByCurrency: [
-            { currency: 'RUB', value: '100' }, { currency: 'USD', value: '20' },
-          ],
-          positions: [
-            { type: 'STOCK', quantity: '2', averagePurchasePrice: { currency: 'RUB', value: '10.000000001' }, absoluteReturn: { currency: 'RUB', value: '0.000000003' } },
-            { type: 'BOND', quantity: '0.5', averagePurchasePrice: { currency: 'RUB', value: '20' }, absoluteReturn: { currency: 'RUB', value: '1.25' } },
-            { type: 'FUND', quantity: '3', averagePurchasePrice: { currency: 'USD', value: '2.5' }, absoluteReturn: null },
-            { type: 'STOCK', quantity: '4', averagePurchasePrice: { currency: 'USD', value: '0' }, absoluteReturn: { currency: 'USD', value: '2.5' } },
-            { type: 'CURRENCY', quantity: '100', averagePurchasePrice: { currency: 'EUR', value: '1' }, absoluteReturn: { currency: 'EUR', value: '5' } },
-            { type: 'BOND', quantity: '1', currentValue: { currency: 'CNY', value: '7' }, averagePurchasePrice: null, absoluteReturn: null },
-          ],
-        },
-      }],
-    });
-
-    expect((await service.list('owner')).data?.[0].portfolioSummary).toMatchObject({
-      stockPositionCount: 2, bondPositionCount: 2,
-      fundPositionCount: 1, totalPositionCount: 6,
-      unrealizedReturnByCurrency: [
-        { currency: 'CNY', absolute: '0', costBasis: '0', percent: null, partial: true },
-        { currency: 'RUB', absolute: '1.250000003', costBasis: '30.000000002', percent: '4.17', partial: false },
-        { currency: 'USD', absolute: '2.5', costBasis: '0', percent: null, partial: true },
-      ],
-    });
-  });
-
-  it('omits return percent for a currency with short positions', async () => {
-    portfolio.saved.mockResolvedValueOnce({
-      membership: meta,
-      accounts: [{
-        id: 'a', name: 'A', type: 'BROKERAGE', openedOn: null, meta,
-        snapshot: {
-          cashBalances: [], structure: {}, totalsByCurrency: [],
-          positions: [
-            { type: 'STOCK', quantity: '-2', averagePurchasePrice: { currency: 'RUB', value: '100' }, absoluteReturn: { currency: 'RUB', value: '-20' } },
-            { type: 'STOCK', quantity: '1', averagePurchasePrice: { currency: 'USD', value: '10' }, absoluteReturn: { currency: 'USD', value: '1' } },
-          ],
-        },
-      }],
-    });
-
-    expect((await service.list('owner')).data?.[0]?.portfolioSummary?.unrealizedReturnByCurrency).toEqual([
-      { currency: 'RUB', absolute: '-20', costBasis: '-200', percent: null, partial: false },
-      { currency: 'USD', absolute: '1', costBasis: '10', percent: '10', partial: false },
-    ]);
-  });
-
  it('observes the latest hourly walk without starting another one', async () => {
    portfolio.saved.mockResolvedValue({ membership: meta, accounts: [] });
    sync.hourly.mockResolvedValue({
@@ -1,82 +1,10 @@
 import { Injectable } from '@nestjs/common';
 import { createHash } from 'node:crypto';

-import {
-  decimalFromString,
-  divide,
-  formatDecimal,
-  isZero,
-  multiply,
-} from '../../../common/decimal';
 import { investmentResourceMeta } from '../investment-resource.mapper';
-import { sumMoneyByCurrency } from '../portfolio/domain/portfolio-totals';
-import { PortfolioPositionDto, PortfolioService } from '../portfolio/portfolio.api';
-import { hourlyAttempt, TbankSyncRepository } from '../tbank-sync/tbank-sync.api';
-import {
-  BrokerageAccountDto,
-  BrokerageAccountsResourceDto,
-  UnrealizedReturnDto,
-} from './brokerage-account.dto';
-
-const PERCENT_DECIMAL_PLACES = 2;
-const ZERO_QUANTITY = 0n;
-
-function unrealizedReturns(positions: PortfolioPositionDto[]): UnrealizedReturnDto[] {
-  // Cash-like CURRENCY positions must not duplicate the separately returned cash balances.
-  const investments = positions.filter((position) => position.type !== 'CURRENCY');
-  const absolute = sumMoneyByCurrency(
-    investments.flatMap((position) => position.absoluteReturn ? [position.absoluteReturn] : []),
-  );
-  const costs = sumMoneyByCurrency(
-    investments.flatMap((position) =>
-      position.absoluteReturn && position.averagePurchasePrice
-        ? [{
-            currency: position.absoluteReturn.currency,
-            value: formatDecimal(multiply(
-              decimalFromString(position.averagePurchasePrice.value),
-              decimalFromString(position.quantity),
-            )),
-          }]
-        : [],
-    ),
-  );
-  const partial = new Set(
-    investments.flatMap((position) => {
-      const money = position.absoluteReturn
-        ? null
-        : position.averagePurchasePrice ?? position.currentValue;
-      return money ? [money.currency] : [];
-    }),
-  );
-  // A short position has negative cost basis, so a percent would flip sign or net out.
-  const withShorts = new Set(
-    investments.flatMap((position) => {
-      const money = position.absoluteReturn ?? position.averagePurchasePrice ?? position.currentValue;
-      return money && decimalFromString(position.quantity).value < ZERO_QUANTITY ? [money.currency] : [];
-    }),
-  );
-  const currencies = new Set([...absolute, ...costs].map((money) => money.currency));
-  return [...new Set([...currencies, ...partial])]
-    .sort((left, right) => left.localeCompare(right))
-    .map((currency) => {
-      const absoluteReturn = absolute.find((money) => money.currency === currency)?.value ?? '0';
-      const costBasis = costs.find((money) => money.currency === currency)?.value ?? '0';
-      const cost = decimalFromString(costBasis);
-      return {
-        currency,
-        absolute: absoluteReturn,
-        costBasis,
-        percent: isZero(cost) || withShorts.has(currency)
-          ? null
-          : formatDecimal(divide(
-              multiply(decimalFromString(absoluteReturn), decimalFromString('100')),
-              cost,
-              PERCENT_DECIMAL_PLACES,
-            )),
-        partial: partial.has(currency),
-      };
-    });
-}
+import { PortfolioService } from '../portfolio/portfolio.api';
+import { TbankSyncRepository } from '../tbank-sync/tbank-sync.repository';
+import { BrokerageAccountDto, BrokerageAccountsResourceDto } from './brokerage-account.dto';

@Injectable()
 export class BrokerageAccountsService {
@@ -98,20 +26,12 @@ export class BrokerageAccountsService {
            portfolioSummary: account.snapshot
              ? {
                  totalsByCurrency: account.snapshot.totalsByCurrency,
-                  cashBalances: account.snapshot.cashBalances,
-                  structure: account.snapshot.structure,
-                  unrealizedReturnByCurrency: unrealizedReturns(account.snapshot.positions),
                  stockPositionCount: account.snapshot.positions.filter(
                    (position) => position.type === 'STOCK',
                  ).length,
                  bondPositionCount: account.snapshot.positions.filter(
                    (position) => position.type === 'BOND',
                  ).length,
-                  fundPositionCount: account.snapshot.positions.filter(
-                    (position) => position.type === 'FUND',
-                  ).length,
-                  // The snapshot mapper already drops zero-quantity positions.
-                  totalPositionCount: account.snapshot.positions.length,
                }
              : null,
          }));
@@ -141,7 +61,6 @@ export class BrokerageAccountsService {
          : null,
        freshForMs: 3_600_000,
        work: null,
-        lastAttempt: hourlyAttempt(hourly, ['membership', 'portfolio']),
        dependencies: saved.accounts.map((account) => account.meta),
      }),
      sync: hourly
@@ -98,7 +98,6 @@ export class IncomeAnalyticsService {
        work: work.id
          ? { id: work.id, state: work.state, errorCode: work.errorCode }
          : null,
-        lastAttempt: current.meta.lastAttempt,
        coverage: current.meta.coverage,
        dependencies,
      }),
@@ -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;
@@ -3,11 +3,15 @@ import {
  Injectable,
  NotFoundException,
 } from '@nestjs/common';
+import { randomUUID } from 'node:crypto';

+import { StructuredLogger } from '../../../../common/logging/structured-logger.service';
+import { isTbankErrorCode, TbankErrorCode } from '../../../../integrations/tbank/tbank-error-code';
 import {
  TbankAccessService,
  TbankClient,
  tbankSourceTtlMs,
+  type TbankSyncAttempt,
 } from '../../../../integrations/tbank/tbank.api';
 import { investmentResourceMeta } from '../../investment-resource.mapper';
 import { InstrumentErrorCode } from '../domain/instrument-error-code';
@@ -27,22 +31,42 @@ import { publicInstrument } from './public-instrument';
 const UNAMBIGUOUS_MATCH_COUNT = 1;
 const NO_MATCHES = 0;
 const FIRST_RESULT_OFFSET = 0;
+const MISSING_DATA_REVISION = '0';

 const tickerAmbiguityLimit = 2;

+type Producer = {
+  attempt: TbankSyncAttempt;
+  force: boolean;
+  input: CatalogQuery;
+  observers: TbankSyncAttempt[];
+};
@Injectable()
 export class CatalogDiscoveryService {
+  private readonly runId = randomUUID();
+  private readonly active = new Set<string>();
+  private readonly producers = new Map<string, Producer>();
+  private readonly queue: Producer[] = [];
+  private reservations: Promise<unknown> = Promise.resolve();
+  private running = false;
+  private readonly completions = new Map<
+    string,
+    { done: Promise<void>; resolve: () => void; workId: string }
+  >();
+
  constructor(
    private readonly repository: CatalogDiscoveryRepository,
    private readonly access: TbankAccessService,
    private readonly tbank: TbankClient,
+    private readonly logger: StructuredLogger,
    private readonly enrichment: CatalogEnrichmentService,
  ) {}

-  async read(userId: string, input: CatalogQuery) {
+  async read(userId: string, input: CatalogQuery, observe = false) {
    input = catalogQuery(input);
    const connection = await this.access.local(userId);
    const saved = await this.repository.read(input);
+    if (!observe) await this.request(userId, connection.revision, input);
    return {
      data: saved.data,
      meta: investmentResourceMeta({
@@ -58,7 +82,7 @@ export class CatalogDiscoveryService {

  async search(userId: string, input: CatalogQuery, observe = false) {
    if (!observe) return this.onlineSearch(userId, catalogQuery(input));
-    const discovery = await this.read(userId, input);
+    const discovery = await this.read(userId, input, observe);
    const sources = discovery.data
      ? await this.enrichment.readMany(
          userId,
@@ -122,11 +146,11 @@ export class CatalogDiscoveryService {
    observe = false,
  ) {
    if (!observe) {
-      const instrument = await this.access.online(userId, ({ token }) =>
+      const token = await this.access.onlineToken(userId);
+      const instrument =
        instrumentType === 'share'
-          ? this.tbank.getShare(token, uid)
-          : this.tbank.getBond(token, uid),
-      );
+          ? await this.tbank.getShare(token, uid)
+          : await this.tbank.getBond(token, uid);
      if (!instrument) throw new NotFoundException();
      return {
        data: { ...publicInstrument({ ...instrument, uid }), uid, slug: instrument.ticker?.toUpperCase() ?? uid },
@@ -158,11 +182,11 @@ export class CatalogDiscoveryService {
      instrument?.ticker &&
      /^[A-Z0-9][\w.@+-]{0,79}$/i.test(instrument.ticker)
    ) {
-      const alias = await this.read(userId, {
-        instrumentType,
-        query: instrument.ticker,
-        exactTicker: true,
-      });
+      const alias = await this.read(
+        userId,
+        { instrumentType, query: instrument.ticker, exactTicker: true },
+        observe,
+      );
      if (alias.data?.length === UNAMBIGUOUS_MATCH_COUNT && alias.data[0].uid === uid) {
        slug = instrument.ticker.toUpperCase();
      }
@@ -201,11 +225,11 @@ export class CatalogDiscoveryService {
  ) {
    if (!observe) {
      const query = ticker.trim().toUpperCase();
-      const found = await this.access.online(userId, ({ token }) =>
+      const token = await this.access.onlineToken(userId);
+      const found =
        instrumentType === 'share'
-          ? this.tbank.findShares(token, query)
-          : this.tbank.findBonds(token, query),
-      );
+          ? await this.tbank.findShares(token, query)
+          : await this.tbank.findBonds(token, query);
      const matches = selectCatalogInstruments(
        found.filter((item) => item.ticker?.trim().toUpperCase() === query),
        query,
@@ -223,11 +247,11 @@ export class CatalogDiscoveryService {
      const result = await this.detail(userId, instrumentType, matches[0].uid);
      return { ...result, data: result.data ? { ...result.data, slug: query } : null };
    }
-    const lookup = await this.read(userId, {
-      instrumentType,
-      query: ticker,
-      exactTicker: true,
-    });
+    const lookup = await this.read(
+      userId,
+      { instrumentType, query: ticker, exactTicker: true },
+      observe,
+    );
    if (lookup.data?.length === NO_MATCHES) throw new NotFoundException();
    if (lookup.data && lookup.data.length > UNAMBIGUOUS_MATCH_COUNT) {
      throw new ConflictException({
@@ -268,32 +292,28 @@ export class CatalogDiscoveryService {
  }

  private async onlineSearch(userId: string, input: CatalogQuery) {
-    const { details, instruments, prices } = await this.access.online(userId, async ({ token }) => {
-      const found =
+    const token = await this.access.onlineToken(userId);
+    const found =
+      input.instrumentType === 'share'
+        ? await this.tbank.findShares(token, input.query)
+        : await this.tbank.findBonds(token, input.query);
+    const instruments = selectCatalogInstruments(
+      input.exactTicker
+        ? found.filter((item) => item.ticker?.trim().toUpperCase() === input.query)
+        : found,
+      input.query,
+      input.instrumentType,
+    ).slice(FIRST_RESULT_OFFSET, input.exactTicker ? tickerAmbiguityLimit : catalogSearchLimit);
+    const details = await Promise.all(
+      instruments.map((item) =>
        input.instrumentType === 'share'
-          ? await this.tbank.findShares(token, input.query)
-          : await this.tbank.findBonds(token, input.query);
-      const instruments = selectCatalogInstruments(
-        input.exactTicker
-          ? found.filter((item) => item.ticker?.trim().toUpperCase() === input.query)
-          : found,
-        input.query,
-        input.instrumentType,
-      ).slice(FIRST_RESULT_OFFSET, input.exactTicker ? tickerAmbiguityLimit : catalogSearchLimit);
-      const [details, prices] = await Promise.all([
-        Promise.all(
-          instruments.map((item) =>
-            input.instrumentType === 'share'
-              ? this.tbank.getShare(token, item.uid)
-              : this.tbank.getBond(token, item.uid),
-          ),
-        ),
-        instruments.length
-          ? this.tbank.getLastPrices(token, instruments.map((item) => item.uid))
-          : [],
-      ]);
-      return { details, instruments, prices };
-    });
+          ? this.tbank.getShare(token, item.uid)
+          : this.tbank.getBond(token, item.uid),
+      ),
+    );
+    const prices = instruments.length
+      ? await this.tbank.getLastPrices(token, instruments.map((item) => item.uid))
+      : [];
    const fetchedAt = new Date();
    const data = instruments.flatMap((item, index) => {
      const detail = details.at(index);
@@ -315,4 +335,162 @@ export class CatalogDiscoveryService {
      }),
    };
  }
+
+  request(
+    userId: string,
+    revision: string,
+    query: CatalogQuery,
+    force = false,
+  ) {
+    const input = catalogQuery(query);
+    const reserved = this.reservations.then(async () => {
+      const saved = await this.repository.read(input);
+      if (
+        !force &&
+        saved.dataRevision !== MISSING_DATA_REVISION
+      ) return null;
+      const reservation = await this.repository.reserve(
+        { userId, revision },
+        input,
+        this.runId,
+        this.active,
+      );
+      if (!reservation) return null;
+      const { id, attemptId } = reservation.work;
+      if (!reservation.launch) {
+        const current = this.producers.get(catalogScope(input));
+        if (current) current.force ||= force;
+        return id;
+      }
+      const attempt = { userId, revision, id, attemptId };
+      this.active.add(attemptId);
+      let resolve = () => {};
+      const done = new Promise<void>((finish) => {
+        resolve = finish;
+      });
+      this.completions.set(attemptId, { workId: id, done, resolve });
+      const key = catalogScope(input);
+      const producer = this.producers.get(key);
+      if (producer) {
+        producer.observers.push(attempt);
+        producer.force ||= force;
+      } else {
+        const queued = { input, attempt, observers: [], force };
+        this.producers.set(key, queued);
+        this.queue.push(queued);
+      }
+      if (!this.running) {
+        this.running = true;
+        setImmediate(() => {
+          void this.drain();
+        });
+      }
+      return id;
+    });
+    this.reservations = reserved.catch(() => undefined);
+    return reserved;
+  }
+
+  async refresh(userId: string, revision: string, query: CatalogQuery) {
+    const id = await this.request(userId, revision, query, true);
+    if (id) {
+      await Promise.all(
+        [...this.completions.values()]
+          .filter((entry) => entry.workId === id)
+          .map((entry) => entry.done),
+      );
+    }
+    const saved = await this.repository.read(catalogQuery(query));
+    const sources = await this.enrichment.readMany(
+      userId,
+      query.instrumentType,
+      saved.data?.map((item) => item.uid) ?? [],
+      true,
+    );
+    return [
+      ...(id ? [id] : []),
+      ...sources.flatMap((source) =>
+        source.meta.sync.id ? [source.meta.sync.id] : [],
+      ),
+    ];
+  }
+
+  private async drain() {
+    try {
+      while (this.queue.length) {
+        const producer = this.queue.shift();
+        if (!producer) break;
+        const { input, attempt } = producer;
+        let success = false;
+        try {
+          const token = await this.access.tokenForAttempt(attempt);
+          if (token) {
+            const found =
+              input.instrumentType === 'share'
+                ? await this.tbank.findShares(token, input.query)
+                : await this.tbank.findBonds(token, input.query);
+            success = await this.repository.publish(
+              attempt,
+              input,
+              selectCatalogInstruments(
+                input.exactTicker
+                  ? found.filter(
+                      (item) =>
+                        item.ticker?.trim().toUpperCase() === input.query,
+                    )
+                  : found,
+                input.query,
+                input.instrumentType,
+              ).slice(
+                FIRST_RESULT_OFFSET,
+                input.exactTicker ? tickerAmbiguityLimit : catalogSearchLimit,
+              ),
+              new Date(),
+            );
+          }
+        } catch (error) {
+          if (error instanceof Error && isTbankErrorCode(error.message, TbankErrorCode.InvalidToken)) {
+            await this.access.rejectMembershipToken(attempt);
+          } else {
+            this.logger.event('warn', 'catalog-discovery.failed', {
+              code: TbankErrorCode.Unavailable,
+            });
+          }
+        }
+        if (success) {
+          const saved = await this.repository.read(input);
+          for (const observer of [attempt, ...producer.observers]) {
+            if (!input.exactTicker || saved.data?.length === UNAMBIGUOUS_MATCH_COUNT) {
+              await this.enrichment.requestMany(
+                observer.userId,
+                observer.revision,
+                input.instrumentType,
+                saved.data?.map((item) => item.uid) ?? [],
+                producer.force,
+                input.exactTicker ? ['detail'] : ['last-price', 'detail'],
+              );
+            }
+          }
+        }
+        this.producers.delete(catalogScope(input));
+        for (const observer of [attempt, ...producer.observers]) {
+          await this.repository.finish(observer, success);
+          this.active.delete(observer.attemptId);
+          this.completions.get(observer.attemptId)?.resolve();
+          this.completions.delete(observer.attemptId);
+        }
+      }
+    } catch {
+      for (const completion of this.completions.values()) completion.resolve();
+      this.completions.clear();
+      this.active.clear();
+      this.producers.clear();
+      this.queue.length = 0;
+      this.logger.event('error', 'catalog-discovery.persistence-failed', {
+        code: TbankErrorCode.Unavailable,
+      });
+    } finally {
+      this.running = false;
+    }
+  }
 }
@@ -231,6 +231,7 @@ export class CatalogEnrichmentService {
    return reservation;
  }

+  // eslint-disable-next-line sonarjs/cognitive-complexity -- Section composition owns the source dependency policy.
  async section(
    userId: string,
    instrumentType: 'bond' | 'share',
@@ -239,20 +240,18 @@ export class CatalogEnrichmentService {
    observe = false,
  ) {
    if (section === 'company' && !observe) {
-      const { description, fundamentals, instrument } = await this.access.online(userId, async ({ token }) => {
-        const instrument =
-          instrumentType === 'share'
-            ? await this.tbank.getShare(token, uid)
-            : await this.tbank.getBond(token, uid);
-        if (!instrument) throw new NotFoundException();
-        const [description, fundamentals] = instrument.assetUid
-          ? await Promise.all([
-              this.tbank.getAssetDescription(token, instrument.assetUid),
-              this.tbank.getFundamentals(token, instrument.assetUid),
-            ])
-          : [null, null];
-        return { description, fundamentals, instrument };
-      });
+      const token = await this.access.onlineToken(userId);
+      const instrument =
+        instrumentType === 'share'
+          ? await this.tbank.getShare(token, uid)
+          : await this.tbank.getBond(token, uid);
+      if (!instrument) throw new NotFoundException();
+      const [description, fundamentals] = instrument.assetUid
+        ? await Promise.all([
+            this.tbank.getAssetDescription(token, instrument.assetUid),
+            this.tbank.getFundamentals(token, instrument.assetUid),
+          ])
+        : [null, null];
      const meta = investmentResourceMeta({
        resourceKey: `${instrumentType}/company/${uid}`,
        dataRevision: `online:${Date.now()}`,
@@ -22,8 +22,6 @@ const row = (
  isin: null,
  ticker: null,
  logoName: null,
-  sector: null,
-  issuer: null,
 });
 const portfolio = (positions: PortfolioPositionDto[]): PortfolioDto => ({
  positions,
@@ -22,16 +22,14 @@ function share(index: number, overrides: Partial<TbankShare> = {}): TbankShare {
 }

 describe('StockScreenerService', () => {
-  const access = { online: jest.fn(), local: jest.fn() };
+  const access = { current: jest.fn(), local: jest.fn() };
  const client = { getAllShares: jest.fn() };
  const logger = { event: jest.fn() };
  let service: StockScreenerService;

  beforeEach(() => {
    jest.clearAllMocks();
-    access.online.mockImplementation((_userId: string, run: (connection: { revision: string; token: string }) => Promise<unknown>) =>
-      run({ revision, token }),
-    );
+    access.current.mockResolvedValue({ revision, token });
    access.local.mockResolvedValue({ revision });
    client.getAllShares.mockResolvedValue(
      Array.from({ length: pageSize + 1 }, (_, index) => share(index)),
@@ -48,8 +48,8 @@ type StockScreenerPage = {
 };
 type Snapshot = { asOf: string; expiresAt: number; items: StockScreenerItem[]; revision: string; userId: string };
 type TbankAccess = {
+  current(userId: string): Promise<{ revision: string; token: string }>;
  local(userId: string): Promise<{ revision: string }>;
-  online<T>(userId: string, run: (connection: { revision: string; token: string }) => Promise<T>): Promise<T>;
 };

@Injectable()
@@ -63,10 +63,8 @@ export class StockScreenerService {
  ) {}

  async search(userId: string, conditions: StockScreenerConditions): Promise<StockScreenerPage> {
-    const { instruments, revision } = await this.access.online(userId, async (connection) => ({
-      instruments: await this.client.getAllShares(connection.token),
-      revision: connection.revision,
-    }));
+    const connection = await this.access.current(userId);
+    const instruments = await this.client.getAllShares(connection.token);
    const asOf = new Date().toISOString();
    const selected = selectStockScreenerInstruments({ asOf: new Date(asOf), instruments }, conditions)
      .instruments.map((instrument) => this.item(instrument));
@@ -76,7 +74,7 @@ export class StockScreenerService {
      asOf,
      expiresAt: Date.now() + SNAPSHOT_TTL_MS,
      items: selected,
-      revision,
+      revision: connection.revision,
      userId,
    });
    this.logger.event('info', 'stock.screener.search.completed', { asOf, count: selected.length, operation: 'stock-screener-search' });
@@ -93,7 +93,7 @@ export class StockScreenerItemDto {
  @ApiProperty({ nullable: true, type: String }) declare currency: null | string;
  @ApiProperty({ nullable: true, type: String }) declare realExchange: null | string;
  @ApiProperty({ nullable: true, type: String }) declare countryOfRisk: null | string;
-  @ApiProperty({ nullable: true, minimum: MIN_TICKER_LENGTH, type: 'integer' }) declare lot: null | number;
+  @ApiProperty({ nullable: true, type: 'integer' }) declare lot: null | number;
 }

 export class StockScreenerPageDto {
@@ -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,16 +6,21 @@ 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,
-} from '../../tbank-sync/tbank-sync.api';
+} from '../../tbank-sync/tbank-sync.repository';
 import { OperationErrorCode } from '../domain/operation-error-code';
 import {
  confirmedOperationRanges,
@@ -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,23 +406,35 @@ 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();
-    const hourly = await this.hourlySync.hourly(userId);
    const membership = investmentResourceMeta({
      resourceKey: 'accounts/membership',
      dataRevision: String(saved?.connection.membershipRevision ?? MISSING_MEMBERSHIP_REVISION),
@@ -463,7 +503,6 @@ export class BrokerageOperationsService {
        fetchedAt,
        freshForMs: plan.intervals.some((range) => range.stale) ? STALE_FRESHNESS_MS : Infinity,
        work,
-        lastAttempt: hourlyAttempt(hourly, 'operations', accountId === 'all' ? undefined : accountId),
        dependencies: [membership],
        coverage: {
          requested: targets.map(serialize),
@@ -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',
@@ -1,4 +1,4 @@
-import assert from 'node:assert/strict';
+import { setImmediate as immediate } from 'node:timers/promises';
 jest.mock('../../../../prisma/prisma.service', () => ({
  PrismaService: class {},
 }));
@@ -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({
@@ -131,9 +97,14 @@ describe('persistent portfolio projection', () => {
      ],
      work: [],
    });
-    const handle = await service.request('user', 'private', 'a');
-    assert(handle);
-    await handle.done;
+    await service.request('user', 'private', 'a');
+    for (
+      let index = 0;
+      index < 10 && !repository.publish.mock.calls.length;
+      index += 1
+    ) {
+      await immediate();
+    }
    const snapshot = (
      repository.publish.mock.calls as [unknown, string, PortfolioDto][]
    )[0][2];
@@ -176,9 +147,10 @@ describe('persistent portfolio projection', () => {
      { units: '99' },
      { currency: 'EUR', units: '1' },
    ] });
-    const handle = await service.request('user', 'private', 'a');
-    assert(handle);
-    await handle.done;
+    await service.request('user', 'private', 'a');
+    for (let index = 0; index < 10 && !repository.publish.mock.calls.length; index++) {
+      await immediate();
+    }
    const snapshot = (repository.publish.mock.calls as [unknown, string, PortfolioDto][])[0][2];
    expect(snapshot.cashBalances).toEqual([
      { currency: 'RUB', value: '0' },
@@ -193,31 +165,6 @@ describe('persistent portfolio projection', () => {
    expect(snapshot.positions[1].averagePurchasePrice).toEqual({ currency: 'RUB', value: '2' });
  });

-  it('counts cash once when T-Bank also returns it as a CURRENCY position', async () => {
-    repository.reserve.mockResolvedValueOnce({
-      launch: true,
-      work: { id: 'work', attemptId: 'attempt' },
-    });
-    tbank.getPortfolio.mockResolvedValue({ positions: [
-      { figi: 'FUND', instrumentType: 'etf', quantity: { units: '1' }, currentPrice: { currency: 'RUB', units: '120', nano: 240000000 } },
-      { figi: 'RUB000UTSTOM', instrumentType: 'currency', quantity: { units: '1', nano: 250000000 }, currentPrice: { currency: 'RUB', units: '1' } },
-    ] });
-    tbank.getPositions.mockResolvedValue({ money: [{ currency: 'RUB', units: '1', nano: 250000000 }] });
-    repository.read.mockResolvedValue({
-      membershipAt,
-      membershipRevision: 1,
-      accounts: [{ accountId: 'a', name: 'A', type: 'BROKERAGE', openedOn: null, portfolio: null }],
-      work: [],
-    });
-    const handle = await service.request('user', 'private', 'a');
-    assert(handle);
-    await handle.done;
-    const snapshot = (repository.publish.mock.calls as [unknown, string, PortfolioDto][])[0][2];
-    expect(snapshot.totalsByCurrency).toEqual([{ currency: 'RUB', value: '121.49' }]);
-    expect(snapshot.positions.map((position) => position.type)).toEqual(['FUND', 'CURRENCY']);
-    expect(snapshot.structure.currencies[0].totalValue).toBe('121.49');
-  });
-
  it('does not turn a missing account snapshot into aggregate zero; summaries stay independent', async () => {
    const snapshot: PortfolioDto = {
      lastSuccessfulAt: membershipAt.toISOString(),
@@ -20,7 +20,7 @@ import { investmentResourceMeta } from '../../investment-resource.mapper';
 import {
  hourlyAttempt,
  TbankSyncRepository,
-} from '../../tbank-sync/tbank-sync.api';
+} from '../../tbank-sync/tbank-sync.repository';
 import { portfolioStructure } from '../domain/portfolio-structure';
 import { sumMoneyByCurrency } from '../domain/portfolio-totals';
 import {
@@ -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,14 +14,12 @@ const position = (
  isin: null,
  ticker: null,
  logoName: null,
-  sector: null,
-  issuer: null,
  absoluteReturn: null,
  averagePurchasePrice: null,
 });

 describe('portfolio structure', () => {
-  it('counts cash once and skips CURRENCY positions that mirror it', () => {
+  it('includes cash once and keeps currency instruments among other assets', () => {
    const result = portfolioStructure(
      [
        position('STOCK', '60'),
@@ -32,13 +30,13 @@ describe('portfolio structure', () => {
    );
    expect(result.currencies[0]).toEqual({
      currency: 'RUB',
-      totalValue: '90',
+      totalValue: '100',
      hasNegativeValues: false,
      categories: [
-        { type: 'STOCK', value: '60', sharePercent: '66.666667' },
-        { type: 'BOND', value: '20', sharePercent: '22.222222' },
-        { type: 'OTHER', value: '0', sharePercent: '0' },
-        { type: 'CASH', value: '10', sharePercent: '11.111111' },
+        { type: 'STOCK', value: '60', sharePercent: '60' },
+        { type: 'BOND', value: '20', sharePercent: '20' },
+        { type: 'OTHER', value: '10', sharePercent: '10' },
+        { type: 'CASH', value: '10', sharePercent: '10' },
      ],
    });
  });
@@ -43,8 +43,6 @@ export function portfolioStructure(
    currencies.set(money.currency, group);
  };
  for (const position of positions) {
-    // CURRENCY positions mirror cash, which is counted once as CASH below.
-    if (position.type === 'CURRENCY') continue;
    const type = ['BOND', 'STOCK'].includes(position.type)
      ? position.type
      : 'OTHER';
@@ -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,
  };
 }

@@ -131,8 +126,7 @@ function totalsByCurrency(
  for (const value of money) addTotal(value.currency, decimal(value));
  for (const position of positions) {
    const price = position.currentPrice;
-    // CURRENCY positions mirror the cash balances already added above.
-    if (!price || types[position.instrumentType?.toLowerCase() ?? ''] === 'CURRENCY') continue;
+    if (!price) continue;
    addTotal(
      price.currency,
      multiply(decimal(position.quantity ?? {}), decimal(price)),
@@ -5,5 +5,4 @@ export { PortfolioService } from './application/portfolio.service';
 export {
  PortfolioDto,
  PortfolioPositionDto,
-  PortfolioStructureDto,
 } from './presentation/portfolio.dto';
@@ -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' });
@@ -1 +0,0 @@
-export { hourlyAttempt, TbankSyncRepository } from './tbank-sync.repository';
@@ -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;
@@ -209,6 +209,13 @@ export const investmentScreenSchema = {
  },
 };

+export class TbankSyncAcceptedDto {
+  @ApiProperty({ format: 'uuid' }) declare id: string;
+  @ApiProperty({ type: Object, ...investmentScreenSchema })
+  declare scope: InvestmentScreenDto;
+
+  @ApiProperty({ format: 'date-time' }) declare now: string;
+}
 export class TbankSyncStatusDto {
  @ApiProperty({ format: 'uuid' }) declare id: string;
  @ApiProperty({ type: Object, ...investmentScreenSchema, nullable: true })
@@ -222,6 +229,26 @@ export class TbankSyncStatusDto {
    null | string;
 }

+export class HourlySyncSectionDto {
+  @ApiProperty({ enum: ['membership', 'portfolio', 'operations', 'events'] })
+  declare section: 'events' | 'membership' | 'operations' | 'portfolio';
+
+  @ApiPropertyOptional({
+    type: String,
+    nullable: false,
+    description: 'Account identifier of the problematic section, when scoped.',
+  })
+  declare accountId?: string;
+
+  @ApiProperty({
+    type: String,
+    nullable: true,
+    description:
+      'Safe error code of the failed section. No tokens or upstream payloads.',
+  })
+  declare errorCode: null | string;
+}
+
 export class HourlySyncStatusDto {
  @ApiProperty({
    enum: ['running', 'succeeded', 'partial', 'failed', 'cancelled'],
@@ -43,17 +43,16 @@ type HourlyAttempt = {

 export function hourlyAttempt(
  hourly: HourlyAttempt | null,
-  section: HourlySection['section'] | readonly HourlySection['section'][],
+  section: HourlySection['section'],
  accountId?: string,
 ): InvestmentAttemptDto {
  if (!hourly) {
    return { state: 'none', startedAt: null, finishedAt: null, problems: [] };
  }
-  const sections = Array.isArray(section) ? section : [section];
  const problems = hourly.sections
    .filter(
      (entry) =>
-        sections.includes(entry.section) &&
+        entry.section === section &&
        (accountId === undefined || entry.accountId === accountId),
    )
    .map((entry) => ({
@@ -183,8 +182,7 @@ export class TbankSyncRepository {

  // The timer only proposes work; this reservation is the durable fence. The
  // attempt start (createdAt) is the basis of the next hourly term, including
-  // failed and interrupted attempts. After downtime the next tick is due at
-  // once, so no catch-up queue forms.
+  // failed and interrupted attempts.
  reserveHourly(userId: string, runId: string, hourMs: number) {
    return this.prisma.$transaction(async (tx) => {
      const connection = await tx.tbankConnection.findFirst({
@@ -202,16 +200,7 @@ export class TbankSyncRepository {
      });
      const now = new Date();
      if (previous) {
-        // Terms are hourMs steps from the attempt start; a walk still running
-        // at a term consumes it. A dead process's attempt has no known end, so
-        // it consumes only its own term.
-        const started = previous.createdAt.valueOf();
-        const ended =
-          previous.state === 'running' ? started : previous.updatedAt.valueOf();
-        const dueAt =
-          started +
-          Math.max(hourMs, Math.ceil((ended - started) / hourMs) * hourMs);
-        const due = now.valueOf() >= dueAt;
+        const due = now.valueOf() - previous.createdAt.valueOf() >= hourMs;
        if (previous.state === 'running') {
          if (previous.processRunId === runId) return null;
          // A dead process cannot finish its attempt; close it from its
@@ -2,27 +2,314 @@ import {
  ConflictException,
  Injectable,
  NotFoundException,
+  ServiceUnavailableException,
 } from '@nestjs/common';
 import { randomUUID } from 'node:crypto';

-import { TbankAccessService } from '../../../integrations/tbank/tbank.api';
-import { BrokerageOperationsSyncService } from '../operations/operations.api';
-import { TbankSyncStatusDto } from './tbank-sync.dto';
+import { ISO_DATE_LENGTH, ISO_DATE_START } from '../../../common/time';
+import { TbankErrorCode } from '../../../integrations/tbank/tbank-error-code';
+import {
+  InstrumentMetadataService,
+  TbankAccessService,
+  TbankMembershipService,
+  type TbankSyncAttempt,
+} from '../../../integrations/tbank/tbank.api';
+import {
+  CandleService,
+  CatalogDiscoveryService,
+  CatalogEnrichmentService,
+} from '../instruments/instruments.api';
+import { planInvestmentScreen } from '../investment-sync-plan';
+import {
+  BrokerageOperationsSyncService,
+  type OperationInterval,
+} from '../operations/operations.api';
+import { PortfolioService } from '../portfolio/portfolio.api';
+import { normalizeScreen } from './tbank-screen';
+import { InvestmentScreenDto, TbankSyncStatusDto } from './tbank-sync.dto';
 import {
  type ScreenIntent,
  TbankSyncRepository,
 } from './tbank-sync.repository';

+const FOREGROUND_CANDLE_PRIORITY = 0;
+
@Injectable()
 export class TbankSyncService {
  private readonly runId = randomUUID();
  private readonly startedAt = new Date();
+  private reservations: Promise<unknown> = Promise.resolve();
  constructor(
    private readonly repository: TbankSyncRepository,
    private readonly access: TbankAccessService,
+    private readonly membership: TbankMembershipService,
+    private readonly portfolio: PortfolioService,
    private readonly operations: BrokerageOperationsSyncService,
+    private readonly metadata: InstrumentMetadataService,
+    private readonly discovery: CatalogDiscoveryService,
+    private readonly sources: CatalogEnrichmentService,
+    private readonly candles: CandleService,
  ) {}

+  async request(userId: string, input: InvestmentScreenDto) {
+    const scope = normalizeScreen(input);
+    const connection = await this.access.local(userId, scope.accountId);
+    const reservation = this.reservations.then(() =>
+      this.repository.reserve(userId, connection.revision, scope, this.runId),
+    );
+    this.reservations = reservation.catch(() => undefined);
+    const reserved = await reservation;
+    if (!reserved) throw new ServiceUnavailableException();
+    const intent = reserved.work.intent as unknown as ScreenIntent;
+    if (reserved.launch) {
+      const attempt = {
+        userId,
+        revision: connection.revision,
+        id: reserved.work.id,
+        attemptId: reserved.work.attemptId,
+      };
+      setImmediate(() => {
+        void this.dispatch(attempt, intent);
+      });
+    }
+    return { id: reserved.work.id, ...intent };
+  }
+
+  private async dispatch(attempt: TbankSyncAttempt, intent: ScreenIntent) {
+    const children: string[] = [];
+    const add = async (ids: (null | string | undefined)[]) => {
+      children.push(...ids.filter((id): id is string => Boolean(id)));
+      await this.repository.progress(attempt, children, false);
+    };
+    try {
+      const { userId, revision } = attempt;
+      const { scope } = intent;
+      const now = new Date(intent.now);
+      const member = await this.membership.request(userId, revision, true);
+      await add([member?.id]);
+      await member?.done;
+      const current = await this.access.local(userId, scope.accountId);
+      if (current.revision !== revision) return;
+      const accountScope = scope.accountId ?? 'all';
+      const selectedAccounts = current.accounts.filter(
+        (account) =>
+          accountScope === 'all' || account.accountId === accountScope,
+      );
+      if (
+        ['account', 'accounts', 'bond', 'events', 'stock'].includes(
+          scope.screen,
+        )
+      ) {
+        for (const account of scope.screen === 'stock' ||
+          scope.screen === 'bond'
+          ? current.accounts
+          : selectedAccounts) {
+          const work = await this.portfolio.request(
+            userId,
+            revision,
+            account.accountId,
+            true,
+          );
+          await add([work?.id]);
+          await work?.done;
+        }
+      }
+      const saved = await this.portfolio.read(
+        userId,
+        scope.screen === 'stock' || scope.screen === 'bond'
+          ? 'all'
+          : accountScope,
+      );
+      const positions = saved.data?.positions ?? [];
+      const instruments = [
+        ...new Map(
+          positions.flatMap((position) =>
+            position.instrumentUid &&
+            (position.type === 'STOCK' || position.type === 'BOND')
+              ? [
+                  [
+                    position.instrumentUid,
+                    {
+                      uid: position.instrumentUid,
+                      type: position.type,
+                      historyFrom: null,
+                    },
+                  ] as const,
+                ]
+              : [],
+          ),
+        ).values(),
+      ];
+      const plan = planInvestmentScreen(
+        {
+          ...scope,
+          candleRange: scope.candleRange
+            ? {
+                from: new Date(scope.candleRange.from),
+                to: new Date(scope.candleRange.to),
+              }
+            : undefined,
+        },
+        {
+          accounts: selectedAccounts,
+          instruments:
+            scope.screen === 'stocks' || scope.screen === 'bonds'
+              ? []
+              : instruments,
+          membershipKnown: Boolean(current.membershipAt),
+        },
+        now,
+        true,
+      );
+      const intervals: OperationInterval[] = plan.sources.flatMap((source) =>
+        source.kind === 'operations' &&
+        source.accountId &&
+        source.from &&
+        source.to
+          ? [
+              {
+                accountId: source.accountId,
+                from: source.from,
+                to: source.to,
+                ...(source.instrumentUid
+                  ? { instrumentUid: source.instrumentUid }
+                  : {}),
+              },
+            ]
+          : [],
+      );
+      if (intervals.length) {
+        await add([
+          await this.operations.request(
+            userId,
+            intervals,
+            true,
+            'screen',
+            revision,
+          ),
+        ]);
+      }
+      for (const source of plan.sources) {
+        const uid = source.instrumentUid;
+        const type = source.instrumentType === 'BOND' ? 'bond' : 'share';
+        if (source.kind === 'catalog') {
+          await add(
+            await this.discovery.refresh(userId, revision, {
+              instrumentType: type,
+              query: source.query ?? '',
+            }),
+          );
+        }
+        if (!uid) continue;
+        if (source.kind === 'metadata') {
+          await add([
+            await this.metadata.request(userId, revision, {
+              instrumentUid: uid,
+            }),
+          ]);
+        }
+        if (source.kind === 'quote') {
+          await add(
+            await this.sources.requestMany(
+              userId,
+              revision,
+              type,
+              [uid],
+              true,
+              [
+                type === 'bond' ? 'bond-current' : 'detail',
+                'last-price',
+                'trading-status',
+                'comparison',
+              ],
+            ),
+          );
+        }
+        if (source.kind === 'company') {
+          await add(
+            await this.sources.requestMany(
+              userId,
+              revision,
+              type,
+              [uid],
+              true,
+              ['description', 'fundamentals'],
+            ),
+          );
+        }
+        if (source.kind === 'metrics') {
+          await add(
+            await this.sources.requestMany(
+              userId,
+              revision,
+              type,
+              [uid],
+              true,
+              ['coupons', 'yield', 'rating'],
+            ),
+          );
+        }
+        if (source.kind === 'calendar' && source.from && source.to) {
+          await add(
+            await this.sources.requestMany(
+              userId,
+              revision,
+              type,
+              [uid],
+              true,
+              [
+                type === 'share'
+                  ? 'dividends'
+                  : scope.screen === 'bond'
+                    ? 'coupons'
+                    : 'bond-events',
+              ],
+              {
+                from: source.from.toISOString().slice(ISO_DATE_START, ISO_DATE_LENGTH),
+                to: source.to.toISOString().slice(ISO_DATE_START, ISO_DATE_LENGTH),
+                ticker:
+                  positions.find((position) => position.instrumentUid === uid)
+                    ?.ticker ?? undefined,
+              },
+            ),
+          );
+        }
+      }
+      if (
+        (scope.screen === 'stock' || scope.screen === 'bond') &&
+        scope.instrumentUid
+      ) {
+        await add([
+          await this.candles.request(
+            userId,
+            revision,
+            {
+              uid: scope.instrumentUid,
+              instrumentType: scope.screen === 'bond' ? 'bond' : 'share',
+              period: scope.candlePeriod ?? 'month',
+              ...(scope.candleRange
+                ? {
+                    range: {
+                      from: new Date(scope.candleRange.from),
+                      to: new Date(scope.candleRange.to),
+                    },
+                  }
+                : {}),
+            },
+            now,
+            true,
+            FOREGROUND_CANDLE_PRIORITY,
+          ),
+        ]);
+      }
+      await this.repository.progress(attempt, children, true);
+    } catch {
+      await this.repository
+        .progress(attempt, children, true, TbankErrorCode.Unavailable)
+        .catch(() => undefined);
+    }
+  }
+
  async status(userId: string, id: string): Promise<TbankSyncStatusDto> {
    const connection = await this.access
      .local(userId)
@@ -24,7 +24,7 @@ import {
 import {
  hourlyAttempt,
  TbankSyncRepository,
-} from '../tbank-sync/tbank-sync.api';
+} from '../tbank-sync/tbank-sync.repository';
 import { bondEvent, dividendEvent } from './upcoming-event.mapper';
 import {
  UpcomingEventDto,
@@ -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,51 +1,11 @@
 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(
+  return SwaggerModule.createDocument(
    app,
    new DocumentBuilder().setTitle('WealthLedger API').setVersion('v1').build(),
  );
-  const schemas = document.components?.schemas ?? {};
-  for (const [name, schema] of Object.entries(schemas)) {
-    if (CLOSED_SCHEMAS.includes(name) && 'properties' in schema) {
-      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;
 }
@@ -9,7 +9,6 @@ import { AppModule } from '../src/app.module';
 import { TbankTokenService } from '../src/integrations/tbank/tbank-token.service';
 import { TbankClient } from '../src/integrations/tbank/tbank.client';
 import { configureApp } from '../src/main';
-import { TbankHourlyScheduler } from '../src/modules/investments/tbank-sync/tbank-hourly.scheduler';
 import { PrismaService } from '../src/prisma/prisma.service';

 describe('All accounts HTTP boundary', () => {
@@ -32,8 +31,6 @@ describe('All accounts HTTP boundary', () => {
    const module = await Test.createTestingModule({ imports: [AppModule] })
      .overrideProvider(TbankClient)
      .useValue(upstream)
-      .overrideProvider(TbankHourlyScheduler)
-      .useValue({ tick: jest.fn() })
      .compile();
    app = module.createNestApplication();
    configureApp(app);
@@ -2,9 +2,7 @@ import { INestApplication } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { JwtService } from '@nestjs/jwt';
 import { Test, TestingModule } from '@nestjs/testing';
-import * as bcrypt from 'bcrypt';
 import { PARAMS_PROVIDER_TOKEN } from 'nestjs-pino';
-import { createHash, randomUUID } from 'node:crypto';
 import request from 'supertest';
 import { App } from 'supertest/types';

@@ -12,7 +10,6 @@ import { AppModule } from '../src/app.module';
 import { loggingOptions } from '../src/common/logging/logging.module';
 import { configureApp } from '../src/main';
 import { AuthService } from '../src/modules/auth/application/auth.service';
-import { TbankHourlyScheduler } from '../src/modules/investments/tbank-sync/tbank-hourly.scheduler';
 import { PrismaService } from '../src/prisma/prisma.service';

 type Authentication = { accessToken: string; user: { email: string } };
@@ -32,15 +29,11 @@ describe('Authentication (e2e)', () => {
        pinoHttp: {
          ...loggingOptions(config),
          level: 'info',
-          transport: undefined,
          stream: { write: (line: string) => logs.push(JSON.parse(line) as Record<string, unknown>) },
        },
        assignResponse: true,
      }),
-    })
-      .overrideProvider(TbankHourlyScheduler)
-      .useValue({ tick: jest.fn() })
-      .compile();
+    }).compile();

    app = moduleFixture.createNestApplication();
    configureApp(app);
@@ -97,171 +90,6 @@ describe('Authentication (e2e)', () => {
    await agent.post('/api/v1/auth/logout').expect(204);
  });

-  it('rejects a valid refresh token as Bearer while its session stays usable', async () => {
-    const registration = await request(app.getHttpServer())
-      .post('/api/v1/auth/register')
-      .send({ email: 'bearer@example.test', password: 'a secure password' })
-      .expect(200);
-    const cookie = registration.headers['set-cookie'][0];
-    const refreshToken = /^refresh_token=([^;]+)/.exec(cookie)?.[1];
-    if (!refreshToken) throw new Error('Expected a refresh token cookie');
-    // Signed, unexpired and backed by a live session: only its type is wrong.
-    await expect(app.get(JwtService).verifyAsync(refreshToken)).resolves.toMatchObject({
-      type: 'refresh',
-    });
-
-    await request(app.getHttpServer())
-      .get('/api/v1/auth/me')
-      .set('Authorization', `Bearer ${refreshToken}`)
-      .expect(401)
-      .expect(({ body }: { body: unknown }) =>
-        expect(body).toEqual({ status: 401, code: 'UNAUTHORIZED' }),
-      );
-
-    await request(app.getHttpServer())
-      .post('/api/v1/auth/refresh')
-      .set('Cookie', cookie)
-      .expect(200);
-  });
-
-  describe('refresh cookie policy', () => {
-    const attributes = (cookie: string) =>
-      cookie
-        .split('; ')
-        .slice(1)
-        .filter((attribute) => !attribute.startsWith('Expires='))
-        .sort((a, b) => a.localeCompare(b));
-    const host = ['HttpOnly', 'Path=/api/v1/auth', 'SameSite=Lax'];
-    // Persistent for the Session lifetime (7 days), otherwise the browser drops it on restart.
-    const persistent = [...host, 'Max-Age=604800'];
-    const sorted = (items: string[]) => [...items].sort((a, b) => a.localeCompare(b));
-    const login = async () => {
-      const registration = await request(app.getHttpServer())
-        .post('/api/v1/auth/register')
-        .send({ email: 'cookie@example.test', password: 'a secure password' })
-        .expect(200);
-      return registration.headers['set-cookie'][0];
-    };
-
-    // The cookie policy reads NODE_ENV per request; the e2e runner defaults to development.
-    const inEnvironment = async <T>(nodeEnv: string, run: () => Promise<T>) => {
-      const previous = process.env['NODE_ENV'];
-      process.env['NODE_ENV'] = nodeEnv;
-      try {
-        return await run();
-      } finally {
-        process.env['NODE_ENV'] = previous;
-      }
-    };
-
-    it('issues and rotates it persistent (Max-Age) HttpOnly, Lax, path-scoped, host-only and Secure in production, and clears it', async () => {
-      await inEnvironment('production', async () => {
-        const issued = await login();
-        const rotated = await request(app.getHttpServer())
-          .post('/api/v1/auth/refresh')
-          .set('Cookie', issued)
-          .expect(200);
-        const cleared = await request(app.getHttpServer())
-          .post('/api/v1/auth/logout')
-          .set('Cookie', rotated.headers['set-cookie'][0])
-          .expect(204);
-
-        // Exact set: any added Domain, changed Max-Age or dropped flag fails.
-        for (const cookie of [issued, rotated.headers['set-cookie'][0]]) {
-          expect(attributes(cookie)).toEqual(sorted([...persistent, 'Secure']));
-        }
-        // Clearing must not carry Max-Age; Express expires it with a past Expires.
-        const clearedCookie = cleared.headers['set-cookie'][0];
-        expect(attributes(clearedCookie)).toEqual(sorted([...host, 'Secure']));
-        expect(clearedCookie).toContain('Expires=Thu, 01 Jan 1970');
-      });
-    });
-
-    it('drops only Secure in development and keeps every other attribute', async () => {
-      await inEnvironment('development', async () => {
-        expect(attributes(await login())).toEqual(sorted(persistent));
-      });
-    });
-  });
-
-  describe('expired credentials', () => {
-    const sha256 = (token: string) => createHash('sha256').update(token).digest('hex');
-    const PAST = () => Math.floor(Date.now() / 1000) - 60;
-    const FUTURE = () => Math.floor(Date.now() / 1000) + 600;
-    const register = async () => {
-      const registration = await request(app.getHttpServer())
-        .post('/api/v1/auth/register')
-        .send({ email: 'expiry@example.test', password: 'a secure password' })
-        .expect(200);
-      const session = await app.get(PrismaService).session.findFirstOrThrow();
-      return {
-        cookie: registration.headers['set-cookie'][0],
-        sub: session.userId,
-        sid: session.id,
-      };
-    };
-
-    it('rejects a signed expired access token but admits the same claims unexpired', async () => {
-      const { sub, sid } = await register();
-      const jwt = app.get(JwtService);
-      const expired = await jwt.signAsync({ sub, sid, type: 'access', exp: PAST() });
-      const fresh = await jwt.signAsync({ sub, sid, type: 'access', exp: FUTURE() });
-
-      await request(app.getHttpServer())
-        .get('/api/v1/auth/me')
-        .set('Authorization', `Bearer ${expired}`)
-        .expect(401);
-      await request(app.getHttpServer())
-        .get('/api/v1/auth/me')
-        .set('Authorization', `Bearer ${fresh}`)
-        .expect(200)
-        .expect(({ body }: { body: unknown }) =>
-          expect((body as { email: string }).email).toBe('expiry@example.test'),
-        );
-    });
-
-    it('rejects a signed expired refresh token that matches the live session hash', async () => {
-      const { sub, sid } = await register();
-      const jwt = app.get(JwtService);
-      const prisma = app.get(PrismaService);
-      const claims = { sub, sid, type: 'refresh' };
-      const expired = await jwt.signAsync({ ...claims, jti: randomUUID(), exp: PAST() });
-      const fresh = await jwt.signAsync({ ...claims, jti: randomUUID(), exp: FUTURE() });
-
-      // Hash, session and signature all valid: only `exp` differs between the two.
-      await prisma.session.update({ where: { id: sid }, data: { refreshTokenHash: sha256(expired) } });
-      const rejected = await request(app.getHttpServer())
-        .post('/api/v1/auth/refresh')
-        .set('Cookie', `refresh_token=${expired}`)
-        .expect(401);
-      expect(rejected.headers['set-cookie']).toBeUndefined();
-
-      await prisma.session.update({ where: { id: sid }, data: { refreshTokenHash: sha256(fresh) } });
-      await request(app.getHttpServer())
-        .post('/api/v1/auth/refresh')
-        .set('Cookie', `refresh_token=${fresh}`)
-        .expect(200);
-    });
-
-    it('rejects a valid refresh token once its session is DB-expired', async () => {
-      const { cookie, sid } = await register();
-      const prisma = app.get(PrismaService);
-      await prisma.session.update({ where: { id: sid }, data: { expiresAt: new Date(Date.now() - 1000) } });
-
-      const rejected = await request(app.getHttpServer())
-        .post('/api/v1/auth/refresh')
-        .set('Cookie', cookie)
-        .expect(401);
-
-      expect(rejected.headers['set-cookie']).toBeUndefined();
-      expect(await prisma.session.count()).toBe(0);
-      await request(app.getHttpServer())
-        .post('/api/v1/auth/refresh')
-        .set('Cookie', cookie)
-        .expect(401);
-    });
-  });
-
  it('keeps logout idempotent for an invalid refresh token', async () => {
    const logout = await request(app.getHttpServer())
      .post('/api/v1/auth/logout')
@@ -433,45 +261,6 @@ describe('Authentication (e2e)', () => {
    expect(await app.get(PrismaService).user.count()).toBe(0);
  });

-  it('applies the ASCII 8..72 password policy on register and keeps login lenient', async () => {
-    const validation = (detail: string) => ({
-      status: 400,
-      code: 'VALIDATION_ERROR',
-      errors: [{ pointer: '#/password', detail }],
-    });
-    for (const [index, password] of ['a'.repeat(8), ' '.repeat(2) + 'b'.repeat(70)].entries()) {
-      const credentials = { email: `user${index}@example.com`, password };
-      await request(app.getHttpServer()).post('/api/v1/auth/register').send(credentials).expect(200);
-      await request(app.getHttpServer()).post('/api/v1/auth/login').send(credentials).expect(200);
-    }
-    for (const password of ['a'.repeat(7), 'a'.repeat(73), 'пароль-пароль', 'passw😀rd', 'pass\tword1']) {
-      await request(app.getHttpServer())
-        .post('/api/v1/auth/register')
-        .send({ email: 'rejected@example.com', password })
-        .expect(400)
-        .expect('Content-Type', /application\/problem\+json/)
-        .expect(({ body }: { body: unknown }) =>
-          expect(body).toEqual(validation('must be 8-72 printable ASCII characters')),
-        );
-    }
-    expect(await app.get(PrismaService).user.count()).toBe(2);
-
-    // An account created under the previous policy (Cyrillic, 12+ chars) must still log in.
-    const legacy = { email: 'legacy@example.com', password: 'пароль-пароль' };
-    const prisma = app.get(PrismaService);
-    await prisma.user.create({
-      data: { id: randomUUID(), email: legacy.email, passwordHash: await bcrypt.hash(legacy.password, 4) },
-    });
-    await request(app.getHttpServer()).post('/api/v1/auth/login').send(legacy).expect(200);
-    await request(app.getHttpServer())
-      .post('/api/v1/auth/login')
-      .send({ email: legacy.email, password: 'a'.repeat(73) })
-      .expect(400)
-      .expect(({ body }: { body: unknown }) =>
-        expect(body).toEqual(validation('must not exceed 72 UTF-8 bytes')),
-      );
-  });
-
  it('guards T-Bank connection and never returns a token', async () => {
    const registration = await request(app.getHttpServer())
      .post('/api/v1/auth/register')
@@ -540,14 +329,7 @@ describe('Authentication (e2e)', () => {
      'X-Request-ID',
    );
    expect(logs.filter((entry) => entry.requestId === response.headers['x-request-id'])).toEqual([
-      expect.objectContaining({
-        level: 40,
-        message: 'http.request.completed',
-        method: 'GET',
-        route: '/api/v1/auth/me',
-        status: 401,
-        code: 'UNAUTHORIZED',
-      }),
+      expect.objectContaining({ level: 40, message: 'http.request.completed', status: 401, code: 'UNAUTHORIZED' }),
    ]);
  });

@@ -559,7 +341,7 @@ describe('Authentication (e2e)', () => {
        new Error('operation failed\npassword: SYNTHETIC_AUDIT_SECRET'),
      );

-    await request(app.getHttpServer())
+    const response = await request(app.getHttpServer())
      .post('/api/v1/auth/login')
      .set('X-Request-ID', clientRequestId)
      .send({ email: 'user@example.com', password: 'a secure password' })
@@ -569,30 +351,17 @@ describe('Authentication (e2e)', () => {
        expect(body).toEqual({ status: 500, code: 'INTERNAL_SERVER_ERROR' }),
      );

-    expect(logs).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          method: 'POST',
-          route: '/api/v1/auth/login',
-          status: 500,
-          code: 'INTERNAL_SERVER_ERROR',
-          level: 50,
-          message: 'http.request.completed',
-        }),
-      ]),
-    );
-    expect(logs).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          clientRequestId,
-          code: 'INTERNAL_SERVER_ERROR',
-          level: 50,
-          message: 'http.request.unhandled',
-          errorName: 'Error',
-          errorStack: expect.stringContaining('    at ') as unknown,
-        }),
-      ]),
-    );
+    const completed = logs.filter((entry) => entry.requestId === response.headers['x-request-id']);
+    expect(completed).toEqual([
+      expect.objectContaining({
+        requestId: response.headers['x-request-id'],
+        clientRequestId,
+        status: 500,
+        code: 'INTERNAL_SERVER_ERROR',
+        level: 50,
+        message: 'http.request.completed',
+      }),
+    ]);
    expect(JSON.stringify(logs)).not.toContain(
      'SYNTHETIC_AUDIT_SECRET',
    );
@@ -16,7 +16,6 @@ import {
  BankSummaryDto,
  ExpenseCategoryDto,
 } from '../src/modules/banking/bank-cards/presentation/bank-card.dto';
-import { TbankHourlyScheduler } from '../src/modules/investments/tbank-sync/tbank-hourly.scheduler';
 import { PrismaService } from '../src/prisma/prisma.service';

 jest.setTimeout(60000);
@@ -78,10 +77,7 @@ describe('Manual bank cards configured HTTP and real SQLite', () => {
  const start = async () => {
    const module = await Test.createTestingModule({
      imports: [AppModule],
-    })
-      .overrideProvider(TbankHourlyScheduler)
-      .useValue({ tick: jest.fn() })
-      .compile();
+    }).compile();
    app = module.createNestApplication();
    configureApp(app);
    await app.listen(0, '127.0.0.1');
@@ -373,8 +369,6 @@ describe('Manual bank cards configured HTTP and real SQLite', () => {
    expect((await getCard(own.id)).balance.value).toBe('1000');
  });
  it('renames default category without role loss; duplicates and stale rename conflict', async () => {
-    // Defaults are seeded by the first write of the user; this case must not depend on earlier cases.
-    await createCard();
    const category = (await categories()).find((c) => c.isDefault);
    assert.ok(category);
    await auth('patch', '/categories/' + category.id)
@@ -731,19 +725,11 @@ describe('Manual bank cards configured HTTP and real SQLite', () => {
    expect(await getCard(card.id)).toEqual(before);
    expect((await getOp(refund.id)).originalExpenseId).toBe(purchase.id);
    await auth('post', '/operations').send(deletedBody).expect(410);
-    // The rename is this case's own prerequisite, not an effect of an earlier case.
-    const defaultCategory = (await categories()).find((c) => c.isDefault);
-    assert.ok(defaultCategory);
-    await auth('patch', '/categories/' + defaultCategory.id)
-      .send({ version: defaultCategory.version, name: 'Остальное' })
-      .expect(200);
    expect((await categories()).find((c) => c.isDefault)?.name).toBe(
      'Остальное',
    );
  });
  it('enforces actual FK and unique constraints', async () => {
-    // Seeds the owner's default categories so the unique-name check has a real row to collide with.
-    await createCard();
    await expect(
      db.expenseCategory.create({
        data: {
@@ -1,6 +1,5 @@
 import type { Server } from 'node:http';

-import { status } from '@grpc/grpc-js';
 import {
  ConflictException,
  INestApplication,
@@ -16,14 +15,6 @@ import { configureApp } from '../src/main';
 import { BondCatalogService } from '../src/modules/investments/instruments/bonds/application/bond-catalog.service';
 import { BondIncomeService } from '../src/modules/investments/instruments/bonds/application/bond-income.service';
 import { BondMarketService } from '../src/modules/investments/instruments/bonds/application/bond-market.service';
-import { TbankHourlyScheduler } from '../src/modules/investments/tbank-sync/tbank-hourly.scheduler';
-import {
-  bootOnlineApp,
-  expectSafeBody,
-  failUpstream,
-  onlineUserId,
-  refusals,
-} from './online-upstream';

 const uid = 'e6123145-9665-43e0-8413-cd61b8aa9b13';
 describe('Bond HTTP contract', () => {
@@ -47,8 +38,6 @@ describe('Bond HTTP contract', () => {
      .useValue(bonds)
      .overrideProvider(BondIncomeService)
      .useValue(bonds)
-      .overrideProvider(TbankHourlyScheduler)
-      .useValue({ tick: jest.fn() })
      .compile();
    app = module.createNestApplication();
    configureApp(app);
@@ -209,39 +198,3 @@ describe('Bond HTTP contract', () => {
    expect(response.body).not.toHaveProperty('stack');
  });
 });
-
-// Real services and TbankClient error mapping; only the gRPC transport is stubbed.
-// Bonds expose no company or screener route; their online entrypoints are search, detail and ticker.
-describe('Bond online reads: upstream failure translation', () => {
-  const rpc = jest.fn();
-  let ctx: Awaited<ReturnType<typeof bootOnlineApp>>;
-  const get = (path: string) => request(ctx.app.getHttpServer()).get(path);
-  // [entrypoint, request, RPC that fails second]: a failure after the first call must translate too.
-  const entrypoints: [string, () => request.Test, string][] = [
-    ['search', () => get('/api/v1/bonds?query=SBER'), 'getLastPrices'],
-    ['detail', () => get(`/api/v1/bonds/${uid}`), 'bondBy'],
-    ['ticker', () => get('/api/v1/bonds/by-ticker/SBER'), 'bondBy'],
-  ];
-  const cases = entrypoints.flatMap(([name, send, later]) =>
-    refusals.flatMap((code) => [undefined, later].map((at) => [name, code, at, send] as const)),
-  );
-
-  beforeAll(async () => {
-    ctx = await bootOnlineApp(rpc);
-  });
-  afterAll(() => ctx.app.close());
-
-  it.each(cases)('%s: upstream auth refusal %s (failing RPC %s) becomes 400/INVALID_TBANK_TOKEN', async (_name, code, at, send) => {
-    failUpstream(rpc, 'bond', code, at);
-    const response = await send().set('Authorization', ctx.bearer).expect(400);
-    expectSafeBody(response.body, 400, 'INVALID_TBANK_TOKEN');
-    const saved = await ctx.prisma.tbankConnection.findUniqueOrThrow({ where: { userId: onlineUserId } });
-    expect(saved).toMatchObject({ invalidToken: false, revision: ctx.connection.revision });
-  });
-
-  it.each(entrypoints)('%s: temporary unavailability stays 503/TBANK_UNAVAILABLE', async (_name, send) => {
-    failUpstream(rpc, 'bond', status.UNAVAILABLE);
-    const response = await send().set('Authorization', ctx.bearer).expect(503);
-    expectSafeBody(response.body, 503, 'TBANK_UNAVAILABLE');
-  });
-});
@@ -1,87 +0,0 @@
-import type { Server } from 'node:http';
-
-import { status } from '@grpc/grpc-js';
-import { INestApplication } from '@nestjs/common';
-import { JwtService } from '@nestjs/jwt';
-import { Test } from '@nestjs/testing';
-
-import { AppModule } from '../src/app.module';
-import { TbankTokenService } from '../src/integrations/tbank/tbank-token.service';
-import { TbankClient } from '../src/integrations/tbank/tbank.client';
-import { configureApp } from '../src/main';
-import { TbankHourlyScheduler } from '../src/modules/investments/tbank-sync/tbank-hourly.scheduler';
-import { PrismaService } from '../src/prisma/prisma.service';
-
-export const onlineUserId = 'online-reader';
-export const onlineToken = 'synthetic-online-token';
-export const rawUpstreamText = 'raw upstream refusal text';
-export const refusals = [status.UNAUTHENTICATED, status.PERMISSION_DENIED];
-
-// Real TbankClient with only the transport stubbed: the gRPC status goes through its real error mapping.
-export async function bootOnlineApp(rpc: jest.Mock) {
-  const upstream = Object.assign(Object.create(TbankClient.prototype) as TbankClient, {
-    logger: { event: jest.fn() },
-    queue: { run: (operation: () => Promise<unknown>) => operation(), size: 0 },
-    request: rpc,
-  });
-  const module = await Test.createTestingModule({ imports: [AppModule] })
-    .overrideProvider(TbankClient)
-    .useValue(upstream)
-    .overrideProvider(TbankHourlyScheduler)
-    .useValue({ tick: jest.fn() })
-    .compile();
-  const app: INestApplication<Server> = module.createNestApplication();
-  configureApp(app);
-  await app.init();
-  await app.listen(0, '127.0.0.1');
-  const prisma = app.get(PrismaService);
-  await prisma.user.create({
-    data: { id: onlineUserId, email: 'online@example.invalid', passwordHash: 'synthetic' },
-  });
-  const connection = await prisma.tbankConnection.create({
-    data: {
-      userId: onlineUserId,
-      encryptedToken: app.get(TbankTokenService).encrypt(onlineToken),
-      connectedAt: new Date(),
-    },
-  });
-  const bearer = `Bearer ${new JwtService().sign(
-    { sub: onlineUserId, type: 'access' },
-    { secret: process.env.JWT_SECRET },
-  )}`;
-  return { app, bearer, connection, prisma };
-}
-
-// Healthy answers for every RPC an online entrypoint uses; `at` picks the single RPC that fails.
-export function failUpstream(rpc: jest.Mock, kind: 'bond' | 'share', code: number, at?: string) {
-  const instrument = {
-    apiTradeAvailableFlag: true,
-    assetUid: 'asset-uid',
-    instrumentKind: kind === 'bond' ? 'INSTRUMENT_TYPE_BOND' : 'INSTRUMENT_TYPE_SHARE',
-    ticker: 'SBER',
-    uid: 'e6123145-9665-43e0-8413-cd61b8aa9b13',
-  };
-  const healthy = new Map<string, unknown>([
-    ['bondBy', { instrument }],
-    ['findInstrument', { instruments: [instrument] }],
-    ['getAssetBy', { asset: { description: 'description' } }],
-    ['getAssetFundamentals', { fundamentals: [] }],
-    ['getLastPrices', { lastPrices: [] }],
-    ['shareBy', { instrument }],
-  ]);
-  const failure = Object.assign(new Error('grpc failure'), {
-    code,
-    details: `${rawUpstreamText} Bearer ${onlineToken}`,
-  });
-  rpc.mockReset();
-  rpc.mockImplementation((_token: string, _client: unknown, method: string) =>
-    !at || method === at ? Promise.reject(failure) : Promise.resolve(healthy.get(method) ?? {}),
-  );
-}
-
-// Safe public error: stable code only, no upstream text, no credentials.
-export function expectSafeBody(body: unknown, status: number, code: string) {
-  expect(body).toEqual({ code, status });
-  expect(JSON.stringify(body)).not.toContain(rawUpstreamText);
-  expect(JSON.stringify(body)).not.toContain(onlineToken);
-}
@@ -121,63 +121,7 @@ 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({
-      additionalProperties: false,
-    });
-    expect(schemas?.StockScreenerItemDto).toMatchObject({
-      properties: { lot: { type: 'integer', minimum: 1, nullable: true } },
-    });
    expect(
      createOpenApiDocument(app).components?.schemas?.ProblemDetailsDto,
    ).toMatchObject({
@@ -1,6 +1,5 @@
 import type { Server } from 'node:http';

-import { status } from '@grpc/grpc-js';
 import {
  ConflictException,
  INestApplication,
@@ -17,14 +16,6 @@ import { StockCatalogService } from '../src/modules/investments/instruments/stoc
 import { StockIncomeService } from '../src/modules/investments/instruments/stocks/application/stock-income.service';
 import { StockMarketService } from '../src/modules/investments/instruments/stocks/application/stock-market.service';
 import { StockScreenerService } from '../src/modules/investments/instruments/stocks/application/stock-screener.service';
-import { TbankHourlyScheduler } from '../src/modules/investments/tbank-sync/tbank-hourly.scheduler';
-import {
-  bootOnlineApp,
-  expectSafeBody,
-  failUpstream,
-  onlineUserId,
-  refusals,
-} from './online-upstream';

 const uid = 'e6123145-9665-43e0-8413-cd61b8aa9b13';
 describe('Stock HTTP contract', () => {
@@ -50,8 +41,6 @@ describe('Stock HTTP contract', () => {
      .useValue(stocks)
      .overrideProvider(StockScreenerService)
      .useValue(screener)
-      .overrideProvider(TbankHourlyScheduler)
-      .useValue({ tick: jest.fn() })
      .compile();
    app = module.createNestApplication();
    configureApp(app);
@@ -209,40 +198,3 @@ describe('Stock HTTP contract', () => {
    expect(response.body).not.toHaveProperty('stack');
  });
 });
-
-// Real services and TbankClient error mapping; only the gRPC transport is stubbed.
-describe('Stock online reads: upstream failure translation', () => {
-  const rpc = jest.fn();
-  let ctx: Awaited<ReturnType<typeof bootOnlineApp>>;
-  const get = (path: string) => request(ctx.app.getHttpServer()).get(path);
-  // [entrypoint, request, RPC that fails second]: a failure after the first call must translate too.
-  const entrypoints: [string, () => request.Test, string][] = [
-    ['search', () => get('/api/v1/stocks?query=SBER'), 'getLastPrices'],
-    ['detail', () => get(`/api/v1/stocks/${uid}`), 'shareBy'],
-    ['ticker', () => get('/api/v1/stocks/by-ticker/SBER'), 'shareBy'],
-    ['company', () => get(`/api/v1/stocks/${uid}/company`), 'getAssetBy'],
-    ['screener', () => request(ctx.app.getHttpServer()).post('/api/v1/stocks/screener/search').send({}), 'shares'],
-  ];
-  const cases = entrypoints.flatMap(([name, send, later]) =>
-    refusals.flatMap((code) => [undefined, later].map((at) => [name, code, at, send] as const)),
-  );
-
-  beforeAll(async () => {
-    ctx = await bootOnlineApp(rpc);
-  });
-  afterAll(() => ctx.app.close());
-
-  it.each(cases)('%s: upstream auth refusal %s (failing RPC %s) becomes 400/INVALID_TBANK_TOKEN', async (_name, code, at, send) => {
-    failUpstream(rpc, 'share', code, at);
-    const response = await send().set('Authorization', ctx.bearer).expect(400);
-    expectSafeBody(response.body, 400, 'INVALID_TBANK_TOKEN');
-    const saved = await ctx.prisma.tbankConnection.findUniqueOrThrow({ where: { userId: onlineUserId } });
-    expect(saved).toMatchObject({ invalidToken: false, revision: ctx.connection.revision });
-  });
-
-  it.each(entrypoints)('%s: temporary unavailability stays 503/TBANK_UNAVAILABLE', async (_name, send) => {
-    failUpstream(rpc, 'share', status.UNAVAILABLE);
-    const response = await send().set('Authorization', ctx.bearer).expect(503);
-    expectSafeBody(response.body, 503, 'TBANK_UNAVAILABLE');
-  });
-});
@@ -1,5 +1,6 @@
 import { ConfigService } from '@nestjs/config';
 import assert from 'node:assert/strict';
+import { setTimeout as delay } from 'node:timers/promises';

 import { TbankAccessService } from '../src/integrations/tbank/tbank-access.service';
 import { TbankTokenService } from '../src/integrations/tbank/tbank-token.service';
@@ -11,7 +12,7 @@ import {
 } from '../src/modules/investments/instruments/infrastructure/catalog-discovery.repository';
 import { PrismaService } from '../src/prisma/prisma.service';

-// Real transactions prove query normalization, confirmed-empty identity and cross-user isolation of shared reads.
+// Real transactions prove query coverage, private work ownership and late-publication fences.
 describe('shared catalog discovery (SQLite)', () => {
  const prisma = new PrismaService(
    new ConfigService({ DATABASE_URL: process.env.DATABASE_URL }),
@@ -29,6 +30,7 @@ describe('shared catalog discovery (SQLite)', () => {
      repository,
      access,
      upstream as never,
+      { event: jest.fn() } as never,
      { requestMany: jest.fn().mockResolvedValue([]) } as never,
    );
  let service: CatalogDiscoveryService;
@@ -49,42 +51,14 @@ describe('shared catalog discovery (SQLite)', () => {
        connectedAt: new Date(),
      },
    });
-  // Writes a finished discovery directly, so the read path is tested without any producer.
-  async function seedCatalog(
-    query: string,
-    instruments: Array<{ payload: CatalogInstrument; uid: string }>,
-  ) {
-    for (const item of instruments) {
-      await prisma.tbankInstrument.create({
-        data: {
-          provider: 'tbank',
-          uid: item.uid,
-          instrumentType: 'share',
-          metadata: {},
-          fetchedAt: new Date(),
-        },
-      });
-      await prisma.tbankInstrumentSource.create({
-        data: {
-          provider: 'tbank',
-          instrumentUid: item.uid,
-          source: 'tbank',
-          kind: 'catalog',
-          rangeKey: 'share',
-          payload: item.payload,
-          fetchedAt: new Date(),
-        },
-      });
+  async function settled() {
+    for (let i = 0; i < 300; i++) {
+      if (!(await prisma.tbankSyncWork.count({ where: { state: 'running' } }))) {
+        return;
+      }
+      await delay(5);
    }
-    await prisma.tbankCatalogDiscovery.create({
-      data: {
-        provider: 'tbank',
-        instrumentType: 'share',
-        query,
-        instrumentUids: instruments.map((item) => item.uid),
-        fetchedAt: new Date(),
-      },
-    });
+    throw new Error('Catalog work did not settle');
  }
  beforeAll(async () => {
    await prisma.$connect();
@@ -98,41 +72,265 @@ describe('shared catalog discovery (SQLite)', () => {
  beforeEach(async () => {
    await prisma.tbankConnection.deleteMany();
    await prisma.tbankCatalogDiscovery.deleteMany();
-    await prisma.tbankInstrumentSource.deleteMany();
    await prisma.tbankInstrument.deleteMany();
    await seed('owner');
    await seed('other');
    jest.resetAllMocks();
+    upstream.findShares.mockResolvedValue([instrument]);
+    upstream.findBonds.mockResolvedValue([
+      { ...instrument, uid: 'bond', instrumentKind: 'INSTRUMENT_TYPE_BOND' },
+    ]);
    service = createService();
  });
-  it('treats an unknown query as unavailable and a seeded query as available for another user', async () => {
+  it('persists normalized query identity and confirmed empty separately from unknown, across users and reopen', async () => {
    const cold = await service.read('owner', { ...query, query: ' sber ' });
    expect(cold.data).toBeNull();
-    expect(cold.meta.availability).toBe('temporarily-unavailable');
-    await seedCatalog('SBER', [{ uid: 'uid', payload: instrument }]);
+    expect(cold.meta.availability).toBe('initial-loading');
+    await settled();
+    await prisma.$disconnect();
+    service = createService();
+    const decrypt = jest.spyOn(tokens, 'decrypt');
    const warm = await service.read('other', query);
    expect(warm.data).toEqual([instrument]);
    expect(warm.meta.availability).toBe('available');
-    expect(upstream.findShares).not.toHaveBeenCalled();
+    expect(warm.meta.completeness).toBe('complete');
+    expect(warm.meta.sync.id).toBeNull();
+    expect(decrypt).not.toHaveBeenCalled();
+    expect(upstream.findShares).toHaveBeenCalledTimes(1);
+    expect(
+      (await service.read('other', { ...query, query: 'GAZP' }, true)).data,
+    ).toBeNull();
+    upstream.findShares.mockResolvedValue([]);
+    await service.read('other', { ...query, query: 'GAZP' });
+    await settled();
+    expect(
+      (await service.read('owner', { ...query, query: 'GAZP' })).data,
+    ).toEqual([]);
+    expect((await service.read('owner', query)).data).toEqual([instrument]);
+    expect(upstream.findShares).toHaveBeenCalledTimes(2);
+    decrypt.mockRestore();
+    await service.read('owner', { ...query, instrumentType: 'bond' });
+    await settled();
+    expect(
+      (await service.read('other', { ...query, instrumentType: 'bond' }))
+        .data?.[0].uid,
+    ).toBe('bond');
  });
-  it('keeps a confirmed empty result distinct from an unknown query', async () => {
-    await seedCatalog('GAZP', []);
-    const empty = await service.read('owner', { ...query, query: 'GAZP' });
-    expect(empty.data).toEqual([]);
-    expect(empty.meta.availability).toBe('available');
-    const unknown = await service.read('owner', { ...query, query: 'LKOH' });
-    expect(unknown.data).toBeNull();
-  });
-  it('keeps the stored selection order and does not expose private fields', async () => {
-    const first = { ...instrument, uid: 'first', name: 'First' };
-    const second = { ...instrument, uid: 'second', name: 'Second' };
-    await seedCatalog('SBER', [
-      { uid: 'second', payload: second },
-      { uid: 'first', payload: first },
+  it('keeps selection ordering, deduplicates before limiting, and retains identity without enrichment or private fields', async () => {
+    upstream.findShares.mockResolvedValue([
+      { ...instrument, uid: 'unavailable', apiTradeAvailableFlag: false },
+      {
+        ...instrument,
+        uid: 'preferred',
+        apiTradeAvailableFlag: true,
+        classCode: 'TQBR',
+        quantity: '999',
+        estimatedAmount: 'secret',
+      },
+      ...Array.from({ length: 40 }, (_, i) => ({
+        ...instrument,
+        uid: `other-${String(i).padStart(2, '0')}`,
+        isin: undefined,
+        ticker: 'OTHER',
+      })),
+      {
+        ...instrument,
+        uid: 'wrong-kind',
+        instrumentKind: 'INSTRUMENT_TYPE_BOND',
+      },
    ]);
-    const result = await service.read('owner', query);
-    assert(result.data);
-    expect(result.data.map((item) => item.uid)).toEqual(['second', 'first']);
-    expect(result.data[0]).not.toHaveProperty('accountId');
+    await service.read('owner', query);
+    await settled();
+    const saved = await service.read('other', query);
+    expect(saved.data).toHaveLength(30);
+    expect(saved.data?.[0].uid).toBe('preferred');
+    expect(
+      saved.data?.some((row) =>
+        ['unavailable', 'wrong-kind'].includes(row.uid),
+      ),
+    ).toBe(false);
+    expect(
+      JSON.stringify(await prisma.tbankInstrumentSource.findMany()),
+    ).not.toMatch(
+      /quantity|estimatedAmount|secret|owner-revision|synthetic-owner/,
+    );
+    expect(await prisma.tbankInstrumentLookup.count()).toBe(0);
+  });
+  it('does not overwrite detailed metadata or its timestamp while refreshing discovery', async () => {
+    const detailed = { ...instrument, sector: 'financial', lot: 10 };
+    const fetchedAt = new Date('2026-01-01');
+    await prisma.tbankInstrument.create({
+      data: {
+        provider: 'tbank',
+        uid: 'uid',
+        instrumentType: 'share',
+        metadata: detailed,
+        fetchedAt,
+      },
+    });
+    await service.read('owner', query);
+    await settled();
+    const row = await prisma.tbankInstrument.findUniqueOrThrow({
+      where: { provider_uid: { provider: 'tbank', uid: 'uid' } },
+    });
+    expect(row.metadata).toEqual(detailed);
+    expect(row.fetchedAt).toEqual(fetchedAt);
+  });
+  it('coalesces twenty concurrent requests and forces with private handles and one upstream call', async () => {
+    const blocked = deferred<CatalogInstrument[]>();
+    upstream.findShares.mockReturnValue(blocked.promise);
+    const reads = await Promise.all(
+      Array.from({ length: 20 }, (_, i) =>
+        service.read(i % 2 ? 'owner' : 'other', query),
+      ),
+    );
+    await service.request('owner', 'owner-revision', query, true);
+    await delay(10);
+    expect(upstream.findShares).toHaveBeenCalledTimes(1);
+    expect(new Set(reads.map((read) => read.meta.sync.id)).size).toBe(2);
+    blocked.resolve([instrument]);
+    await settled();
+    expect(
+      await prisma.tbankSyncWork.count({ where: { state: 'complete' } }),
+    ).toBe(2);
+  });
+  it.each(['delete', 'replace'])(
+    'discards late %s publication and does not borrow observer credentials',
+    async (action) => {
+      const blocked = deferred<CatalogInstrument[]>();
+      upstream.findShares.mockReturnValueOnce(blocked.promise);
+      await service.read('owner', query);
+      await service.read('other', query);
+      await delay(10);
+      await prisma.tbankConnection.delete({ where: { userId: 'owner' } });
+      if (action === 'replace') {
+        await prisma.tbankConnection.create({
+          data: {
+            userId: 'owner',
+            revision: 'replacement',
+            encryptedToken: tokens.encrypt('replacement'),
+            connectedAt: new Date(),
+          },
+        });
+      }
+      blocked.resolve([instrument]);
+      await settled();
+      expect(await prisma.tbankCatalogDiscovery.count()).toBe(0);
+      expect(await prisma.tbankInstrument.count()).toBe(0);
+      expect(
+        (await service.read('other', query, true)).meta.sync.errorCode,
+      ).toBe('TBANK_UNAVAILABLE');
+      expect(upstream.findShares).toHaveBeenCalledTimes(1);
+      await service.read('other', query);
+      await settled();
+      expect((await service.read('other', query, true)).data).toEqual([
+        instrument,
+      ]);
+    },
+  );
+  it('preserves a successful result and its timestamp after a failed force without observe retry', async () => {
+    await service.read('owner', query);
+    await settled();
+    const before = await repository.read(query);
+    upstream.findShares.mockRejectedValue(new Error('outage'));
+    await service.request('owner', 'owner-revision', query, true);
+    await settled();
+    for (let i = 0; i < 5; i++) await service.read('owner', query, true);
+    expect(await repository.read(query)).toEqual(before);
+    expect((await service.read('owner', query, true)).meta.sync.state).toBe(
+      'failed',
+    );
+    expect(upstream.findShares).toHaveBeenCalledTimes(2);
+    expect((await service.read('other', query)).meta.sync.errorCode).toBeNull();
+  });
+  it('isolates invalid credentials from shared empty lookup and another user', async () => {
+    const blocked = deferred<CatalogInstrument[]>();
+    upstream.findShares.mockReturnValueOnce(blocked.promise);
+    await service.read('owner', query);
+    await service.read('other', query);
+    blocked.reject(new Error('INVALID_TBANK_TOKEN'));
+    await settled();
+    expect(await prisma.tbankCatalogDiscovery.count()).toBe(0);
+    expect(
+      (
+        await prisma.tbankConnection.findUniqueOrThrow({
+          where: { userId: 'owner' },
+        })
+      ).invalidToken,
+    ).toBe(true);
+    expect((await service.read('other', query, true)).meta.sync.errorCode).toBe(
+      'TBANK_UNAVAILABLE',
+    );
+    await service.read('other', query);
+    await settled();
+    expect((await service.read('other', query, true)).data).toEqual([
+      instrument,
+    ]);
+  });
+  it('recovers abandoned work only on the next ordinary request and rejects superseded attempts', async () => {
+    const abandoned = await repository.reserve(
+      { userId: 'owner', revision: 'owner-revision' },
+      query,
+      'old-process',
+      new Set(),
+    );
+    assert(abandoned);
+    service = createService();
+    await service.read('owner', query, true);
+    await delay(10);
+    expect(upstream.findShares).not.toHaveBeenCalled();
+    await service.read('owner', query);
+    await settled();
+    expect(
+      await repository.publish(
+        {
+          userId: 'owner',
+          revision: 'owner-revision',
+          id: abandoned.work.id,
+          attemptId: abandoned.work.attemptId,
+        },
+        query,
+        [],
+        new Date(),
+      ),
+    ).toBe(false);
+    expect((await service.read('owner', query, true)).data).toEqual([
+      instrument,
+    ]);
+  });
+  it('keeps known discovery stable between refresh requests', async () => {
+    await service.read('owner', query);
+    await settled();
+    const now = Date.now();
+    const clock = jest.spyOn(Date, 'now').mockReturnValue(now);
+    try {
+      await prisma.tbankCatalogDiscovery.updateMany({
+        data: { fetchedAt: new Date(now - 86_399_000) },
+      });
+      await service.read('other', query);
+      expect(upstream.findShares).toHaveBeenCalledTimes(1);
+      await prisma.tbankCatalogDiscovery.updateMany({
+        data: { fetchedAt: new Date(now - 86_400_000) },
+      });
+      expect((await service.read('other', query, true)).meta.freshness).toBe('fresh');
+      expect(upstream.findShares).toHaveBeenCalledTimes(1);
+      await service.read('other', query);
+      expect(upstream.findShares).toHaveBeenCalledTimes(1);
+    } finally {
+      clock.mockRestore();
+    }
  });
 });
+function deferred<T>() {
+  let resolve: (value: T) => void = () => {
+    throw new Error('Uninitialized deferred');
+  };
+  let reject: (error: Error) => void = () => {
+    throw new Error('Uninitialized deferred');
+  };
+  const promise = new Promise<T>((yes, no) => {
+    resolve = yes;
+    reject = no;
+  });
+  return { promise, resolve, reject };
+}
@@ -10,7 +10,6 @@ import { TbankAccessService } from '../src/integrations/tbank/tbank-access.servi
 import { TbankTokenService } from '../src/integrations/tbank/tbank-token.service';
 import { TbankClient } from '../src/integrations/tbank/tbank.client';
 import { configureApp } from '../src/main';
-import { TbankHourlyScheduler } from '../src/modules/investments/tbank-sync/tbank-hourly.scheduler';
 import { PrismaService } from '../src/prisma/prisma.service';

 describe('Persistent T-Bank connection boundary (SQLite/HTTP)', () => {
@@ -32,8 +31,6 @@ describe('Persistent T-Bank connection boundary (SQLite/HTTP)', () => {
    const module = await Test.createTestingModule({ imports: [AppModule] })
      .overrideProvider(TbankClient)
      .useValue(upstream)
-      .overrideProvider(TbankHourlyScheduler)
-      .useValue({ tick: jest.fn() })
      .compile();
    app = module.createNestApplication();
    configureApp(app);
@@ -385,83 +385,6 @@ describe('hourly attempt lifecycle (SQLite)', () => {
    expect(next?.state).not.toBe('running');
  });

-  describe('hourly term eligibility', () => {
-    const at = (h: number, m = 0) => new Date(Date.UTC(2026, 0, 1, h, m));
-    const seed = (
-      state: 'complete' | 'failed' | 'running',
-      start: Date,
-      end: Date,
-      processRunId = 'other-process',
-    ) =>
-      prisma.tbankSyncWork.create({
-        data: {
-          id: randomUUID(),
-          userId: USER,
-          revision: REVISION,
-          scopeKey: 'hourly',
-          attemptId: randomUUID(),
-          processRunId,
-          priority: 0,
-          intent: {},
-          progress: {},
-          state,
-          createdAt: start,
-          updatedAt: end,
-        },
-      });
-    const reserve = async (when: Date) => {
-      jest.setSystemTime(when);
-      return repository.reserveHourly(USER, 'this-process', 3_600_000);
-    };
-
-    it.each([
-      ['short attempt', 'complete', at(10), at(10, 5), at(10, 59), at(11)],
-      ['failed attempt', 'failed', at(10), at(10, 5), at(10, 59), at(11)],
-      ['walk past one term', 'complete', at(10), at(11, 10), at(11, 59), at(12)],
-      ['walk past two terms', 'complete', at(10), at(12, 10), at(12, 59), at(13)],
-      ['walk ending on a term', 'complete', at(10), at(11), at(10, 59), at(11)],
-    ] as const)('%s', async (_name, state, start, end, early, due) => {
-      await seed(state, start, end);
-      expect(await reserve(early)).toBeNull();
-      const reserved = await reserve(due);
-      expect(reserved?.work.state).toBe('running');
-      expect(reserved?.work.createdAt).toEqual(due);
-    });
-
-    it('starts a new revision at once', async () => {
-      await seed('complete', at(10), at(10, 5));
-      await prisma.tbankConnection.deleteMany({ where: { userId: USER } });
-      await prisma.tbankConnection.create({
-        data: {
-          userId: USER,
-          revision: 'next-revision',
-          encryptedToken: tokens.encrypt('synthetic'),
-          connectedAt: at(10, 10),
-        },
-      });
-      expect((await reserve(at(10, 10)))?.work.revision).toBe('next-revision');
-    });
-
-    it('closes a dead process attempt without early retry and runs one catch-up after downtime', async () => {
-      await seed('running', at(10), at(10, 1), 'dead-process');
-      expect(await reserve(at(10, 30))).toBeNull();
-      expect((await hourlyRow())?.errorCode).toBe('INTERRUPTED');
-      expect(await reserve(at(10, 59))).toBeNull();
-      expect((await reserve(at(14, 30)))?.work.createdAt).toEqual(at(14, 30));
-      expect(await reserve(at(14, 31))).toBeNull();
-      expect(
-        await prisma.tbankSyncWork.count({
-          where: { userId: USER, scopeKey: 'hourly' },
-        }),
-      ).toBe(1);
-    });
-
-    it('does not reserve while this process still runs the attempt', async () => {
-      await seed('running', at(10), at(10, 1), 'this-process');
-      expect(await reserve(at(12, 30))).toBeNull();
-    });
-  });
-
  it('does not overlap a running attempt with a second walk', async () => {
    operations.request.mockImplementation(async () => {
      const row = await child('running', null, 'operations');
@@ -15,7 +15,6 @@ import {
 } from '../src/modules/investments/income/income-analytics.dto';
 import { moscowDate } from '../src/modules/investments/investment-calendar';
 import { BrokerageOperationsRepository } from '../src/modules/investments/operations/infrastructure/brokerage-operations.repository';
-import { TbankHourlyScheduler } from '../src/modules/investments/tbank-sync/tbank-hourly.scheduler';
 import { PrismaService } from '../src/prisma/prisma.service';

 // Financial proof uses real persisted rows/coverage and the configured HTTP boundary.
@@ -60,8 +59,6 @@ describe('local income completeness and exact money (SQLite)', () => {
    const module = await Test.createTestingModule({ imports: [AppModule] })
      .overrideProvider(TbankClient)
      .useValue(upstream)
-      .overrideProvider(TbankHourlyScheduler)
-      .useValue({ tick: jest.fn() })
      .compile();
    app = module.createNestApplication();
    configureApp(app);
@@ -269,9 +266,7 @@ describe('local income completeness and exact money (SQLite)', () => {
    await repo.fail(fence, false);
    const after = await read();
    expect(after.data).toEqual(before.data);
-    // Without an hourly walk the durable attempt is absent; the failed
-    // source work stays a technical observation, not the hourly attempt.
-    expect(after.meta.lastAttempt.state).toBe('none');
+    expect(after.meta.lastAttempt.state).toBe('failed');
    expect(upstream.getOperationsByCursor).not.toHaveBeenCalled();
  });
  it('retains current-month observed completeness and does not renew source timestamps', async () => {
@@ -297,58 +292,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);
@@ -15,7 +15,6 @@ import { TbankClient } from '../src/integrations/tbank/tbank.client';
 import { configureApp } from '../src/main';
 import { BrokerageOperationsRepository } from '../src/modules/investments/operations/infrastructure/brokerage-operations.repository';
 import { BrokerageOperationsResourceDto } from '../src/modules/investments/operations/presentation/brokerage-operation.dto';
-import { TbankHourlyScheduler } from '../src/modules/investments/tbank-sync/tbank-hourly.scheduler';
 import { PrismaService } from '../src/prisma/prisma.service';

 const uid = '11111111-1111-4111-8111-111111111111';
@@ -46,8 +45,6 @@ describe('persistent ledger HTTP and cursor (SQLite)', () => {
    const module = await Test.createTestingModule({ imports: [AppModule] })
      .overrideProvider(TbankClient)
      .useValue(upstream)
-      .overrideProvider(TbankHourlyScheduler)
-      .useValue({ tick: jest.fn() })
      .compile();
    app = module.createNestApplication();
    configureApp(app);
@@ -113,50 +110,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 +406,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 () => {
@@ -3,7 +3,6 @@ import type { Server } from 'node:http';
 import { INestApplication } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
 import { Test } from '@nestjs/testing';
-import assert from 'node:assert/strict';
 import { setTimeout as delay } from 'node:timers/promises';
 import request from 'supertest';

@@ -16,10 +15,8 @@ import {
 } from '../src/integrations/tbank/tbank.client';
 import { configureApp } from '../src/main';
 import { BrokerageAccountsResourceDto } from '../src/modules/investments/brokerage-accounts/brokerage-account.dto';
-import { IncomeAnalyticsResourceDto } from '../src/modules/investments/income/income-analytics.dto';
 import { PortfolioService } from '../src/modules/investments/portfolio/application/portfolio.service';
 import { PortfolioResourceDto } from '../src/modules/investments/portfolio/presentation/portfolio.dto';
-import { TbankHourlyScheduler } from '../src/modules/investments/tbank-sync/tbank-hourly.scheduler';
 import { PrismaService } from '../src/prisma/prisma.service';

 function deferred<T>() {
@@ -104,8 +101,6 @@ describe('local accounts and portfolio HTTP (SQLite)', () => {
    const module = await Test.createTestingModule({ imports: [AppModule] })
      .overrideProvider(TbankClient)
      .useValue(upstream)
-      .overrideProvider(TbankHourlyScheduler)
-      .useValue({ tick: jest.fn() })
      .compile();
    app = module.createNestApplication();
    configureApp(app);
@@ -216,27 +211,7 @@ describe('local accounts and portfolio HTTP (SQLite)', () => {
    ).toEqual({
      stockPositionCount: 1,
      bondPositionCount: 0,
-      fundPositionCount: 0,
-      totalPositionCount: 1,
      totalsByCurrency: [{ currency: 'RUB', value: '21.100000002' }],
-      cashBalances: [{ currency: 'RUB', value: '1.1' }],
-      structure: {
-        currencies: [{
-          currency: 'RUB',
-          totalValue: '21.100000002',
-          hasNegativeValues: false,
-          categories: [
-            { type: 'STOCK', value: '20.000000002', sharePercent: '94.78673' },
-            { type: 'BOND', value: '0', sharePercent: '0' },
-            { type: 'OTHER', value: '0', sharePercent: '0' },
-            { type: 'CASH', value: '1.1', sharePercent: '5.21327' },
-          ],
-        }],
-        unvaluedCategories: [],
-      },
-      unrealizedReturnByCurrency: [
-        { currency: 'RUB', absolute: '0', costBasis: '0', percent: null, partial: true },
-      ],
    });
    const portfolio = await get('brokerage-accounts/account/portfolio').expect(
      200,
@@ -350,74 +325,6 @@ describe('local accounts and portfolio HTTP (SQLite)', () => {
    expect(upstream.getPortfolio).toHaveBeenCalledTimes(1);
  });

-  it('reports the durable hourly attempt in accounts and income meta with section relevance', async () => {
-    await put().expect(200);
-    await seedMembership();
-    await requestPortfolio('account');
-    await settled();
-    const connection = await prisma.tbankConnection.findUniqueOrThrow({
-      where: { userId: 'owner' },
-    });
-    const startedAt = new Date('2026-10-10T10:00:00.000Z');
-    const finishedAt = new Date('2026-10-10T10:05:00.000Z');
-    await prisma.tbankSyncWork.create({
-      data: {
-        id: 'hourly-attempt',
-        userId: 'owner',
-        revision: connection.revision,
-        scopeKey: 'hourly',
-        intent: {},
-        state: 'complete',
-        attemptId: 'hourly-attempt',
-        processRunId: 'test',
-        priority: 0,
-        progress: {
-          result: 'partial',
-          sections: [
-            {
-              section: 'portfolio',
-              accountId: 'account',
-              errorCode: 'TBANK_UNAVAILABLE',
-            },
-            {
-              section: 'operations',
-              accountId: 'account',
-              errorCode: 'TBANK_UNAVAILABLE',
-            },
-          ],
-        },
-        createdAt: startedAt,
-        updatedAt: finishedAt,
-      },
-    });
-    const accounts = await get('brokerage-accounts').expect(200);
-    const accountsMeta = (accounts.body as BrokerageAccountsResourceDto).meta;
-    expect(accountsMeta.lastAttempt.state).toBe('partial');
-    expect(accountsMeta.lastAttempt.startedAt).toBe(startedAt.toISOString());
-    expect(accountsMeta.lastAttempt.finishedAt).toBe(finishedAt.toISOString());
-    expect(accountsMeta.lastAttempt.problems).toEqual([
-      {
-        section: 'portfolio',
-        accountId: 'account',
-        errorCode: 'TBANK_UNAVAILABLE',
-      },
-    ]);
-    const income = await get(
-      'brokerage-accounts/account/income-analytics?sync=observe',
-    ).expect(200);
-    const incomeMeta = (income.body as IncomeAnalyticsResourceDto).meta;
-    expect(incomeMeta.lastAttempt.state).toBe('partial');
-    expect(incomeMeta.lastAttempt.startedAt).toBe(startedAt.toISOString());
-    expect(incomeMeta.lastAttempt.finishedAt).toBe(finishedAt.toISOString());
-    expect(incomeMeta.lastAttempt.problems).toEqual([
-      {
-        section: 'operations',
-        accountId: 'account',
-        errorCode: 'TBANK_UNAVAILABLE',
-      },
-    ]);
-  });
-
  it('recovers abandoned discovery only on a data request and coalesces concurrent reads', async () => {
    await put().expect(200);
    const connection = await prisma.tbankConnection.update({
@@ -512,18 +419,9 @@ describe('local accounts and portfolio HTTP (SQLite)', () => {
    }
    const summaries = (await get('brokerage-accounts?sync=observe').expect(200))
      .body as BrokerageAccountsResourceDto;
-    expect(summaries.data?.[0].portfolioSummary).toMatchObject({
-      totalsByCurrency: [{ currency: 'RUB', value: '21.1' }],
-      cashBalances: [{ currency: 'RUB', value: '1.1' }],
-      structure: { currencies: [{ currency: 'RUB' }] },
-      unrealizedReturnByCurrency: [
-        { currency: 'RUB', absolute: '0', costBasis: '0', percent: null, partial: true },
-      ],
-      stockPositionCount: 1,
-      bondPositionCount: 0,
-      fundPositionCount: 0,
-      totalPositionCount: 1,
-    });
+    expect(summaries.data?.[0].portfolioSummary?.totalsByCurrency).toEqual([
+      { currency: 'RUB', value: '21.1' },
+    ]);
    expect(summaries.data?.[1].portfolioSummary).toBeNull();
    expect(summaries.meta.availability).toBe('available');
    expect(summaries.meta.completeness).toBe('complete');
@@ -603,30 +501,16 @@ describe('local accounts and portfolio HTTP (SQLite)', () => {
    await put().expect(200);
    await seedMembership();
    const blocked = deferred<TbankPortfolio>();
-    const started = deferred<void>();
-    upstream.getPortfolio.mockImplementationOnce(() => {
-      started.resolve();
-      return blocked.promise;
-    });
-    // Starts the real portfolio producer, the same path the hourly walk uses.
-    const late = await portfolioService.request(
-      'owner',
-      (await prisma.tbankConnection.findUniqueOrThrow({ where: { userId: 'owner' } })).revision,
-      'account',
-      true,
-    );
-    assert(late);
-    // The late upstream call must have begun before the connection is replaced.
-    await started.promise;
+    upstream.getPortfolio.mockReturnValueOnce(blocked.promise);
+    await get('brokerage-accounts/account/portfolio').expect(200);
    await put().expect(200);
    await seedMembership();
    blocked.resolve({ positions: [] });
-    // Barrier: the fenced producer's completion, not a timer.
-    await late.done;
-    expect(await prisma.tbankPortfolio.count()).toBe(0);
+    await delay(20);
    const replaced = await get(
      'brokerage-accounts/account/portfolio?sync=observe',
    ).expect(200);
    expect((replaced.body as PortfolioResourceDto).data).toBeNull();
+    expect(await prisma.tbankPortfolio.count()).toBe(0);
  });
 });
@@ -129,17 +129,13 @@ describe('durable shared instrument metadata (SQLite)', () => {
  });
  it('coalesces twenty requests across users while giving each user a private handle', async () => {
    const blocked = deferred<TbankInstrument>();
-    const started = deferred<void>();
-    upstream.getInstrumentByUid.mockImplementation(() => {
-      started.resolve();
-      return blocked.promise;
-    });
+    upstream.getInstrumentByUid.mockReturnValue(blocked.promise);
    const responses = await Promise.all(
      Array.from({ length: 20 }, (_, i) =>
        service.read(i % 2 ? 'owner' : 'other', identity),
      ),
    );
-    await started.promise;
+    await delay(10);
    expect(upstream.getInstrumentByUid).toHaveBeenCalledTimes(1);
    const ids = new Set(responses.map((response) => response?.work?.id));
    expect(ids.size).toBe(2);
@@ -155,13 +151,9 @@ describe('durable shared instrument metadata (SQLite)', () => {
    'discards a producer after %s, including shared freshness, without borrowing another user token',
    async (action) => {
      const blocked = deferred<TbankInstrument>();
-      const started = deferred<void>();
-      upstream.getInstrumentByUid.mockImplementationOnce(() => {
-        started.resolve();
-        return blocked.promise;
-      });
+      upstream.getInstrumentByUid.mockReturnValueOnce(blocked.promise);
      await service.read('owner', identity);
-      await started.promise;
+      await delay(10);
      await service.read('other', identity);
      await prisma.tbankConnection.delete({ where: { userId: 'owner' } });
      if (action === 'replace') {
@@ -195,13 +187,9 @@ describe('durable shared instrument metadata (SQLite)', () => {
  );
  it('does not turn initiating credentials failure into a shared negative lookup or a foreign credentials error', async () => {
    const blocked = deferred<TbankInstrument>();
-    const started = deferred<void>();
-    upstream.getInstrumentByUid.mockImplementationOnce(() => {
-      started.resolve();
-      return blocked.promise;
-    });
+    upstream.getInstrumentByUid.mockReturnValueOnce(blocked.promise);
    await service.read('owner', identity);
-    await started.promise;
+    await delay(10);
    await service.read('other', identity);
    blocked.reject(new Error('INVALID_TBANK_TOKEN'));
    await settled();
@@ -238,6 +226,7 @@ describe('durable shared instrument metadata (SQLite)', () => {
    expect(failed?.fetchedAt).toEqual(old);
    if (!failedHandle) throw new Error('Expected forced refresh work');
    expect((await prisma.tbankSyncWork.findUniqueOrThrow({ where: { id: failedHandle } })).state).toBe('failed');
+    await delay(20);
    expect(upstream.getInstrumentByUid).toHaveBeenCalledTimes(calls + 1);
  });
  it('coalesces forced refresh and retains freshness/timestamp when it fails before the TTL', async () => {
@@ -296,7 +285,7 @@ describe('durable shared instrument metadata (SQLite)', () => {
    await prisma.$disconnect();
    service = createService();
    await service.read('owner', identity, true);
-    // Observation starts no work, so a no-call assertion holds without waiting.
+    await delay(10);
    expect(upstream.getInstrumentByUid).not.toHaveBeenCalled();
    await service.read('owner', identity);
    await settled();
@@ -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)(
@@ -152,12 +151,8 @@ describe('Request-driven operations synchronization (SQLite)', () => {

  it('joins overlapping account and instrument refresh into one atomic publication group', async () => {
    const gate = deferred<TbankOperationsByCursorResponse>();
-    const started = deferred<void>();
    upstream.getOperationsByCursor
-      .mockImplementationOnce(() => {
-        started.resolve();
-        return gate.promise;
-      })
+      .mockReturnValueOnce(gate.promise)
      .mockResolvedValue({
        hasNext: false,
        items: [{ ...operation(), instrumentUid: 'uid' }],
@@ -169,7 +164,7 @@ describe('Request-driven operations synchronization (SQLite)', () => {
        true,
      ),
    );
-    await started.promise;
+    await delay(5);
    const whole = requiredHandle(
      await service.request('owner', [january], true),
    );
@@ -187,17 +182,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 +201,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 +221,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 +237,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 +467,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 +500,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 +522,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 +557,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 +579,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 +612,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 +647,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 +655,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 +695,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 +709,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 +748,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,192 +0,0 @@
-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';
-
-// Real SQLite transaction: a running attempt of the current revision publishes its snapshot.
-describe('portfolio publication (SQLite)', () => {
-  const prisma = new PrismaService(
-    new ConfigService({ DATABASE_URL: process.env.DATABASE_URL }),
-  );
-  const repository = new PortfolioRepository(prisma);
-  const snapshot = {
-    lastSuccessfulAt: '2026-01-01T00:00:00.000Z',
-    isStale: false,
-    totalsByCurrency: [],
-    positions: [],
-    cashBalances: [],
-    structure: { currencies: [], unvaluedCategories: [] },
-  } satisfies PortfolioDto;
-  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();
-    await prisma.user.create({
-      data: { id: 'owner', email: 'owner@example.invalid', passwordHash: 'synthetic' },
-    });
-  });
-  afterAll(async () => prisma.$disconnect());
-  afterEach(() => jest.restoreAllMocks());
-  beforeEach(async () => {
-    await prisma.tbankPortfolioValueHistory.deleteMany();
-    await prisma.tbankConnection.deleteMany();
-    await prisma.tbankConnection.create({
-      data: {
-        userId: 'owner',
-        revision: 'current',
-        encryptedToken: 'synthetic',
-        connectedAt: new Date(),
-        accounts: {
-          create: {
-            accountId,
-            type: 'brokerage',
-            name: 'Synthetic',
-            upstreamOrder: 0,
-          },
-        },
-      },
-    });
-  });
-
-  it('publishes the same snapshot for the running attempt of the current revision', async () => {
-    await createRunningAttempt();
-    const published = await repository.publish(
-      { id: 'live', attemptId: 'live-attempt', userId: 'owner', revision: 'current' },
-      accountId,
-      snapshot,
-    );
-    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);
-    },
-  );
-});
@@ -21,7 +21,6 @@ import {
  TbankOperationsByCursorRequest,
 } from '../src/integrations/tbank/tbank.client';
 import { configureApp } from '../src/main';
-import { TbankHourlyScheduler } from '../src/modules/investments/tbank-sync/tbank-hourly.scheduler';
 import { PrismaService } from '../src/prisma/prisma.service';

 const evidenceDirectory = mkdtempSync(join(tmpdir(), 'wealthledger-read-evidence-'));
@@ -216,8 +215,6 @@ describe('T-Bank persisted read budget', () => {
      })
      .overrideProvider(NcrRatingsClient)
      .useValue({ rating: () => counted('ncrRating', null) })
-      .overrideProvider(TbankHourlyScheduler)
-      .useValue({ tick: jest.fn() })
      .compile();
    app = module.createNestApplication();
    app.use((_req: Request, res: Response, next: NextFunction) => {
@@ -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' }],
Author	SHA1	Message	Date
codex-bot	d0e86b9304	Merge branch 'develop' into test/72-slim-sqlite-regression Backend verify / commits (pull_request) Failing after 25s Details Backend verify / security (pull_request) Skipped Details Backend verify / verify (pull_request) Skipped Details	2026-10-14 08:13:34 +03:00
ksv741	11e5bc08e3	test: slim sqlite runner regression workload (WealthLedger/backend#72 ) Backend verify / commits (pull_request) Successful in 28s Details Backend verify / security (pull_request) Successful in 10s Details Backend verify / verify (pull_request) Successful in 4m54s Details	2026-10-13 23:46:20 +03:00
@@ -1 +1 @@
 .22.1
 .21.0
				`@@ -1 +0,0 @@`
				`export { hourlyAttempt, TbankSyncRepository } from './tbank-sync.repository';`