fix(editor): restore reading position only after the layout settles (#266)

Follow-up to the merged title-autofocus fix (#301). Confirmed via Chrome DevTools
on the live app: a residual reload jitter remained — the document renders
progressively (measured height 17729 -> 32185, collapsing mid-swap), and the
restore fired TOO EARLY (twice, at partial heights) because it only checked
"is the target reachable", not "has the layout settled". While the doc grew,
scroll-anchoring dragged the position and the second restore yanked it back
(the jitter), landing ~6000px off.

- restoreScrollPosition now polls the document height and restores ONCE the
  height has been stable for HEIGHT_STABLE_MS (400ms) AND the target is
  reachable; the MAX_RESTORE_WAIT_MS (5s) timeout is the only fallback that
  clamps. Removed the restoreStartRef shared budget; idempotency is now the
  `pollTimerRef !== null` guard (a running wait suppresses a second trigger).
- The two-trigger wiring (early on-mount for the offline path + post-swap) is
  unchanged; both call the now-settle-waiting, idempotent restore.
- A shadow simulation on the live page confirmed the new logic fires once,
  accurately (vs the old two-fire-plus-drift).
- Tests updated for the stable-height timing; (k) rewritten to pin the
  idempotency guard (mutation-verified); (d3) added for "waits until height
  stops changing".

Tradeoff: on progressively-rendering pages the position now appears once the
layout settles (~0.5-2s) in one smooth move, instead of an early-but-jittery,
often-inaccurate restore.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

.env.example

@@ -173,21 +173,9 @@ MCP_DOCMOST_PASSWORD=
 # Keep-alive recycle window (ms) for streaming chat/agent AI + external-MCP calls.
 # A pooled connection idle longer than this is closed instead of reused, so a
 # NAT / egress firewall / reverse proxy that silently drops idle connections
-# cannot poison a reused socket into a PRE-RESPONSE `read ECONNRESET`. Kept under
+# cannot poison a reused socket into a PRE-RESPONSE `read ECONNRESET`. Lower it if
-# common ~5s upstream/middlebox idle cutoffs so undici recycles the socket before
+# your egress drops idle connections faster than ~10s. Default 10000 (10 s).
-# the network kills it (fewer resets), while still reusing within a burst of
+# AI_STREAM_KEEPALIVE_MS=10000
-# back-to-back calls. Lower it further if your egress drops idle connections even
-# faster. Default 4000 (4 s).
-# AI_STREAM_KEEPALIVE_MS=4000
-
-# Number of PRE-RESPONSE connection retries for streaming chat/agent AI calls: a
-# reset/timeout BEFORE any response byte (e.g. `read ECONNRESET` on a stale pooled
-# socket) is retried on a fresh connection with jittered exponential backoff.
-# Total attempts = value + 1, so the default 4 gives 5 attempts — headroom to
-# absorb a short BURST of upstream resets without exhausting the budget. Safe to
-# retry: a started stream is never replayed, only a connect that never responded.
-# 0 disables the retry. Default 4.
-# AI_STREAM_PRE_RESPONSE_RETRIES=4
 
 # Silence timeout (ms) for EXTERNAL-MCP transport ONLY (not the chat provider).
 # Tighter than AI_STREAM_TIMEOUT_MS so a byte-silent/hung MCP server is broken in
@@ -202,27 +190,6 @@ MCP_DOCMOST_PASSWORD=
 # Default 900000 (15 min).
 # AI_MCP_CALL_TIMEOUT_MS=900000
 
-# Deferred tool loading for the in-app AI chat (#332). Default ON: the agent sees
-# a compact <tool_catalog> and only CORE tools + a loadTools meta-tool are active
-# each step; deferred tools (the fat/rare ones + all external MCP tools) load on
-# demand. Set AI_CHAT_DEFERRED_TOOLS=false to restore the old "all tools always
-# active" behavior.
-# AI_CHAT_DEFERRED_TOOLS=true
-
-# --- Autonomous / detached agent runs (settings.ai.autonomousRuns) ---
-# Opt-in per workspace (AI settings; off by default). When on, a chat turn becomes
-# a server-side RUN that survives a browser disconnect — only an explicit Stop ends
-# it, and a client reconnects/live-follows the run.
-#
-# DEPLOY CONSTRAINT — SINGLE-INSTANCE ONLY in phase 1: Stop and the in-process
-# AbortController that backs it are process-local, so a Stop only aborts a run
-# executing on the SAME replica that owns it (cross-instance pub/sub stop is phase
-# 2 and not yet reliable). Do NOT enable autonomousRuns on a horizontally-scaled
-# deployment (multiple replicas behind a load balancer, or Docmost cloud
-# CLOUD=true) — run a single instance instead. The server logs a startup WARNING
-# when it detects a multi-instance deployment (CLOUD=true) so the constraint is
-# visible, and a startup sweep settles any run left dangling by a restart.
-
 # --- Anonymous public-share AI assistant ---
 # Opt-in per workspace (AI settings -> "public share assistant"; off by default).
 # When enabled, anonymous visitors of a published share can ask an AI about that
@@ -256,27 +223,3 @@ MCP_DOCMOST_PASSWORD=
 # FAILS CLOSED if Redis is unavailable (default: 1,000,000 tokens per workspace
 # per rolling day).
 # SHARE_AI_WORKSPACE_TOKEN_BUDGET_PER_DAY=1000000
-
-# --- Observability / perf metrics (#355) ---
-#
-# Two INDEPENDENT toggles, both OFF by default:
-#
-# 1) METRICS_PORT — the server-side Prometheus scrape endpoint.
-#    UNSET (default) => the whole prom subsystem is OFF: no registry, no
-#    collectors, and NOTHING is exposed on the main app port. There is NO
-#    default port — leaving it blank disables it. When set to a port (e.g.
-#    9464), a SEPARATE bare node:http listener serves GET /metrics on that port
-#    only (never on the main :3000 app listener), for a scraper such as
-#    VictoriaMetrics/Prometheus reaching it as <host>:<port>/metrics.
-# METRICS_PORT=9464
-#
-# 2) CLIENT_TELEMETRY_ENABLED — the public client perf-telemetry sink.
-#    OFF by default. When true, the unauthenticated POST /api/telemetry/vitals
-#    endpoint is registered and browsers collect + send web-vitals / editor
-#    metrics into the `client_metrics` table (read directly by Grafana, separate
-#    from METRICS_PORT). Leave OFF unless you actually consume this data: the
-#    endpoint is public and the table has NO app-side retention, so enabling it
-#    requires an EXTERNAL pruner to bound `client_metrics` growth (the deployed
-#    infra prunes rows >90d via a maintenance container). When off, the endpoint
-#    does not exist and the client installs no observers.
-# CLIENT_TELEMETRY_ENABLED=false

.github/workflows/develop.yml

@@ -18,48 +18,12 @@ env:
   IMAGE: ghcr.io/vvzvlad/gitmost
 
 jobs:
-  # Run the reusable test suite. Together with the e2e jobs below it gates the
+  # Run the reusable test suite first so a failing test blocks the image build.
-  # publish job (the image push), not the build itself — build runs in parallel.
   test:
     uses: ./.github/workflows/test.yml
 
-  # Runs in parallel with the test/e2e jobs and only warms the buildx cache
-  # (GHA cache, scope develop-amd64). No push happens here — the publish job
-  # below is the only one that pushes the image.
   build:
-    runs-on: ubuntu-latest
+    needs: test
-    timeout-minutes: 30
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Resolve version
-        id: version
-        run: echo "value=$(git describe --tags --always)" >> "$GITHUB_OUTPUT"
-
-      - name: Build develop image (warm cache, no push)
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          platforms: linux/amd64
-          build-args: |
-            APP_VERSION=${{ steps.version.outputs.value }}
-            AI_AGENT_ROLES_CATALOG_URL=https://raw.githubusercontent.com/vvzvlad/gitmost/develop/agent-roles-catalog
-          push: false
-          cache-from: type=gha,scope=develop-amd64
-          cache-to: type=gha,scope=develop-amd64,mode=max,ignore-error=true
-
-  # The gate: rebuilds from the cache the build job just wrote (near-instant on
-  # a cache hit; worst case — cache eviction — a full rebuild, which matches the
-  # old sequential timing) and pushes :develop only when unit tests AND both
-  # e2e suites AND the build are green.
-  publish:
-    needs: [test, e2e-server, e2e-mcp, build]
     runs-on: ubuntu-latest
     timeout-minutes: 30
     steps:
@@ -93,10 +57,13 @@ jobs:
           push: true
           tags: ${{ env.IMAGE }}:develop
           cache-from: type=gha,scope=develop-amd64
+          cache-to: type=gha,scope=develop-amd64,mode=max,ignore-error=true
 
-  # e2e jobs gate the publish (image push), not the build: the :develop image
+  # e2e jobs run on every develop push but DO NOT gate the build/publish above:
-  # is pushed only when unit tests AND both e2e suites pass (publish.needs
+  # `build` stays `needs: test` only, so the :develop image still ships even if
-  # lists them all).
+  # e2e fails. A failing e2e job turns the run red and triggers GitHub's email
+  # to the pusher — that red run + email is the intended notification, not a
+  # deploy block.
   e2e-server:
     runs-on: ubuntu-latest
     # Hard cap: the full-AppModule e2e leaks open handles and hung jest to the 6h max.
@@ -157,7 +124,9 @@ jobs:
       - name: Run server e2e
         run: pnpm --filter ./apps/server test:e2e
 
-  # Gates the publish too — see the comment above e2e-server.
+  # Same rationale as e2e-server: this job is intentionally NOT in
+  # `build.needs`. Deploy of the :develop image must not be blocked by e2e;
+  # a red run plus GitHub's email to the pusher is the notification mechanism.
   e2e-mcp:
     runs-on: ubuntu-latest
     timeout-minutes: 20

.github/workflows/test.yml

@@ -72,14 +72,6 @@ jobs:
       - name: Build editor-ext
         run: pnpm --filter @docmost/editor-ext build
 
-      # @docmost/prosemirror-markdown is the shared converter (#293/#326); its
-      # build/ is gitignored, and plain `pnpm -r test` does NOT honour nx
-      # `dependsOn: ^build`, so its consumers (mcp `pretest: tsc`, git-sync vitest
-      # typecheck) fail with TS2307 Cannot find module '@docmost/prosemirror-markdown'
-      # unless it is built first. Build it before the recursive test run.
-      - name: Build prosemirror-markdown
-        run: pnpm --filter @docmost/prosemirror-markdown build
-
       - name: Run unit tests
         run: pnpm -r test
 

.gitignore

@@ -4,20 +4,7 @@
 data
 # compiled output
 /dist
-node_modules
+/node_modules
-
-# git-sync compiled output (built in CI/Docker via `pnpm build`, never committed,
-# so src/ and prod can never silently diverge).
-packages/git-sync/build/
-
-# prosemirror-markdown compiled output (built in CI/Docker via `pnpm build`,
-# never committed, so src/ and prod can never silently diverge).
-packages/prosemirror-markdown/build/
-
-# mcp compiled output (built in CI/Docker via `pnpm build`, never committed, so
-# src/ and prod can never silently diverge). Matches the git-sync/prosemirror-
-# markdown convention; the package is private and rebuilt at deploy.
-packages/mcp/build/
 
 # Logs
 logs
@@ -56,8 +43,6 @@ lerna-debug.log*
 .nx/cache
 .claude/worktrees/
 .claude/tmp/
-# Local Chrome performance traces recorded by the AI-chat perf harness
-.claude/perf-traces/
 
 # TypeScript incremental build artifacts
 *.tsbuildinfo

AGENTS.md

@@ -200,8 +200,7 @@ pnpm workspace (`pnpm@10.4.0`) orchestrated by **Nx**. Four workspace packages:
 | `apps/server` | `server` | NestJS 11 + Fastify, Kysely (Postgres), Redis | Backend API, collaboration, AI |
 | `apps/client` | `client` | React 18 + Vite + Mantine 8 + TanStack Query + Jotai | SPA frontend |
 | `packages/editor-ext` | `@docmost/editor-ext` | Tiptap/ProseMirror | Shared Tiptap node/mark extensions, imported by both the client and the server |
-| `packages/mcp` | `@docmost/mcp` | MCP SDK, Tiptap, Yjs | Standalone MCP server, also bundled into the server at `/mcp`. Consumes the shared converter/schema from `@docmost/prosemirror-markdown` (#293) — it no longer carries its own vendored converter/schema copy |
+| `packages/mcp` | `@docmost/mcp` | MCP SDK, Tiptap, Yjs | Standalone MCP server, also bundled into the server at `/mcp`. Does **not** import `editor-ext` — it keeps its own vendored mirror of the schema in `packages/mcp/src/lib/` |
-| `packages/prosemirror-markdown` | `@docmost/prosemirror-markdown` | Tiptap, marked, jsdom | The single, canonical ProseMirror↔Markdown converter + Docmost schema mirror (#293). Consumed by `mcp` and `git-sync`; there is exactly ONE copy of the converter now |
 
 `build` targets are Nx-cached and dependency-ordered (`dependsOn: ["^build"]`), so `editor-ext` builds before the apps. `nx.json` sets `affected.defaultBase: main`.
 
@@ -279,12 +278,11 @@ The API server is a Fastify app with a global `/api` prefix (`main.ts` excludes
    - `core/ai-chat/tools/` — the agent's ~40 read+write tools. Every tool runs under the **calling user's** CASL permissions via a per-user loopback access token (`docmost-client.loader.ts`), so the agent can never exceed what the user could do. Only **reversible** operations are exposed (page history + trash; no permanent delete). Agent edits get an "AI agent" provenance badge in page history (`20260616T130000-agent-provenance` migration).
    - `core/ai-chat/embedding/` — RAG indexer + a BullMQ consumer on `AI_QUEUE` that embeds pages into `page_embeddings` (vector search), complementing Postgres full-text search. Pages are (re)indexed on edit; `AI_EMBEDDING_TIMEOUT_MS` bounds a hung embeddings endpoint.
    - `core/ai-chat/external-mcp/` — admins can attach external MCP servers (e.g. Tavily) to give the agent web access. **`ssrf-guard.ts` validates outbound MCP URLs against SSRF** — keep that guard in the path when touching external-MCP connection logic.
-   - `core/ai-chat/ai-chat-run.service.ts` + `ai_chat_runs` — **detached/autonomous agent runs** (`#184`), behind the per-workspace `settings.ai.autonomousRuns` flag (off by default). When on, a turn becomes a server-side RUN that survives a browser disconnect; only an explicit `POST /ai-chat/stop` ends it, and a client reconnects/live-follows via `POST /ai-chat/run`. **DEPLOY CONSTRAINT — single-instance only in phase 1:** Stop and the AbortController that backs it are process-local, so a Stop only aborts a run executing on the **same** replica that owns it (cross-instance pub/sub stop is phase 2). Do **not** enable `autonomousRuns` on a horizontally-scaled deployment (multiple replicas behind a load balancer, or Docmost cloud `CLOUD=true`) — run a single instance instead. The server logs a startup WARNING when it detects a multi-instance deployment (`CLOUD=true`) so the constraint is visible. The startup sweep settles any run left dangling by a restart.
 
 ### Client structure
 Vite SPA. Code is organized by feature under `apps/client/src/features/*` (mirrors the server domains: `page`, `space`, `comment`, `ai-chat`, `editor`, …). Conventions:
 - **TanStack Query** for server state (one `queries/` file per feature), **Jotai** atoms for local/shared UI state, **Mantine 8** + CSS modules (`*.module.css`) + `postcss-preset-mantine` for UI.
-- The editor is Tiptap; shared node/mark extensions live in `packages/editor-ext` and are imported by **both the client and the server** (collaboration, import/export) — editor schema changes often need to be made in `editor-ext`, not just the client. The ProseMirror↔Markdown converter and its Docmost schema mirror now live in a SINGLE package, `@docmost/prosemirror-markdown` (#293), consumed by both `mcp` and `git-sync` — do NOT reintroduce a per-package copy. `editor-ext` is the upstream source of the Tiptap schema; the package's `docmost-schema.ts` mirrors it and a serializer-contract test (`packages/prosemirror-markdown/test/serializer-contract.test.ts`) guards the boundary (every schema node must have a converter case), so a drift surfaces as a failing test rather than silent divergence.
+- The editor is Tiptap; shared node/mark extensions live in `packages/editor-ext` and are imported by **both the client and the server** (collaboration, import/export) — editor schema changes often need to be made in `editor-ext`, not just the client. Note `packages/mcp` does *not* depend on `editor-ext`; it carries its own mirrored copy of the schema, so keep the two in sync manually when the document schema changes.
 - API access goes through `apps/client/src/lib/api-client.ts` (axios). The `@` alias maps to `apps/client/src`.
 - Runtime config is injected at build time by `vite.config.ts` via `define` (`APP_URL`, `COLLAB_URL`, `APP_VERSION`, …) — these come from the root `.env`, not from `import.meta.env`.
 
@@ -295,7 +293,6 @@ Vite SPA. Code is organized by feature under `apps/client/src/features/*` (mirro
 - The version string shown in the UI comes from `APP_VERSION` (CI/Docker) or `git describe --tags --always` (local), resolved in `vite.config.ts` — not from `package.json`.
 - Server TS config is permissive (`noImplicitAny: false`, `strictNullChecks: false`, `no-explicit-any` lint disabled). Follow the existing relaxed style rather than tightening types broadly.
 - Dependency versions are heavily pinned via `pnpm.overrides` and `pnpm.patchedDependencies` (`scimmy`, `yjs`) in the root `package.json`. Don't bump pinned/patched deps casually; the patches and overrides exist for compatibility/security reasons.
-- **Adding/renaming/removing an MCP tool requires updating `SERVER_INSTRUCTIONS`** in `packages/mcp/src/index.ts` — the intent-routing guide MCP clients receive on initialize. This applies both to inline `server.registerTool(...)` calls in `index.ts` and to specs in `packages/mcp/src/tool-specs.ts`. Enforced by `packages/mcp/test/unit/server-instructions.test.mjs`, which fails when a registered tool is not mentioned in the guide (deliberate opt-outs go into its `EXCEPTIONS` list). `packages/mcp/build/` is gitignored and rebuilt in CI/Docker via `pnpm build` (same convention as `git-sync`/`prosemirror-markdown`) — never commit it; rebuild locally after editing to run the tests.
 
 ## CI / release
 

CHANGELOG.md

@@ -72,19 +72,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   append/prepend fragments, nor to COMMENT bodies — a comment may legitimately
   contain a standalone footnote definition, which canonicalization would drop.
   (#228)
-- **Detached, autonomous agent runs that survive a browser disconnect.** When the
-  new `settings.ai.autonomousRuns` workspace flag is on (off by default), an
-  AI-chat turn becomes a first-class, server-side RUN tracked in a new
-  `ai_chat_runs` table instead of a socket-bound stream: closing the tab or
-  losing the connection no longer aborts the turn — it keeps executing and
-  persisting server-side, and only an explicit Stop ends it. A client can
-  reconnect and live-follow (or stop) an in-flight run via `POST /ai-chat/run`
-  (resolve the latest run + its assistant message for a chat) and
-  `POST /ai-chat/stop` (stop by `runId` or `chatId`). A partial unique index
-  enforces one active run per chat, and a startup sweep settles any run left
-  dangling by a restart. Phase 1 is single-instance-only (cross-instance Stop is
-  not yet reliable); the server warns at startup on a horizontally-scaled
-  deployment. (#184)
 - **Out-of-band page transfer via an in-RAM blob sandbox (`stash_page`).** A
   new MCP tool serializes a whole page (its full ProseMirror JSON, with every
   internal image/file mirrored) into an ephemeral in-RAM blob and returns only

Dockerfile

@@ -5,13 +5,6 @@ RUN npm install -g pnpm@10.4.0
 
 FROM base AS builder
 
-# re2 (packages/mcp) always compiles from source under pnpm (the prebuilt-binary
-# download cannot identify the GitHub repo), so node-gyp needs python3/make/g++.
-# This stage is discarded, so the toolchain can stay installed.
-RUN apt-get update \
-  && apt-get install -y --no-install-recommends python3 make g++ \
-  && rm -rf /var/lib/apt/lists/*
-
 WORKDIR /app
 
 COPY . .
@@ -45,14 +38,6 @@ COPY --from=builder /app/packages/editor-ext/dist /app/packages/editor-ext/dist
 COPY --from=builder /app/packages/editor-ext/package.json /app/packages/editor-ext/package.json
 COPY --from=builder /app/packages/mcp/build /app/packages/mcp/build
 COPY --from=builder /app/packages/mcp/package.json /app/packages/mcp/package.json
-# mcp now depends on @docmost/prosemirror-markdown (workspace:*) and eager-imports
-# it at runtime (the in-app ai-chat DocmostClient loads build/index.js -> lib/
-# markdown-converter.js). Ship the built package + its manifest, or the prod
-# install resolves a broken workspace symlink and every ai-chat tool dies with
-# ERR_MODULE_NOT_FOUND (#293/#326 step 5). (git-sync has no runtime consumer yet;
-# revisit at step 6 when #119 lands.)
-COPY --from=builder /app/packages/prosemirror-markdown/build /app/packages/prosemirror-markdown/build
-COPY --from=builder /app/packages/prosemirror-markdown/package.json /app/packages/prosemirror-markdown/package.json
 
 # Copy root package files
 COPY --from=builder /app/package.json /app/package.json
@@ -64,17 +49,10 @@ COPY --from=builder /app/patches /app/patches
 
 RUN chown -R node:node /app
 
-# Toolchain is needed transiently to compile re2 during the prod install; install
-# and purge it in one layer to keep the final image slim. The install itself runs
-# as the node user via su to keep node_modules ownership without a costly chown layer.
-RUN apt-get update \
-  && apt-get install -y --no-install-recommends python3 make g++ \
-  && su node -c "pnpm install --frozen-lockfile --prod" \
-  && apt-get purge -y --auto-remove python3 make g++ \
-  && rm -rf /var/lib/apt/lists/*
-
 USER node
 
+RUN pnpm install --frozen-lockfile --prod
+
 RUN mkdir -p /app/data/storage
 
 VOLUME ["/app/data/storage"]

agent-roles-catalog/bundles/editorial/en.yaml

@@ -34,13 +34,11 @@ roles:
       Read the whole text first. Think at the level of sections and paragraphs, not sentences.
 
       HOW TO LEAVE COMMENTS
-      You don't edit the text yourself. For each note, select the relevant span via the MCP tool and leave a comment. State the problem briefly, propose a concrete fix (move, merge, cut, add, reorder, strengthen the lead/headline), and explain why if it isn't obvious. Tag severity:
+      You don't edit the text yourself. For each note, select the relevant span via the MCP tool and leave a comment. Open the comment with the label `[Structure]`. Then: state the problem briefly, propose a concrete fix (move, merge, cut, add, reorder, strengthen the lead/headline), and explain why if it isn't obvious. Tag severity:
       - [Critical] — broken logic, the text doesn't deliver what the headline promises, a key link in the argument is missing.
       - [Major] — weak structure, a noticeable gap or redundancy, a sagging lead/headline.
       - [Minor] — an optional improvement to framing or flow.
 
-      Structural fixes (move, merge, cut) can't be expressed as a fragment replacement — a comment is enough for those. But when your proposal boils down to replacing a specific wording in place (a headline, a lead phrase), attach a suggested replacement to the comment (the `suggestedText` parameter): the exact new text for the selected fragment, plain text with no markup — the author applies it with one click. The selected fragment must occur exactly once in the text; if it isn't unique, extend the selection with surrounding context.
-
       TONE
       Respectful and to the point. The author may know the subject better than you. Flag only what matters structurally. When unsure, phrase it as a question.
 
@@ -87,7 +85,7 @@ roles:
       - Don't rewrite the text yourself or impose your own voice. Your job is to make the author's voice livelier, not to replace it.
 
       HOW TO LEAVE COMMENTS
-      You don't edit the text directly. For each note, select the span via the MCP tool and leave a comment. Give a concrete rephrasing, not "revise", and attach it to the comment as a suggested replacement (the `suggestedText` parameter): the exact new text for the selected fragment, plain text with no markup — the author applies it with one click. The selected fragment must occur exactly once in the text; if it isn't unique, extend the selection with surrounding context. Tag severity:
+      You don't edit the text directly. For each note, select the span via the MCP tool and leave a comment. Open the comment with the label `[Style]`. Give a concrete rephrasing, not "revise". Tag severity:
       - [Critical] — the sentence is unclear or distorts the meaning.
       - [Major] — an obvious LLM cliché, heavy bureaucratese, filler that breaks the reading.
       - [Minor] — a stylistic improvement to taste.
@@ -128,7 +126,7 @@ roles:
       - Don't fabricate confirmations. If you can't verify, honestly mark [Unverified] or [Unverifiable].
 
       HOW TO LEAVE COMMENTS
-      You don't edit the text directly. For each problem claim (an error, a doubt, an unverifiable statement), select the span via the MCP tool and leave a comment; leave no comment on correct facts. Give the verdict, the correction (if any), and the source. For an [Incorrect] verdict, ALWAYS attach the ready correction as a suggested replacement (the `suggestedText` parameter): since you found the correct value in the sources, propose the ready fix right away instead of merely describing the error. The replacement is the exact new text for the selected fragment, plain text with no markup; the author applies it with one click instead of retyping the fragment. The selected fragment must occur exactly once in the text; if it isn't unique, extend the selection with surrounding context. When a figure, name, term, or version to check recurs across the page, use search_in_page to find every occurrence in one call first, then place a targeted comment per hit instead of reading block by block. Do not attach a replacement to [Unverified], [Unverifiable], or [Opinion] verdicts. Tag severity:
+      You don't edit the text directly. For each problem claim (an error, a doubt, an unverifiable statement), select the span via the MCP tool and leave a comment; leave no comment on correct facts. Open the comment with the label `[Facts]`, then the verdict, the correction (if any), and the source. Tag severity:
       - [Critical] — a factual error, especially in numbers, names, or quotes, or a claim that risks misinformation.
       - [Major] — a doubtful or unconfirmed claim that needs a source.
       - [Minor] — a small correction, or false precision worth rounding or confirming.
@@ -168,17 +166,14 @@ roles:
       - Don't verify facts — that's the Fact-checker.
       - Don't make substantive changes. Edits are minimal and mechanical.
 
-      HOW TO WORK
-      Go through the whole text from start to finish in a single pass. Flag EVERY violation, including all repeat occurrences of the same error and minor items tagged [Minor] — don't stop at the first few or the most conspicuous. Don't summarize instead of marking up: until you've reached the end of the document, the job isn't done. One run covers the whole text, not just "the most important". For a systematic issue that recurs — straight quotes, a hyphen used as a dash, an inconsistent unit or spelling — use search_in_page to list every occurrence in one call first, then leave a targeted comment (with its replacement) on each hit, instead of scanning block by block.
-
       HOW TO LEAVE COMMENTS
-      You don't edit the text directly. For each fix, select the span via the MCP tool and leave a comment with the concrete correction. Attach a suggested replacement to every fix (the `suggestedText` parameter): the exact corrected text for the selected fragment, plain text with no markup — the author applies it with one click. The selected fragment must occur exactly once in the text; if it isn't unique, extend the selection with surrounding context. Do NOT leave summary notes like "throughout, replace X with Y" or "make the units/quotes/spelling consistent": such a comment can't be applied with a button. If the same error occurs in several places, walk EVERY occurrence and leave a separate targeted comment with its own replacement on each — ten targeted fixes instead of one blanket note. The only exception is a note that genuinely cannot be expressed as a replacement of a concrete fragment; leave those rare cases as an ordinary comment without a replacement. Tag severity:
+      You don't edit the text directly. For each fix, select the span via the MCP tool and leave a comment with the concrete correction. Open the comment with the label `[Copyedit]`. Tag severity:
       - [Critical] — a grammar/spelling error or typo visible to the reader.
       - [Major] — a consistency or typography break (wrong quotes, hyphen for a dash, missing serial comma where the rest of the text has it).
       - [Minor] — optional polish.
 
       TONE
-      To the point, no explaining the obvious. Don't fold repeated fixes into a single "change it everywhere" note — spread them across the specific spots: ten targeted comments each carrying a ready replacement beat one blanket comment that can't be applied with a button. Don't worry about "spawning" comments — for a copyeditor that's normal.
+      To the point, no explaining the obvious. Group repeated fixes (e.g. "throughout: straight quotes → curly") so you don't spawn dozens of identical comments.
 
       WHEN UNSURE
       If a fix touches meaning, don't make it — that's out of scope. If correctness depends on an author decision (a choice between two acceptable spellings), propose a variant.
@@ -277,7 +272,7 @@ roles:
       First read the whole text and assess it as a story as a whole. Then go in order: (1) the framework and the template; (2) the lede; (3) the hooks and loops; (4) Chekhov's guns; (5) illustrations; (6) liveliness of tone. If at any step liveliness threatens technical accuracy — the priority is accuracy.
 
       ═══ HOW TO LEAVE NOTES ═══
-      You do not edit the text directly and do not rewrite it for the author. Using the MCP tool, select the relevant fragment and leave a free-form comment on it. Explain not only “what” but also “why” — what effect it will have on the reader. Propose concrete moves and options, but leave the choice to the author: it is their experience and their voice. When one of your options is a single ready-made text (e.g. a new lead phrase), you may attach it as a suggested replacement (the `suggestedText` parameter: the exact new text for the selected fragment, no markup; the fragment must occur exactly once in the text, otherwise extend the selection) — the button imposes nothing, the author is free not to apply it. Comment on what will strengthen the story, not on every little thing.
+      You do not edit the text directly and do not rewrite it for the author. Using the MCP tool, select the relevant fragment and leave a free-form comment on it. Explain not only “what” but also “why” — what effect it will have on the reader. Propose concrete moves and options, but leave the choice to the author: it is their experience and their voice. Comment on what will strengthen the story, not on every little thing.
 
       ═══ TONE ═══
       Respectfully, with enthusiasm, in a human way. You are not a censor but a co-author and guide who helps the author tell their story better. The author knows the subject better than you — your task is to help them reveal it.

agent-roles-catalog/bundles/editorial/ru.yaml

@@ -34,13 +34,11 @@ roles:
       Сначала прочитай весь текст целиком. Думай на уровне разделов и абзацев, а не предложений.
 
       КАК ОСТАВЛЯТЬ ЗАМЕЧАНИЯ
-      Ты не редактируешь текст сам. Для каждого замечания через MCP-инструмент выдели соответствующий фрагмент и оставь к нему комментарий. Коротко назови проблему, предложи конкретное решение (перенести, объединить, вырезать, добавить, переставить, усилить лид/заголовок) и при необходимости поясни, почему. Помечай важность:
+      Ты не редактируешь текст сам. Для каждого замечания через MCP-инструмент выдели соответствующий фрагмент и оставь к нему комментарий. Начинай комментарий с метки `[Структура]`. Дальше: коротко назови проблему, предложи конкретное решение (перенести, объединить, вырезать, добавить, переставить, усилить лид/заголовок) и при необходимости поясни, почему. Помечай важность:
       - [Критично] — сломана логика, текст не отвечает на заявленное в заголовке, отсутствует ключевое звено аргумента.
       - [Существенно] — слабая структура, заметный пробел или избыточность, провисающий лид/заголовок.
       - [Незначительно] — улучшение подачи или стройности, не обязательное.
 
-      Структурные правки (перенести, объединить, вырезать) через замену фрагмента не выражаются — для них достаточно комментария. Но если предложение сводится к замене конкретной формулировки на месте (заголовок, лид-фраза), приложи к комментарию предложение-замену (параметр `suggestedText`): точный новый текст взамен выделенного фрагмента, обычным текстом без разметки — автор применит его одной кнопкой. Выделенный фрагмент должен встречаться в тексте ровно один раз; если он не уникален, расширь выделение контекстом.
-
       ТОН
       Уважительно и по делу. Автор может разбираться в теме лучше тебя. Помечай только то, что важно для структуры. Если сомневаешься, формулируй вопросом.
 
@@ -87,7 +85,7 @@ roles:
       - Не переписываешь текст сам и не навязываешь свой голос. Твоя задача — сделать авторскую интонацию живее, а не заменить собой.
 
       КАК ОСТАВЛЯТЬ ЗАМЕЧАНИЯ
-      Ты не редактируешь текст напрямую. Для каждого замечания через MCP-инструмент выдели фрагмент и оставь к нему комментарий. Давай конкретный вариант переформулировки, а не «переделать», и прикладывай его к комментарию как предложение-замену (параметр `suggestedText`): точный новый текст взамен выделенного фрагмента, обычным текстом без разметки — автор применит его одной кнопкой. Выделенный фрагмент должен встречаться в тексте ровно один раз; если он не уникален, расширь выделение контекстом. Помечай важность:
+      Ты не редактируешь текст напрямую. Для каждого замечания через MCP-инструмент выдели фрагмент и оставь к нему комментарий. Начинай комментарий с метки `[Стиль]`. Давай конкретный вариант переформулировки, а не «переделать». Помечай важность:
       - [Критично] — предложение непонятно или искажает смысл.
       - [Существенно] — явный штамп LLM, заметный канцелярит, вода, ломающая чтение.
       - [Незначительно] — стилистическое улучшение на вкус.
@@ -128,7 +126,7 @@ roles:
       - Не выдумываешь подтверждения. Если не можешь проверить — честно ставь [Не проверено] или [Непроверяемо].
 
       КАК ОСТАВЛЯТЬ ЗАМЕЧАНИЯ
-      Ты не редактируешь текст напрямую. Для каждого проблемного утверждения (ошибка, сомнение, непроверяемость) через MCP-инструмент выдели фрагмент и оставь комментарий; на верные факты комментарии не оставляй. В комментарии дай вердикт, исправление (если нужно) и источник. К вердикту [Неверно] всегда прикладывай готовое исправление как предложение-замену (параметр `suggestedText`): раз ты нашёл по источникам верное значение — сразу предлагай готовую правку, а не только описывай ошибку. Замена — это точный новый текст взамен выделенного фрагмента, обычным текстом без разметки; автор применит её одной кнопкой, не переписывая фрагмент вручную. Выделенный фрагмент должен встречаться в тексте ровно один раз; если он не уникален, расширь выделение контекстом. Когда проверяемая цифра, имя, термин или версия встречается по тексту несколько раз, сначала одним вызовом search_in_page найди все вхождения, а затем ставь целевой комментарий на каждое — не читая страницу поблочно. К вердиктам [Не проверено], [Непроверяемо] и [Это мнение] замену не прикладывай. Помечай важность:
+      Ты не редактируешь текст напрямую. Для каждого проблемного утверждения (ошибка, сомнение, непроверяемость) через MCP-инструмент выдели фрагмент и оставь комментарий; на верные факты комментарии не оставляй. Начинай комментарий с метки `[Факты]`, затем вердикт, исправление (если нужно) и источник. Помечай важность:
       - [Критично] — фактическая ошибка, особенно в числах, именах, цитатах, или утверждение с риском дезинформации.
       - [Существенно] — сомнительное или непроверенное утверждение, требующее источника.
       - [Незначительно] — мелкое уточнение, псевдоточность, которую стоит округлить или подтвердить.
@@ -169,17 +167,14 @@ roles:
       - Не проверяешь достоверность фактов — это фактчекер.
       - Не вносишь содержательных изменений. Правки — минимальные и механические.
 
-      КАК РАБОТАТЬ
-      Пройди весь текст от начала до конца за один проход. Помечай КАЖДОЕ нарушение, включая все повторные вхождения одной и той же ошибки и мелочи с меткой [Незначительно], — не ограничивайся первыми несколькими или самыми заметными. Не подводи итог вместо разбора: пока не дошёл до конца документа, работа не закончена. Один прогон покрывает весь текст, а не «самое важное». Для систематической ошибки, которая повторяется — прямые кавычки, «е» вместо «ё», дефис вместо тире, неединообразная единица или написание, — сначала одним вызовом search_in_page получи все вхождения, а затем оставь на каждом целевой комментарий с заменой, вместо поблочного просмотра.
-
       КАК ОСТАВЛЯТЬ ЗАМЕЧАНИЯ
-      Ты не редактируешь текст напрямую. Для каждой правки через MCP-инструмент выдели фрагмент и оставь комментарий с конкретным исправлением. К каждой правке прикладывай предложение-замену (параметр `suggestedText`): точный исправленный текст взамен выделенного фрагмента, обычным текстом без разметки — автор применит его одной кнопкой. Выделенный фрагмент должен встречаться в тексте ровно один раз; если он не уникален, расширь выделение контекстом. НЕ оставляй сводных замечаний вида «во всём тексте заменить X на Y» или «привести единицы/кавычки/написание к единообразию»: такой комментарий нельзя применить кнопкой. Если одна и та же ошибка встречается в нескольких местах, обойди КАЖДОЕ вхождение и оставь на нём отдельный целевой комментарий со своей заменой — десять точечных правок вместо одной общей. Единственное исключение — замечание, которое в принципе невозможно выразить заменой конкретного фрагмента; такие редкие случаи оставляй обычным комментарием без замены. Помечай важность:
+      Ты не редактируешь текст напрямую. Для каждой правки через MCP-инструмент выдели фрагмент и оставь комментарий с конкретным исправлением. Начинай комментарий с метки `[Корректура]`. Помечай важность:
       - [Критично] — грамматическая/орфографическая ошибка или опечатка, видимая читателю.
       - [Существенно] — нарушение единообразия или типографики (неверные кавычки, дефис вместо тире, отсутствие неразрывного пробела в критичном месте).
       - [Незначительно] — необязательная шлифовка.
 
       ТОН
-      По делу, без объяснений очевидного. Не сворачивай однотипные правки в одно сводное замечание «поменять везде» — разнеси их по конкретным местам: десять целевых комментариев с готовой заменой в каждом лучше одного общего, который нельзя применить кнопкой. Не бойся «плодить» комментарии: для корректора это норма.
+      По делу, без объяснений очевидного. Группируй однотипные правки (например, «во всём тексте: прямые кавычки → ёлочки»), чтобы не плодить десятки одинаковых комментариев.
 
       ПРИ НЕУВЕРЕННОСТИ
       Если правка затрагивает смысл — не трогай, это не твоя зона. Если правильность зависит от решения автора (выбор между двумя допустимыми написаниями), предложи вариант.
@@ -278,7 +273,7 @@ roles:
       Сначала прочитай весь текст и оцени его как историю целиком. Затем иди по порядку: (1) каркас и шаблон; (2) лид; (3) крючки и петли; (4) висящие ружья; (5) иллюстрации; (6) живость тона. Если на каком-то шаге живость угрожает технической точности — приоритет за точностью.
 
       ═══ КАК ОСТАВЛЯТЬ ЗАМЕЧАНИЯ ═══
-      Ты не редактируешь текст напрямую и не переписываешь его за автора. Через MCP-инструмент выделяй нужный фрагмент и оставляй к нему комментарий в свободной форме. Объясняй не только «что», но и «зачем» — какой эффект на читателя это даст. Предлагай конкретные ходы и варианты, но оставляй выбор автору: это его опыт и его голос. Если среди вариантов есть один готовый текст (например, новая формулировка лида), можешь приложить его к комментарию как предложение-замену (параметр `suggestedText`: точный новый текст взамен выделенного фрагмента, без разметки; фрагмент должен встречаться в тексте ровно один раз, иначе расширь выделение) — кнопка ничего не навязывает, автор волен не применять. Комментируй то, что усилит историю, а не каждую мелочь.
+      Ты не редактируешь текст напрямую и не переписываешь его за автора. Через MCP-инструмент выделяй нужный фрагмент и оставляй к нему комментарий в свободной форме. Объясняй не только «что», но и «зачем» — какой эффект на читателя это даст. Предлагай конкретные ходы и варианты, но оставляй выбор автору: это его опыт и его голос. Комментируй то, что усилит историю, а не каждую мелочь.
 
       ═══ ТОН ═══
       Уважительно, увлечённо, по-человечески. Ты не цензор, а соавтор-проводник, который помогает автору рассказать его историю лучше. Автор знает тему лучше тебя — твоя задача помочь ему её раскрыть.

agent-roles-catalog/index.yaml

@@ -12,15 +12,15 @@ bundles:
       - en
     roles:
       - slug: structural-editor
-        version: 4
-      - slug: line-editor
-        version: 4
-      - slug: fact-checker
-        version: 6
-      - slug: proofreader
-        version: 8
-      - slug: narrator
         version: 2
+      - slug: line-editor
+        version: 2
+      - slug: fact-checker
+        version: 3
+      - slug: proofreader
+        version: 3
+      - slug: narrator
+        version: 1
   - id: research
     name:
       ru: Исследование

agent-roles-catalog/scripts/content-hashes.json

@@ -1,26 +1,26 @@
 {
   "fact-checker": {
-    "version": 6,
+    "version": 3,
-    "hash": "6bb22a9e5a5079b5cb287b5b26addbd36b9afeb7c9508287dcad9343fc53d685"
+    "hash": "a94931fbd20272570a588c72159ac9e48a89c99bd8f718449cda5e7ca4280fdf"
   },
   "line-editor": {
-    "version": 4,
+    "version": 2,
-    "hash": "890d10f3f0bd7f2b2cfcc94463634221c557a3140e3794721748dc8d99979780"
+    "hash": "cca324110dc6f96d2a8a239a2fb95b0ba09fad5806c9b6090a3c210ea7883ceb"
   },
   "narrator": {
-    "version": 2,
+    "version": 1,
-    "hash": "66fe653003b4f63ef3c3a5c5c48552fe47daeefffc16907c37c35f0e8da98851"
+    "hash": "36b38785fea6ae1c70bf6fb6b29ae5278bb86e389e61f7b9736675a589fa434c"
   },
   "proofreader": {
-    "version": 8,
+    "version": 3,
-    "hash": "cef39fed321779631ddd1077fcba53399adf0e48b301df281c71eb042610900d"
+    "hash": "a36047c5cab837b2a727f63d4ddafc269b1fc44b90b365e770ecdb8f77e13952"
   },
   "researcher": {
     "version": 1,
     "hash": "853658fda43ddbe0a4d08f2c6e50b5116d29a2e9ccd7f46e173e65920d8f6ace"
   },
   "structural-editor": {
-    "version": 4,
+    "version": 2,
-    "hash": "89100e0a00b88daa0d2118fd98ec1c27d06b972bfc6ec58b705553a4daed85df"
+    "hash": "83093baa7262aef8193871a1afcf2b43b11a56fe2d00cade41355cf66d972b74"
   }
 }

apps/client/package.json

@@ -40,7 +40,6 @@
     "axios": "1.16.0",
     "blueimp-load-image": "5.16.0",
     "clsx": "2.1.1",
-    "diff": "8.0.3",
     "dompurify": "3.4.1",
     "file-saver": "2.0.5",
     "highlightjs-sap-abap": "0.3.0",
@@ -61,7 +60,6 @@
     "react-clear-modal": "^2.0.18",
     "react-dom": "^18.3.1",
     "react-drawio": "1.0.7",
-    "web-vitals": "^5.1.0",
     "react-error-boundary": "6.1.1",
     "react-helmet-async": "3.0.0",
     "react-i18next": "16.5.8",
@@ -83,7 +81,6 @@
     "@types/react": "18.3.12",
     "@types/react-dom": "18.3.1",
     "@vitejs/plugin-react": "6.0.1",
-    "@vitest/coverage-v8": "4.1.6",
     "eslint": "9.28.0",
     "eslint-plugin-react": "7.37.5",
     "eslint-plugin-react-hooks": "7.0.1",

apps/client/perf/ai-chat-perf-main.tsx

@@ -1,50 +0,0 @@
-/**
- * DEV-ONLY entry for the AI chat perf harness (served by the vite dev server at
- * /perf/ai-chat-perf.html; never part of the production build, which uses the
- * single default index.html entry).
- *
- * Mounts the minimal provider stack the real ChatThread needs (Mantine, router
- * for tool-card Links, react-query, i18n) and patches `window.fetch` BEFORE
- * React mounts so ChatThread's DefaultChatTransport requests to
- * /api/ai-chat/stream are answered by the synthetic SSE generator.
- */
-
-import "@mantine/core/styles.css";
-
-import ReactDOM from "react-dom/client";
-import { MantineProvider } from "@mantine/core";
-import { MemoryRouter } from "react-router-dom";
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { mantineCssResolver, theme } from "../src/theme.ts";
-// i18n side-effect init (http-backend). Translations load from /locales in dev;
-// missing keys fall back to the key text, which is fine for the harness.
-import "../src/i18n.ts";
-import { installAiChatStreamFetchPatch } from "./synthetic-turn.ts";
-import PerfHarness from "./harness.tsx";
-
-// MUST run before React mounts: ChatThread creates its transport with the
-// global fetch, so the patch has to be in place before the first send.
-installAiChatStreamFetchPatch();
-
-const queryClient = new QueryClient({
-  defaultOptions: {
-    queries: {
-      refetchOnMount: false,
-      refetchOnWindowFocus: false,
-      retry: false,
-      staleTime: 5 * 60 * 1000,
-    },
-  },
-});
-
-const container = document.getElementById("root") as HTMLElement;
-
-ReactDOM.createRoot(container).render(
-  <MemoryRouter>
-    <MantineProvider theme={theme} cssVariablesResolver={mantineCssResolver}>
-      <QueryClientProvider client={queryClient}>
-        <PerfHarness />
-      </QueryClientProvider>
-    </MantineProvider>
-  </MemoryRouter>,
-);

apps/client/perf/ai-chat-perf.html

@@ -1,12 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>AI chat perf harness</title>
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="./ai-chat-perf-main.tsx"></script>
-  </body>
-</html>

apps/client/perf/harness.tsx

@@ -1,390 +0,0 @@
-/**
- * DEV-ONLY perf harness UI for the AI chat feature.
- *
- * Left panel: controls + live stats. Right side: a bordered box (~real chat
- * window size) hosting the REAL ChatThread component.
- *
- * Scenario A "Open existing chat": mount ChatThread seeded with a large
- * persisted transcript and measure click -> post-mount-paint time.
- * Scenario B "Live agent stream": mount an empty chat and auto-send a message;
- * the fetch patch (see synthetic-turn.ts) answers with a synthetic SSE stream
- * through the real useChat pipeline.
- */
-
-import { useEffect, useMemo, useRef, useState } from "react";
-import type { CSSProperties, MutableRefObject } from "react";
-import ChatThread from "../src/features/ai-chat/components/chat-thread.tsx";
-import type { IAiChatMessageRow } from "../src/features/ai-chat/types/ai-chat.types.ts";
-import {
-  PRESETS,
-  buildPersistedRows,
-  buildTurnScript,
-  setLiveStreamSettings,
-  type PresetKey,
-} from "./synthetic-turn.ts";
-
-const AUTO_SEND_TEXT = "Run the synthetic perf turn";
-const AUTO_SEND_TIMEOUT_MS = 1000;
-/** Stats display refresh period — 2x/s so the display itself stays cheap. */
-const STATS_FLUSH_MS = 500;
-
-// ---------------------------------------------------------------------------
-// Shared mutable stats (written from callbacks, flushed to state at 2 Hz)
-// ---------------------------------------------------------------------------
-
-interface PerfStats {
-  longtaskCount: number;
-  longtaskTotalMs: number;
-  longtaskMaxMs: number;
-  fps: number;
-  sseChunks: number;
-  sseChars: number;
-  mountAMs: number | null;
-  streamState: "idle" | "streaming" | "done" | "aborted";
-}
-
-function emptyStats(): PerfStats {
-  return {
-    longtaskCount: 0,
-    longtaskTotalMs: 0,
-    longtaskMaxMs: 0,
-    fps: 0,
-    sseChunks: 0,
-    sseChars: 0,
-    mountAMs: null,
-    streamState: "idle",
-  };
-}
-
-/**
- * Self-contained stats panel: owns the longtask observer, the FPS meter and the
- * 2 Hz flush interval. Isolated in its OWN component so its periodic setState
- * re-renders only this panel — NOT the ChatThread under measurement.
- */
-function StatsPanel({ stats }: { stats: MutableRefObject<PerfStats> }) {
-  const [snapshot, setSnapshot] = useState<PerfStats>(() => ({ ...stats.current }));
-
-  // Long tasks (main-thread blocks > 50ms).
-  useEffect(() => {
-    let observer: PerformanceObserver | null = null;
-    try {
-      observer = new PerformanceObserver((list) => {
-        for (const entry of list.getEntries()) {
-          stats.current.longtaskCount += 1;
-          stats.current.longtaskTotalMs += entry.duration;
-          stats.current.longtaskMaxMs = Math.max(stats.current.longtaskMaxMs, entry.duration);
-        }
-      });
-      observer.observe({ type: "longtask", buffered: true });
-    } catch {
-      // longtask entries unsupported in this browser — panel shows zeros.
-    }
-    return () => observer?.disconnect();
-  }, [stats]);
-
-  // FPS: frames rendered within the trailing 1s window.
-  useEffect(() => {
-    let raf = 0;
-    const frames: number[] = [];
-    const loop = (now: number) => {
-      frames.push(now);
-      while (frames.length > 0 && frames[0] <= now - 1000) frames.shift();
-      stats.current.fps = frames.length;
-      raf = requestAnimationFrame(loop);
-    };
-    raf = requestAnimationFrame(loop);
-    return () => cancelAnimationFrame(raf);
-  }, [stats]);
-
-  // Flush the mutable stats into the display at most 2x/s.
-  useEffect(() => {
-    const id = window.setInterval(() => setSnapshot({ ...stats.current }), STATS_FLUSH_MS);
-    return () => window.clearInterval(id);
-  }, [stats]);
-
-  const resetLongtasks = () => {
-    stats.current.longtaskCount = 0;
-    stats.current.longtaskTotalMs = 0;
-    stats.current.longtaskMaxMs = 0;
-    setSnapshot({ ...stats.current });
-  };
-
-  const row: CSSProperties = { display: "flex", justifyContent: "space-between", gap: 8 };
-  return (
-    <div style={{ fontFamily: "monospace", fontSize: 12, lineHeight: 1.7 }}>
-      <div style={{ fontWeight: 700, marginBottom: 4 }}>Stats</div>
-      <div style={row}><span>FPS (1s)</span><span>{snapshot.fps}</span></div>
-      <div style={row}><span>Long tasks</span><span>{snapshot.longtaskCount}</span></div>
-      <div style={row}><span>Long total</span><span>{snapshot.longtaskTotalMs.toFixed(0)} ms</span></div>
-      <div style={row}><span>Long max</span><span>{snapshot.longtaskMaxMs.toFixed(0)} ms</span></div>
-      <div style={row}><span>SSE chunks</span><span>{snapshot.sseChunks}</span></div>
-      <div style={row}><span>SSE chars</span><span>{snapshot.sseChars.toLocaleString()}</span></div>
-      <div style={row}><span>Stream</span><span>{snapshot.streamState}</span></div>
-      <div style={row}>
-        <span>Mount A</span>
-        <span>{snapshot.mountAMs === null ? "—" : `${snapshot.mountAMs.toFixed(0)} ms`}</span>
-      </div>
-      <button type="button" onClick={resetLongtasks} style={{ marginTop: 6 }}>
-        Reset long tasks
-      </button>
-    </div>
-  );
-}
-
-// ---------------------------------------------------------------------------
-// Auto-send (scenario B): drive the REAL composer in the mounted DOM
-// ---------------------------------------------------------------------------
-
-/**
- * Fill the composer textarea via the native value setter + an `input` event
- * (React 18 controlled-input pattern), then click the enabled "Send" button.
- * Retried on rAF until the elements exist (ChatThread mounts asynchronously).
- */
-function autoSend(host: HTMLElement, text: string): void {
-  const deadline = performance.now() + AUTO_SEND_TIMEOUT_MS;
-
-  const tryClick = () => {
-    const button = host.querySelector<HTMLButtonElement>('button[aria-label="Send"]');
-    if (button && !button.disabled) {
-      button.click();
-      return;
-    }
-    if (performance.now() < deadline) requestAnimationFrame(tryClick);
-    else console.error("[perf] auto-send: Send button never became clickable");
-  };
-
-  const trySetValue = () => {
-    const textarea = host.querySelector("textarea");
-    if (!textarea) {
-      if (performance.now() < deadline) requestAnimationFrame(trySetValue);
-      else console.error("[perf] auto-send: textarea not found");
-      return;
-    }
-    const setter = Object.getOwnPropertyDescriptor(
-      window.HTMLTextAreaElement.prototype,
-      "value",
-    )?.set;
-    setter?.call(textarea, text);
-    textarea.dispatchEvent(new Event("input", { bubbles: true }));
-    // Click on a later frame so React commits the controlled value (which
-    // enables the Send button) before we press it.
-    requestAnimationFrame(tryClick);
-  };
-
-  requestAnimationFrame(trySetValue);
-}
-
-// ---------------------------------------------------------------------------
-// Harness
-// ---------------------------------------------------------------------------
-
-interface MountState {
-  mode: "A" | "B";
-  key: number;
-  chatId: string | null;
-  rows: IAiChatMessageRow[];
-}
-
-const noop = (): void => {};
-
-export default function PerfHarness() {
-  const [preset, setPreset] = useState<PresetKey>("20k");
-  const [intervalMs, setIntervalMs] = useState<number>(15);
-  const [mounted, setMounted] = useState<MountState | null>(null);
-  const [fixtureInfo, setFixtureInfo] = useState<string | null>(null);
-
-  const statsRef = useRef<PerfStats>(emptyStats());
-  const hostRef = useRef<HTMLDivElement>(null);
-  const keyCounterRef = useRef(0);
-  const mountStartRef = useRef(0);
-  const pendingMountMeasureRef = useRef(false);
-
-  // The scripted live turn for the current preset (reused across B runs; the
-  // script is immutable data, so rebuilding per run is unnecessary).
-  const liveScript = useMemo(() => buildTurnScript(PRESETS[preset], "live"), [preset]);
-
-  const openPage = useMemo(() => ({ id: "page-1", title: "Perf test page" }), []);
-
-  // Scenario A: mount ChatThread seeded with a large persisted transcript.
-  const handleMountA = () => {
-    const fixture = buildPersistedRows(PRESETS[preset]);
-    setFixtureInfo(
-      `Persisted fixture: ${fixture.rows.length} rows, ` +
-        `${fixture.totalChars.toLocaleString()} chars ≈ ${fixture.approxTokens.toLocaleString()} tokens`,
-    );
-    statsRef.current.mountAMs = null;
-    // Mark AFTER fixture generation: we measure mount cost, not generation cost
-    // (production receives its rows from the network).
-    performance.mark("perf:mountA:start");
-    mountStartRef.current = performance.now();
-    pendingMountMeasureRef.current = true;
-    keyCounterRef.current += 1;
-    setMounted({ mode: "A", key: keyCounterRef.current, chatId: "perf-chat", rows: fixture.rows });
-  };
-
-  // Measure scenario A: effect runs after the mount commit; double rAF lands
-  // after the first paint of the mounted transcript.
-  useEffect(() => {
-    if (!pendingMountMeasureRef.current) return;
-    pendingMountMeasureRef.current = false;
-    requestAnimationFrame(() => {
-      requestAnimationFrame(() => {
-        statsRef.current.mountAMs = performance.now() - mountStartRef.current;
-        performance.mark("perf:mountA:end");
-        try {
-          performance.measure("perf:mountA", "perf:mountA:start", "perf:mountA:end");
-        } catch {
-          // Marks cleared mid-run — ignore.
-        }
-      });
-    });
-  }, [mounted]);
-
-  // Scenario B: mount an empty chat, arm the synthetic stream, auto-send.
-  const handleStartB = () => {
-    statsRef.current.sseChunks = 0;
-    statsRef.current.sseChars = 0;
-    statsRef.current.streamState = "streaming";
-    setLiveStreamSettings({
-      script: liveScript,
-      chunkIntervalMs: intervalMs,
-      onProgress: (chunks, chars) => {
-        statsRef.current.sseChunks = chunks;
-        statsRef.current.sseChars = chars;
-      },
-      onDone: () => {
-        statsRef.current.streamState = "done";
-        performance.mark("perf:streamB:end");
-        try {
-          performance.measure("perf:streamB", "perf:streamB:start", "perf:streamB:end");
-        } catch {
-          // Start mark missing (e.g. marks cleared) — ignore.
-        }
-      },
-      onAbort: () => {
-        statsRef.current.streamState = "aborted";
-      },
-    });
-    performance.mark("perf:streamB:start");
-    keyCounterRef.current += 1;
-    setMounted({ mode: "B", key: keyCounterRef.current, chatId: null, rows: [] });
-    if (hostRef.current) autoSend(hostRef.current, AUTO_SEND_TEXT);
-  };
-
-  const handleUnmount = () => setMounted(null);
-
-  const label: CSSProperties = { display: "block", fontSize: 12, margin: "10px 0 2px" };
-  const button: CSSProperties = { display: "block", width: "100%", margin: "6px 0", padding: "6px 8px" };
-
-  return (
-    <div style={{ display: "flex", height: "100vh", fontFamily: "system-ui, sans-serif" }}>
-      {/* Left: controls + stats */}
-      <div
-        style={{
-          width: 260,
-          flex: "0 0 260px",
-          padding: 12,
-          borderRight: "1px solid #ccc",
-          overflowY: "auto",
-          boxSizing: "border-box",
-        }}
-      >
-        <div style={{ fontWeight: 700, marginBottom: 4 }}>AI chat perf harness</div>
-
-        <label style={label}>Preset</label>
-        <select
-          value={preset}
-          onChange={(e) => setPreset(e.target.value as PresetKey)}
-          style={{ width: "100%" }}
-        >
-          <option value="5k">5k tokens</option>
-          <option value="20k">20k tokens</option>
-          <option value="50k">50k tokens</option>
-        </select>
-
-        <label style={label}>Chunk interval (scenario B)</label>
-        <select
-          value={intervalMs}
-          onChange={(e) => setIntervalMs(Number(e.target.value))}
-          style={{ width: "100%" }}
-        >
-          <option value={15}>15 ms (normal)</option>
-          <option value={5}>5 ms (stress)</option>
-        </select>
-
-        <div style={{ marginTop: 12 }}>
-          <button type="button" style={button} onClick={handleMountA}>
-            Mount persisted chat (A)
-          </button>
-          <button type="button" style={button} onClick={handleStartB}>
-            Start live stream (B)
-          </button>
-          <button type="button" style={button} onClick={handleUnmount} disabled={!mounted}>
-            Unmount
-          </button>
-        </div>
-
-        <div style={{ fontSize: 11, color: "#555", margin: "8px 0" }}>
-          <div>
-            Live turn: {liveScript.totalChars.toLocaleString()} chars ≈{" "}
-            {liveScript.approxTokens.toLocaleString()} tokens
-          </div>
-          {fixtureInfo && <div>{fixtureInfo}</div>}
-          {mounted && (
-            <div>
-              Mounted: scenario {mounted.mode} (key {mounted.key})
-            </div>
-          )}
-        </div>
-
-        <hr style={{ border: "none", borderTop: "1px solid #ddd" }} />
-        <StatsPanel stats={statsRef} />
-      </div>
-
-      {/* Right: the real ChatThread inside a real-window-sized box */}
-      <div
-        style={{
-          flex: 1,
-          display: "flex",
-          alignItems: "center",
-          justifyContent: "center",
-          background: "#f4f4f5",
-        }}
-      >
-        <div
-          ref={hostRef}
-          style={{
-            width: 540,
-            height: 680,
-            border: "1px solid #bbb",
-            borderRadius: 8,
-            background: "#fff",
-            padding: 8,
-            boxSizing: "border-box",
-            overflow: "hidden",
-          }}
-        >
-          {mounted ? (
-            <ChatThread
-              key={mounted.key}
-              chatId={mounted.chatId}
-              threadKey={`perf-${mounted.key}`}
-              initialRows={mounted.rows}
-              openPage={openPage}
-              roleId={null}
-              roles={[]}
-              onRolePicked={noop}
-              assistantName="Perf agent"
-              onTurnFinished={noop}
-              onServerChatId={noop}
-            />
-          ) : (
-            <div style={{ color: "#888", fontSize: 13, padding: 16 }}>
-              ChatThread unmounted. Use the controls on the left.
-            </div>
-          )}
-        </div>
-      </div>
-    </div>
-  );
-}

apps/client/perf/synthetic-turn.ts

@@ -1,517 +0,0 @@
-/**
- * DEV-ONLY synthetic agent-turn generator for the AI chat perf harness.
- *
- * Produces one scripted agent turn (reasoning + tool calls + markdown answer)
- * from a size config, and materializes it two ways:
- *  - as an AI SDK v6 UI-message SSE stream (scenario B "live agent stream"),
- *    served by a `window.fetch` patch that intercepts `/api/ai-chat/stream`;
- *  - as persisted `IAiChatMessageRow[]` history (scenario A "open existing chat").
- *
- * Wire format verified against the installed ai@6.0.207 `uiMessageChunkSchema`
- * (strict objects — only the exact field names below are accepted).
- */
-
-import type { UIMessage } from "@ai-sdk/react";
-import type { IAiChatMessageRow } from "../src/features/ai-chat/types/ai-chat.types.ts";
-
-// ---------------------------------------------------------------------------
-// Config / presets
-// ---------------------------------------------------------------------------
-
-/** 1 token ~= 4 chars — the approximation used throughout this module. */
-const CHARS_PER_TOKEN = 4;
-
-export interface TurnConfig {
-  /** Number of agent steps; each step = one reasoning block + one tool call. */
-  steps: number;
-  /** Approximate reasoning tokens generated per step. */
-  reasoningTokensPerStep: number;
-  /** Size of each tool call's output `content` filler, in bytes (ASCII). */
-  toolOutputBytes: number;
-  /** Approximate size of the final markdown answer, in tokens. */
-  answerTokens: number;
-}
-
-export type PresetKey = "5k" | "20k" | "50k";
-
-export const PRESETS: Record<PresetKey, TurnConfig> = {
-  "5k": {
-    steps: 3,
-    reasoningTokensPerStep: 500,
-    toolOutputBytes: 10_000,
-    answerTokens: 600,
-  },
-  "20k": {
-    steps: 6,
-    reasoningTokensPerStep: 2500,
-    toolOutputBytes: 20_000,
-    answerTokens: 1500,
-  },
-  "50k": {
-    steps: 10,
-    reasoningTokensPerStep: 4000,
-    toolOutputBytes: 40_000,
-    answerTokens: 3000,
-  },
-};
-
-// ---------------------------------------------------------------------------
-// Text generators
-// ---------------------------------------------------------------------------
-
-/** Mixed Russian/English prose sentences cycled to build reasoning text. */
-const REASONING_SENTENCES = [
-  "Пользователь просит проанализировать документ и выделить ключевые тезисы по каждому разделу.",
-  "First I need to inspect the current page content to understand its overall structure.",
-  "Судя по оглавлению, раздел с техническими требованиями находится ближе к концу документа.",
-  "The table in section three contains the migration matrix that I should cross-check against the summary.",
-  "Проверю, нет ли противоречий между описанием API и приведёнными в тексте примерами вызовов.",
-  "Let me compare the numbers from the executive summary with the raw data in the appendix.",
-  "Похоже, автор использует термины «воркспейс» и workspace взаимозаменяемо — это стоит нормализовать.",
-  "I should keep the page ids from the tool output so the final answer can cite the source pages.",
-  "Осталось свести найденные несоответствия в одну таблицу и предложить порядок исправлений.",
-  "The remaining sections look consistent, so I can move on to drafting the structured answer.",
-];
-
-/**
- * Build realistic prose of ~`targetChars` characters, inserting a newline
- * roughly every 200 characters (mirrors how reasoning text tends to wrap).
- */
-function makeProse(targetChars: number): string {
-  const pieces: string[] = [];
-  let length = 0;
-  let sinceNewline = 0;
-  let i = 0;
-  while (length < targetChars) {
-    const sentence = REASONING_SENTENCES[i % REASONING_SENTENCES.length];
-    i += 1;
-    pieces.push(sentence);
-    length += sentence.length + 1;
-    sinceNewline += sentence.length + 1;
-    if (sinceNewline >= 200) {
-      pieces.push("\n");
-      sinceNewline = 0;
-    } else {
-      pieces.push(" ");
-    }
-  }
-  return pieces.join("").trimEnd();
-}
-
-/** One markdown section (~700 chars): heading, prose, bullets, GFM table, code. */
-function markdownSection(n: number): string {
-  return [
-    `## Section ${n}: migration analysis`,
-    ``,
-    `The workspace contains **${n * 12} pages** that still reference the legacy API. ` +
-      `Most of them live under [Perf test page](/p/page-1) and need the new transport. ` +
-      `Ниже приведена сводка по разделу с оценкой трудозатрат и основных рисков.`,
-    ``,
-    `- Update the fetch layer to the v6 transport`,
-    `- Перенести таблицы соответствия идентификаторов`,
-    `- Verify citation links after the move`,
-    `- Проверить отображение длинных ответов в узкой панели`,
-    ``,
-    `| Область | Страниц | Статус | Риск |`,
-    `| --- | --- | --- | --- |`,
-    `| API reference | ${n + 4} | migrated | low |`,
-    `| Onboarding | ${n + 2} | in progress | medium |`,
-    `| Release notes | ${n * 3} | pending | high |`,
-    ``,
-    "```ts",
-    `export function migrateSection${n}(rows: Row[]): Row[] {`,
-    `  return rows`,
-    `    .filter((row) => row.section === ${n})`,
-    `    .map((row) => ({ ...row, migrated: true }));`,
-    `}`,
-    "```",
-  ].join("\n");
-}
-
-/** Realistic markdown answer of ~`targetChars` chars (sections repeated to size). */
-function makeMarkdownAnswer(targetChars: number): string {
-  const sections: string[] = [];
-  let length = 0;
-  let n = 1;
-  while (length < targetChars) {
-    const section = markdownSection(n);
-    sections.push(section);
-    length += section.length + 2;
-    n += 1;
-  }
-  return sections.join("\n\n");
-}
-
-/** Plain ASCII filler of exactly `bytes` characters for tool outputs. */
-function makeFiller(bytes: number): string {
-  const unit = "Perf filler content for the synthetic getPage tool output. ";
-  return unit.repeat(Math.ceil(bytes / unit.length)).slice(0, bytes);
-}
-
-// ---------------------------------------------------------------------------
-// Turn script
-// ---------------------------------------------------------------------------
-
-export interface TurnToolCall {
-  toolCallId: string;
-  toolName: "getPage";
-  input: { pageId: string };
-  output: { id: string; title: string; content: string };
-}
-
-export interface TurnStep {
-  reasoningText: string;
-  tool: TurnToolCall;
-}
-
-export interface TurnScript {
-  steps: TurnStep[];
-  answerText: string;
-  /** Approximate reasoning tokens for the whole turn (chars / 4). */
-  reasoningTokens: number;
-  /** Approximate context size after this turn, in tokens. */
-  contextTokens: number;
-  maxContextTokens: number;
-  /** Actual generated visible chars: reasoning + tool outputs + answer. */
-  totalChars: number;
-  /** totalChars / 4, rounded. */
-  approxTokens: number;
-}
-
-/**
- * Build the scripted agent turn for a config. `idPrefix` keeps tool call ids
- * unique when several scripts coexist (e.g. 3 persisted turns in one chat).
- */
-export function buildTurnScript(config: TurnConfig, idPrefix = "live"): TurnScript {
-  const steps: TurnStep[] = [];
-  let reasoningChars = 0;
-  let toolChars = 0;
-  for (let i = 0; i < config.steps; i++) {
-    const reasoningText = makeProse(config.reasoningTokensPerStep * CHARS_PER_TOKEN);
-    const content = makeFiller(config.toolOutputBytes);
-    reasoningChars += reasoningText.length;
-    toolChars += content.length;
-    steps.push({
-      reasoningText,
-      tool: {
-        toolCallId: `${idPrefix}-call-${i + 1}`,
-        toolName: "getPage",
-        input: { pageId: "page-1" },
-        output: { id: "page-1", title: "Perf test page", content },
-      },
-    });
-  }
-  const answerText = makeMarkdownAnswer(config.answerTokens * CHARS_PER_TOKEN);
-  const totalChars = reasoningChars + toolChars + answerText.length;
-  return {
-    steps,
-    answerText,
-    reasoningTokens: Math.round(reasoningChars / CHARS_PER_TOKEN),
-    contextTokens: Math.round(totalChars / CHARS_PER_TOKEN),
-    maxContextTokens: 200_000,
-    totalChars,
-    approxTokens: Math.round(totalChars / CHARS_PER_TOKEN),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Scenario A: persisted rows
-// ---------------------------------------------------------------------------
-
-/** Number of user+assistant pairs the preset is split across for history. */
-const HISTORY_TURNS = 3;
-
-const USER_PROMPTS = [
-  "Проанализируй документ и выдели ключевые тезисы по каждому разделу.",
-  "Now cross-check the migration matrix against the summary and list every mismatch.",
-  "Собери финальный план миграции с оценкой рисков по каждой области.",
-];
-
-/** Persisted UIMessage parts for one finished assistant turn. */
-function scriptToPersistedParts(script: TurnScript): UIMessage["parts"] {
-  const parts: unknown[] = [];
-  for (const step of script.steps) {
-    parts.push({ type: "reasoning", text: step.reasoningText, state: "done" });
-    parts.push({
-      type: `tool-${step.tool.toolName}`,
-      toolCallId: step.tool.toolCallId,
-      state: "output-available",
-      input: step.tool.input,
-      output: step.tool.output,
-    });
-  }
-  parts.push({ type: "text", text: script.answerText, state: "done" });
-  return parts as UIMessage["parts"];
-}
-
-export interface PersistedFixture {
-  rows: IAiChatMessageRow[];
-  totalChars: number;
-  approxTokens: number;
-}
-
-/**
- * Materialize the preset as a finished 3-turn transcript: user row + assistant
- * row per turn, with the preset's steps/answer split across the assistant turns.
- * Approximate accounting — the actual totals are reported back for display.
- */
-export function buildPersistedRows(config: TurnConfig): PersistedFixture {
-  const rows: IAiChatMessageRow[] = [];
-  const baseTime = Date.now() - HISTORY_TURNS * 60_000;
-  let totalChars = 0;
-
-  for (let t = 0; t < HISTORY_TURNS; t++) {
-    // Distribute steps as evenly as possible (earlier turns get the remainder).
-    const stepsForTurn =
-      Math.floor(config.steps / HISTORY_TURNS) +
-      (t < config.steps % HISTORY_TURNS ? 1 : 0);
-    const turnConfig: TurnConfig = {
-      steps: Math.max(1, stepsForTurn),
-      reasoningTokensPerStep: config.reasoningTokensPerStep,
-      toolOutputBytes: config.toolOutputBytes,
-      answerTokens: Math.max(50, Math.round(config.answerTokens / HISTORY_TURNS)),
-    };
-    const script = buildTurnScript(turnConfig, `hist-${t + 1}`);
-    totalChars += script.totalChars;
-
-    const userText = USER_PROMPTS[t % USER_PROMPTS.length];
-    rows.push({
-      id: `perf-row-u${t + 1}`,
-      role: "user",
-      content: userText,
-      metadata: null,
-      createdAt: new Date(baseTime + t * 60_000).toISOString(),
-    });
-    rows.push({
-      id: `perf-row-a${t + 1}`,
-      role: "assistant",
-      content: script.answerText,
-      metadata: {
-        parts: scriptToPersistedParts(script),
-        usage: { reasoningTokens: script.reasoningTokens },
-        contextTokens: script.contextTokens,
-        maxContextTokens: script.maxContextTokens,
-        finishReason: "stop",
-      },
-      createdAt: new Date(baseTime + t * 60_000 + 30_000).toISOString(),
-    });
-  }
-
-  return {
-    rows,
-    totalChars,
-    approxTokens: Math.round(totalChars / CHARS_PER_TOKEN),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Scenario B: SSE stream
-// ---------------------------------------------------------------------------
-
-/** Streaming delta size in chars (reasoning/answer text is split into these). */
-const DELTA_CHARS = 200;
-
-function splitDeltas(text: string, size = DELTA_CHARS): string[] {
-  const deltas: string[] = [];
-  for (let i = 0; i < text.length; i += size) {
-    deltas.push(text.slice(i, i + size));
-  }
-  return deltas;
-}
-
-/** One pre-serialized SSE frame plus its visible-char contribution for stats. */
-interface SseFrame {
-  data: string;
-  chars: number;
-}
-
-function frame(chunk: Record<string, unknown>, chars = 0): SseFrame {
-  return { data: `data: ${JSON.stringify(chunk)}\n\n`, chars };
-}
-
-/**
- * Serialize the whole scripted turn into AI SDK v6 UI-message SSE frames
- * (excluding the final `data: [DONE]` terminator, appended by the pump).
- */
-function buildSseFrames(script: TurnScript, messageId: string, chatId: string): SseFrame[] {
-  const frames: SseFrame[] = [];
-  frames.push(frame({ type: "start", messageId, messageMetadata: { chatId } }));
-
-  script.steps.forEach((step, i) => {
-    frames.push(frame({ type: "start-step" }));
-    const reasoningId = `${messageId}-r${i + 1}`;
-    frames.push(frame({ type: "reasoning-start", id: reasoningId }));
-    for (const delta of splitDeltas(step.reasoningText)) {
-      frames.push(frame({ type: "reasoning-delta", id: reasoningId, delta }, delta.length));
-    }
-    frames.push(frame({ type: "reasoning-end", id: reasoningId }));
-
-    const { toolCallId, toolName, input, output } = step.tool;
-    frames.push(frame({ type: "tool-input-start", toolCallId, toolName }));
-    frames.push(frame({ type: "tool-input-available", toolCallId, toolName, input }));
-    // The tool result arrives as ONE chunk, like the real server sends it.
-    frames.push(frame({ type: "tool-output-available", toolCallId, output }, output.content.length));
-    frames.push(frame({ type: "finish-step" }));
-  });
-
-  // Final step: the markdown answer.
-  frames.push(frame({ type: "start-step" }));
-  const textId = `${messageId}-answer`;
-  frames.push(frame({ type: "text-start", id: textId }));
-  for (const delta of splitDeltas(script.answerText)) {
-    frames.push(frame({ type: "text-delta", id: textId, delta }, delta.length));
-  }
-  frames.push(frame({ type: "text-end", id: textId }));
-  frames.push(frame({ type: "finish-step" }));
-
-  frames.push(
-    frame({
-      type: "finish",
-      messageMetadata: {
-        usage: { reasoningTokens: script.reasoningTokens },
-        contextTokens: script.contextTokens,
-        maxContextTokens: script.maxContextTokens,
-        finishReason: "stop",
-      },
-    }),
-  );
-  return frames;
-}
-
-export interface LiveStreamSettings {
-  script: TurnScript;
-  /** Delay between SSE chunks (one chunk per tick). */
-  chunkIntervalMs: number;
-  /** Progress callback: cumulative emitted chunk count and visible chars. */
-  onProgress?: (chunks: number, chars: number) => void;
-  /** Fired once after the `[DONE]` terminator is enqueued. */
-  onDone?: () => void;
-  /** Fired if the client aborted the stream (Stop button). */
-  onAbort?: () => void;
-}
-
-/**
- * Build a synthetic SSE Response streaming the scripted turn, one chunk every
- * `chunkIntervalMs`. Honors the fetch `AbortSignal` so the real Stop button works.
- */
-export function buildSseResponse(
-  settings: LiveStreamSettings,
-  signal?: AbortSignal | null,
-): Response {
-  const messageId = `m-live-${Date.now()}`;
-  const frames = buildSseFrames(settings.script, messageId, "perf-chat");
-  const encoder = new TextEncoder();
-  let index = 0;
-  let emittedChars = 0;
-  let timer: number | undefined;
-
-  const stream = new ReadableStream<Uint8Array>({
-    start(controller) {
-      const stopPump = () => {
-        if (timer !== undefined) {
-          clearTimeout(timer);
-          timer = undefined;
-        }
-      };
-      const pump = () => {
-        timer = undefined;
-        if (signal?.aborted) {
-          stopPump();
-          try {
-            controller.close();
-          } catch {
-            // Already closed/cancelled — nothing to do.
-          }
-          return;
-        }
-        if (index >= frames.length) {
-          try {
-            controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-            controller.close();
-          } catch {
-            // Cancelled mid-flight.
-          }
-          settings.onDone?.();
-          return;
-        }
-        const next = frames[index];
-        index += 1;
-        try {
-          controller.enqueue(encoder.encode(next.data));
-        } catch {
-          stopPump();
-          return;
-        }
-        emittedChars += next.chars;
-        settings.onProgress?.(index, emittedChars);
-        timer = window.setTimeout(pump, settings.chunkIntervalMs);
-      };
-      signal?.addEventListener(
-        "abort",
-        () => {
-          stopPump();
-          try {
-            controller.close();
-          } catch {
-            // Reader already cancelled.
-          }
-          settings.onAbort?.();
-        },
-        { once: true },
-      );
-      timer = window.setTimeout(pump, settings.chunkIntervalMs);
-    },
-    cancel() {
-      if (timer !== undefined) {
-        clearTimeout(timer);
-        timer = undefined;
-      }
-    },
-  });
-
-  return new Response(stream, {
-    status: 200,
-    headers: {
-      "content-type": "text/event-stream",
-      "cache-control": "no-cache",
-      "x-vercel-ai-ui-message-stream": "v1",
-    },
-  });
-}
-
-// ---------------------------------------------------------------------------
-// window.fetch patch
-// ---------------------------------------------------------------------------
-
-let currentLiveSettings: LiveStreamSettings | null = null;
-
-/** Arm the next `/api/ai-chat/stream` request with a scripted turn. */
-export function setLiveStreamSettings(settings: LiveStreamSettings): void {
-  currentLiveSettings = settings;
-}
-
-/**
- * Patch `window.fetch` BEFORE React mounts: requests to `/api/ai-chat/stream`
- * get the synthetic SSE Response; everything else passes through untouched.
- */
-export function installAiChatStreamFetchPatch(): void {
-  const originalFetch = window.fetch.bind(window);
-  window.fetch = (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
-    const url =
-      typeof input === "string"
-        ? input
-        : input instanceof URL
-          ? input.href
-          : input.url;
-    if (url.includes("/api/ai-chat/stream")) {
-      const settings = currentLiveSettings;
-      if (!settings) {
-        return Promise.resolve(
-          new Response("perf harness: no live stream configured", { status: 500 }),
-        );
-      }
-      return Promise.resolve(buildSseResponse(settings, init?.signal ?? null));
-    }
-    return originalFetch(input, init);
-  };
-}

apps/client/public/locales/en-US/translation.json

@@ -1274,10 +1274,6 @@
   "Voice dictation is not configured": "Voice dictation is not configured",
   "Microphone is unavailable or already in use": "Microphone is unavailable or already in use",
   "Audio recording is not available in this browser/context": "Audio recording is not available in this browser/context",
-  "Dictation": "Dictation",
-  "Dictation becomes available once the page finishes connecting": "Dictation becomes available once the page finishes connecting",
-  "No connection to the collaboration server — dictation unavailable": "No connection to the collaboration server — dictation unavailable",
-  "This page is read-only": "This page is read-only",
   "Request format": "Request format",
   "How transcription requests are sent to the endpoint": "How transcription requests are sent to the endpoint",
   "OpenAI-compatible (multipart/form-data)": "OpenAI-compatible (multipart/form-data)",
@@ -1377,13 +1373,5 @@
   "Updated to the latest version": "Updated to the latest version",
   "This role is no longer in the catalog": "This role is no longer in the catalog",
   "This language is no longer available in the catalog": "This language is no longer available in the catalog",
-  "Connecting… (read-only)": "Connecting… (read-only)",
+  "Connecting… (read-only)": "Connecting… (read-only)"
-  "Apply": "Apply",
-  "Applied": "Applied",
-  "Suggestion applied": "Suggestion applied",
-  "Failed to apply suggestion": "Failed to apply suggestion",
-  "The commented text changed since this suggestion was made; it was not applied.": "The commented text changed since this suggestion was made; it was not applied.",
-  "Dismiss": "Dismiss",
-  "Suggestion dismissed": "Suggestion dismissed",
-  "Failed to dismiss suggestion": "Failed to dismiss suggestion"
 }

apps/client/public/locales/ru-RU/translation.json

@@ -393,17 +393,6 @@
   "No speech detected": "Речь не распознана",
   "Transcription failed": "Не удалось распознать речь",
   "Voice dictation is not configured": "Голосовой ввод не настроен",
-  "Start dictation": "Начать диктовку",
-  "Stop recording": "Остановить запись",
-  "Microphone access denied": "Доступ к микрофону запрещён",
-  "No microphone found": "Микрофон не найден",
-  "Microphone is unavailable or already in use": "Микрофон недоступен или уже используется",
-  "Could not start recording": "Не удалось начать запись",
-  "Audio recording is not available in this browser/context": "Запись аудио недоступна в этом браузере/контексте",
-  "Dictation": "Диктовка",
-  "Dictation becomes available once the page finishes connecting": "Диктовка станет доступна после подключения к документу",
-  "No connection to the collaboration server — dictation unavailable": "Нет связи с сервером совместного редактирования — диктовка недоступна",
-  "This page is read-only": "Страница открыта только для чтения",
   "Embed PDF": "Встроить PDF",
   "Upload and embed a PDF file.": "Загрузите и встроите PDF-файл.",
   "Embed as PDF": "Встроить как PDF",
@@ -1240,13 +1229,5 @@
   "Updated to the latest version": "Обновлено до последней версии",
   "This role is no longer in the catalog": "Эта роль больше не представлена в каталоге",
   "This language is no longer available in the catalog": "Этот язык больше не доступен в каталоге",
-  "Connecting… (read-only)": "Подключение… (только чтение)",
+  "Connecting… (read-only)": "Подключение… (только чтение)"
-  "Apply": "Применить",
-  "Applied": "Применено",
-  "Suggestion applied": "Предложение применено",
-  "Failed to apply suggestion": "Не удалось применить предложение",
-  "The commented text changed since this suggestion was made; it was not applied.": "Прокомментированный текст изменился после создания предложения; оно не было применено.",
-  "Dismiss": "Не применять",
-  "Suggestion dismissed": "Предложение отклонено",
-  "Failed to dismiss suggestion": "Не удалось отклонить предложение"
 }

apps/client/src/components/ui/agent-avatar-stack.test.tsx

@@ -3,7 +3,6 @@ import { render, screen, fireEvent } from "@testing-library/react";
 import { MantineProvider } from "@mantine/core";
 import { Provider, createStore } from "jotai";
 import { AgentAvatarStack } from "./agent-avatar-stack";
-import { avatarStyle } from "@/lib/avatar-palette";
 import {
   activeAiChatIdAtom,
   aiChatWindowOpenAtom,
@@ -14,18 +13,6 @@ import {
 
 type Props = React.ComponentProps<typeof AgentAvatarStack>;
 
-// The DOM normalizes an inline hex `background-color` to `rgb(...)`. Push the
-// expected color through the same CSSOM path so the comparison stays exact and
-// non-vacuous (an empty string — i.e. no inline background, as in the pre-fix
-// Avatar approach — can never match a real color). NOTE: jsdom's CSSOM does not
-// round-trip a `linear-gradient` in the `background` shorthand, which is why the
-// glyph carries an explicit solid `background-color` we assert on here.
-function normalizeColor(value: string): string {
-  const probe = document.createElement("div");
-  probe.style.backgroundColor = value;
-  return probe.style.backgroundColor;
-}
-
 function renderStack(props: Props) {
   const store = createStore();
   store.set(aiChatDraftAtom, "leftover draft from another chat");
@@ -40,7 +27,7 @@ function renderStack(props: Props) {
 }
 
 describe("AgentAvatarStack", () => {
-  it("internal chat WITH role: emoji glyph + human launcher badge in front", () => {
+  it("internal chat WITH role: emoji glyph in front + human launcher behind", () => {
     const { container } = renderStack({
       agent: { name: "Researcher", emoji: "🔬", avatarUrl: null },
       launcher: { name: "Alice", avatarUrl: null },
@@ -56,57 +43,6 @@ describe("AgentAvatarStack", () => {
     expect(screen.getByText("Alice")).toBeDefined();
   });
 
-  it("emoji glyph applies its per-agent gradient as an inline DOM background", () => {
-    // Pins the actual fix: the hashed gradient must reach the DOM as an inline
-    // `background` on the glyph Box. The pre-fix `Avatar variant="filled"` set no
-    // inline background (Mantine's --avatar-bg overrode it), so this fails there.
-    const agent = { name: "Researcher", emoji: "🔬", avatarUrl: null };
-    const { container } = renderStack({
-      agent,
-      launcher: { name: "Alice", avatarUrl: null },
-      aiChatId: "chat-1",
-    });
-
-    const glyph = container.querySelector<HTMLElement>(
-      '[data-testid="agent-glyph"]',
-    );
-    expect(glyph).not.toBeNull();
-    const expected = normalizeColor(avatarStyle(agent.name).bg);
-    // Non-vacuous: the pre-fix Avatar set no inline background at all.
-    expect(expected).not.toBe("");
-    expect(glyph!.style.backgroundColor).toBe(expected);
-    // (The gradient overlay is a browser-only enhancement — jsdom's CSSOM does
-    // not round-trip linear-gradient — so its stops/angle are covered by the
-    // avatarStyle unit tests above, not asserted on the DOM here.)
-  });
-
-  it("agents with distinct styles reach the DOM as distinct backgrounds", () => {
-    // "Researcher" and "Нарратор" hash to different palette entries, so their
-    // applied DOM backgrounds must differ — pins "distinct colors reach the DOM".
-    expect(avatarStyle("Researcher").bg).not.toBe(avatarStyle("Нарратор").bg);
-
-    const a = renderStack({
-      agent: { name: "Researcher", emoji: "🔬", avatarUrl: null },
-      launcher: null,
-      aiChatId: null,
-    });
-    const b = renderStack({
-      agent: { name: "Нарратор", emoji: "📖", avatarUrl: null },
-      launcher: null,
-      aiChatId: null,
-    });
-
-    const glyphA = a.container.querySelector<HTMLElement>(
-      '[data-testid="agent-glyph"]',
-    );
-    const glyphB = b.container.querySelector<HTMLElement>(
-      '[data-testid="agent-glyph"]',
-    );
-    expect(glyphA!.style.backgroundColor).not.toBe("");
-    // Different base colors reach the DOM (the serialized rgb values differ).
-    expect(glyphA!.style.backgroundColor).not.toBe(glyphB!.style.backgroundColor);
-  });
-
   it("showName=false: renders only the avatars, no inline name label", () => {
     renderStack({
       agent: { name: "Researcher", emoji: "🔬", avatarUrl: null },
@@ -138,7 +74,7 @@ describe("AgentAvatarStack", () => {
     expect(screen.getByText("Bob")).toBeDefined();
   });
 
-  it("external MCP: agent avatar only, NO human launcher badge", () => {
+  it("external MCP: agent avatar in front, NO launcher behind", () => {
     const { container } = renderStack({
       agent: { name: "MCP Bot", avatarUrl: "http://example.test/a.png" },
       launcher: null,

apps/client/src/components/ui/agent-avatar-stack.tsx

@@ -1,10 +1,9 @@
-import { Box, Group, Text, Tooltip } from "@mantine/core";
+import { Avatar, Box, Group, Text, Tooltip } from "@mantine/core";
 import { IconSparkles } from "@tabler/icons-react";
 import { useCallback } from "react";
 import { useTranslation } from "react-i18next";
 import { useSetAtom } from "jotai";
 import { CustomAvatar } from "@/components/ui/custom-avatar.tsx";
-import { avatarStyle, avatarBackgroundCss } from "@/lib/avatar-palette";
 import {
   activeAiChatIdAtom,
   aiChatWindowOpenAtom,
@@ -24,17 +23,19 @@ export interface LauncherInfo {
   avatarUrl?: string | null;
 }
 
+// Same violet token as the former AiAgentBadge (which used color="violet").
+const AGENT_COLOR = "violet";
 const GLYPH_SIZE = 38;
 const LAUNCHER_SIZE = 22;
-// How far the launcher avatar sticks out past the agent's top-right corner — it
+// How far the launcher avatar sticks out past the agent's bottom-right corner, so
-// sits as a small badge over that corner (above the glyph) and stays fully visible.
+// the "human behind" reads as behind (lower z-index) yet stays clearly visible.
 const LAUNCHER_OVERHANG = 8;
 
 /**
  * The front avatar. Image-source priority (#300):
  *   1. agent.avatarUrl -> a real avatar image (external MCP agent account).
- *   2. agent.emoji     -> the role emoji on a per-agent gradient circle.
+ *   2. agent.emoji     -> the role emoji on a violet circle.
- *   3. otherwise       -> the IconSparkles glyph on a per-agent gradient circle.
+ *   3. otherwise       -> the IconSparkles glyph on a violet circle (fallback).
  */
 function AgentGlyph({ agent }: { agent: AgentInfo }) {
   if (agent.avatarUrl) {
@@ -47,42 +48,20 @@ function AgentGlyph({ agent }: { agent: AgentInfo }) {
     );
   }
 
-  // Emoji/sparkles glyph on a per-agent gradient circle (color, gradient partner
+  if (agent.emoji) {
-  // and split angle all hashed from the agent name via avatarStyle — see
-  // @/lib/avatar-palette). Rendered as a plain Box, NOT a Mantine
-  // `Avatar variant="filled"` — Mantine's `--avatar-bg` overrode the background
-  // (every agent fell back to the theme's violet). The foreground (the sparkles
-  // icon) uses the ring's WCAG-checked readable text color.
-  const style = avatarStyle(agent.name);
     return (
-    <Box
+      <Avatar size={GLYPH_SIZE} radius="xl" color={AGENT_COLOR} variant="filled">
-      data-testid="agent-glyph"
-      style={{
-        width: GLYPH_SIZE,
-        height: GLYPH_SIZE,
-        borderRadius: "50%",
-        // Solid base color is the fallback (and the testable value); the gradient
-        // paints over it in browsers that support it.
-        backgroundColor: style.bg,
-        backgroundImage: avatarBackgroundCss(style),
-        color:
-          style.text === "white"
-            ? "var(--mantine-color-white)"
-            : "var(--mantine-color-black)",
-        display: "flex",
-        alignItems: "center",
-        justifyContent: "center",
-        lineHeight: 1,
-      }}
-    >
-      {agent.emoji ? (
         <span style={{ fontSize: Math.round(GLYPH_SIZE * 0.5) }} aria-hidden>
           {agent.emoji}
         </span>
-      ) : (
+      </Avatar>
+    );
+  }
+
+  return (
+    <Avatar size={GLYPH_SIZE} radius="xl" color={AGENT_COLOR} variant="filled">
       <IconSparkles size={Math.round(GLYPH_SIZE * 0.55)} stroke={2} />
-      )}
+    </Avatar>
-    </Box>
   );
 }
 
@@ -102,10 +81,8 @@ export interface AgentAvatarStackProps {
 }
 
 /**
- * The "agent avatar stack" (#300): the AGENT glyph, and — for an internal AI
+ * The "agent avatar stack" (#300): the AGENT glyph in front, and — for an
- * chat — the HUMAN who launched it as a smaller avatar badge on top, overhanging
+ * internal AI chat — the HUMAN who launched it as a smaller avatar offset behind.
- * the glyph's top-right corner in FRONT (zIndex 2 > the glyph's zIndex 1) so the
- * launcher stays fully visible rather than being half-hidden behind the glyph.
  * Replaces the old text `AI-agent` badge. When the item carries an `aiChatId` the
  * whole stack is a deep-link into that chat (the click the old badge owned moved
  * here); the click is contained (stopPropagation) so it does not also trigger an
@@ -179,9 +156,7 @@ export function AgentAvatarStack({
         : {})}
     >
       {launcher && (
-        // Launcher badge sits ABOVE the agent glyph (zIndex) at the top-right so
+        <Box pos="absolute" bottom={0} right={0} style={{ zIndex: 0 }}>
-        // it is fully visible, not half-hidden behind the agent circle.
-        <Box pos="absolute" top={0} right={0} style={{ zIndex: 2 }}>
           <CustomAvatar
             size={LAUNCHER_SIZE}
             avatarUrl={launcher.avatarUrl}
@@ -190,8 +165,8 @@ export function AgentAvatarStack({
           />
         </Box>
       )}
-      {/* The agent glyph keeps its own size (flex-centered in the container); the
+      {/* Pin the agent glyph to the top-left at its own size; the launcher then
-          launcher overhangs it by LAUNCHER_OVERHANG at the top-right and stays visible. */}
+          overhangs it by LAUNCHER_OVERHANG at the bottom-right and stays visible. */}
       <Box
         style={{
           position: "relative",

apps/client/src/features/ai-chat/components/ai-chat-window.tsx

@@ -19,7 +19,7 @@ import {
   IconPlus,
   IconX,
 } from "@tabler/icons-react";
-import { useAtom, useAtomValue, useSetAtom } from "jotai";
+import { useAtom, useSetAtom } from "jotai";
 import { useLocation, useMatch } from "react-router-dom";
 import { useTranslation } from "react-i18next";
 import { useQueryClient } from "@tanstack/react-query";
@@ -41,24 +41,13 @@ import { extractPageSlugId } from "@/lib";
 import {
   AI_CHATS_RQ_KEY,
   AI_CHAT_MESSAGES_RQ_KEY,
-  AI_CHAT_RUN_RQ_KEY,
   useAiChatMessagesQuery,
-  useAiChatRunQuery,
   useAiChatsQuery,
   useAiRolesQuery,
 } from "@/features/ai-chat/queries/ai-chat-query.ts";
-import {
-  shouldClearLatchOnQueryError,
-  shouldClearStoppingLatch,
-  shouldObserveRun,
-} from "@/features/ai-chat/utils/run-polling.ts";
-import { workspaceAtom } from "@/features/user/atoms/current-user-atom";
 import ConversationList from "@/features/ai-chat/components/conversation-list.tsx";
 import ChatThread from "@/features/ai-chat/components/chat-thread.tsx";
-import {
+import { exportAiChat } from "@/features/ai-chat/services/ai-chat-service.ts";
-  exportAiChat,
-  stopRun,
-} from "@/features/ai-chat/services/ai-chat-service.ts";
 import { useChatSession } from "@/features/ai-chat/hooks/use-chat-session.ts";
 import {
   shouldCollapseOnOutsidePointer,
@@ -245,147 +234,6 @@ export default function AiChatWindow() {
   const { data: messageRows, isLoading: messagesLoading } =
     useAiChatMessagesQuery(activeChatId ?? undefined);
 
-  // #184 reconnect-and-live-follow. Whether detached agent runs are enabled for
-  // this workspace. The reconnect endpoint itself is NOT flag-gated server-side
-  // (it is only owner-gated and returns `{ run: null }` when the chat has no
-  // run); but when the feature is off no runs are ever created, so polling it
-  // would always come back empty — we gate it off here to avoid pointless polls.
-  const workspace = useAtomValue(workspaceAtom);
-  const autonomousRunsEnabled =
-    workspace?.settings?.ai?.autonomousRuns === true;
-
-  // Whether THIS tab is the one actively streaming the open chat's run locally
-  // (it started the run here and holds the SSE). Reported up from ChatThread. We
-  // are the STREAMER while true and a passive OBSERVER while false — the basis of
-  // the observer-vs-streamer detection. Reset to false by the fresh ChatThread's
-  // mount effect on every chat switch.
-  const [localStreaming, setLocalStreaming] = useState(false);
-  const onStreamingChange = useCallback((streaming: boolean) => {
-    setLocalStreaming(streaming);
-  }, []);
-
-  // #184 Stop wiring. While a detached run is being stopped we SUPPRESS the
-  // observer merge so the stopping run's still-persisting output does not
-  // re-stream back into view between the moment the user pressed Stop and the run
-  // actually settling as 'aborted' server-side. Polling itself keeps running (so
-  // the terminal transition is still detected) — only the visual merge is gated.
-  // Cleared when the run is observed terminal (below) or the chat is switched.
-  const [stoppingRun, setStoppingRun] = useState(false);
-  // Reset the stopping latch whenever the open chat changes: it is scoped to the
-  // run of the previously-open chat.
-  useEffect(() => {
-    setStoppingRun(false);
-  }, [activeChatId]);
-
-  // Authoritative stop of the open chat's detached run (the Stop button in
-  // autonomous mode). Latch "stopping" first (suppresses the re-stream flash),
-  // then request the server stop — the ONLY thing that ends a detached run; a mere
-  // local SSE abort is a client disconnect the server ignores. On failure we
-  // release the latch so the observer resumes (better to show the live run than to
-  // freeze the view) and surface the error.
-  const handleServerStop = useCallback(
-    (chatId: string): void => {
-      setStoppingRun(true);
-      // #234 F4: drop the PREVIOUS turn's run from the cache so `run` becomes null
-      // until the CURRENT turn's run is fetched fresh. Without this, once the local
-      // stream aborts (localStreaming -> false) the run query re-enables and
-      // react-query SYNCHRONOUSLY returns the still-cached prior terminal run; the
-      // terminal effect would then clear the stopping latch against that STALE run
-      // before the current turn's (still-running, detached, growing) run is ever
-      // observed — re-opening the observer merge and flashing the growing output
-      // over the frozen row. With the cache cleared the terminal effect's
-      // `if (!run) return` holds the latch until the current run itself is observed
-      // terminal (see shouldClearStoppingLatch).
-      queryClient.removeQueries({ queryKey: AI_CHAT_RUN_RQ_KEY(chatId) });
-      void stopRun(chatId).catch(() => {
-        setStoppingRun(false);
-        notifications.show({
-          message: t("Failed to stop the run"),
-          color: "red",
-        });
-      });
-    },
-    [t, queryClient],
-  );
-
-  // Poll the latest run of the open chat ONLY when we are a passive observer:
-  // feature on, a chat is open, and we are NOT the local streamer (the streamer
-  // already has the live SSE — polling/merging too would double-render). The
-  // query's own status-keyed refetchInterval stops once the run is terminal.
-  const { data: runData, isError: runQueryFailed } = useAiChatRunQuery(
-    activeChatId ?? undefined,
-    autonomousRunsEnabled && !localStreaming,
-  );
-  const run = runData?.run ?? null;
-
-  // Safety net (#234 F4 review): after handleServerStop clears the run cache,
-  // `run` is null until the current turn's run is fetched fresh, and the terminal
-  // effect below holds the latch via `if (!run) return`. If that refetch instead
-  // ERRORS PERMANENTLY (the GET-run keeps failing) while we are no longer the
-  // streamer, the run stays null, its status-keyed refetchInterval is off, and
-  // nothing would ever observe a terminal run — freezing the view with the
-  // observer merge suppressed. Release the latch on that error so the live view
-  // resumes rather than stays stuck (the local stopRun may already have succeeded
-  // independently).
-  //
-  // #234 F7: this must NOT fire on a TRANSIENT error while `run` is still an
-  // ACTIVE held run. In TanStack Query v5 (retry:false) the query's `data` is
-  // RETAINED on error, so `runQueryFailed` can be true while `run` is still
-  // pending/running — releasing then would re-open the observer merge and flash
-  // the growing detached run over the frozen row (the very flash F4 prevents). The
-  // decision is the pure, unit-tested `shouldClearLatchOnQueryError`, which gates
-  // on the run NOT being active: it cures only the genuine permanent-null-freeze
-  // (`run === null`) and never releases against an active run.
-  useEffect(() => {
-    if (
-      shouldClearLatchOnQueryError({
-        stoppingRun,
-        isLocalStreaming: localStreaming,
-        runQueryFailed,
-        run,
-      })
-    )
-      setStoppingRun(false);
-  }, [stoppingRun, localStreaming, runQueryFailed, run]);
-  // The run's incrementally-persisted assistant message to merge into the thread,
-  // but only while we are an observer (never when we are the streamer — guards
-  // against a stale poll fighting the live stream). Includes a terminal run so the
-  // final persisted output is shown on reopen.
-  const observedRow =
-    shouldObserveRun(run, localStreaming) && !stoppingRun
-      ? (runData?.message ?? null)
-      : null;
-
-  // When the observed run reaches a terminal status, do a final messages refetch
-  // so the persisted final state (token/context badge, export source) is shown,
-  // then the query's refetchInterval has already stopped polling. Deduped per run
-  // id so it fires exactly once per run, not on every subsequent poll-less render.
-  const finalizedRunIdRef = useRef<string | null>(null);
-  useEffect(() => {
-    if (!run || !activeChatId) return;
-    if (run.status === "pending" || run.status === "running") {
-      // Active again (a new run) — re-arm so its terminal transition fires once.
-      finalizedRunIdRef.current = null;
-      return;
-    }
-    // Terminal: a stop we requested has landed (or the run finished on its own),
-    // so release the stopping latch — the observer merge can now show the final
-    // persisted (aborted/finished) output without any live re-stream. The decision
-    // is the pure, unit-tested `shouldClearStoppingLatch` (run-polling.ts): release
-    // ONLY when we requested a stop, this tab is no longer the streamer, AND the
-    // CURRENT run is terminal. The #234 F4 cache removal in handleServerStop makes
-    // `run` null (this branch's `if (!run) return` above holds) until the current
-    // turn's run is fetched fresh, so the latch can never clear against a stale
-    // cached run.
-    if (shouldClearStoppingLatch({ stoppingRun, run, isLocalStreaming: localStreaming }))
-      setStoppingRun(false);
-    if (finalizedRunIdRef.current === run.id) return;
-    finalizedRunIdRef.current = run.id;
-    queryClient.invalidateQueries({
-      queryKey: AI_CHAT_MESSAGES_RQ_KEY(activeChatId),
-    });
-  }, [run, activeChatId, queryClient, stoppingRun, localStreaming]);
-
   // The page the user is currently viewing. AiChatWindow lives in a pathless
   // parent layout route, so useParams() can't see :pageSlug. Match the full
   // pathname against the authenticated page route instead so "the current page"
@@ -1034,18 +882,6 @@ export default function AiChatWindow() {
               assistantName={currentRole?.name}
               onTurnFinished={onTurnFinished}
               onServerChatId={onServerChatId}
-              // #184: live-follow a still-running run when we reopened the chat as
-              // a passive observer; null when there is nothing to observe or this
-              // tab is the streamer. onStreamingChange lets the window stop polling
-              // while we are the streamer.
-              observedRow={observedRow}
-              onStreamingChange={onStreamingChange}
-              // #184: in autonomous mode the Stop button must hit the authoritative
-              // server stop (a local SSE abort is a client disconnect the server
-              // ignores). onServerStop also arms the "stopping" latch above so the
-              // stopped run's output does not re-stream via the observer merge.
-              autonomousRunsEnabled={autonomousRunsEnabled}
-              onServerStop={handleServerStop}
             />
           )}
         </div>

apps/client/src/features/ai-chat/components/ai-chat.module.css

@@ -164,8 +164,8 @@
     /* NOTE: `white-space: pre-wrap` is intentionally NOT set here. On the
        rendered markdown <div> it would turn the newlines between block tags
        (</li>\n<li>, </p>\n<ol>) into visible blank lines/indents on top of the
-       margins. The streaming plain-text path that needs pre-wrap sets it
+       margins. The plain-text fallback <Text> that needs pre-wrap sets it
-       per chunk instead, in PlainChunk (see streaming-plain-text.tsx). */
+       inline itself (see reasoning-block.tsx). */
 }
 
 .reasoningText p {

apps/client/src/features/ai-chat/components/chat-thread.test.tsx

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, vi } from "vitest";
-import { render, screen, fireEvent, act, cleanup } from "@testing-library/react";
+import { render, screen, fireEvent, act } from "@testing-library/react";
 import { MantineProvider } from "@mantine/core";
 
 // Shared, hoisted mock state so the @ai-sdk/react and "ai" module mocks (hoisted
@@ -11,7 +11,6 @@ const h = vi.hoisted(() => ({
     onFinish: null as null | ((arg: Record<string, unknown>) => void),
     sendMessage: vi.fn(),
     stop: vi.fn(),
-    setMessages: vi.fn(),
     transport: null as null | {
       prepareSendMessagesRequest: (arg: {
         messages: unknown[];
@@ -31,8 +30,6 @@ vi.mock("@ai-sdk/react", () => ({
       status: h.state.status,
       stop: h.state.stop,
       error: null,
-      // #184: ChatThread reads setMessages to merge a polled observer run.
-      setMessages: h.state.setMessages,
     };
   },
 }));
@@ -143,144 +140,3 @@ describe("ChatThread — send now (#198)", () => {
     expect(prep({ messages: [], body: {} }).body.interrupted).toBe(false);
   });
 });
-
-// The turn-end decision lives in the `onFinish` handler: given the terminal
-// outcome of a turn (`isAbort` / `isDisconnect` / `isError`, or none = clean),
-// it decides whether to CONTINUE (flush the next queued message) or END (leave
-// the queue intact for the user), and which stop notice — if any — to show.
-// `sendNow` is exercised above; these tests pin down the plain outcomes.
-describe("ChatThread — turn-end decision (onFinish)", () => {
-  beforeEach(() => {
-    h.state.status = "streaming";
-    h.state.onFinish = null;
-    h.state.sendMessage.mockClear();
-    h.state.stop.mockClear();
-    h.state.transport = null;
-  });
-
-  // Drive a fresh onFinish with the given terminal flags after queueing a
-  // message, and report both what the parent was told and whether the queue was
-  // flushed (a resend to the sendMessage spy).
-  function finishWith(flags: {
-    isAbort?: boolean;
-    isDisconnect?: boolean;
-    isError?: boolean;
-  }) {
-    // Tear down any prior render so the loop-driven "every outcome" case does
-    // not leave duplicate queue buttons in the DOM.
-    cleanup();
-    h.state.sendMessage.mockClear();
-    const { onTurnFinished } = renderThread();
-    // Populate the queue while the turn is streaming.
-    fireEvent.click(screen.getByTestId("queue-btn"));
-    act(() => {
-      h.state.onFinish?.({
-        message: { id: "a", role: "assistant", parts: [] },
-        isAbort: false,
-        isDisconnect: false,
-        isError: false,
-        ...flags,
-      });
-    });
-    return { onTurnFinished };
-  }
-
-  it("CONTINUES — flushes the next queued message on a clean finish", () => {
-    finishWith({});
-    // Clean finish (no terminal flag): the queued message is auto-sent.
-    expect(h.state.sendMessage).toHaveBeenCalledWith({ text: "queued text" });
-    // A clean finish shows no stop notice.
-    expect(screen.queryByText("Response stopped.")).toBeNull();
-  });
-
-  it("ENDS — keeps the queue intact on a user abort and shows the stopped notice", () => {
-    finishWith({ isAbort: true });
-    // A plain Stop (not the sendNow interrupt path) must NOT auto-resend: the
-    // queue is preserved for the user to decide.
-    expect(h.state.sendMessage).not.toHaveBeenCalled();
-    expect(screen.getByText("Response stopped.")).toBeTruthy();
-  });
-
-  it("ENDS — keeps the queue intact on a disconnect and shows the connection-lost notice", () => {
-    finishWith({ isDisconnect: true });
-    expect(h.state.sendMessage).not.toHaveBeenCalled();
-    expect(
-      screen.getByText("Connection lost — the answer was interrupted."),
-    ).toBeTruthy();
-  });
-
-  it("ENDS — keeps the queue intact on a stream error (no auto-retry, no stopped notice)", () => {
-    finishWith({ isError: true });
-    // Blindly retrying after a failure would be wrong; the queue is left alone.
-    expect(h.state.sendMessage).not.toHaveBeenCalled();
-    // isError clears the neutral notice (the error banner covers this case).
-    expect(screen.queryByText("Response stopped.")).toBeNull();
-  });
-
-  it("notifies the parent on EVERY terminal outcome", () => {
-    // The chat-list refresh / new-chat id adoption must run on success and on
-    // every failure path alike.
-    for (const flags of [
-      {},
-      { isAbort: true },
-      { isDisconnect: true },
-      { isError: true },
-    ]) {
-      const { onTurnFinished } = finishWith(flags);
-      expect(onTurnFinished).toHaveBeenCalled();
-    }
-  });
-});
-
-// #184 passive-observer merge: when reconnecting to a still-running run, the
-// parent feeds the polled run message via `observedRow`; ChatThread merges it via
-// setMessages — but ONLY when this tab is NOT itself streaming (the streamer's
-// SSE owns the view, so a stale observedRow must never overwrite it).
-describe("ChatThread — observer run merge (#184)", () => {
-  beforeEach(() => {
-    h.state.onFinish = null;
-    h.state.setMessages.mockReset();
-  });
-
-  const observedRow = {
-    id: "a-run",
-    role: "assistant",
-    content: "step 1\nstep 2",
-    metadata: {
-      parts: [{ type: "text", text: "step 1\nstep 2" }],
-    },
-    createdAt: "2026-01-01T00:00:00Z",
-  } as const;
-
-  function renderObserver(status: string) {
-    h.state.status = status;
-    render(
-      <MantineProvider>
-        <ChatThread
-          chatId="c1"
-          initialRows={[]}
-          onTurnFinished={vi.fn()}
-          observedRow={observedRow as never}
-        />
-      </MantineProvider>,
-    );
-  }
-
-  it("merges the polled run message when this tab is a passive observer", () => {
-    renderObserver("ready");
-    expect(h.state.setMessages).toHaveBeenCalledTimes(1);
-    // The updater replaces/append the observed assistant row by id.
-    const updater = h.state.setMessages.mock.calls[0][0] as (
-      prev: { id: string; parts: { text: string }[] }[],
-    ) => { id: string; parts: { text: string }[] }[];
-    const merged = updater([{ id: "u1", parts: [{ text: "hi" }] }]);
-    expect(merged).toHaveLength(2);
-    expect(merged[1].id).toBe("a-run");
-    expect(merged[1].parts[0].text).toBe("step 1\nstep 2");
-  });
-
-  it("does NOT merge while THIS tab is the streamer (no double-render)", () => {
-    renderObserver("streaming");
-    expect(h.state.setMessages).not.toHaveBeenCalled();
-  });
-});

apps/client/src/features/ai-chat/components/chat-thread.tsx

@@ -24,7 +24,6 @@ import {
 } from "@/features/ai-chat/utils/role-launch.ts";
 import { describeChatError } from "@/features/ai-chat/utils/error-message.ts";
 import { extractServerChatId } from "@/features/ai-chat/utils/adopt-chat-id.ts";
-import { mergeObservedMessage } from "@/features/ai-chat/utils/run-polling.ts";
 import {
   dequeue,
   enqueueMessage,
@@ -87,29 +86,6 @@ interface ChatThreadProps {
    *  Copy/export button available mid-stream). Distinct from onTurnFinished,
    *  which fires only at the terminal outcome. */
   onServerChatId?: (serverChatId?: string) => void;
-  /** #184 reconnect-and-live-follow. When THIS tab reopened a chat whose agent
-   *  run is still going (it is a PASSIVE OBSERVER — it did not start the run here),
-   *  the parent polls the reconnect endpoint and feeds the run's incrementally-
-   *  persisted assistant message here; we merge it into the live list so new
-   *  steps/tool-calls appear as they are persisted. Null when there is nothing to
-   *  observe (no run, feature off, or this tab IS the streamer). The merge is
-   *  ADDITIONALLY guarded by our own `isStreaming`, so a stale value can never
-   *  fight the local stream when we are the streamer. */
-  observedRow?: IAiChatMessageRow | null;
-  /** Report this tab's live streaming status up to the parent, so it can stop
-   *  polling the run while WE are the active streamer (the SSE owns the view) and
-   *  resume once we go idle. Called from an effect on every transition. */
-  onStreamingChange?: (streaming: boolean) => void;
-  /** #184: whether detached/autonomous agent runs are enabled for this workspace.
-   *  When true the Stop button must additionally hit the AUTHORITATIVE server stop
-   *  (via onServerStop) — aborting only the local SSE is just a client disconnect,
-   *  which the server deliberately ignores, so the detached run would keep going. */
-  autonomousRunsEnabled?: boolean;
-  /** #184: request the server-side stop of this chat's active run (the parent owns
-   *  the endpoint call + the "stopping" latch that keeps observer-polling from
-   *  immediately re-streaming the stopping run's output). Called with the resolved
-   *  chat id when the user presses Stop in autonomous mode. */
-  onServerStop?: (chatId: string) => void;
 }
 
 /**
@@ -155,10 +131,6 @@ export default function ChatThread({
   assistantName,
   onTurnFinished,
   onServerChatId,
-  observedRow,
-  onStreamingChange,
-  autonomousRunsEnabled,
-  onServerStop,
 }: ChatThreadProps) {
   const { t } = useTranslation();
 
@@ -244,16 +216,6 @@ export default function ChatThread({
   const flushOnAbortRef = useRef(false);
   const interruptNextSendRef = useRef(false);
 
-  // #234 F5: the user pressed Stop while streaming a BRAND-NEW chat whose server
-  // chat id has not been adopted yet (the `start` chunk carrying it hadn't landed
-  // when Stop was pressed). A local SSE abort alone does NOT stop the DETACHED
-  // autonomous run — it keeps burning tokens and WRITING TO PAGES — so we cannot
-  // just no-op. We latch the stop as PENDING and fire the authoritative server
-  // stop the moment onServerChatId adopts the id (below). Read-and-cleared there;
-  // also defused on every new turn start so it can never fire against a later,
-  // unrelated turn's run.
-  const stopPendingRef = useRef(false);
-
   // FIFO dequeue + send the next queued message (no-op when the queue is empty).
   // Returns whether a message was actually sent, so callers can tell an empty
   // dequeue (nothing to flush) from a real send.
@@ -312,7 +274,7 @@ export default function ChatThread({
     [],
   );
 
-  const { messages, sendMessage, status, stop, error, setMessages } = useChat({
+  const { messages, sendMessage, status, stop, error } = useChat({
     // Stable per-mount key. Existing chats use their real id; new chats use a
     // generated client id (never `undefined`) so the store is NOT re-created on
     // every render mid-stream (see `chatStoreId` above).
@@ -403,14 +365,7 @@ export default function ChatThread({
       return;
     lastForwardedChatIdRef.current = serverChatId;
     onServerChatId(serverChatId);
-    // #234 F5: if Stop was pressed before the id was known, the authoritative
+  }, [messages, onServerChatId]);
-    // server stop was deferred to this adoption point — fire it now with the
-    // just-adopted id. One-shot (read-and-clear) so it can't fire twice.
-    if (stopPendingRef.current) {
-      stopPendingRef.current = false;
-      onServerStop?.(serverChatId);
-    }
-  }, [messages, onServerChatId, onServerStop]);
 
   // Live "turn was interrupted" marker for the CURRENT session. The red error
   // banner (driven by `error`) covers the error case; this covers an aborted
@@ -423,27 +378,6 @@ export default function ChatThread({
 
   const isStreaming = status === "submitted" || status === "streaming";
 
-  // #184: report our live streaming status up so the parent stops polling the run
-  // while WE are the streamer (the SSE owns the view) and resumes once we go idle.
-  // Effect (not render) so it never updates parent state during our own render;
-  // fires on mount with `false`, which also re-syncs the parent after a chat
-  // switch remounts this thread (a fresh mount is idle until the user sends).
-  useEffect(() => {
-    onStreamingChange?.(isStreaming);
-  }, [isStreaming, onStreamingChange]);
-
-  // #184 passive-observer merge: when the parent feeds a polled run message (we
-  // reopened a chat whose run is still going and did NOT start it here), merge it
-  // into the live list so new steps/tool-calls appear as they are persisted. Hard-
-  // gated by `!isStreaming`: if THIS tab is actually the streamer, the local SSE
-  // owns the view and a stale observedRow must never overwrite it. `observedRow`
-  // is a stable per-poll object, so this runs once per poll, not per render.
-  useEffect(() => {
-    if (isStreaming || !observedRow) return;
-    const observed = rowToUiMessage(observedRow);
-    setMessages((prev) => mergeObservedMessage(prev, observed));
-  }, [observedRow, isStreaming, setMessages]);
-
   // "Send now" on a queued message: interrupt the current turn and immediately
   // send THIS message, keeping the agent's partial output. Other queued messages
   // stay queued and flush normally after the new turn. Reuses the existing
@@ -475,40 +409,6 @@ export default function ChatThread({
     [setQueue, stop],
   );
 
-  // Stop the current turn. ALWAYS abort the local SSE (`stop()`) so the composer
-  // returns to idle immediately. In AUTONOMOUS mode the turn is a DETACHED run:
-  // aborting the local SSE is only a client disconnect, which the server ignores,
-  // so the run would keep executing — we ADDITIONALLY request the authoritative
-  // server-side stop (the parent owns that call + the "stopping" latch that keeps
-  // observer-polling from re-streaming the stopping run's output). The chat id is
-  // read live from chatIdRef (adopted early at the stream's `start` chunk); if it
-  // is not known yet — a brand-new chat in the first moment of its first turn —
-  // only the local abort happens (there is no server-side run handle to stop yet).
-  const handleStop = useCallback(() => {
-    stop();
-    if (!autonomousRunsEnabled) return;
-    if (chatIdRef.current) {
-      onServerStop?.(chatIdRef.current);
-    } else {
-      // #234 F5: no chat id yet (brand-new chat in the first moment of its first
-      // turn, before the `start` chunk adopted the id). Latch the stop as pending;
-      // the onServerChatId adoption effect fires the deferred server stop as soon
-      // as the id appears, so the detached run is still authoritatively stopped
-      // instead of left running by a silent local-only abort.
-      //
-      // KNOWN LIMITATION (#234 F5 review): `stop()` above has already aborted the
-      // local SSE reader. In the rare sub-window where Stop is pressed while still
-      // `submitted` (request sent, not one chunk read yet), that abort can cancel
-      // the reader BEFORE the `start` chunk is applied to `messages`, so the
-      // adoption effect never runs and this pending stop never fires. The detached
-      // run then keeps going for that turn. This is not a regression (the pre-fix
-      // behavior sent no server stop at all); closing it fully would require
-      // deferring the local abort until adoption, which is riskier and out of scope
-      // for this fix. Documented so a future change can address the abort-ordering.
-      stopPendingRef.current = true;
-    }
-  }, [stop, autonomousRunsEnabled, onServerStop]);
-
   // Clear the stopped marker as soon as a new turn begins streaming, and drop any
   // stale "Send now" interrupt flags. On the legit interrupt path both refs are
   // already consumed synchronously (onFinish + prepareSendMessagesRequest) before
@@ -520,11 +420,6 @@ export default function ChatThread({
       setStopNotice(null);
       flushOnAbortRef.current = false;
       interruptNextSendRef.current = false;
-      // #234 F5: a new turn is starting — drop any pending deferred-stop from a
-      // previous turn that never adopted an id, so it can never fire against this
-      // (or a later) unrelated turn's run. A deferred stop for the CURRENT turn is
-      // set AFTER this effect (on the Stop click), so this does not clobber it.
-      stopPendingRef.current = false;
     }
   }, [isStreaming]);
 
@@ -644,7 +539,7 @@ export default function ChatThread({
         <ChatInput
           onSend={(text) => sendMessage({ text })}
           onQueue={enqueue}
-          onStop={handleStop}
+          onStop={stop}
           isStreaming={isStreaming}
         />
       </Stack>

apps/client/src/features/ai-chat/components/message-item.test.ts

@@ -65,25 +65,6 @@ describe("arePropsEqual", () => {
     expect(arePropsEqual(props(m), props(m))).toBe(true);
   });
 
-  // REGRESSION (stranded reasoning part): a reasoning part is left at
-  // `state:"streaming"` forever when the turn ends without `reasoning-end`
-  // (manual Stop during thinking). The signature is EQUAL across that turn-end
-  // flip (nothing in the message changed), so the comparator must ALSO compare
-  // `turnStreaming` — otherwise the memo swallows the flip and ReasoningBlock
-  // never switches from chunked plain text to its one-time markdown parse.
-  it("returns false when turnStreaming differs despite an equal signature", () => {
-    const m = msg([
-      { type: "reasoning", text: "thinking", state: "streaming" },
-      { type: "text", text: "answer" },
-    ]);
-    expect(
-      arePropsEqual(
-        props(m, { turnStreaming: true }),
-        props(m, { turnStreaming: false }),
-      ),
-    ).toBe(false);
-  });
-
   it("returns true for the same content in a different message object", () => {
     const a = msg([{ type: "text", text: "answer" }]);
     const b = msg([{ type: "text", text: "answer" }]);

apps/client/src/features/ai-chat/components/message-item.tsx

@@ -52,20 +52,6 @@ interface MessageItemProps {
    * absent; the public share passes the configured identity (agent role) name.
    */
   assistantName?: string;
-  /**
-   * Whether the WHOLE turn is still streaming (MessageList's `isStreaming`).
-   * A reasoning part may be left `state: "streaming"` forever when the turn
-   * ends without a `reasoning-end` chunk (manual Stop during the thinking
-   * phase, or a provider that never emits it) — the AI SDK finalizes reasoning
-   * state ONLY on `reasoning-end`, not on `finish-step`/`finish`. So part-level
-   * state alone cannot prove liveness; the reasoning part is treated as live
-   * only while the whole turn is still streaming. Defaults to false.
-   *
-   * The parent passes it as "turn is live AND this is the tail row", so a
-   * stranded part in an EARLIER row never re-activates when a later turn
-   * streams.
-   */
-  turnStreaming?: boolean;
 }
 
 /**
@@ -119,7 +105,6 @@ function MessageItem({
   showCitations = true,
   neutralizeInternalLinks = false,
   assistantName,
-  turnStreaming = false,
 }: MessageItemProps) {
   // `signature` is intentionally not read in the body — it exists solely as the
   // memo key (see arePropsEqual). The render reads `message` directly.
@@ -170,23 +155,8 @@ function MessageItem({
           const text = (part as { text?: string }).text ?? "";
           if (!text.trim() && !(reasoningTokens && reasoningTokens > 0))
             return null;
-          // Absent state (persisted rows) and "done" both mean finalized.
-          // `messageSignature` already includes each part's `state`, so the
-          // streaming→done flip changes the row signature and re-renders this
-          // row — which is what lets ReasoningBlock switch from chunked plain
-          // text to its one-time markdown parse (see reasoning-block.tsx).
-          // ALSO require the turn to be live: a part stranded at
-          // `state:"streaming"` after the turn ended (no `reasoning-end` — see
-          // the `turnStreaming` prop doc) must still finalize and parse.
-          const streaming =
-            turnStreaming && (part as { state?: string }).state === "streaming";
           return (
-            <ReasoningBlock
+            <ReasoningBlock key={index} text={text} tokens={reasoningTokens} />
-              key={index}
-              text={text}
-              tokens={reasoningTokens}
-              streaming={streaming}
-            />
           );
         }
 
@@ -275,11 +245,7 @@ export function arePropsEqual(
     prev.signature === next.signature &&
     prev.showCitations === next.showCitations &&
     prev.neutralizeInternalLinks === next.neutralizeInternalLinks &&
-    prev.assistantName === next.assistantName &&
+    prev.assistantName === next.assistantName
-    // The turn-end flip re-renders every row once (cheap, terminal event) —
-    // that is what converts a stranded `state:"streaming"` reasoning part to
-    // its one-time markdown parse (see the `turnStreaming` prop doc).
-    prev.turnStreaming === next.turnStreaming
   );
 }
 

apps/client/src/features/ai-chat/components/message-list.test.tsx

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from "vitest";
-import { fireEvent, render } from "@testing-library/react";
+import { render } from "@testing-library/react";
 import { MantineProvider } from "@mantine/core";
 import type { UIMessage } from "@ai-sdk/react";
 
@@ -50,9 +50,8 @@ vi.stubGlobal(
 
 // One assistant message wrapping the given `parts`. Reused across renders in the
 // regression test to model how the AI SDK hands back the SAME message object.
-// Pass an explicit `id` when a test renders several rows at once.
+const msg = (parts: UIMessage["parts"]): UIMessage =>
-const msg = (parts: UIMessage["parts"], id = "m1"): UIMessage =>
+  ({ id: "m1", role: "assistant", parts }) as UIMessage;
-  ({ id, role: "assistant", parts }) as UIMessage;
 
 describe("MessageList", () => {
   it("wires the real MessageItem and supplies a valid signature end-to-end", () => {
@@ -117,102 +116,4 @@ describe("MessageList", () => {
       renderChatMarkdownSpy.mock.calls.some((c) => c[0] === "streamed answer"),
     ).toBe(true);
   });
-
-  // REGRESSION (stranded reasoning part): the AI SDK sets a reasoning part's
-  // state to "done" ONLY on the `reasoning-end` chunk — `finish-step`/`finish`
-  // do NOT finalize it. A manual Stop during the thinking phase (or a provider
-  // that never emits `reasoning-end`) therefore leaves the part at
-  // `state:"streaming"` forever. MessageItem must derive ReasoningBlock's
-  // `streaming` from part state AND turn liveness (MessageList's `isStreaming`,
-  // forwarded as `turnStreaming`): while the turn streams the expanded block
-  // shows chunked plain text (no parse); once the turn ends — even though the
-  // part is still `state:"streaming"` — the block finalizes and does its
-  // one-time markdown parse. Note the message signature does NOT change across
-  // that flip, so this also exercises the `turnStreaming` memo comparison in
-  // arePropsEqual (without it the row would never re-render).
-  it("finalizes a reasoning part stranded at state:'streaming' when the turn ends", () => {
-    renderChatMarkdownSpy.mockClear();
-    const reasoningText = "**bold** thinking";
-    // Reasoning part stranded mid-stream + a non-empty answer part (a
-    // reasoning-only message renders nothing — see message-content.ts).
-    const message = msg([
-      { type: "reasoning", text: reasoningText, state: "streaming" },
-      { type: "text", text: "partial answer" },
-    ]);
-    const parsesOfReasoning = () =>
-      renderChatMarkdownSpy.mock.calls.filter((c) => c[0] === reasoningText)
-        .length;
-
-    const { rerender, getByRole, queryByText } = render(
-      <MantineProvider>
-        <MessageList messages={[message]} isStreaming />
-      </MantineProvider>,
-    );
-    // Expand the reasoning block (its toggle is the only button in the list).
-    fireEvent.click(getByRole("button"));
-    // Turn live + part streaming -> ReasoningBlock received streaming=true:
-    // the body is chunked plain text (raw markdown syntax), NOT parsed.
-    expect(queryByText(/bold/)).not.toBeNull();
-    expect(parsesOfReasoning()).toBe(0);
-
-    // The turn ends WITHOUT `reasoning-end`: the part object is untouched
-    // (still state:"streaming"), only the turn-level flag flips.
-    rerender(
-      <MantineProvider>
-        <MessageList messages={[message]} isStreaming={false} />
-      </MantineProvider>,
-    );
-    // ReasoningBlock now received streaming=false and did its one-time parse.
-    expect(parsesOfReasoning()).toBe(1);
-  });
-
-  // REGRESSION (turn-global liveness leaking into earlier rows): `isStreaming`
-  // is turn-global, so forwarding it to EVERY row would re-mark a reasoning
-  // part stranded at `state:"streaming"` in a PREVIOUS message (see the test
-  // above) as live again whenever a LATER turn streams — an expanded stranded
-  // block would flip markdown -> raw plain text -> markdown across turn
-  // boundaries, re-parsing each time. MessageList must gate `turnStreaming`
-  // to the TAIL row only.
-  it("keeps a stranded reasoning part in an earlier message finalized while a later turn streams", () => {
-    renderChatMarkdownSpy.mockClear();
-    const reasoningText = "**bold** thinking";
-    // First (earlier) assistant message: its turn was stopped during the
-    // thinking phase, leaving the reasoning part at state:"streaming".
-    const first = msg(
-      [
-        { type: "reasoning", text: reasoningText, state: "streaming" },
-        { type: "text", text: "first answer" },
-      ],
-      "m1",
-    );
-    // Second assistant message: the LATER turn, currently streaming.
-    const second = msg([{ type: "text", text: "second answer" }], "m2");
-    const parsesOfReasoning = () =>
-      renderChatMarkdownSpy.mock.calls.filter((c) => c[0] === reasoningText)
-        .length;
-
-    const { rerender, getByRole, queryByText } = render(
-      <MantineProvider>
-        <MessageList messages={[first, second]} isStreaming />
-      </MantineProvider>,
-    );
-    // Expand the first row's reasoning block (the only toggle in the list —
-    // the second message has no reasoning or tool parts).
-    fireEvent.click(getByRole("button"));
-    // The turn is live but the first row is NOT the tail: its ReasoningBlock
-    // received streaming=false, so the stranded part stays finalized and does
-    // its one-time markdown parse instead of dropping to chunked plain text.
-    expect(queryByText(/bold/)).not.toBeNull();
-    expect(parsesOfReasoning()).toBe(1);
-
-    // A later-turn delta re-renders the list; the earlier block must neither
-    // flip back to streaming nor re-parse.
-    (second.parts[0] as { text: string }).text = "second answer grows";
-    rerender(
-      <MantineProvider>
-        <MessageList messages={[first, second]} isStreaming />
-      </MantineProvider>,
-    );
-    expect(parsesOfReasoning()).toBe(1);
-  });
 });

apps/client/src/features/ai-chat/components/message-list.tsx

@@ -196,7 +196,7 @@ export default function MessageList({
   return (
     <ScrollArea className={classes.messages} viewportRef={viewportRef} scrollbarSize={6} type="scroll">
       <Stack gap={0} pr="xs">
-        {messages.map((message, index) => (
+        {messages.map((message) => (
           // `signature` is snapshotted HERE (parent render) into an immutable
           // string and handed to MessageItem as its memo key. It must NOT be
           // recomputed inside MessageItem's arePropsEqual: the AI SDK mutates the
@@ -210,13 +210,6 @@ export default function MessageList({
             showCitations={showCitations}
             neutralizeInternalLinks={neutralizeInternalLinks}
             assistantName={assistantName}
-            // Turn-level liveness, gated to the TAIL row: only the tail message
-            // can belong to the in-flight turn, so a reasoning part stranded at
-            // `state:"streaming"` in an EARLIER message (its turn ended without
-            // `reasoning-end`) stays finalized and doesn't flip back to plain
-            // text (and re-parse) whenever a later turn streams — see
-            // message-item.tsx.
-            turnStreaming={isStreaming && index === messages.length - 1}
           />
         ))}
         {typing && (

apps/client/src/features/ai-chat/components/reasoning-block.test.tsx

@@ -1,14 +1,7 @@
 import { describe, it, expect, vi } from "vitest";
-import { render, screen, fireEvent } from "@testing-library/react";
+import { render, screen } from "@testing-library/react";
 import { MantineProvider } from "@mantine/core";
 
-// Spy on the markdown renderer so we can assert it is NOT called while the block
-// is collapsed (the #302 fix) and IS called once on expand. The count/fallback
-// tests don't depend on real markdown, so a light stub is safe.
-vi.mock("@/features/ai-chat/utils/markdown.ts", () => ({
-  renderChatMarkdown: vi.fn((md: string) => `<p>${md}</p>`),
-}));
-
 // Stub react-i18next so `t` returns the key with `{{count}}` interpolated. This
 // keeps the assertions on the component's OWN count logic (authoritative vs
 // estimate) rather than on translation, and mirrors the t-mock pattern used by
@@ -24,15 +17,10 @@ vi.mock("react-i18next", () => ({
 
 import ReasoningBlock from "./reasoning-block";
 import { estimateTokens } from "@/features/ai-chat/utils/count-stream-tokens.ts";
-import { renderChatMarkdown } from "@/features/ai-chat/utils/markdown.ts";
 
 // matchMedia (read by MantineProvider) is stubbed globally in vitest.setup.ts.
 
-function renderBlock(props: {
+function renderBlock(props: { text: string; tokens?: number }) {
-  text: string;
-  tokens?: number;
-  streaming?: boolean;
-}) {
   return render(
     <MantineProvider>
       <ReasoningBlock {...props} />
@@ -74,68 +62,4 @@ describe("ReasoningBlock", () => {
     // either way the text is present in the document.
     expect(screen.getByText(/reasoning/)).toBeDefined();
   });
-
-  it("does not parse the reasoning markdown while collapsed; parses on expand (#302)", () => {
-    const renderSpy = vi.mocked(renderChatMarkdown);
-    renderSpy.mockClear();
-    renderBlock({ text: "**bold** reasoning", tokens: 5 });
-    // Collapsed is the default. The expensive markdown parse (marked + DOMPurify)
-    // must NOT run for the hidden body — that O(n^2) re-parse on every streamed
-    // delta is exactly what froze the chat (#302). The collapsed body shows the
-    // cheap raw-text fallback instead.
-    expect(renderSpy).not.toHaveBeenCalled();
-    // Expanding parses the current text exactly once (a user-initiated click).
-    fireEvent.click(screen.getByRole("button"));
-    expect(renderSpy).toHaveBeenCalledTimes(1);
-  });
-
-  it("does not parse while expanded and STREAMING; shows chunked plain text", () => {
-    const renderSpy = vi.mocked(renderChatMarkdown);
-    renderSpy.mockClear();
-    renderBlock({
-      text: "первый абзац размышлений\n\nвторой абзац растёт",
-      tokens: 5,
-      streaming: true,
-    });
-    fireEvent.click(screen.getByRole("button"));
-    // Expanded + still streaming: NO markdown parse and NO innerHTML swaps per
-    // delta — the body is chunked plain text (only the tail chunk updates).
-    // This is the O(n²) hole #302 left open (Safari whole-tab freeze).
-    expect(renderSpy).not.toHaveBeenCalled();
-    // Both paragraph chunks' raw text is present in the body.
-    expect(screen.getByText(/первый абзац размышлений/)).toBeDefined();
-    expect(screen.getByText(/второй абзац растёт/)).toBeDefined();
-  });
-
-  it("parses exactly once when streaming flips to done while expanded", () => {
-    const renderSpy = vi.mocked(renderChatMarkdown);
-    renderSpy.mockClear();
-    const { rerender } = renderBlock({
-      text: "**bold** reasoning",
-      tokens: 5,
-      streaming: true,
-    });
-    fireEvent.click(screen.getByRole("button"));
-    expect(renderSpy).not.toHaveBeenCalled();
-
-    // Finalization: the part's state flips streaming→done, the parent
-    // re-renders the row (the flip changes the message signature), and the
-    // block does its ONE markdown parse of the now-stable text.
-    rerender(
-      <MantineProvider>
-        <ReasoningBlock text="**bold** reasoning" tokens={5} streaming={false} />
-      </MantineProvider>,
-    );
-    expect(renderSpy).toHaveBeenCalledTimes(1);
-    // The parsed html branch rendered (the mock wraps the input in <p>…</p>).
-    expect(screen.getByText(/reasoning/)).toBeDefined();
-
-    // Further re-renders with unchanged props do not re-parse.
-    rerender(
-      <MantineProvider>
-        <ReasoningBlock text="**bold** reasoning" tokens={5} streaming={false} />
-      </MantineProvider>,
-    );
-    expect(renderSpy).toHaveBeenCalledTimes(1);
-  });
 });

apps/client/src/features/ai-chat/components/reasoning-block.tsx

@@ -5,7 +5,6 @@ import { useTranslation } from "react-i18next";
 import { estimateTokens } from "@/features/ai-chat/utils/count-stream-tokens.ts";
 import { collapseBlankLines } from "@/features/ai-chat/utils/collapse-blank-lines.ts";
 import { renderChatMarkdown } from "@/features/ai-chat/utils/markdown.ts";
-import { StreamingPlainText } from "@/features/ai-chat/components/streaming-plain-text.tsx";
 import classes from "@/features/ai-chat/components/ai-chat.module.css";
 
 interface ReasoningBlockProps {
@@ -16,10 +15,6 @@ interface ReasoningBlockProps {
    *  step/turn has finished. When absent (or 0) the count is estimated from the
    *  text length so it ticks live as the reasoning streams in. */
   tokens?: number;
-  /** True while the reasoning part is still streaming (part `state ===
-   *  "streaming"`). False means finalized: persisted history or `state ===
-   *  "done"`. Gates the markdown parse — see the invariant on the memo below. */
-  streaming?: boolean;
 }
 
 /**
@@ -32,30 +27,22 @@ interface ReasoningBlockProps {
  * Providers that don't stream reasoning TEXT still render this block from the
  * authoritative count alone (header only, empty body) so the cost is visible.
  */
-function ReasoningBlock({ text, tokens, streaming = false }: ReasoningBlockProps) {
+function ReasoningBlock({ text, tokens }: ReasoningBlockProps) {
   const { t } = useTranslation();
   const [open, setOpen] = useState(false);
 
   // Authoritative count wins; otherwise estimate live from the streamed text.
   const count = tokens && tokens > 0 ? tokens : estimateTokens(text);
   const trimmed = text.trim();
-  // Markdown parse invariant (per throttled ~20Hz stream delta the text GROWS):
+  // Memoize the markdown render so toggling `open` (or a parent re-render caused
-  //  1. Collapsed -> never parse (#302): the html is only shown inside
+  // by an unrelated streamed delta) does not re-parse the reasoning text; it
-  //     <Collapse in={open}>, so parsing for a hidden body would be an O(n²)
+  // recomputes only when the reasoning text itself changes (while it streams in).
-  //     marked + DOMPurify storm.
+  // collapseBlankLines collapses the blank-line gaps the model emits between every
-  //  2. Expanded + STREAMING -> no parse and no innerHTML swaps either: the body
+  // list item / paragraph so the reasoning renders compactly (tight lists, joined
-  //     renders as chunked plain text (StreamingPlainText) with a memoized
+  // paragraphs) — ONLY here, not in the normal answer.
-  //     stable prefix, so each delta updates only the tail chunk's text node.
-  //     This closes the O(n²) hole #302 left open ("expanded while streaming")
-  //     that froze the whole tab in Safari when watching the thinking stream.
-  //  3. Finalized + expanded -> exactly one parse: `trimmed` and `streaming`
-  //     are stable after the part is done, so this memo runs once per expand.
   const html = useMemo(
-    () =>
+    () => (trimmed ? renderChatMarkdown(collapseBlankLines(trimmed), {}) : ""),
-      open && trimmed && !streaming
+    [trimmed],
-        ? renderChatMarkdown(collapseBlankLines(trimmed), {})
-        : "",
-    [open, trimmed, streaming],
   );
 
   return (
@@ -92,12 +79,12 @@ function ReasoningBlock({ text, tokens, streaming = false }: ReasoningBlockProps
               dangerouslySetInnerHTML={{ __html: html }}
             />
           ) : (
-            // Still streaming (or markdown yielded nothing): chunked plain text.
+            <Text
-            // The wrapper carries the reasoningText styling; each chunk sets its
+              className={classes.reasoningText}
-            // own pre-wrap inline (NOT on this div — see ai-chat.module.css).
+              style={{ whiteSpace: "pre-wrap" }}
-            <div className={classes.reasoningText}>
+            >
-              <StreamingPlainText text={trimmed} />
+              {trimmed}
-            </div>
+            </Text>
           )}
         </Collapse>
       )}
@@ -105,7 +92,7 @@ function ReasoningBlock({ text, tokens, streaming = false }: ReasoningBlockProps
   );
 }
 
-// Memoized: re-renders only when `text`/`tokens`/`streaming` change (primitive
+// Memoized: re-renders only when `text`/`tokens` change (primitive props, default
-// props, default shallow compare), so a parent re-render during streaming of OTHER
+// shallow compare), so a parent re-render during streaming of OTHER content does
-// content does not re-run the markdown parse for an already-finalized reasoning block.
+// not re-run the markdown parse for an already-finalized reasoning block.
 export default memo(ReasoningBlock);

apps/client/src/features/ai-chat/components/streaming-plain-text.test.tsx

@@ -1,146 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { render } from "@testing-library/react";
-
-import {
-  splitPlainChunks,
-  StreamingPlainText,
-} from "./streaming-plain-text";
-
-describe("splitPlainChunks", () => {
-  // THE load-bearing property (see the invariant comment in the module): under
-  // append-only growth, every chunk except the LAST must be byte-identical
-  // between successive calls, so the memoized chunk components never re-render
-  // for the stable prefix and each stream delta touches only the tail chunk.
-  it("keeps all non-last chunks byte-identical across append-only growth", () => {
-    // A simulated reasoning stream covering: appends inside the last paragraph,
-    // appends that ADD new blank lines, growth of a trailing newline run, and a
-    // trailing separator later followed by text.
-    const steps = [
-      "Пер",
-      "Первый абзац",
-      "Первый абзац\n",
-      "Первый абзац\n\n",
-      "Первый абзац\n\n\n",
-      "Первый абзац\n\n\nВторой",
-      "Первый абзац\n\n\nВторой абзац растёт",
-      "Первый абзац\n\n\nВторой абзац растёт\n\nТретий",
-      "Первый абзац\n\n\nВторой абзац растёт\n\nТретий абзац\n\n",
-      "Первый абзац\n\n\nВторой абзац растёт\n\nТретий абзац\n\nЧетвёртый",
-    ];
-    let prev: string[] = [];
-    for (const text of steps) {
-      const next = splitPlainChunks(text);
-      // Lossless: chunks always reassemble into the exact input.
-      expect(next.join("")).toBe(text);
-      // Chunk count never shrinks (boundaries never disappear).
-      expect(next.length).toBeGreaterThanOrEqual(prev.length);
-      // Every previously-FINAL chunk (all but prev's last) is unchanged.
-      for (let i = 0; i < prev.length - 1; i++) {
-        expect(next[i]).toBe(prev[i]);
-      }
-      prev = next;
-    }
-    // Guard against a vacuous pass: the final split must be multi-chunk.
-    expect(prev.length).toBeGreaterThanOrEqual(4);
-  });
-
-  it("attaches the blank-line separator run to the preceding chunk", () => {
-    expect(splitPlainChunks("a\n\nb")).toEqual(["a\n\n", "b"]);
-    // A longer run is ONE separator, not several boundaries.
-    expect(splitPlainChunks("a\n\n\n\nb")).toEqual(["a\n\n\n\n", "b"]);
-    expect(splitPlainChunks("a\n\nb\n\n\nc")).toEqual(["a\n\n", "b\n\n\n", "c"]);
-  });
-
-  it("single newlines are not boundaries", () => {
-    expect(splitPlainChunks("a\nb\nc")).toEqual(["a\nb\nc"]);
-  });
-
-  // INTENTIONAL: CRLF blank lines are NOT boundaries (the regex is `\n{2,}`
-  // only). Supporting `(?:\r?\n){2,}` would break the stable-prefix invariant:
-  // a lone trailing `\r` is not a boundary, but a later-appended `\n` would
-  // merge with it into a new separator unit and retroactively create a boundary
-  // INSIDE previously-emitted text, moving old chunk edges. So CRLF input stays
-  // in one (still lossless) chunk — only granularity is coarser; LLM output is
-  // `\n` in practice. See the doc comment on splitPlainChunks.
-  it("keeps CRLF blank lines inside one chunk", () => {
-    expect(splitPlainChunks("a\r\n\r\nb")).toEqual(["a\r\n\r\nb"]);
-    // Mixed input: only pure-`\n` runs split.
-    expect(splitPlainChunks("a\r\n\r\nb\n\nc")).toEqual(["a\r\n\r\nb\n\n", "c"]);
-  });
-
-  it("never emits empty phantom chunks (multi-blank-line / trailing newlines)", () => {
-    expect(splitPlainChunks("")).toEqual([]);
-    // A trailing newline run stays inside the last chunk (it may still grow).
-    expect(splitPlainChunks("a\n")).toEqual(["a\n"]);
-    expect(splitPlainChunks("a\n\n")).toEqual(["a\n\n"]);
-    expect(splitPlainChunks("a\n\nb\n\n")).toEqual(["a\n\n", "b\n\n"]);
-    // Degenerate all-newlines input is a single deterministic chunk.
-    expect(splitPlainChunks("\n\n\n")).toEqual(["\n\n\n"]);
-    for (const text of ["a\n\n\nb\n\n", "x\n\n\n\n\ny\n\nz\n"]) {
-      for (const chunk of splitPlainChunks(text)) {
-        expect(chunk.length).toBeGreaterThan(0);
-      }
-    }
-  });
-});
-
-describe("StreamingPlainText", () => {
-  it("renders one block per chunk, stripping trailing separator newlines at display time", () => {
-    const text = "первый абзац\n\nвторой абзац\n\n\nтретий";
-    const { container } = render(<StreamingPlainText text={text} />);
-    const blocks = Array.from(container.querySelectorAll("div"));
-    // One block element per chunk.
-    expect(blocks.length).toBe(splitPlainChunks(text).length);
-    // DISPLAY-ONLY strip: each rendered block drops its chunk's trailing
-    // separator newlines — rendering them inside a pre-wrap block would add an
-    // empty line ON TOP of the block break (a doubled gap). The RAW chunks
-    // keep their separators (losslessness is asserted on splitPlainChunks
-    // above); multi-blank-line runs collapse to one uniform gap, consistent
-    // with collapseBlankLines on the finalized markdown path.
-    expect(blocks.map((b) => b.textContent)).toEqual([
-      "первый абзац",
-      "второй абзац",
-      "третий",
-    ]);
-    // The uniform paragraph gap comes from the block margin instead (matches
-    // the `.reasoningText p { margin: 0 0 4px }` rhythm of the markdown path).
-    for (const block of blocks) {
-      expect((block as HTMLElement).style.marginBottom).toBe("4px");
-    }
-  });
-
-  it("keeps interior newlines intact — only the trailing run is stripped", () => {
-    const text = "строка один\nстрока два\n\nхвост";
-    const { container } = render(<StreamingPlainText text={text} />);
-    const blocks = Array.from(container.querySelectorAll("div"));
-    expect(blocks.map((b) => b.textContent)).toEqual([
-      "строка один\nстрока два",
-      "хвост",
-    ]);
-  });
-
-  // SECURITY INVARIANT — the load-bearing property of the streaming path: the
-  // reasoning text is raw, untrusted model output rendered WITHOUT a sanitizer
-  // (no marked/DOMPurify, no innerHTML). PlainChunk emits it as a React text
-  // node, which escapes it, so HTML in the model output is inert. This test
-  // pins that the path is a TEXT sink, not an HTML sink: a future change to
-  // `dangerouslySetInnerHTML` (reintroducing XSS) MUST fail here.
-  //
-  // The existing tests assert via textContent, which strips tags and so cannot
-  // distinguish an escaped literal from injected DOM. This one asserts on the
-  // parsed DOM directly: if the markup were injected as HTML, the <img>/<b>
-  // would become real elements and querySelector would find them.
-  it("renders HTML-like reasoning as an escaped literal, never as injected DOM", () => {
-    const text = "<img src=x onerror=alert(1)>\n\n<b>hi</b>";
-    const { container } = render(<StreamingPlainText text={text} />);
-    // No DOM elements were created from the payload — it was NOT parsed as HTML.
-    expect(container.querySelector("img")).toBeNull();
-    expect(container.querySelector("b")).toBeNull();
-    // The raw markup survived verbatim as text (proving it is escaped, not
-    // interpreted). textContent alone can't prove this, but combined with the
-    // querySelector assertions above it does: the literals are present AND no
-    // elements exist.
-    expect(container.textContent).toContain("<b>hi</b>");
-    expect(container.textContent).toContain("<img src=x onerror=alert(1)>");
-  });
-});

apps/client/src/features/ai-chat/components/streaming-plain-text.tsx

@@ -1,90 +0,0 @@
-import { memo, useMemo } from "react";
-
-/**
- * Split plain text into chunks at blank-line (paragraph) boundaries, keeping
- * each separator run attached to the END of the preceding chunk, so the chunks
- * always reassemble byte-for-byte into the input.
- *
- * A boundary is the end of a maximal `\n{2,}` run that is followed by at least
- * one more character. A newline run that is a SUFFIX of the text is NOT a
- * boundary yet: under append-only growth it may still gain more newlines, and
- * cutting there would move the boundary on the next call.
- *
- * CRITICAL INVARIANT (load-bearing for StreamingPlainText's memoization): for
- * APPEND-ONLY growth of `text`, every chunk except the LAST is byte-identical
- * between successive calls — previously-emitted boundaries never move. Proof
- * sketch: appending never modifies existing characters, so (a) an existing
- * boundary's newline run and its following character are untouched and the
- * boundary persists at the same offset; (b) no NEW boundary can appear strictly
- * inside the old text, because a `\n{2,}` run followed by a character entirely
- * within the old text would already have been a boundary. New boundaries can
- * only materialize at or after the old text's end, i.e. inside the last chunk.
- *
- * CRLF is deliberately NOT a boundary: supporting `(?:\r?\n){2,}` would BREAK
- * the invariant above — a lone trailing `\r` is not a boundary, but a later-
- * appended `\n` would merge with it into a new separator unit and retroactively
- * create a boundary INSIDE previously-emitted text, moving old chunk edges.
- * With `\n`-only runs, appended characters can never extend a run that is
- * already followed by a non-`\n` character, so old boundaries are immutable.
- * CRLF blank lines therefore intentionally stay inside one chunk: correctness/
- * losslessness are unaffected, only chunk granularity for CRLF input (LLM
- * output is `\n` in practice).
- */
-export function splitPlainChunks(text: string): string[] {
-  const chunks: string[] = [];
-  let start = 0;
-  for (const match of text.matchAll(/\n{2,}/g)) {
-    const end = match.index + match[0].length;
-    // Suffix run: not a stable boundary yet (see the invariant above).
-    if (end >= text.length) break;
-    chunks.push(text.slice(start, end));
-    start = end;
-  }
-  if (start < text.length) chunks.push(text.slice(start));
-  return chunks;
-}
-
-/**
- * One immutable chunk. Memoized on its string prop: during streaming only the
- * TAIL chunk's text changes (see the splitPlainChunks invariant), so React
- * skips every stable chunk and the per-delta DOM work is a single text-node
- * update. `pre-wrap` is set per chunk (like the old raw-text fallback did), NOT
- * on the surrounding markdown-styled container — see the note in
- * ai-chat.module.css. Font/size/color are inherited from that container.
- *
- * DISPLAY-ONLY newline strip: the raw chunk keeps its trailing `\n{2,}`
- * separator run attached (the splitPlainChunks invariant, load-bearing for the
- * memo), but rendering those newlines inside a pre-wrap block would add an
- * empty line ON TOP of the block break — a doubled gap. So the RENDERED string
- * drops trailing newlines and the paragraph gap comes from `marginBottom: 4`
- * instead, matching the `.reasoningText p { margin: 0 0 4px }` rhythm of the
- * finalized markdown. Multi-blank-line runs thus collapse to one uniform gap,
- * consistent with `collapseBlankLines` on the markdown path. The last chunk
- * usually has no trailing newlines (strip is a no-op); its margin is harmless.
- */
-const PlainChunk = memo(function PlainChunk({ text }: { text: string }) {
-  return (
-    <div style={{ whiteSpace: "pre-wrap", marginBottom: 4 }}>
-      {text.replace(/\n+$/, "")}
-    </div>
-  );
-});
-
-/**
- * Renders still-streaming plain text as a list of paragraph chunks where only
- * the tail chunk changes per delta. No markdown, no sanitizer, no innerHTML —
- * this is the cheap streaming-time stand-in for the one-time markdown parse
- * that happens after the part is finalized (see reasoning-block.tsx).
- */
-export function StreamingPlainText({ text }: { text: string }) {
-  const chunks = useMemo(() => splitPlainChunks(text), [text]);
-  return (
-    <>
-      {chunks.map((chunk, index) => (
-        // Index keys are stable here: chunks are append-only (the invariant),
-        // so an index never gets a different chunk's content mid-stream.
-        <PlainChunk key={index} text={chunk} />
-      ))}
-    </>
-  );
-}

apps/client/src/features/ai-chat/hooks/use-open-ai-chat.ts

@@ -27,9 +27,7 @@ export function useOpenAiChatForCurrentPage() {
   // AiChatWindow lives in a pathless parent layout route, so useParams() can't
   // see :pageSlug — match the full path against the authenticated page route.
   const match = useMatch("/s/:spaceSlug/p/:pageSlug");
-  // A page slugId (10-char nanoid), NOT a uuid; the server resolves it to the
+  const pageId = extractPageSlugId(match?.params?.pageSlug);
-  // real page uuid (PageRepo.findById accepts slugId or uuid).
-  const slugId = extractPageSlugId(match?.params?.pageSlug);
 
   return useCallback(async () => {
     // Re-clicks while the window is already open (incl. minimized) must NOT
@@ -42,9 +40,9 @@ export function useOpenAiChatForCurrentPage() {
     // connection the first click reads as a hung control until the POST returns.
     setWindowOpen(true);
     let resolved: string | null = activeChatId; // off-a-page: keep current
-    if (slugId) {
+    if (pageId) {
       try {
-        resolved = await getBoundChat(slugId); // null => fresh chat
+        resolved = await getBoundChat(pageId); // null => fresh chat
       } catch {
         resolved = null; // fail-soft: a fresh chat is always a safe fallback
       }
@@ -60,7 +58,7 @@ export function useOpenAiChatForCurrentPage() {
   }, [
     windowOpen,
     activeChatId,
-    slugId,
+    pageId,
     setWindowOpen,
     setActiveChatId,
     setDraft,

apps/client/src/features/ai-chat/queries/ai-chat-query.ts

@@ -12,7 +12,6 @@ import {
   deleteAiChat,
   deleteAiRole,
   getAiChatMessages,
-  getAiChatRun,
   getAiChats,
   getAiRoleCatalog,
   getAiRoleCatalogBundle,
@@ -25,7 +24,6 @@ import {
 import {
   IAiChat,
   IAiChatMessageRow,
-  IAiChatRunResponse,
   IAiRole,
   IAiRoleCatalog,
   IAiRoleCatalogBundle,
@@ -36,7 +34,6 @@ import {
   IAiRoleUpdateFromCatalogResult,
 } from "@/features/ai-chat/types/ai-chat.types.ts";
 import { IPagination } from "@/lib/types.ts";
-import { runPollInterval } from "@/features/ai-chat/utils/run-polling.ts";
 
 export const AI_CHATS_RQ_KEY = ["ai-chats"];
 export const AI_ROLES_RQ_KEY = ["ai-roles"];
@@ -54,18 +51,16 @@ export const AI_CHAT_MESSAGES_RQ_KEY = (chatId: string) => [
   "ai-chat-messages",
   chatId,
 ];
-export const AI_CHAT_RUN_RQ_KEY = (chatId: string) => ["ai-chat-run", chatId];
 
 /** Paginated list of the current user's chats (auto-loads further pages). */
 export function useAiChatsQuery() {
   const query = useInfiniteQuery({
     queryKey: AI_CHATS_RQ_KEY,
-    queryFn: ({ pageParam }) => getAiChats({ cursor: pageParam, limit: 50 }),
+    queryFn: ({ pageParam }) =>
+      getAiChats({ cursor: pageParam, limit: 50 }),
     initialPageParam: undefined as string | undefined,
     getNextPageParam: (lastPage) =>
-      lastPage.meta.hasNextPage
+      lastPage.meta.hasNextPage ? (lastPage.meta.nextCursor ?? undefined) : undefined,
-        ? (lastPage.meta.nextCursor ?? undefined)
-        : undefined,
   });
 
   const data = useMemo<IPagination<IAiChat> | undefined>(() => {
@@ -95,9 +90,7 @@ export function useAiChatMessagesQuery(chatId: string | undefined) {
       getAiChatMessages({ chatId: chatId as string, cursor: pageParam }),
     initialPageParam: undefined as string | undefined,
     getNextPageParam: (lastPage) =>
-      lastPage.meta.hasNextPage
+      lastPage.meta.hasNextPage ? (lastPage.meta.nextCursor ?? undefined) : undefined,
-        ? (lastPage.meta.nextCursor ?? undefined)
-        : undefined,
     enabled: !!chatId,
   });
 
@@ -138,34 +131,6 @@ export function useAiChatMessagesQuery(chatId: string | undefined) {
   };
 }
 
-/**
- * Reconnect to a chat's latest agent run and LIVE-FOLLOW it (#184). While the run
- * is active the query re-polls every {@link runPollInterval} ms (driven off the
- * fetched `run.status`, the same status-keyed refetchInterval pattern as the
- * embeddings reindex polling); once the run reaches a terminal status — or there
- * is no run — the interval returns `false` and polling stops on its own. Polling
- * is thus naturally bounded by the run terminating; no separate timeout cap.
- *
- * `enabled` gates the whole thing: callers pass `false` when the autonomous-runs
- * feature is off (the endpoint is NOT flag-gated server-side, but with the feature
- * off the chat has no runs, so polling would only ever return `{ run: null }`) OR
- * when THIS tab is the one actively streaming the run (the live SSE owns the view,
- * so we must not also poll/merge). The global `retry: false` means a failed fetch
- * leaves `data` undefined, so refetchInterval(undefined run) returns false — a
- * failed fetch can never spin a tight loop.
- */
-export function useAiChatRunQuery(
-  chatId: string | undefined,
-  enabled: boolean,
-) {
-  return useQuery<IAiChatRunResponse, Error>({
-    queryKey: AI_CHAT_RUN_RQ_KEY(chatId ?? ""),
-    queryFn: () => getAiChatRun(chatId as string),
-    enabled: !!chatId && enabled,
-    refetchInterval: (query) => runPollInterval(query.state.data?.run),
-  });
-}
-
 export function useRenameAiChatMutation() {
   const queryClient = useQueryClient();
   const { t } = useTranslation();
@@ -315,14 +280,11 @@ export function useImportAiRolesFromCatalogMutation() {
     mutationFn: (payload) => importAiRolesFromCatalog(payload),
     onSuccess: (result) => {
       notifications.show({
-        message: t(
+        message: t("Imported {{created}}, renamed {{renamed}}, skipped {{skipped}}", {
-          "Imported {{created}}, renamed {{renamed}}, skipped {{skipped}}",
-          {
           created: result.created,
           renamed: result.renamed,
           skipped: result.skipped,
-          },
+        }),
-        ),
       });
       // Surface partial failures (e.g. unique-name races) as a red warning.
       if (result.errors.length > 0) {

apps/client/src/features/ai-chat/queries/ai-chat-run-query.test.tsx

@@ -1,92 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import React from "react";
-import { renderHook, waitFor } from "@testing-library/react";
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import type { IAiChatRunResponse } from "@/features/ai-chat/types/ai-chat.types.ts";
-
-// react-i18next is pulled in transitively by ai-chat-query.ts (the mutation hooks
-// use it); stub it so the module imports cleanly in this hook test.
-vi.mock("react-i18next", () => ({
-  useTranslation: () => ({ t: (key: string) => key }),
-}));
-
-vi.mock("@mantine/notifications", () => ({
-  notifications: { show: vi.fn() },
-}));
-
-// Mock the whole service module; only getAiChatRun is exercised here, but the
-// other named exports must exist so ai-chat-query.ts imports resolve.
-vi.mock("@/features/ai-chat/services/ai-chat-service.ts", () => ({
-  getAiChatRun: vi.fn(),
-  getAiChatMessages: vi.fn(),
-  getAiChats: vi.fn(),
-  getAiRoleCatalog: vi.fn(),
-  getAiRoleCatalogBundle: vi.fn(),
-  getAiRoles: vi.fn(),
-  importAiRolesFromCatalog: vi.fn(),
-  createAiRole: vi.fn(),
-  deleteAiChat: vi.fn(),
-  deleteAiRole: vi.fn(),
-  renameAiChat: vi.fn(),
-  updateAiRole: vi.fn(),
-  updateAiRoleFromCatalog: vi.fn(),
-}));
-
-import { getAiChatRun } from "@/features/ai-chat/services/ai-chat-service.ts";
-import { useAiChatRunQuery } from "@/features/ai-chat/queries/ai-chat-query.ts";
-
-function createWrapper() {
-  const queryClient = new QueryClient({
-    defaultOptions: { queries: { retry: false } },
-  });
-  return function Wrapper({ children }: { children: React.ReactNode }) {
-    return (
-      <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
-    );
-  };
-}
-
-const runningResponse: IAiChatRunResponse = {
-  run: { id: "run-1", chatId: "c1", status: "running" },
-  message: {
-    id: "a1",
-    role: "assistant",
-    content: "working...",
-    createdAt: "2026-01-01T00:00:00Z",
-  },
-};
-
-describe("useAiChatRunQuery — enable gating", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("fetches the run when enabled (passive observer, feature on)", async () => {
-    vi.mocked(getAiChatRun).mockResolvedValue(runningResponse);
-    const { result } = renderHook(() => useAiChatRunQuery("c1", true), {
-      wrapper: createWrapper(),
-    });
-    await waitFor(() => expect(result.current.isSuccess).toBe(true));
-    expect(getAiChatRun).toHaveBeenCalledWith("c1");
-    expect(result.current.data?.run?.status).toBe("running");
-  });
-
-  it("does NOT fetch when disabled (this tab is the streamer / feature off)", async () => {
-    vi.mocked(getAiChatRun).mockResolvedValue(runningResponse);
-    renderHook(() => useAiChatRunQuery("c1", false), {
-      wrapper: createWrapper(),
-    });
-    // Give any errant fetch a chance to fire, then assert none did.
-    await new Promise((r) => setTimeout(r, 20));
-    expect(getAiChatRun).not.toHaveBeenCalled();
-  });
-
-  it("does NOT fetch when there is no chat id", async () => {
-    vi.mocked(getAiChatRun).mockResolvedValue(runningResponse);
-    renderHook(() => useAiChatRunQuery(undefined, true), {
-      wrapper: createWrapper(),
-    });
-    await new Promise((r) => setTimeout(r, 20));
-    expect(getAiChatRun).not.toHaveBeenCalled();
-  });
-});

apps/client/src/features/ai-chat/services/ai-chat-service.ts

@@ -5,7 +5,6 @@ import {
   IAiChatListParams,
   IAiChatMessageRow,
   IAiChatMessagesParams,
-  IAiChatRunResponse,
   IAiRole,
   IAiRoleCatalog,
   IAiRoleCatalogBundle,
@@ -43,47 +42,13 @@ export async function getAiChatMessages(
   return req.data;
 }
 
-/**
- * Reconnect to the latest agent run of a chat (#184). Returns the run's
- * persisted lifecycle state and the assistant message it materializes (the
- * partial output while the run is in-flight, the final output once it finished).
- * The DB is the source of truth, so this works for an in-flight run (the browser
- * dropped, the run kept going) and a finished one alike; `{ run: null }` when the
- * chat has never had a run. Owner-gated server-side (the requesting user must own
- * the chat); it is NOT flag-gated — when the feature is off the chat simply has no
- * runs, so the endpoint returns `{ run: null }`.
- */
-export async function getAiChatRun(
-  chatId: string,
-): Promise<IAiChatRunResponse> {
-  const req = await api.post<IAiChatRunResponse>("/ai-chat/run", { chatId });
-  return req.data;
-}
-
-/**
- * Explicitly STOP the active agent run of a chat (#184). This is the ONLY thing
- * that ends a DETACHED run — a mere browser disconnect (aborting the local SSE)
- * is deliberately ignored server-side, so the client must call this to actually
- * stop an autonomous run. Targeted by `chatId` (the server resolves whatever run
- * is active on it); owner-gated server-side. Returns `{ stopped }` — false when
- * there was nothing active to stop.
- */
-export async function stopRun(
-  chatId: string,
-): Promise<{ stopped: boolean }> {
-  const req = await api.post<{ stopped: boolean }>("/ai-chat/stop", { chatId });
-  return req.data;
-}
-
 /**
  * Resolve the chat bound to a document (the current user's most-recent chat
  * created on that page), or null when there is none. Drives auto-open-on-page.
  */
-export async function getBoundChat(slugId: string): Promise<string | null> {
+export async function getBoundChat(pageId: string): Promise<string | null> {
-  // The `pageId` body field accepts a page slugId or a uuid; the server resolves
-  // it to the real page uuid (the wire key stays `pageId` for the DTO).
   const req = await api.post<{ chatId: string | null }>("/ai-chat/bound-chat", {
-    pageId: slugId,
+    pageId,
   });
   return req.data.chatId;
 }

apps/client/src/features/ai-chat/types/ai-chat.types.ts

@@ -200,38 +200,6 @@ export interface IAiChatMessageRow {
   createdAt: string;
 }
 
-/**
- * A persisted agent-run row (#184), mirroring the `ai_chat_runs` fields the
- * client reads from `POST /ai-chat/run`. Only `status` is load-bearing for the
- * reconnect-and-live-update UX (it drives the poll cadence); the rest are carried
- * for display/diagnostics. The DB is the source of truth, so this resolves for an
- * in-flight run (the browser dropped, the run kept going) and a finished one.
- */
-export interface IAiChatRun {
-  id: string;
-  chatId: string;
-  // 'pending' | 'running' | 'succeeded' | 'failed' | 'aborted'. The first two are
-  // ACTIVE (keep polling); the rest are TERMINAL (stop polling).
-  status: "pending" | "running" | "succeeded" | "failed" | "aborted" | string;
-  error?: string | null;
-  stepCount?: number;
-  assistantMessageId?: string | null;
-  startedAt?: string | null;
-  finishedAt?: string | null;
-  createdAt?: string;
-  updatedAt?: string;
-}
-
-/**
- * Response of `POST /ai-chat/run` (#184): the latest run of a chat and the
- * assistant message it materializes (the partial/final output, projected from the
- * persisted rows). Both are `null` when the chat has never had a run.
- */
-export interface IAiChatRunResponse {
-  run: IAiChatRun | null;
-  message: IAiChatMessageRow | null;
-}
-
 export interface IAiChatListParams extends QueryParams {}
 
 export interface IAiChatMessagesParams {

apps/client/src/features/ai-chat/utils/run-polling.test.ts

@@ -1,303 +0,0 @@
-import { describe, it, expect } from "vitest";
-import type { UIMessage } from "@ai-sdk/react";
-import type { IAiChatRun } from "@/features/ai-chat/types/ai-chat.types.ts";
-import {
-  RUN_POLL_INTERVAL_MS,
-  isRunActive,
-  runPollInterval,
-  shouldObserveRun,
-  shouldClearStoppingLatch,
-  shouldClearLatchOnQueryError,
-  mergeObservedMessage,
-} from "./run-polling.ts";
-
-function makeRun(status: string): IAiChatRun {
-  return { id: "run-1", chatId: "c1", status };
-}
-
-function makeMsg(id: string, text: string): UIMessage {
-  return {
-    id,
-    role: "assistant",
-    parts: [{ type: "text", text }],
-  } as UIMessage;
-}
-
-describe("isRunActive", () => {
-  it("treats pending and running as active", () => {
-    expect(isRunActive(makeRun("pending"))).toBe(true);
-    expect(isRunActive(makeRun("running"))).toBe(true);
-  });
-
-  it("treats terminal / unknown / nullish as not active", () => {
-    expect(isRunActive(makeRun("succeeded"))).toBe(false);
-    expect(isRunActive(makeRun("failed"))).toBe(false);
-    expect(isRunActive(makeRun("aborted"))).toBe(false);
-    expect(isRunActive(makeRun("weird-future-status"))).toBe(false);
-    expect(isRunActive(null)).toBe(false);
-    expect(isRunActive(undefined)).toBe(false);
-  });
-});
-
-describe("runPollInterval (the refetchInterval helper)", () => {
-  it("returns 2000ms while the run is pending/running", () => {
-    expect(runPollInterval(makeRun("pending"))).toBe(RUN_POLL_INTERVAL_MS);
-    expect(runPollInterval(makeRun("running"))).toBe(RUN_POLL_INTERVAL_MS);
-    expect(RUN_POLL_INTERVAL_MS).toBe(2000);
-  });
-
-  it("returns false (stop polling) once the run is terminal", () => {
-    expect(runPollInterval(makeRun("succeeded"))).toBe(false);
-    expect(runPollInterval(makeRun("failed"))).toBe(false);
-    expect(runPollInterval(makeRun("aborted"))).toBe(false);
-  });
-
-  it("returns false (no polling) when there is no run", () => {
-    expect(runPollInterval(null)).toBe(false);
-    expect(runPollInterval(undefined)).toBe(false);
-  });
-});
-
-describe("shouldObserveRun (observer-vs-streamer decision)", () => {
-  it("observes an active run when this tab is NOT the local streamer", () => {
-    expect(shouldObserveRun(makeRun("running"), false)).toBe(true);
-    expect(shouldObserveRun(makeRun("pending"), false)).toBe(true);
-  });
-
-  it("observes a terminal run too (so the final output shows on reopen)", () => {
-    expect(shouldObserveRun(makeRun("succeeded"), false)).toBe(true);
-  });
-
-  it("does NOT observe when this tab IS the streamer (no double-render)", () => {
-    expect(shouldObserveRun(makeRun("running"), true)).toBe(false);
-    expect(shouldObserveRun(makeRun("succeeded"), true)).toBe(false);
-  });
-
-  it("does NOT observe when there is no run", () => {
-    expect(shouldObserveRun(null, false)).toBe(false);
-    expect(shouldObserveRun(undefined, false)).toBe(false);
-  });
-});
-
-describe("shouldClearStoppingLatch (#234 latch-release decision)", () => {
-  // The one case the latch SHOULD clear: we requested a stop, we are the passive
-  // observer (not streaming), and the CURRENT run is terminal.
-  it("clears only when stopping, observing, and the run is terminal", () => {
-    expect(
-      shouldClearStoppingLatch({
-        stoppingRun: true,
-        run: makeRun("aborted"),
-        isLocalStreaming: false,
-      }),
-    ).toBe(true);
-    expect(
-      shouldClearStoppingLatch({
-        stoppingRun: true,
-        run: makeRun("succeeded"),
-        isLocalStreaming: false,
-      }),
-    ).toBe(true);
-    expect(
-      shouldClearStoppingLatch({
-        stoppingRun: true,
-        run: makeRun("failed"),
-        isLocalStreaming: false,
-      }),
-    ).toBe(true);
-  });
-
-  // Round-3 regression: clearing while THIS tab is still the local streamer would
-  // re-open the flash for the current turn the moment we switch to observer role.
-  // A predicate lacking the streaming gate would (wrongly) return true here.
-  it("does NOT clear while this tab is the local streamer", () => {
-    expect(
-      shouldClearStoppingLatch({
-        stoppingRun: true,
-        run: makeRun("aborted"),
-        isLocalStreaming: true,
-      }),
-    ).toBe(false);
-    expect(
-      shouldClearStoppingLatch({
-        stoppingRun: true,
-        run: makeRun("succeeded"),
-        isLocalStreaming: true,
-      }),
-    ).toBe(false);
-  });
-
-  // The detached run keeps growing after a local abort — while it is still
-  // active the latch MUST hold so the observer merge stays suppressed.
-  it("does NOT clear while the run is still active", () => {
-    expect(
-      shouldClearStoppingLatch({
-        stoppingRun: true,
-        run: makeRun("running"),
-        isLocalStreaming: false,
-      }),
-    ).toBe(false);
-    expect(
-      shouldClearStoppingLatch({
-        stoppingRun: true,
-        run: makeRun("pending"),
-        isLocalStreaming: false,
-      }),
-    ).toBe(false);
-  });
-
-  // #234 F4: on Stop the stale PREVIOUS-turn run is removed from the cache, so the
-  // observed `run` is null until the current turn's run is fetched fresh. A null
-  // run HOLDS the latch — it can never clear against the just-removed stale run,
-  // only against the current turn's own terminal run once observed.
-  it("does NOT clear against a removed/absent run (F4 stale-run guard)", () => {
-    expect(
-      shouldClearStoppingLatch({
-        stoppingRun: true,
-        run: null,
-        isLocalStreaming: false,
-      }),
-    ).toBe(false);
-    expect(
-      shouldClearStoppingLatch({
-        stoppingRun: true,
-        run: undefined,
-        isLocalStreaming: false,
-      }),
-    ).toBe(false);
-  });
-
-  it("does NOT clear when no stop was requested", () => {
-    expect(
-      shouldClearStoppingLatch({
-        stoppingRun: false,
-        run: makeRun("aborted"),
-        isLocalStreaming: false,
-      }),
-    ).toBe(false);
-  });
-});
-
-describe("shouldClearLatchOnQueryError (#234 F7 error-safety-net decision)", () => {
-  // This guards the REAL anti-flash decision the component's run-query-error
-  // safety-net effect uses (ai-chat-window.tsx wires the effect to THIS helper,
-  // not a copy — so the test is non-vacuous vs the live code).
-
-  // (b) The F7 hole: a TRANSIENT run-query error while `run` is STILL ACTIVE must
-  // NOT clear the latch. TanStack Query v5 retains `data` on error, so
-  // runQueryFailed can be true while the held run is still pending/running.
-  // Against the PRE-F7 condition (without `!isRunActive(run)`) this would return
-  // true — so this assertion fails on the buggy code (non-vacuous).
-  it("does NOT clear on a transient error while the run is still ACTIVE (F7)", () => {
-    expect(
-      shouldClearLatchOnQueryError({
-        stoppingRun: true,
-        isLocalStreaming: false,
-        runQueryFailed: true,
-        run: makeRun("running"),
-      }),
-    ).toBe(false);
-    expect(
-      shouldClearLatchOnQueryError({
-        stoppingRun: true,
-        isLocalStreaming: false,
-        runQueryFailed: true,
-        run: makeRun("pending"),
-      }),
-    ).toBe(false);
-  });
-
-  // (a) The genuine permanent-null-freeze: run cache cleared by removeQueries +
-  // the refetch keeps ERRORING, so `run === null`. This is the ONLY case the
-  // safety-net exists to cure — it MUST clear so the frozen view resumes.
-  it("clears on a permanent error when the run is null (permanent-null-freeze)", () => {
-    expect(
-      shouldClearLatchOnQueryError({
-        stoppingRun: true,
-        isLocalStreaming: false,
-        runQueryFailed: true,
-        run: null,
-      }),
-    ).toBe(true);
-    expect(
-      shouldClearLatchOnQueryError({
-        stoppingRun: true,
-        isLocalStreaming: false,
-        runQueryFailed: true,
-        run: undefined,
-      }),
-    ).toBe(true);
-  });
-
-  // A TERMINAL run also satisfies `!isRunActive`; clearing then is harmless — the
-  // terminal effect (shouldClearStoppingLatch) already clears for a terminal run,
-  // so this only ever agrees with it. Asserted so the (c) reasoning is pinned.
-  it("clears on an error when the run is terminal (harmless, agrees with terminal effect)", () => {
-    expect(
-      shouldClearLatchOnQueryError({
-        stoppingRun: true,
-        isLocalStreaming: false,
-        runQueryFailed: true,
-        run: makeRun("aborted"),
-      }),
-    ).toBe(true);
-  });
-
-  it("does NOT clear without an actual query error", () => {
-    expect(
-      shouldClearLatchOnQueryError({
-        stoppingRun: true,
-        isLocalStreaming: false,
-        runQueryFailed: false,
-        run: null,
-      }),
-    ).toBe(false);
-  });
-
-  it("does NOT clear while this tab is the local streamer", () => {
-    expect(
-      shouldClearLatchOnQueryError({
-        stoppingRun: true,
-        isLocalStreaming: true,
-        runQueryFailed: true,
-        run: null,
-      }),
-    ).toBe(false);
-  });
-
-  it("does NOT clear when no stop was requested", () => {
-    expect(
-      shouldClearLatchOnQueryError({
-        stoppingRun: false,
-        isLocalStreaming: false,
-        runQueryFailed: true,
-        run: null,
-      }),
-    ).toBe(false);
-  });
-});
-
-describe("mergeObservedMessage", () => {
-  it("replaces the message with the same id in place (per-step growth)", () => {
-    const prev = [makeMsg("u1", "hi"), makeMsg("a1", "step 1")];
-    const observed = makeMsg("a1", "step 1\nstep 2");
-    const next = mergeObservedMessage(prev, observed);
-    expect(next).toHaveLength(2);
-    expect(next[1]).toBe(observed);
-    expect(next[0]).toBe(prev[0]); // untouched
-    expect(next).not.toBe(prev); // new array (never mutates input)
-  });
-
-  it("appends when the observed message is not yet present", () => {
-    const prev = [makeMsg("u1", "hi")];
-    const observed = makeMsg("a1", "first token");
-    const next = mergeObservedMessage(prev, observed);
-    expect(next).toHaveLength(2);
-    expect(next[1]).toBe(observed);
-  });
-
-  it("returns the original list unchanged when there is nothing to merge", () => {
-    const prev = [makeMsg("u1", "hi")];
-    expect(mergeObservedMessage(prev, null)).toBe(prev);
-    expect(mergeObservedMessage(prev, undefined)).toBe(prev);
-  });
-});

apps/client/src/features/ai-chat/utils/run-polling.ts

@@ -1,151 +0,0 @@
-import type { UIMessage } from "@ai-sdk/react";
-import type { IAiChatRun } from "@/features/ai-chat/types/ai-chat.types.ts";
-
-/**
- * Reconnect-and-live-follow helpers (#184). When a chat is reopened while its
- * agent run is STILL going, this tab is a PASSIVE OBSERVER: it did not start the
- * run here (no local SSE stream), so it catches up by POLLING the reconnect
- * endpoint (`POST /ai-chat/run`) and merging the run's incrementally-persisted
- * assistant message into the rendered thread. These are the small pure decisions
- * that machinery hangs off, extracted so they can be unit-tested in isolation
- * (mirrors how reindex polling / editor-sync-state are tested).
- */
-
-/** How often to re-poll the reconnect endpoint while a run is ACTIVE. */
-export const RUN_POLL_INTERVAL_MS = 2000;
-
-// 'pending' and 'running' are the two ACTIVE statuses; 'succeeded' | 'failed' |
-// 'aborted' are TERMINAL (and any unknown future status is treated as terminal,
-// so a stale/odd value never polls forever).
-const ACTIVE_STATUSES = new Set(["pending", "running"]);
-
-/** Whether a run is still going (worth polling / merging live updates from). */
-export function isRunActive(run: IAiChatRun | null | undefined): boolean {
-  return !!run && ACTIVE_STATUSES.has(run.status);
-}
-
-/**
- * The TanStack Query `refetchInterval` value for the run query: poll every
- * {@link RUN_POLL_INTERVAL_MS} while the run is active, and `false` (stop) once
- * it is terminal or there is no run. Polling is thus naturally bounded by the run
- * reaching a terminal status — no separate timeout cap is needed.
- */
-export function runPollInterval(
-  run: IAiChatRun | null | undefined,
-): number | false {
-  return isRunActive(run) ? RUN_POLL_INTERVAL_MS : false;
-}
-
-/**
- * Observer-vs-streamer decision. We render the polled run message (catch up +
- * keep advancing) ONLY when this tab is a passive observer: there IS a run AND
- * this tab is NOT the one locally streaming it (we reconnected, we didn't start
- * it here). When this tab is the streamer, the live SSE stream owns the view, so
- * we neither poll nor merge — avoiding a double-render fight. Terminal runs still
- * merge (so the final persisted output is shown on reopen); the poll itself is
- * stopped separately by {@link runPollInterval}.
- */
-export function shouldObserveRun(
-  run: IAiChatRun | null | undefined,
-  localStreaming: boolean,
-): boolean {
-  return !!run && !localStreaming;
-}
-
-/**
- * Should the "stopping" latch — which suppresses the observer re-stream flash
- * after the user pressed Stop — be RELEASED now? All three must hold:
- *  - `stoppingRun`: we actually requested a stop (otherwise nothing to release);
- *  - `!isLocalStreaming`: this tab is NOT the local streamer. While we are the
- *    streamer the run query is disabled, so the observed `run` is not the run we
- *    are following — releasing the latch then would re-open the flash for the
- *    current turn the instant we switch to observer role;
- *  - the observed `run` EXISTS and has reached a TERMINAL status.
- *
- * The null / still-active `run` case is the #234 F4 invariant. On Stop the stale
- * PREVIOUS-turn run is removed from the query cache (`removeQueries`), so `run`
- * is null until the CURRENT turn's run is re-fetched fresh; a null or active run
- * therefore HOLDS the latch, so it can only ever clear against the current turn's
- * OWN terminal run — never a stale cached one. (The cache removal itself is
- * integration-level in AiChatWindow; this predicate encodes the decision given
- * whatever run is currently observed, and a stale terminal run is
- * indistinguishable from a current terminal run at the predicate level — hence
- * the cache removal is what guarantees only the current run is ever passed here.)
- */
-export function shouldClearStoppingLatch(args: {
-  stoppingRun: boolean;
-  run: IAiChatRun | null | undefined;
-  isLocalStreaming: boolean;
-}): boolean {
-  const { stoppingRun, run, isLocalStreaming } = args;
-  if (!stoppingRun || isLocalStreaming) return false;
-  return !!run && !isRunActive(run);
-}
-
-/**
- * Should the "stopping" latch be RELEASED by the run-query ERROR safety-net?
- * (#234 F7 — a NEW path of the same re-stream flash the F4 latch exists to
- * prevent.) After Stop, `handleServerStop` clears the run cache; the terminal
- * effect then holds the latch via `if (!run) return` until the CURRENT turn's run
- * is fetched fresh. If that refetch instead ERRORS permanently, `run` stays null,
- * its status-keyed refetchInterval is off, and nothing would ever observe a
- * terminal run — freezing the view with the observer merge suppressed. This
- * safety-net cures ONLY that genuine permanent-null-freeze.
- *
- * All four must hold:
- *  - `stoppingRun`: we actually requested a stop (otherwise nothing to release);
- *  - `!isLocalStreaming`: this tab is NOT the local streamer (same reason as
- *    {@link shouldClearStoppingLatch});
- *  - `runQueryFailed`: the run query is in its error state (TanStack Query v5 with
- *    retry:false — isError);
- *  - `!isRunActive(run)`: the observed `run` is NOT an active (pending/running)
- *    held run. This is the F7 gate. In TanStack Query v5 the query's `data` is
- *    RETAINED on error, so `runQueryFailed` can be true while `run` is STILL an
- *    ACTIVE run (a single transient GET-run failure in the window between Stop and
- *    settle). Without this gate a transient error would release the latch early —
- *    re-opening the observer merge and flashing the growing detached run over the
- *    frozen row (exactly the F4 flash). Gating on the run NOT being active means we
- *    only ever cure the permanent-null-freeze (`run === null`, so
- *    `isRunActive(null)` is false), never release against an active run.
- *
- * (A terminal `run` also satisfies `!isRunActive(run)`; clearing then is harmless
- * — the terminal effect's {@link shouldClearStoppingLatch} already clears the
- * latch for a terminal run, so this only ever agrees with it, never conflicts.)
- *
- * INVARIANT (do not break): clearing the latch on the `run === null` branch is safe
- * ONLY because the run query's `refetchInterval` (see {@link runPollInterval}) stops
- * polling when the data is empty — so after we clear on null+error there is no
- * subsequent auto-poll that could return a still-active detached run and re-open the
- * merge. If `refetchInterval` is ever changed to keep polling on `run === null`/on
- * error, this null-branch clear would re-open the F7 flash through the null path.
- * Do not change the run query's refetchInterval without re-checking this path.
- */
-export function shouldClearLatchOnQueryError(args: {
-  stoppingRun: boolean;
-  isLocalStreaming: boolean;
-  runQueryFailed: boolean;
-  run: IAiChatRun | null | undefined;
-}): boolean {
-  const { stoppingRun, isLocalStreaming, runQueryFailed, run } = args;
-  return (
-    stoppingRun && !isLocalStreaming && runQueryFailed && !isRunActive(run)
-  );
-}
-
-/**
- * Merge an observed assistant message into the rendered list: replace the message
- * with the same id in place (the in-progress assistant row is already seeded from
- * history, so per-step growth replaces it), or append it when absent. Returns a
- * new array; the input is never mutated.
- */
-export function mergeObservedMessage(
-  messages: UIMessage[],
-  observed: UIMessage | null | undefined,
-): UIMessage[] {
-  if (!observed) return messages;
-  const idx = messages.findIndex((m) => m.id === observed.id);
-  if (idx === -1) return [...messages, observed];
-  const next = messages.slice();
-  next[idx] = observed;
-  return next;
-}

apps/client/src/features/comment/components/comment-content-view.test.tsx

@@ -1,250 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { render, screen } from "@testing-library/react";
-import { MantineProvider } from "@mantine/core";
-import { MemoryRouter } from "react-router-dom";
-
-// matchMedia (read by MantineProvider) is stubbed globally in vitest.setup.ts.
-
-// The fallback path renders the full TipTap editor; stub it so we can assert the
-// safety valve fired without pulling in the editor stack.
-vi.mock("@/features/comment/components/comment-editor", () => ({
-  default: () => <div data-testid="comment-editor-fallback" />,
-}));
-
-// Mention rendering hits react-query; stub the page/share queries so the mention
-// case renders in isolation.
-vi.mock("@/features/page/queries/page-query.ts", () => ({
-  usePageQuery: () => ({ data: undefined, isLoading: false, isError: false }),
-}));
-vi.mock("@/features/share/queries/share-query.ts", () => ({
-  useSharePageQuery: () => ({ data: undefined }),
-}));
-
-import { CommentContentView } from "./comment-content-view";
-
-function renderView(content: string | object) {
-  return render(
-    <MantineProvider>
-      <MemoryRouter>
-        <CommentContentView content={content} />
-      </MemoryRouter>
-    </MantineProvider>,
-  );
-}
-
-const doc = (content: any[]) => JSON.stringify({ type: "doc", content });
-const para = (content: any[]) => ({ type: "paragraph", content });
-const text = (t: string, marks?: any[]) => ({ type: "text", text: t, marks });
-
-describe("CommentContentView", () => {
-  it("renders paragraphs as <p> with text", () => {
-    const { container } = renderView(doc([para([text("Hello world")])]));
-    expect(screen.getByText("Hello world")).toBeDefined();
-    expect(container.querySelector("p")).not.toBeNull();
-  });
-
-  it("reproduces the read-only CommentEditor DOM nesting for CSS parity", () => {
-    const { container } = renderView(doc([para([text("x")])]));
-    // outer .commentEditor > .ProseMirror (module) > .ProseMirror (global) > p
-    const globalPm = container.querySelector("div.ProseMirror > p");
-    expect(globalPm).not.toBeNull();
-  });
-
-  it("renders the bold mark as <strong>", () => {
-    const { container } = renderView(
-      doc([para([text("bold", [{ type: "bold" }])])]),
-    );
-    const el = container.querySelector("strong");
-    expect(el?.textContent).toBe("bold");
-  });
-
-  it("renders the italic mark as <em>", () => {
-    const { container } = renderView(
-      doc([para([text("it", [{ type: "italic" }])])]),
-    );
-    expect(container.querySelector("em")?.textContent).toBe("it");
-  });
-
-  it("renders the strike mark as <s>", () => {
-    const { container } = renderView(
-      doc([para([text("st", [{ type: "strike" }])])]),
-    );
-    expect(container.querySelector("s")?.textContent).toBe("st");
-  });
-
-  it("renders the underline mark as <u> (not the editor fallback)", () => {
-    const { container } = renderView(
-      doc([para([text("un", [{ type: "underline" }])])]),
-    );
-    expect(container.querySelector("u")?.textContent).toBe("un");
-    // Underline is a supported mark, so no degrade to the editor fallback.
-    expect(screen.queryByTestId("comment-editor-fallback")).toBeNull();
-  });
-
-  it("renders the code mark as <code>", () => {
-    const { container } = renderView(
-      doc([para([text("co", [{ type: "code" }])])]),
-    );
-    expect(container.querySelector("code")?.textContent).toBe("co");
-  });
-
-  it("renders the link mark as an anchor with safe rel/target", () => {
-    const { container } = renderView(
-      doc([
-        para([
-          text("click", [
-            { type: "link", attrs: { href: "https://example.com" } },
-          ]),
-        ]),
-      ]),
-    );
-    const a = container.querySelector("a");
-    expect(a?.getAttribute("href")).toBe("https://example.com");
-    expect(a?.getAttribute("target")).toBe("_blank");
-    expect(a?.getAttribute("rel")).toBe("noopener noreferrer nofollow");
-    expect(a?.textContent).toBe("click");
-  });
-
-  it("neutralizes a javascript: link href (stored XSS) while keeping the text", () => {
-    const { container } = renderView(
-      doc([
-        para([
-          text("click", [
-            { type: "link", attrs: { href: "javascript:alert(1)" } },
-          ]),
-        ]),
-      ]),
-    );
-    const a = container.querySelector("a");
-    expect(a).not.toBeNull();
-    // No navigable javascript: href — attribute is absent (or empty).
-    expect(a?.getAttribute("href")).toBeFalsy();
-    // The link text is still rendered.
-    expect(a?.textContent).toBe("click");
-  });
-
-  it("neutralizes a control-char-obfuscated javascript: href", () => {
-    const { container } = renderView(
-      doc([
-        para([
-          text("x", [
-            { type: "link", attrs: { href: "java\tscript:alert(1)" } },
-          ]),
-        ]),
-      ]),
-    );
-    expect(container.querySelector("a")?.getAttribute("href")).toBeFalsy();
-  });
-
-  it("neutralizes a data: link href", () => {
-    const { container } = renderView(
-      doc([
-        para([
-          text("x", [
-            {
-              type: "link",
-              attrs: { href: "data:text/html,<script>alert(1)</script>" },
-            },
-          ]),
-        ]),
-      ]),
-    );
-    expect(container.querySelector("a")?.getAttribute("href")).toBeFalsy();
-  });
-
-  it("preserves a mailto: link href (allowlisted scheme)", () => {
-    const { container } = renderView(
-      doc([
-        para([
-          text("mail", [
-            { type: "link", attrs: { href: "mailto:a@b.com" } },
-          ]),
-        ]),
-      ]),
-    );
-    expect(container.querySelector("a")?.getAttribute("href")).toBe(
-      "mailto:a@b.com",
-    );
-  });
-
-  it("preserves a relative link href (no scheme, not a script vector)", () => {
-    const { container } = renderView(
-      doc([
-        para([
-          text("rel", [{ type: "link", attrs: { href: "/some/path" } }]),
-        ]),
-      ]),
-    );
-    expect(container.querySelector("a")?.getAttribute("href")).toBe(
-      "/some/path",
-    );
-  });
-
-  it("nests multiple marks on one text node", () => {
-    const { container } = renderView(
-      doc([para([text("x", [{ type: "bold" }, { type: "italic" }])])]),
-    );
-    // bold wraps italic (or vice versa) — both elements exist around the text.
-    expect(container.querySelector("strong")).not.toBeNull();
-    expect(container.querySelector("em")).not.toBeNull();
-    expect(screen.getByText("x")).toBeDefined();
-  });
-
-  it("renders hardBreak as <br/>", () => {
-    const { container } = renderView(
-      doc([para([text("a"), { type: "hardBreak" }, text("b")])]),
-    );
-    expect(container.querySelector("br")).not.toBeNull();
-  });
-
-  it("renders a user mention as a styled span", () => {
-    const { container } = renderView(
-      doc([
-        para([
-          {
-            type: "mention",
-            attrs: { label: "Alice", entityType: "user", entityId: "u1" },
-          },
-        ]),
-      ]),
-    );
-    expect(screen.getByText("@Alice")).toBeDefined();
-    // No fallback to the editor.
-    expect(screen.queryByTestId("comment-editor-fallback")).toBeNull();
-  });
-
-  it("renders a page mention as a link", () => {
-    const { container } = renderView(
-      doc([
-        para([
-          {
-            type: "mention",
-            attrs: {
-              label: "Some Page",
-              entityType: "page",
-              slugId: "pg1",
-            },
-          },
-        ]),
-      ]),
-    );
-    expect(container.querySelector("a")).not.toBeNull();
-    expect(screen.getByText("Some Page")).toBeDefined();
-  });
-
-  it("renders a legacy plain-text (non-JSON) string as plain text", () => {
-    renderView("just a legacy string");
-    expect(screen.getByText("just a legacy string")).toBeDefined();
-    expect(screen.queryByTestId("comment-editor-fallback")).toBeNull();
-  });
-
-  it("falls back to CommentEditor for an unknown node type", () => {
-    renderView(doc([{ type: "codeBlock", content: [text("x")] }]));
-    expect(screen.getByTestId("comment-editor-fallback")).toBeDefined();
-  });
-
-  it("falls back to CommentEditor for malformed JSON", () => {
-    renderView('{"type":"doc","content":[');
-    expect(screen.getByTestId("comment-editor-fallback")).toBeDefined();
-  });
-});

apps/client/src/features/comment/components/comment-content-view.tsx

@@ -1,199 +0,0 @@
-import React from "react";
-import classes from "./comment.module.css";
-import { MentionContent } from "@/features/editor/components/mention/mention-view";
-import CommentEditor from "@/features/comment/components/comment-editor";
-
-// Static, editor-free renderer of a comment body (ProseMirror JSON). It walks the
-// document and emits plain DOM, avoiding the cost of a full TipTap/ProseMirror
-// instance per comment (the panel used to spin up 400+ editors on mount).
-//
-// The supported node/mark set MUST mirror what CommentEditor enables
-// (StarterKit + Mention + LinkExtension). Anything outside that set makes the
-// whole comment degrade to the read-only CommentEditor via the fallback below,
-// so we never show a half-rendered comment.
-
-// Sentinel thrown when we hit a node/mark we don't know how to render statically.
-// Caught at the top level to trigger the CommentEditor fallback for the whole comment.
-class UnknownNodeError extends Error {}
-
-// Protocol allowlist mirroring @tiptap/extension-link's default (the read-only
-// CommentEditor path relies on it to blank javascript:/data: hrefs). The static
-// renderer must apply the SAME sanitization because the backend stores comment
-// content verbatim and React does not neutralize javascript: in an href.
-const ALLOWED_URI_SCHEMES = /^(?:https?|ftps?|mailto|tel|callto|sms|cid|xmpp):/i;
-
-function safeHref(href: unknown): string | undefined {
-  if (typeof href !== "string") return undefined;
-  // Strip control chars/whitespace that could smuggle a scheme past the test
-  // (e.g. "java\tscript:").
-  const cleaned = href.replace(/[\u0000-\u0020]/g, "").trim();
-  // Allow relative/anchor/protocol-relative links (no scheme) — not script vectors.
-  if (!/^[a-z][a-z0-9+.-]*:/i.test(cleaned)) return href;
-  return ALLOWED_URI_SCHEMES.test(cleaned) ? href : undefined;
-}
-
-interface PMMark {
-  type: string;
-  attrs?: Record<string, any>;
-}
-
-interface PMNode {
-  type: string;
-  attrs?: Record<string, any>;
-  content?: PMNode[];
-  text?: string;
-  marks?: PMMark[];
-}
-
-// Wrap a text node's string in its marks (marks nest, e.g. bold + italic).
-function renderMarks(
-  text: React.ReactNode,
-  marks: PMMark[] | undefined,
-  keyPrefix: string,
-): React.ReactNode {
-  if (!marks || marks.length === 0) return text;
-
-  return marks.reduce<React.ReactNode>((acc, mark, i) => {
-    const key = `${keyPrefix}-m${i}`;
-    switch (mark.type) {
-      case "bold":
-        return <strong key={key}>{acc}</strong>;
-      case "italic":
-        return <em key={key}>{acc}</em>;
-      case "strike":
-        return <s key={key}>{acc}</s>;
-      case "underline":
-        // StarterKit enables the Underline extension by default (Mod-u) and
-        // CommentEditor does not disable it, so real comments can carry this
-        // mark. Render it here rather than degrading the whole comment.
-        return <u key={key}>{acc}</u>;
-      case "code":
-        return <code key={key}>{acc}</code>;
-      case "link": {
-        // LinkExtension (TiptapLink) opens links in a new tab; keep the same
-        // safe rel semantics the editor produces. Sanitize the href against the
-        // extension's protocol allowlist — a disallowed scheme (javascript:,
-        // data:) yields undefined so the anchor is non-navigable but still shows
-        // its text, matching how extension-link blanks a bad href.
-        const href = safeHref(mark.attrs?.href);
-        return (
-          <a
-            key={key}
-            href={href}
-            target="_blank"
-            rel="noopener noreferrer nofollow"
-          >
-            {acc}
-          </a>
-        );
-      }
-      default:
-        throw new UnknownNodeError(`Unknown mark type: ${mark.type}`);
-    }
-  }, text);
-}
-
-function renderNode(node: PMNode, key: string): React.ReactNode {
-  switch (node.type) {
-    case "paragraph":
-      return <p key={key}>{renderChildren(node.content, key)}</p>;
-    case "text":
-      return (
-        <React.Fragment key={key}>
-          {renderMarks(node.text ?? "", node.marks, key)}
-        </React.Fragment>
-      );
-    case "hardBreak":
-      return <br key={key} />;
-    case "mention":
-      return (
-        <span key={key} style={{ display: "inline" }}>
-          <MentionContent attrs={node.attrs as any} />
-        </span>
-      );
-    default:
-      throw new UnknownNodeError(`Unknown node type: ${node.type}`);
-  }
-}
-
-function renderChildren(
-  content: PMNode[] | undefined,
-  keyPrefix: string,
-): React.ReactNode {
-  if (!content) return null;
-  return content.map((child, i) => renderNode(child, `${keyPrefix}-${i}`));
-}
-
-// Reproduce the exact DOM nesting the read-only CommentEditor renders so the
-// scoped CSS in comment.module.css (which targets
-// `.commentEditor .ProseMirror :global(.ProseMirror)` and `.ProseMirror p`)
-// applies pixel-for-pixel. Read-only => no data-editable / data-surface attrs.
-function Shell({ children }: { children: React.ReactNode }) {
-  return (
-    <div className={classes.commentEditor}>
-      <div className={classes.ProseMirror}>
-        <div className="ProseMirror">{children}</div>
-      </div>
-    </div>
-  );
-}
-
-interface CommentContentViewProps {
-  content: string | object;
-}
-
-export function CommentContentView({ content }: CommentContentViewProps) {
-  // Degrade this single comment to the old editor-based render (safety valve).
-  const fallback = () => {
-    if (import.meta.env.DEV) {
-      console.warn(
-        "CommentContentView: unsupported comment content, falling back to editor",
-      );
-    }
-    return <CommentEditor defaultContent={content} editable={false} />;
-  };
-
-  let doc: unknown = content;
-
-  if (typeof content === "string") {
-    try {
-      doc = JSON.parse(content);
-    } catch {
-      const trimmed = content.trim();
-      // Looks like it was meant to be JSON but is malformed -> safety-valve fallback.
-      if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-        return fallback();
-      }
-      // Otherwise it's a legacy plain-text comment: render as a single paragraph.
-      return (
-        <Shell>
-          <p>{content}</p>
-        </Shell>
-      );
-    }
-  }
-
-  // Double-stringified / legacy plain-text stored as a JSON string.
-  if (typeof doc === "string") {
-    return (
-      <Shell>
-        <p>{doc}</p>
-      </Shell>
-    );
-  }
-
-  try {
-    const pmDoc = doc as PMNode;
-    if (!pmDoc || typeof pmDoc !== "object" || pmDoc.type !== "doc") {
-      throw new UnknownNodeError("Not a ProseMirror doc");
-    }
-    return <Shell>{renderChildren(pmDoc.content, "n")}</Shell>;
-  } catch (err) {
-    if (err instanceof UnknownNodeError) {
-      return fallback();
-    }
-    throw err;
-  }
-}
-
-export default CommentContentView;

apps/client/src/features/comment/components/comment-list-item.test.tsx

@@ -1,5 +1,5 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { describe, it, expect, vi } from "vitest";
-import { render, screen, fireEvent, waitFor } from "@testing-library/react";
+import { render, screen } from "@testing-library/react";
 import { MantineProvider } from "@mantine/core";
 import { IComment } from "@/features/comment/types/comment.types";
 
@@ -7,75 +7,18 @@ import { IComment } from "@/features/comment/types/comment.types";
 
 // The comment mutation hooks reach out to react-query/network — stub them so the
 // component renders in isolation. We only assert the AI-badge rendering branch.
-const applyMutateAsync = vi.fn();
-const dismissMutateAsync = vi.fn();
-const updateMutateAsync = vi.fn();
 vi.mock("@/features/comment/queries/comment-query", () => ({
   useDeleteCommentMutation: () => ({ mutateAsync: vi.fn() }),
   useResolveCommentMutation: () => ({ mutateAsync: vi.fn() }),
-  useUpdateCommentMutation: () => ({ mutateAsync: updateMutateAsync }),
+  useUpdateCommentMutation: () => ({ mutateAsync: vi.fn() }),
-  useApplySuggestionMutation: () => ({
-    mutateAsync: applyMutateAsync,
-    isPending: false,
-  }),
-  useDismissSuggestionMutation: () => ({
-    mutateAsync: dismissMutateAsync,
-    isPending: false,
-  }),
 }));
 
-// The document the mocked editor emits via onUpdate when the edit form is open.
-// Duplicated inside the mock factory (below) to keep the factory self-contained.
-const EDITED_DOC = {
-  type: "doc",
-  content: [
-    { type: "paragraph", content: [{ type: "text", text: "edited via editor" }] },
-  ],
-};
-
 // CommentEditor pulls in the full TipTap editor stack; replace it with a stub.
-// In edit mode the stub exposes buttons that fire the real onUpdate/onSave props
+vi.mock("@/features/comment/components/comment-editor", () => ({
-// so the edit->save/cancel flow can be driven without a live editor.
+  default: () => <div data-testid="comment-editor" />,
-vi.mock("@/features/comment/components/comment-editor", () => {
-  const doc = {
-    type: "doc",
-    content: [
-      { type: "paragraph", content: [{ type: "text", text: "edited via editor" }] },
-    ],
-  };
-  return {
-    default: ({ onUpdate, onSave }: any) => (
-      <div data-testid="comment-editor">
-        <button
-          type="button"
-          data-testid="editor-emit-update"
-          onClick={() => onUpdate?.(doc)}
-        />
-        <button
-          type="button"
-          data-testid="editor-emit-save"
-          onClick={() => onSave?.()}
-        />
-      </div>
-    ),
-  };
-});
-
-// CommentContentView (used for the read-only body) imports the mention view,
-// which pulls page-query -> main.tsx (createRoot). Stub the queries so the item
-// renders in isolation without the app entry side-effect.
-vi.mock("@/features/page/queries/page-query.ts", () => ({
-  usePageQuery: () => ({ data: undefined, isLoading: false, isError: false }),
-}));
-vi.mock("@/features/share/queries/share-query.ts", () => ({
-  useSharePageQuery: () => ({ data: undefined }),
 }));
 
 import CommentListItem from "./comment-list-item";
-import {
-  canShowApply,
-  canShowDismiss,
-} from "@/features/comment/utils/suggestion";
 
 const baseComment = (over?: Partial<IComment>): IComment =>
   ({
@@ -89,21 +32,10 @@ const baseComment = (over?: Partial<IComment>): IComment =>
     ...over,
   }) as IComment;
 
-function renderItem(
+function renderItem(comment: IComment) {
-  comment: IComment,
-  canEdit = true,
-  canComment = true,
-  userSpaceRole?: string,
-) {
   return render(
     <MantineProvider>
-      <CommentListItem
+      <CommentListItem comment={comment} pageId="page-1" canComment={true} />
-        comment={comment}
-        pageId="page-1"
-        canComment={canComment}
-        canEdit={canEdit}
-        userSpaceRole={userSpaceRole}
-      />
     </MantineProvider>,
   );
 }
@@ -155,306 +87,3 @@ describe("CommentListItem — agent avatar stack", () => {
   // are covered directly in agent-avatar-stack.test.tsx; this integration suite
   // only guards the insertion gate (agent → stack, user → no stack).
 });
-
-describe("CommentListItem — suggested edit (#315)", () => {
-  const suggestion = (over?: Partial<IComment>): IComment =>
-    baseComment({
-      selection: "old wording here",
-      suggestedText: "new wording here",
-      ...over,
-    });
-
-  it("renders the было→стало diff and an Apply button when canEdit and not applied/resolved", () => {
-    const { container } = renderItem(suggestion(), true);
-    // Old text appears as the selection quote (a single unsplit Text node).
-    expect(screen.getAllByText("old wording here").length).toBeGreaterThan(0);
-    // The new line is now rendered as per-fragment spans (intraline diff, #331),
-    // so it is no longer a single text node — assert the concatenated content.
-    expect(container.textContent).toContain("new wording here");
-    // Apply button is present.
-    expect(screen.getByRole("button", { name: "Apply" })).toBeDefined();
-    // No Applied badge yet.
-    expect(screen.queryByText("Applied")).toBeNull();
-  });
-
-  it("hides the Apply button when canEdit is false", () => {
-    const { container } = renderItem(suggestion(), false);
-    // Diff still renders (as per-fragment spans, #331)...
-    expect(container.textContent).toContain("new wording here");
-    // ...but no Apply button.
-    expect(screen.queryByRole("button", { name: "Apply" })).toBeNull();
-  });
-
-  it("shows an Applied badge (no Apply button) once suggestionAppliedAt is set", () => {
-    renderItem(suggestion({ suggestionAppliedAt: new Date() }), true);
-    expect(screen.getByText("Applied")).toBeDefined();
-    expect(screen.queryByRole("button", { name: "Apply" })).toBeNull();
-  });
-
-  it("hides the Apply button once the thread is resolved", () => {
-    renderItem(suggestion({ resolvedAt: new Date() }), true);
-    expect(screen.queryByRole("button", { name: "Apply" })).toBeNull();
-  });
-
-  it("calls the apply mutation when the Apply button is clicked", () => {
-    applyMutateAsync.mockClear();
-    renderItem(suggestion(), true);
-    fireEvent.click(screen.getByRole("button", { name: "Apply" }));
-    expect(applyMutateAsync).toHaveBeenCalledWith({
-      commentId: "c-1",
-      pageId: "page-1",
-    });
-  });
-
-  it("does not render the diff block for a reply (child) comment", () => {
-    renderItem(
-      suggestion({ parentCommentId: "c-0" }),
-      true,
-    );
-    expect(screen.queryByText("new wording here")).toBeNull();
-    expect(screen.queryByRole("button", { name: "Apply" })).toBeNull();
-  });
-});
-
-describe("CommentListItem — dismiss suggestion (#329)", () => {
-  const suggestion = (over?: Partial<IComment>): IComment =>
-    baseComment({
-      selection: "old wording here",
-      suggestedText: "new wording here",
-      ...over,
-    });
-
-  // A space admin (userSpaceRole="admin") satisfies the owner-or-admin gate
-  // regardless of who authored the comment; the tests below use it as the lever
-  // since the currentUser atom is unseeded (null) in this harness.
-  it("renders a Dismiss button alongside Apply when canEdit and canComment (owner/admin)", () => {
-    renderItem(suggestion(), true, true, "admin");
-    expect(screen.getByRole("button", { name: "Apply" })).toBeDefined();
-    expect(screen.getByRole("button", { name: "Dismiss" })).toBeDefined();
-  });
-
-  it("shows Dismiss but NOT Apply for an admin commenter who cannot edit", () => {
-    renderItem(suggestion(), false, true, "admin");
-    expect(screen.queryByRole("button", { name: "Apply" })).toBeNull();
-    expect(screen.getByRole("button", { name: "Dismiss" })).toBeDefined();
-  });
-
-  it("hides Dismiss when the viewer cannot comment", () => {
-    renderItem(suggestion(), false, false, "admin");
-    expect(screen.queryByRole("button", { name: "Dismiss" })).toBeNull();
-    expect(screen.queryByRole("button", { name: "Apply" })).toBeNull();
-  });
-
-  it("hides Dismiss for a non-owner non-admin even with canComment (#338 F5: mirrors server 403)", () => {
-    // canComment=true but NOT a space admin and NOT the comment owner (the
-    // currentUser atom is null while the comment is authored by user-1), so the
-    // server would 403 a dismiss — the button must not be shown at all.
-    renderItem(suggestion(), false, true, "member");
-    expect(screen.queryByRole("button", { name: "Dismiss" })).toBeNull();
-  });
-
-  it("hides Dismiss once the thread is resolved", () => {
-    renderItem(suggestion({ resolvedAt: new Date() }), true, true, "admin");
-    expect(screen.queryByRole("button", { name: "Dismiss" })).toBeNull();
-  });
-
-  it("hides Dismiss (shows the Applied badge) once applied", () => {
-    renderItem(suggestion({ suggestionAppliedAt: new Date() }), true, true, "admin");
-    expect(screen.queryByRole("button", { name: "Dismiss" })).toBeNull();
-    expect(screen.getByText("Applied")).toBeDefined();
-  });
-
-  it("calls the dismiss mutation when the Dismiss button is clicked", () => {
-    dismissMutateAsync.mockClear();
-    renderItem(suggestion(), true, true, "admin");
-    fireEvent.click(screen.getByRole("button", { name: "Dismiss" }));
-    expect(dismissMutateAsync).toHaveBeenCalledWith({
-      commentId: "c-1",
-      pageId: "page-1",
-    });
-  });
-});
-
-describe("canShowApply predicate", () => {
-  const c = (over?: Partial<IComment>): IComment =>
-    ({ suggestedText: "x", ...over }) as IComment;
-
-  it("true when suggestion present, editable, not applied/resolved, top-level", () => {
-    expect(canShowApply(c(), true)).toBe(true);
-  });
-  it("false without edit permission", () => {
-    expect(canShowApply(c(), false)).toBe(false);
-  });
-  it("false when no suggestion", () => {
-    expect(canShowApply(c({ suggestedText: null }), true)).toBe(false);
-  });
-  it("false when already applied", () => {
-    expect(canShowApply(c({ suggestionAppliedAt: new Date() }), true)).toBe(
-      false,
-    );
-  });
-  it("false when resolved", () => {
-    expect(canShowApply(c({ resolvedAt: new Date() }), true)).toBe(false);
-  });
-  it("false for a reply comment", () => {
-    expect(canShowApply(c({ parentCommentId: "p" }), true)).toBe(false);
-  });
-});
-
-describe("canShowDismiss predicate", () => {
-  const c = (over?: Partial<IComment>): IComment =>
-    ({ suggestedText: "x", ...over }) as IComment;
-
-  it("true when suggestion present, can comment, owner/admin, not applied/resolved, top-level", () => {
-    expect(canShowDismiss(c(), true, true)).toBe(true);
-  });
-  it("false without comment permission", () => {
-    expect(canShowDismiss(c(), false, true)).toBe(false);
-  });
-  it("false when not owner and not admin (#338 F5)", () => {
-    expect(canShowDismiss(c(), true, false)).toBe(false);
-  });
-  it("false when no suggestion", () => {
-    expect(canShowDismiss(c({ suggestedText: null }), true, true)).toBe(false);
-  });
-  it("false when already applied", () => {
-    expect(canShowDismiss(c({ suggestionAppliedAt: new Date() }), true, true)).toBe(
-      false,
-    );
-  });
-  it("false when resolved", () => {
-    expect(canShowDismiss(c({ resolvedAt: new Date() }), true, true)).toBe(false);
-  });
-  it("false for a reply comment", () => {
-    expect(canShowDismiss(c({ parentCommentId: "p" }), true, true)).toBe(false);
-  });
-});
-
-describe("CommentListItem — edit -> save/cancel flow (#340 F3)", () => {
-  const body = (t: string) =>
-    JSON.stringify({
-      type: "doc",
-      content: [{ type: "paragraph", content: [{ type: "text", text: t }] }],
-    });
-
-  // The edit menu item is gated on the viewer owning the comment
-  // (currentUser.id === creatorId). currentUserAtom is atomWithStorage-backed,
-  // so seed localStorage to make the viewer the owner (creatorId "user-1").
-  beforeEach(() => {
-    updateMutateAsync.mockClear();
-    localStorage.setItem(
-      "currentUser",
-      JSON.stringify({ user: { id: "user-1", name: "Owner" } }),
-    );
-  });
-  afterEach(() => {
-    localStorage.clear();
-  });
-
-  async function openEditor() {
-    // Open the comment menu, then click "Edit comment" to toggle into edit mode.
-    fireEvent.click(screen.getByLabelText("Comment menu"));
-    fireEvent.click(await screen.findByText("Edit comment"));
-    // Edit form (mocked editor + actions) is now mounted.
-    await screen.findByTestId("comment-editor");
-  }
-
-  it("saves the edited content and, on cache update, shows the new body", async () => {
-    const { rerender } = renderItem(
-      baseComment({ content: body("original body") }),
-    );
-    // Static body first.
-    expect(screen.getByText("original body")).toBeDefined();
-
-    await openEditor();
-
-    // Editor emits an update (populates editContentRef), then Save is clicked.
-    fireEvent.click(screen.getByTestId("editor-emit-update"));
-    fireEvent.click(screen.getByRole("button", { name: "Save" }));
-
-    // mutateAsync is called with the stringified edited doc.
-    expect(updateMutateAsync).toHaveBeenCalledWith({
-      commentId: "c-1",
-      content: JSON.stringify(EDITED_DOC),
-    });
-
-    // On success the form closes (isEditing -> false); the static body renders
-    // from the comment.content prop again.
-    await waitFor(() =>
-      expect(screen.queryByTestId("comment-editor")).toBeNull(),
-    );
-
-    // Simulate the cache invalidation swapping in a new comment object with the
-    // updated content — the static body reflects it.
-    rerender(
-      <MantineProvider>
-        <CommentListItem
-          comment={baseComment({ content: body("updated body after save") })}
-          pageId="page-1"
-          canComment={true}
-          canEdit={true}
-        />
-      </MantineProvider>,
-    );
-    expect(screen.getByText("updated body after save")).toBeDefined();
-    expect(screen.queryByText("original body")).toBeNull();
-  });
-
-  it("cancel restores the static body and does not call the update mutation", async () => {
-    renderItem(baseComment({ content: body("original body") }));
-    await openEditor();
-
-    // Type something (editContentRef set), then cancel.
-    fireEvent.click(screen.getByTestId("editor-emit-update"));
-    fireEvent.click(screen.getByRole("button", { name: "Cancel" }));
-
-    // Editor unmounts, static body restored, no save happened.
-    await waitFor(() =>
-      expect(screen.queryByTestId("comment-editor")).toBeNull(),
-    );
-    expect(screen.getByText("original body")).toBeDefined();
-    expect(updateMutateAsync).not.toHaveBeenCalled();
-  });
-
-  it("saving without editing sends the existing content (editContentRef cleared after cancel)", async () => {
-    renderItem(baseComment({ content: body("original body") }));
-
-    // Cancel path clears editContentRef...
-    await openEditor();
-    fireEvent.click(screen.getByTestId("editor-emit-update"));
-    fireEvent.click(screen.getByRole("button", { name: "Cancel" }));
-    await waitFor(() =>
-      expect(screen.queryByTestId("comment-editor")).toBeNull(),
-    );
-
-    // ...so re-opening and saving WITHOUT an update falls back to comment.content.
-    await openEditor();
-    fireEvent.click(screen.getByRole("button", { name: "Save" }));
-    expect(updateMutateAsync).toHaveBeenCalledWith({
-      commentId: "c-1",
-      content: JSON.stringify(body("original body")),
-    });
-  });
-});
-
-describe("CommentListItem — read-only body renders statically", () => {
-  it("renders the comment body as static text without a TipTap editor", () => {
-    renderItem(
-      baseComment({
-        content: JSON.stringify({
-          type: "doc",
-          content: [
-            {
-              type: "paragraph",
-              content: [{ type: "text", text: "Hello static world" }],
-            },
-          ],
-        }),
-      }),
-    );
-    // Body text is present...
-    expect(screen.getByText("Hello static world")).toBeDefined();
-    // ...and it did NOT go through the (mocked) CommentEditor instance.
-    expect(screen.queryByTestId("comment-editor")).toBeNull();
-  });
-});

apps/client/src/features/comment/components/comment-list-item.tsx

@@ -1,29 +1,21 @@
-import { Group, Text, Box, Badge, Button } from "@mantine/core";
+import { Group, Text, Box } from "@mantine/core";
 import { AgentAvatarStack } from "@/components/ui/agent-avatar-stack.tsx";
-import React, { useMemo, useRef, useState } from "react";
+import React, { useEffect, useRef, useState } from "react";
 import classes from "./comment.module.css";
 import { useAtom, useAtomValue } from "jotai";
 import { useTimeAgo } from "@/hooks/use-time-ago";
 import CommentEditor from "@/features/comment/components/comment-editor";
-import CommentContentView from "@/features/comment/components/comment-content-view";
 import { pageEditorAtom } from "@/features/editor/atoms/editor-atoms";
 import CommentActions from "@/features/comment/components/comment-actions";
 import CommentMenu from "@/features/comment/components/comment-menu";
 import ResolveComment from "@/features/comment/components/resolve-comment";
 import { useHover } from "@mantine/hooks";
 import {
-  useApplySuggestionMutation,
   useDeleteCommentMutation,
-  useDismissSuggestionMutation,
   useResolveCommentMutation,
   useUpdateCommentMutation,
 } from "@/features/comment/queries/comment-query";
 import { IComment } from "@/features/comment/types/comment.types";
-import {
-  canShowApply,
-  canShowDismiss,
-  computeSuggestionDiff,
-} from "@/features/comment/utils/suggestion";
 import { CustomAvatar } from "@/components/ui/custom-avatar.tsx";
 import { currentUserAtom } from "@/features/user/atoms/current-user-atom.ts";
 import { useTranslation } from "react-i18next";
@@ -32,10 +24,6 @@ interface CommentListItemProps {
   comment: IComment;
   pageId: string;
   canComment: boolean;
-  // Real page-edit permission (page.permissions.canEdit) — gates the suggestion
-  // "Apply" button. Distinct from `canComment`, which may be looser (viewers
-  // allowed to comment cannot apply edits).
-  canEdit?: boolean;
   userSpaceRole?: string;
 }
 
@@ -43,7 +31,6 @@ function CommentListItem({
   comment,
   pageId,
   canComment,
-  canEdit,
   userSpaceRole,
 }: CommentListItemProps) {
   const { t } = useTranslation();
@@ -51,43 +38,30 @@ function CommentListItem({
   const [isEditing, setIsEditing] = useState(false);
   const [isLoading, setIsLoading] = useState(false);
   const editor = useAtomValue(pageEditorAtom);
+  const [content, setContent] = useState<string>(comment.content);
   const editContentRef = useRef<any>(null);
   const updateCommentMutation = useUpdateCommentMutation();
   const deleteCommentMutation = useDeleteCommentMutation(comment.pageId);
   const resolveCommentMutation = useResolveCommentMutation();
-  const applySuggestionMutation = useApplySuggestionMutation();
-  const dismissSuggestionMutation = useDismissSuggestionMutation();
   const [currentUser] = useAtom(currentUserAtom);
   const createdAtAgo = useTimeAgo(comment.createdAt);
 
-  // Intraline "before -> after" diff (#331) for a suggested edit: only the
+  useEffect(() => {
-  // fragments that actually changed get emphasised inside the red/green block,
+    setContent(comment.content);
-  // instead of striking through / greening the whole line. Memoised on the
+  }, [comment]);
-  // (selection, suggestedText) pair so it recomputes only when they change.
-  const suggestionDiff = useMemo(
-    () =>
-      comment.suggestedText != null
-        ? computeSuggestionDiff(comment.selection ?? "", comment.suggestedText)
-        : null,
-    [comment.selection, comment.suggestedText],
-  );
-
-  // Owner-or-space-admin gate (#338): mirrors the server authz for both the
-  // comment menu (edit/delete) and the suggestion Dismiss button, so we never
-  // render an action the server will 403.
-  const isOwnerOrAdmin =
-    currentUser?.user?.id === comment.creatorId || userSpaceRole === "admin";
-
 
   async function handleUpdateComment() {
     try {
       setIsLoading(true);
       const commentToUpdate = {
         commentId: comment.id,
-        content: JSON.stringify(editContentRef.current ?? comment.content),
+        content: JSON.stringify(editContentRef.current ?? content),
       };
       await updateCommentMutation.mutateAsync(commentToUpdate);
+      if (editContentRef.current) {
+        setContent(editContentRef.current);
         editContentRef.current = null;
+      }
       setIsEditing(false);
     } catch (error) {
       console.error("Failed to update comment:", error);
@@ -121,31 +95,6 @@ function CommentListItem({
     }
   }
 
-  async function handleApplySuggestion() {
-    try {
-      await applySuggestionMutation.mutateAsync({
-        commentId: comment.id,
-        pageId: comment.pageId,
-      });
-    } catch (error) {
-      // Errors surface via the mutation's onError notification (incl. 409).
-      console.error("Failed to apply suggestion:", error);
-    }
-  }
-
-  async function handleDismissSuggestion() {
-    try {
-      await dismissSuggestionMutation.mutateAsync({
-        commentId: comment.id,
-        pageId: comment.pageId,
-      });
-    } catch (error) {
-      // Idempotent races are reconciled to success in the mutation's onError;
-      // anything else surfaces there as a notification.
-      console.error("Failed to dismiss suggestion:", error);
-    }
-  }
-
   function handleCommentClick(comment: IComment) {
     const el = document.querySelector(
       `.comment-mark[data-comment-id="${comment.id}"]`,
@@ -221,7 +170,7 @@ function CommentListItem({
                 />
               )}
 
-              {isOwnerOrAdmin && (
+              {(currentUser?.user?.id === comment.creatorId || userSpaceRole === 'admin') && (
                 <CommentMenu
                   onEditComment={handleEditToggle}
                   onDeleteComment={handleDeleteComment}
@@ -262,93 +211,12 @@ function CommentListItem({
           </Box>
         )}
 
-        {/* Suggested-edit (#315): "было → стало" diff for a top-level comment
-            carrying a suggestion. Old text struck-through/red, new text green. */}
-        {!comment.parentCommentId && comment.suggestedText && (
-          <Box className={classes.suggestionBlock}>
-            {comment.selection && (
-              // Old line: read as removed as a whole (line-through/red); only the
-              // changed fragments carry the extra intraline emphasis.
-              <Text size="xs" className={classes.suggestionOld}>
-                {suggestionDiff?.old.map((segment, index) => (
-                  <span
-                    key={index}
-                    className={segment.changed ? classes.suggestionChanged : undefined}
-                  >
-                    {segment.text}
-                  </span>
-                ))}
-              </Text>
-            )}
-            <Text size="xs" className={classes.suggestionNew}>
-              {suggestionDiff?.new.map((segment, index) => (
-                <span
-                  key={index}
-                  className={segment.changed ? classes.suggestionChanged : undefined}
-                >
-                  {segment.text}
-                </span>
-              ))}
-            </Text>
-
-            {comment.suggestionAppliedAt ? (
-              <Badge
-                size="sm"
-                color="green"
-                variant="light"
-                mt={6}
-                aria-label={t("Applied")}
-              >
-                {t("Applied")}
-              </Badge>
-            ) : (
-              (canShowApply(comment, canEdit) ||
-                canShowDismiss(comment, canComment, isOwnerOrAdmin)) && (
-                <Group gap="xs" mt={6}>
-                  {canShowApply(comment, canEdit) && (
-                    <Button
-                      size="compact-xs"
-                      variant="light"
-                      color="green"
-                      onClick={handleApplySuggestion}
-                      loading={applySuggestionMutation.isPending}
-                      disabled={
-                        applySuggestionMutation.isPending ||
-                        dismissSuggestionMutation.isPending
-                      }
-                    >
-                      {t("Apply")}
-                    </Button>
-                  )}
-                  {/* Dismiss ("Не применять", #329): removes the suggestion
-                      without changing the page text. Gated on canComment. */}
-                  {canShowDismiss(comment, canComment, isOwnerOrAdmin) && (
-                    <Button
-                      size="compact-xs"
-                      variant="subtle"
-                      color="gray"
-                      onClick={handleDismissSuggestion}
-                      loading={dismissSuggestionMutation.isPending}
-                      disabled={
-                        applySuggestionMutation.isPending ||
-                        dismissSuggestionMutation.isPending
-                      }
-                    >
-                      {t("Dismiss")}
-                    </Button>
-                  )}
-                </Group>
-              )
-            )}
-          </Box>
-        )}
-
         {!isEditing ? (
-          <CommentContentView content={comment.content} />
+          <CommentEditor defaultContent={content} editable={false} />
         ) : (
           <>
             <CommentEditor
-              defaultContent={comment.content}
+              defaultContent={content}
               editable={true}
               onUpdate={(newContent: any) => { editContentRef.current = newContent; }}
               onSave={handleUpdateComment}
@@ -368,6 +236,4 @@ function CommentListItem({
   );
 }
 
-// Memoized so a resolve/apply/reply cache update (which only replaces the touched
+export default CommentListItem;
-// comment's object identity) re-renders that one thread, not all ~356 items.
-export default React.memo(CommentListItem);

apps/client/src/features/comment/components/comment-list-with-tabs.test.tsx

@@ -1,108 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { render, screen, fireEvent } from "@testing-library/react";
-import { MantineProvider } from "@mantine/core";
-import { IComment } from "@/features/comment/types/comment.types";
-
-// matchMedia (read by MantineProvider) is stubbed globally in vitest.setup.ts.
-
-// CommentEditor pulls in the full TipTap editor stack; replace it with a stub so
-// the lazy reply editor's mount transition can be observed without the editor.
-vi.mock("@/features/comment/components/comment-editor", () => ({
-  default: () => <div data-testid="comment-editor" />,
-}));
-
-// page-query -> main.tsx (createRoot) is a module side effect; stub the queries
-// pulled in transitively so importing the module is side-effect free.
-vi.mock("@/features/page/queries/page-query.ts", () => ({
-  usePageQuery: () => ({ data: undefined, isLoading: false, isError: false }),
-}));
-vi.mock("@/features/share/queries/share-query.ts", () => ({
-  useSharePageQuery: () => ({ data: undefined }),
-}));
-// space-query -> main.tsx (createRoot) is another module side effect; stub it.
-vi.mock("@/features/space/queries/space-query.ts", () => ({
-  useGetSpaceBySlugQuery: () => ({ data: undefined }),
-}));
-
-import {
-  buildChildrenByParent,
-  CommentEditorWithActions,
-} from "./comment-list-with-tabs";
-
-const c = (id: string, parentCommentId: string | null = null): IComment =>
-  ({ id, parentCommentId }) as IComment;
-
-describe("buildChildrenByParent (childrenByParent grouping)", () => {
-  it("returns an empty map for undefined or empty input", () => {
-    expect(buildChildrenByParent(undefined).size).toBe(0);
-    expect(buildChildrenByParent([]).size).toBe(0);
-  });
-
-  it("does not index a top-level comment (parentCommentId null)", () => {
-    const map = buildChildrenByParent([c("p1", null)]);
-    expect(map.size).toBe(0);
-    expect(map.has("p1")).toBe(false);
-  });
-
-  it("groups replies under the correct parent, including reply-to-reply nesting", () => {
-    const p1 = c("p1", null);
-    const r1 = c("r1", "p1");
-    const r2 = c("r2", "r1"); // a reply to a reply
-    const map = buildChildrenByParent([p1, r1, r2]);
-    expect(map.get("p1")).toEqual([r1]);
-    expect(map.get("r1")).toEqual([r2]);
-    // The top-level comment itself is never a key.
-    expect(map.has("p1") && map.get("p1")?.length).toBe(1);
-  });
-
-  it("still groups a reply whose parent is not present in items", () => {
-    const orphan = c("o1", "missing-parent");
-    const map = buildChildrenByParent([orphan]);
-    expect(map.get("missing-parent")).toEqual([orphan]);
-  });
-
-  it("preserves insertion order among sibling replies", () => {
-    const map = buildChildrenByParent([
-      c("a", "p1"),
-      c("b", "p1"),
-      c("d", "p1"),
-    ]);
-    expect(map.get("p1")?.map((x) => x.id)).toEqual(["a", "b", "d"]);
-  });
-});
-
-function renderReplyEditor() {
-  return render(
-    <MantineProvider>
-      <CommentEditorWithActions commentId="c-1" onSave={vi.fn()} />
-    </MantineProvider>,
-  );
-}
-
-describe("CommentEditorWithActions — lazy reply editor activation", () => {
-  it("shows only the stub initially (no editor instance mounted)", () => {
-    renderReplyEditor();
-    expect(screen.getByRole("button")).toBeDefined();
-    expect(screen.queryByTestId("comment-editor")).toBeNull();
-  });
-
-  it("mounts the real editor when the stub is clicked and keeps it mounted", () => {
-    renderReplyEditor();
-    fireEvent.click(screen.getByRole("button"));
-    expect(screen.getByTestId("comment-editor")).toBeDefined();
-    // The stub button is replaced by the editor subtree.
-    expect(screen.queryByRole("button")).toBeNull();
-  });
-
-  it("mounts the editor when the stub receives focus", () => {
-    renderReplyEditor();
-    fireEvent.focus(screen.getByRole("button"));
-    expect(screen.getByTestId("comment-editor")).toBeDefined();
-  });
-
-  it("mounts the editor on Enter keydown of the stub", () => {
-    renderReplyEditor();
-    fireEvent.keyDown(screen.getByRole("button"), { key: "Enter" });
-    expect(screen.getByTestId("comment-editor")).toBeDefined();
-  });
-});

apps/client/src/features/comment/components/comment-list-with-tabs.tsx

@@ -23,6 +23,7 @@ import CommentActions from "@/features/comment/components/comment-actions";
 import { useFocusWithin } from "@mantine/hooks";
 import { IComment } from "@/features/comment/types/comment.types.ts";
 import { usePageQuery } from "@/features/page/queries/page-query.ts";
+import { IPagination } from "@/lib/types.ts";
 import { extractPageSlugId } from "@/lib";
 import { useTranslation } from "react-i18next";
 import { useGetSpaceBySlugQuery } from "@/features/space/queries/space-query.ts";
@@ -35,24 +36,6 @@ interface CommentListWithTabsProps {
   onClose?: () => void;
 }
 
-// Index replies by their parent id once (O(n)), instead of an O(n^2) filter per
-// thread. Replies whose parent is not in `items` are still grouped under their
-// parentCommentId (they simply won't be reached by the top-level walk).
-// Exported for unit testing.
-export function buildChildrenByParent(
-  items: IComment[] | undefined,
-): Map<string, IComment[]> {
-  const m = new Map<string, IComment[]>();
-  for (const c of items ?? []) {
-    if (c.parentCommentId) {
-      const arr = m.get(c.parentCommentId);
-      if (arr) arr.push(c);
-      else m.set(c.parentCommentId, [c]);
-    }
-  }
-  return m;
-}
-
 function CommentListWithTabs({ onClose }: CommentListWithTabsProps) {
   const { t } = useTranslation();
   const { pageSlug } = useParams();
@@ -63,15 +46,11 @@ function CommentListWithTabs({ onClose }: CommentListWithTabsProps) {
     isError,
   } = useCommentsQuery({ pageId: page?.id });
   const createCommentMutation = useCreateCommentMutation();
-  // mutateAsync is a stable reference across renders; depend on it (not the
+  const [isLoading, setIsLoading] = useState(false);
-  // mutation object) so the reply/comment callbacks stay stable.
-  const createCommentAsync = createCommentMutation.mutateAsync;
   const { data: space } = useGetSpaceBySlugQuery(page?.space?.slug);
 
-  const canEdit = page?.permissions?.canEdit ?? false;
-
   const canComment =
-    canEdit ||
+    (page?.permissions?.canEdit ?? false) ||
     (space?.settings?.comments?.allowViewerComments === true);
 
   // Separate active and resolved comments
@@ -94,21 +73,13 @@ function CommentListWithTabs({ onClose }: CommentListWithTabsProps) {
     return { activeComments: active, resolvedComments: resolved };
   }, [comments]);
 
-  // Index replies by their parent once, instead of an O(n^2) filter per thread.
-  // The map ref changes on any comments update, so MemoizedChildComments re-runs
-  // (cheap) and re-looks-up, while memoized CommentListItems skip unchanged items.
-  const childrenByParent = useMemo(
-    () => buildChildrenByParent(comments?.items),
-    [comments?.items],
-  );
-
   const [isPageCommentLoading, setIsPageCommentLoading] = useState(false);
 
   const handleAddPageComment = useCallback(
     async (_commentId: string, content: string) => {
       try {
         setIsPageCommentLoading(true);
-        const createdComment = await createCommentAsync({
+        const createdComment = await createCommentMutation.mutateAsync({
           pageId: page?.id,
           content: JSON.stringify(content),
         });
@@ -127,26 +98,27 @@ function CommentListWithTabs({ onClose }: CommentListWithTabsProps) {
         setIsPageCommentLoading(false);
       }
     },
-    [createCommentAsync, page?.id],
+    [createCommentMutation, page?.id],
   );
 
   const handleAddReply = useCallback(
     async (commentId: string, content: string) => {
-      // Pending state lives inside CommentEditorWithActions so sending a reply
-      // does not churn renderComments and re-render the whole list.
       try {
+        setIsLoading(true);
         const commentData = {
           pageId: page?.id,
           parentCommentId: commentId,
           content: JSON.stringify(content),
         };
 
-        await createCommentAsync(commentData);
+        await createCommentMutation.mutateAsync(commentData);
       } catch (error) {
         console.error("Failed to post comment:", error);
+      } finally {
+        setIsLoading(false);
       }
     },
-    [createCommentAsync, page?.id],
+    [createCommentMutation, page?.id],
   );
 
   const renderComments = useCallback(
@@ -165,15 +137,13 @@ function CommentListWithTabs({ onClose }: CommentListWithTabsProps) {
             comment={comment}
             pageId={page?.id}
             canComment={canComment}
-            canEdit={canEdit}
             userSpaceRole={space?.membership?.role}
           />
           <MemoizedChildComments
-            childrenByParent={childrenByParent}
+            comments={comments}
             parentId={comment.id}
             pageId={page?.id}
             canComment={canComment}
-            canEdit={canEdit}
             userSpaceRole={space?.membership?.role}
           />
         </div>
@@ -184,19 +154,13 @@ function CommentListWithTabs({ onClose }: CommentListWithTabsProps) {
             <CommentEditorWithActions
               commentId={comment.id}
               onSave={handleAddReply}
+              isLoading={isLoading}
             />
           </>
         )}
       </Paper>
     ),
-    [
+    [comments, handleAddReply, isLoading, space?.membership?.role, canComment],
-      childrenByParent,
-      handleAddReply,
-      page?.id,
-      space?.membership?.role,
-      canComment,
-      canEdit,
-    ],
   );
 
   if (isCommentsLoading) {
@@ -228,11 +192,6 @@ function CommentListWithTabs({ onClose }: CommentListWithTabsProps) {
       <Tabs
         defaultValue="open"
         variant="default"
-        // Default to not mounting an inactive tab (the heavy Resolved list stays
-        // unmounted while Open is shown). The Open panel overrides this with its
-        // own keepMounted (below) so an in-progress reply/edit draft survives an
-        // Open -> Resolved -> Open switch.
-        keepMounted={false}
         style={{
           flex: "1 1 auto",
           display: "flex",
@@ -291,10 +250,7 @@ function CommentListWithTabs({ onClose }: CommentListWithTabsProps) {
           type="scroll"
         >
           <div style={{ paddingBottom: "8px" }}>
-            {/* keepMounted keeps the Open panel alive even while Resolved is
+            <Tabs.Panel value="open" pt="xs">
-                active, so a lazily-mounted reply editor's draft (and an
-                in-progress edit) is not discarded on tab switch. */}
-            <Tabs.Panel value="open" pt="xs" keepMounted>
               {activeComments.length === 0 ? (
                 <Center py="xl">
                   <Stack align="center" gap="xs">
@@ -340,40 +296,42 @@ function CommentListWithTabs({ onClose }: CommentListWithTabsProps) {
 }
 
 interface ChildCommentsProps {
-  childrenByParent: Map<string, IComment[]>;
+  comments: IPagination<IComment>;
   parentId: string;
   pageId: string;
   canComment: boolean;
-  canEdit?: boolean;
   userSpaceRole?: string;
 }
 const ChildComments = ({
-  childrenByParent,
+  comments,
   parentId,
   pageId,
   canComment,
-  canEdit,
   userSpaceRole,
 }: ChildCommentsProps) => {
-  const children = childrenByParent.get(parentId) ?? [];
+  const getChildComments = useCallback(
+    (parentId: string) =>
+      comments.items.filter(
+        (comment: IComment) => comment.parentCommentId === parentId,
+      ),
+    [comments.items],
+  );
 
   return (
     <div>
-      {children.map((childComment) => (
+      {getChildComments(parentId).map((childComment) => (
         <div key={childComment.id}>
           <CommentListItem
             comment={childComment}
             pageId={pageId}
             canComment={canComment}
-            canEdit={canEdit}
             userSpaceRole={userSpaceRole}
           />
           <MemoizedChildComments
-            childrenByParent={childrenByParent}
+            comments={comments}
             parentId={childComment.id}
             pageId={pageId}
             canComment={canComment}
-            canEdit={canEdit}
             userSpaceRole={userSpaceRole}
           />
         </div>
@@ -384,61 +342,22 @@ const ChildComments = ({
 
 const MemoizedChildComments = memo(ChildComments);
 
-export const CommentEditorWithActions = ({
+const CommentEditorWithActions = ({
   commentId,
   onSave,
+  isLoading,
   placeholder = undefined,
 }) => {
-  const { t } = useTranslation();
-  // Lazily mount the TipTap reply editor: until the user interacts with the
-  // stub, no editor instance is created for this thread. Once mounted it stays
-  // mounted so the draft is preserved.
-  const [mounted, setMounted] = useState(false);
   const [content, setContent] = useState("");
-  const [isSending, setIsSending] = useState(false);
   const { ref, focused } = useFocusWithin();
   const commentEditorRef = useRef(null);
 
-  const activate = useCallback(() => setMounted(true), []);
+  const handleSave = useCallback(() => {
-
+    onSave(commentId, content);
-  const handleSave = useCallback(async () => {
-    try {
-      setIsSending(true);
-      await onSave(commentId, content);
     setContent("");
     commentEditorRef.current?.clearContent();
-    } finally {
-      setIsSending(false);
-    }
   }, [commentId, content, onSave]);
 
-  if (!mounted) {
-    return (
-      <div
-        role="button"
-        tabIndex={0}
-        onClick={activate}
-        onFocus={activate}
-        onKeyDown={(e) => {
-          if (e.key === "Enter" || e.key === " ") {
-            e.preventDefault();
-            activate();
-          }
-        }}
-        style={{
-          padding: "6px",
-          fontSize: "var(--mantine-font-size-sm)",
-          lineHeight: 1.4,
-          color: "var(--mantine-color-placeholder)",
-          cursor: "text",
-          borderRadius: "var(--mantine-radius-sm)",
-        }}
-      >
-        {placeholder || t("Reply...")}
-      </div>
-    );
-  }
-
   return (
     <div ref={ref}>
       <CommentEditor
@@ -447,9 +366,8 @@ export const CommentEditorWithActions = ({
         onSave={handleSave}
         editable={true}
         placeholder={placeholder}
-        autofocus={true}
       />
-      {focused && <CommentActions onSave={handleSave} isLoading={isSending} />}
+      {focused && <CommentActions onSave={handleSave} isLoading={isLoading} />}
     </div>
   );
 };

apps/client/src/features/comment/components/comment.module.css

@@ -21,53 +21,6 @@
     box-sizing: border-box;
 }
 
-/* Suggested-edit (#315) "было → стало" diff block. */
-.suggestionBlock {
-    margin-top: 8px;
-    margin-left: 6px;
-    padding: 6px;
-    border-radius: var(--mantine-radius-sm);
-    border: 1px solid var(--mantine-color-default-border);
-    overflow-wrap: break-word;
-    word-break: break-word;
-    max-width: 100%;
-    box-sizing: border-box;
-    display: flex;
-    flex-direction: column;
-    align-items: flex-start;
-}
-
-.suggestionOld {
-    text-decoration: line-through;
-    color: var(--mantine-color-red-7);
-    background: var(--mantine-color-red-light);
-    border-radius: 2px;
-    padding: 1px 3px;
-}
-
-.suggestionNew {
-    color: var(--mantine-color-green-9);
-    background: var(--mantine-color-green-light);
-    border-radius: 2px;
-    padding: 1px 3px;
-    margin-top: 4px;
-}
-
-/* Intraline diff (#331): the fragment that actually changed within the
-   red "before" / green "after" block. It inherits the surrounding red/green
-   framing and adds a stronger tint plus bold weight so the eye lands on the
-   changed letters/words (git/GitHub-style) rather than the whole line. The
-   container's line-through (old) / green (new) still marks the full line. */
-.suggestionChanged {
-    /* Stronger tint of the surrounding red/green so the changed fragment pops
-       within the block. `currentColor` follows the parent's red (old) or green
-       (new) text colour. No `text-decoration` here on purpose: the old block's
-       inherited line-through must survive on the changed letters too. */
-    background: color-mix(in srgb, currentColor 22%, transparent);
-    border-radius: 2px;
-    font-weight: 700;
-}
-
 .commentEditor {
 
     &[data-editable][data-surface="muted"] .ProseMirror:not(.focused) {

apps/client/src/features/comment/queries/comment-query.suggestion-outcome.test.tsx

@@ -1,279 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import React from "react";
-import { renderHook, waitFor } from "@testing-library/react";
-import {
-  QueryClient,
-  QueryClientProvider,
-  InfiniteData,
-} from "@tanstack/react-query";
-
-/**
- * Coverage for the ephemeral-suggestion (#329) cache reconciliation in
- * useApplySuggestionMutation / useDismissSuggestionMutation: the mutations act on
- * the server `outcome` — 'deleted' drops the comment from the local list,
- * 'resolved' relocates it (by stamping resolvedAt, which the tabs split on).
- */
-
-vi.mock("@mantine/notifications", () => ({
-  notifications: { show: vi.fn() },
-}));
-
-vi.mock("@/features/comment/services/comment-service", () => ({
-  applySuggestion: vi.fn(),
-  dismissSuggestion: vi.fn(),
-  createComment: vi.fn(),
-  updateComment: vi.fn(),
-  deleteComment: vi.fn(),
-  resolveComment: vi.fn(),
-  getPageComments: vi.fn(),
-}));
-
-import { notifications } from "@mantine/notifications";
-import {
-  applySuggestion,
-  dismissSuggestion,
-} from "@/features/comment/services/comment-service";
-import {
-  useApplySuggestionMutation,
-  useDismissSuggestionMutation,
-  RQ_KEY,
-} from "@/features/comment/queries/comment-query";
-import { IComment } from "@/features/comment/types/comment.types";
-
-const PAGE_ID = "page-1";
-
-function seededClient(comment: IComment) {
-  const queryClient = new QueryClient({
-    defaultOptions: { mutations: { retry: false } },
-  });
-  const seed: InfiniteData<any> = {
-    pageParams: [undefined],
-    pages: [{ items: [comment], meta: { hasNextPage: false, nextCursor: null } }],
-  };
-  queryClient.setQueryData(RQ_KEY(PAGE_ID), seed);
-  const wrapper = ({ children }: { children: React.ReactNode }) => (
-    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
-  );
-  return { queryClient, wrapper };
-}
-
-function items(queryClient: QueryClient): IComment[] {
-  const cache = queryClient.getQueryData(RQ_KEY(PAGE_ID)) as
-    | InfiniteData<any>
-    | undefined;
-  return cache?.pages.flatMap((p) => p.items) ?? [];
-}
-
-const comment = (over?: Partial<IComment>): IComment =>
-  ({
-    id: "c-1",
-    pageId: PAGE_ID,
-    content: "{}",
-    creatorId: "u-1",
-    workspaceId: "ws-1",
-    createdAt: new Date(),
-    suggestedText: "new",
-    ...over,
-  }) as IComment;
-
-describe("useApplySuggestionMutation — outcome handling (#329)", () => {
-  beforeEach(() => vi.clearAllMocks());
-
-  it("outcome=deleted → removes the comment from the list", async () => {
-    vi.mocked(applySuggestion).mockResolvedValue({
-      id: "c-1",
-      pageId: PAGE_ID,
-      outcome: "deleted",
-    } as any);
-    const { queryClient, wrapper } = seededClient(comment());
-
-    const { result } = renderHook(() => useApplySuggestionMutation(), {
-      wrapper,
-    });
-    await result.current.mutateAsync({ commentId: "c-1", pageId: PAGE_ID });
-    await waitFor(() => expect(result.current.isSuccess).toBe(true));
-
-    expect(items(queryClient)).toHaveLength(0);
-  });
-
-  it("outcome=resolved → keeps the comment and stamps resolvedAt/applied fields", async () => {
-    const resolvedAt = new Date();
-    vi.mocked(applySuggestion).mockResolvedValue({
-      id: "c-1",
-      pageId: PAGE_ID,
-      outcome: "resolved",
-      resolvedAt,
-      resolvedById: "u-1",
-      resolvedBy: { id: "u-1", name: "A" },
-      suggestionAppliedAt: resolvedAt,
-      suggestionAppliedById: "u-1",
-    } as any);
-    const { queryClient, wrapper } = seededClient(comment());
-
-    const { result } = renderHook(() => useApplySuggestionMutation(), {
-      wrapper,
-    });
-    await result.current.mutateAsync({ commentId: "c-1", pageId: PAGE_ID });
-    await waitFor(() => expect(result.current.isSuccess).toBe(true));
-
-    const list = items(queryClient);
-    expect(list).toHaveLength(1);
-    expect(list[0].resolvedAt).toBe(resolvedAt);
-    expect(list[0].suggestionAppliedAt).toBe(resolvedAt);
-  });
-});
-
-describe("useDismissSuggestionMutation — outcome handling (#329)", () => {
-  beforeEach(() => vi.clearAllMocks());
-
-  it("outcome=deleted → removes the comment from the list", async () => {
-    vi.mocked(dismissSuggestion).mockResolvedValue({
-      id: "c-1",
-      pageId: PAGE_ID,
-      outcome: "deleted",
-    } as any);
-    const { queryClient, wrapper } = seededClient(comment());
-
-    const { result } = renderHook(() => useDismissSuggestionMutation(), {
-      wrapper,
-    });
-    await result.current.mutateAsync({ commentId: "c-1", pageId: PAGE_ID });
-    await waitFor(() => expect(result.current.isSuccess).toBe(true));
-
-    expect(items(queryClient)).toHaveLength(0);
-  });
-
-  it("outcome=resolved → keeps the comment and stamps resolvedAt", async () => {
-    const resolvedAt = new Date();
-    vi.mocked(dismissSuggestion).mockResolvedValue({
-      id: "c-1",
-      pageId: PAGE_ID,
-      outcome: "resolved",
-      resolvedAt,
-      resolvedById: "u-1",
-      resolvedBy: { id: "u-1", name: "A" },
-    } as any);
-    const { queryClient, wrapper } = seededClient(comment());
-
-    const { result } = renderHook(() => useDismissSuggestionMutation(), {
-      wrapper,
-    });
-    await result.current.mutateAsync({ commentId: "c-1", pageId: PAGE_ID });
-    await waitFor(() => expect(result.current.isSuccess).toBe(true));
-
-    const list = items(queryClient);
-    expect(list).toHaveLength(1);
-    expect(list[0].resolvedAt).toBe(resolvedAt);
-  });
-
-  it("idempotent race (404) → treated as success, comment removed from the list", async () => {
-    vi.mocked(dismissSuggestion).mockRejectedValue({
-      response: { status: 404 },
-    });
-    const { queryClient, wrapper } = seededClient(comment());
-
-    const { result } = renderHook(() => useDismissSuggestionMutation(), {
-      wrapper,
-    });
-    // mutateAsync rejects even though onError reconciles the cache; swallow it.
-    await result.current
-      .mutateAsync({ commentId: "c-1", pageId: PAGE_ID })
-      .catch(() => undefined);
-    await waitFor(() => expect(result.current.isError).toBe(true));
-
-    expect(items(queryClient)).toHaveLength(0);
-    // #338 F3: the idempotent race must still fire the SUCCESS toast, not just
-    // silently drop the comment.
-    expect(notifications.show).toHaveBeenCalledWith({
-      message: "Suggestion dismissed",
-    });
-  });
-
-  it("dismiss 400 (thread still alive) → NOT a success, comment kept, no green toast (#338 F2)", async () => {
-    // 400 means the thread is alive (already resolved / a reply raced in).
-    // Narrowed onError: only 404 is a success-noop; 400 must surface a real error
-    // and keep the comment in the cache.
-    vi.mocked(dismissSuggestion).mockRejectedValue({
-      response: { status: 400 },
-    });
-    const { queryClient, wrapper } = seededClient(comment());
-
-    const { result } = renderHook(() => useDismissSuggestionMutation(), {
-      wrapper,
-    });
-    await result.current
-      .mutateAsync({ commentId: "c-1", pageId: PAGE_ID })
-      .catch(() => undefined);
-    await waitFor(() => expect(result.current.isError).toBe(true));
-
-    // Comment NOT dropped from the cache.
-    expect(items(queryClient)).toHaveLength(1);
-    // A real (red) error, never the success message.
-    expect(notifications.show).toHaveBeenCalledWith(
-      expect.objectContaining({ color: "red" }),
-    );
-    expect(notifications.show).not.toHaveBeenCalledWith({
-      message: "Suggestion dismissed",
-    });
-  });
-
-  it("APPLY idempotent race (404) → treated as success, comment removed from the list", async () => {
-    // After #329 an applied reply-less suggestion is hard-deleted, so a racing
-    // second apply hits 404 — must reconcile to success like dismiss, not a red
-    // error (restores the #315 apply idempotency).
-    vi.mocked(applySuggestion).mockRejectedValue({
-      response: { status: 404 },
-    });
-    const { queryClient, wrapper } = seededClient(comment());
-
-    const { result } = renderHook(() => useApplySuggestionMutation(), {
-      wrapper,
-    });
-    await result.current
-      .mutateAsync({ commentId: "c-1", pageId: PAGE_ID })
-      .catch(() => undefined);
-    await waitFor(() => expect(result.current.isError).toBe(true));
-
-    expect(items(queryClient)).toHaveLength(0);
-    // #338 F3: the idempotent race must still fire the SUCCESS toast.
-    expect(notifications.show).toHaveBeenCalledWith({
-      message: "Suggestion applied",
-    });
-  });
-
-  it("APPLY 400 (thread resolved, not applied) → NOT a success, comment kept, red error (#338 F2)", async () => {
-    // apply's only 400 is "Cannot apply … on a resolved comment thread" — the
-    // thread was resolved (often with discussion) but NOT applied. It must be a
-    // real error surfacing the server message, and must NOT drop the live thread.
-    vi.mocked(applySuggestion).mockRejectedValue({
-      response: {
-        status: 400,
-        data: {
-          message: "Cannot apply a suggested edit on a resolved comment thread",
-        },
-      },
-    });
-    const { queryClient, wrapper } = seededClient(comment());
-
-    const { result } = renderHook(() => useApplySuggestionMutation(), {
-      wrapper,
-    });
-    await result.current
-      .mutateAsync({ commentId: "c-1", pageId: PAGE_ID })
-      .catch(() => undefined);
-    await waitFor(() => expect(result.current.isError).toBe(true));
-
-    // The live thread is NOT dropped from the cache.
-    expect(items(queryClient)).toHaveLength(1);
-    // Surfaces the server's specific message as a red error, never a success.
-    expect(notifications.show).toHaveBeenCalledWith(
-      expect.objectContaining({
-        message: "Cannot apply a suggested edit on a resolved comment thread",
-        color: "red",
-      }),
-    );
-    expect(notifications.show).not.toHaveBeenCalledWith({
-      message: "Suggestion applied",
-    });
-  });
-});

apps/client/src/features/comment/queries/comment-query.ts

@@ -5,10 +5,8 @@ import {
   InfiniteData,
 } from "@tanstack/react-query";
 import {
-  applySuggestion,
   createComment,
   deleteComment,
-  dismissSuggestion,
   getPageComments,
   resolveComment,
   updateComment,
@@ -17,7 +15,6 @@ import {
   ICommentParams,
   IComment,
   IResolveComment,
-  ISuggestionOutcome,
 } from "@/features/comment/types/comment.types";
 import { notifications } from "@mantine/notifications";
 import { IPagination } from "@/lib/types.ts";
@@ -53,10 +50,7 @@ export function useCommentsQuery(params: ICommentParams) {
 
   return {
     data,
-    // Paint the first page as soon as it arrives instead of blocking until every
+    isLoading: query.isLoading || query.hasNextPage,
-    // page has loaded; the background effect above keeps streaming the rest
-    // (tab counts grow as pages arrive).
-    isLoading: query.isLoading,
     isError: query.isError,
   };
 }
@@ -182,196 +176,6 @@ function updateCommentInCache(
   };
 }
 
-function removeCommentFromCache(
-  cache: InfiniteData<IPagination<IComment>>,
-  commentId: string,
-): InfiniteData<IPagination<IComment>> {
-  return {
-    ...cache,
-    pages: cache.pages.map((page) => ({
-      ...page,
-      items: page.items.filter((comment) => comment.id !== commentId),
-    })),
-  };
-}
-
-// Reconcile the local comment cache with an ephemeral-suggestion outcome (#329)
-// returned by apply/dismiss: 'deleted' → drop the comment (it disappeared);
-// 'resolved' → the thread had replies and was resolved, so carry the resolved
-// state through (which relocates it to the resolved tab).
-function applySuggestionOutcomeToCache(
-  queryClient: ReturnType<typeof useQueryClient>,
-  pageId: string,
-  commentId: string,
-  data: ISuggestionOutcome,
-) {
-  const cache = queryClient.getQueryData(RQ_KEY(pageId)) as
-    | InfiniteData<IPagination<IComment>>
-    | undefined;
-  if (!cache) return;
-
-  if (data.outcome === "deleted") {
-    queryClient.setQueryData(RQ_KEY(pageId), removeCommentFromCache(cache, commentId));
-    return;
-  }
-
-  // 'resolved' (or an older server that omits outcome): reflect the resolved
-  // state and the applied stamps (apply sets them; dismiss leaves them null).
-  queryClient.setQueryData(
-    RQ_KEY(pageId),
-    updateCommentInCache(cache, commentId, (comment) => ({
-      ...comment,
-      suggestionAppliedAt: data.suggestionAppliedAt,
-      suggestionAppliedById: data.suggestionAppliedById,
-      resolvedAt: data.resolvedAt,
-      resolvedById: data.resolvedById,
-      resolvedBy: data.resolvedBy,
-    })),
-  );
-}
-
-export function useApplySuggestionMutation() {
-  const queryClient = useQueryClient();
-  const { t } = useTranslation();
-
-  return useMutation<
-    ISuggestionOutcome,
-    any,
-    { commentId: string; pageId: string }
-  >({
-    // No optimistic update: apply can fail with 409 (the commented text drifted),
-    // so we only mutate the cache once the server confirms.
-    mutationFn: ({ commentId }) => applySuggestion(commentId),
-    onSuccess: (data, variables) => {
-      // Ephemeral (#329): the server hard-deletes the applied suggestion when the
-      // thread has no replies ('deleted') or resolves it when it does ('resolved').
-      applySuggestionOutcomeToCache(
-        queryClient,
-        variables.pageId,
-        variables.commentId,
-        data,
-      );
-
-      notifications.show({ message: t("Suggestion applied") });
-    },
-    onError: (err: any, variables) => {
-      const status = err?.response?.status;
-      // Idempotent race (double-click, or apply↔dismiss): after #329 an applied
-      // reply-less suggestion is hard-deleted, so a second/racing apply hits 404
-      // (already gone). ONLY 404 is a real success-noop — drop it from the cache
-      // and report success, the user's intent is already satisfied (restores the
-      // #315 apply idempotency the ephemeral delete would otherwise break).
-      //
-      // 400 is NOT success (#338 F2): apply's only 400 is "Cannot apply … on a
-      // resolved comment thread" — the thread was resolved (often WITH a live
-      // discussion) but the edit was NOT applied. Treating it as "Suggestion
-      // applied" is a false success that also drops a live thread from the cache.
-      // The #315 idempotent repeat does NOT produce 400 (childless → 404;
-      // with-replies → 200), so we never lose idempotency by excluding it here.
-      if (status === 404) {
-        const cache = queryClient.getQueryData(RQ_KEY(variables.pageId)) as
-          | InfiniteData<IPagination<IComment>>
-          | undefined;
-        if (cache) {
-          queryClient.setQueryData(
-            RQ_KEY(variables.pageId),
-            removeCommentFromCache(cache, variables.commentId),
-          );
-        }
-        notifications.show({ message: t("Suggestion applied") });
-        return;
-      }
-      // 400 => the thread was resolved and the edit could not be applied. Show a
-      // real error and KEEP the comment in the cache (it is still alive). Prefer
-      // the server's specific message when it carries one.
-      if (status === 400) {
-        const serverMsg = err?.response?.data?.message;
-        notifications.show({
-          message:
-            typeof serverMsg === "string" && serverMsg.length > 0
-              ? serverMsg
-              : t("Failed to apply suggestion"),
-          color: "red",
-        });
-        return;
-      }
-      // 409 => the commented text changed since the suggestion was made. Surface
-      // a specific message (with the current text) rather than a generic error.
-      const currentText = err?.response?.data?.currentText;
-      if (status === 409 && typeof currentText === "string") {
-        const shortText =
-          currentText.length > 80
-            ? `${currentText.slice(0, 80)}…`
-            : currentText;
-        notifications.show({
-          title: t(
-            "The commented text changed since this suggestion was made; it was not applied.",
-          ),
-          message: shortText,
-          color: "red",
-        });
-        return;
-      }
-      notifications.show({
-        message: t("Failed to apply suggestion"),
-        color: "red",
-      });
-    },
-  });
-}
-
-export function useDismissSuggestionMutation() {
-  const queryClient = useQueryClient();
-  const { t } = useTranslation();
-
-  return useMutation<
-    ISuggestionOutcome,
-    any,
-    { commentId: string; pageId: string }
-  >({
-    mutationFn: ({ commentId }) => dismissSuggestion(commentId),
-    onSuccess: (data, variables) => {
-      // Ephemeral (#329): dismiss hard-deletes the suggestion when the thread has
-      // no replies ('deleted') or resolves it when it does ('resolved').
-      applySuggestionOutcomeToCache(
-        queryClient,
-        variables.pageId,
-        variables.commentId,
-        data,
-      );
-
-      notifications.show({ message: t("Suggestion dismissed") });
-    },
-    onError: (err: any, variables) => {
-      // Idempotent race (double-click, or apply↔dismiss): the comment is already
-      // gone (404). ONLY 404 is a real success-noop — drop it from the cache and
-      // report success, the user's intent (make it disappear) is satisfied.
-      //
-      // 400 is NOT success (#338 F2): it means the thread is still ALIVE (already
-      // resolved, or a reply raced in), so treating it as "dismissed" would drop
-      // a live thread from the cache. Show a real error and keep the comment.
-      const status = err?.response?.status;
-      if (status === 404) {
-        const cache = queryClient.getQueryData(RQ_KEY(variables.pageId)) as
-          | InfiniteData<IPagination<IComment>>
-          | undefined;
-        if (cache) {
-          queryClient.setQueryData(
-            RQ_KEY(variables.pageId),
-            removeCommentFromCache(cache, variables.commentId),
-          );
-        }
-        notifications.show({ message: t("Suggestion dismissed") });
-        return;
-      }
-      notifications.show({
-        message: t("Failed to dismiss suggestion"),
-        color: "red",
-      });
-    },
-  });
-}
-
 export function useResolveCommentMutation() {
   const queryClient = useQueryClient();
   const { t } = useTranslation();

apps/client/src/features/comment/services/comment-service.ts

@@ -3,7 +3,6 @@ import {
   ICommentParams,
   IComment,
   IResolveComment,
-  ISuggestionOutcome,
 } from "@/features/comment/types/comment.types";
 import { IPagination } from "@/lib/types.ts";
 
@@ -19,24 +18,6 @@ export async function resolveComment(data: IResolveComment): Promise<IComment> {
   return req.data;
 }
 
-export async function applySuggestion(
-  commentId: string,
-): Promise<ISuggestionOutcome> {
-  // Mirrors resolveComment: let axios reject on non-2xx so the mutation can read
-  // the 409 body (`{ message, currentText }`) off err.response.data.
-  const req = await api.post("/comments/apply-suggestion", { commentId });
-  return req.data.data ?? req.data;
-}
-
-export async function dismissSuggestion(
-  commentId: string,
-): Promise<ISuggestionOutcome> {
-  // Dismiss ("Не применять") a suggested edit (#329): the server hard-deletes
-  // the comment (or resolves it when it has replies) and returns the outcome.
-  const req = await api.post("/comments/dismiss-suggestion", { commentId });
-  return req.data.data ?? req.data;
-}
-
 export async function updateComment(
   data: Partial<IComment>,
 ): Promise<IComment> {

apps/client/src/features/comment/types/comment.types.ts

@@ -28,13 +28,6 @@ export interface IComment {
   createdSource?: string;
   aiChatId?: string | null;
   resolvedSource?: string | null;
-  // Suggested-edit (#315): when an agent proposes a replacement for the
-  // commented `selection`, `suggestedText` holds the "стало" text. Once a user
-  // applies it server-side the backend stamps `suggestionAppliedAt` /
-  // `suggestionAppliedById` and auto-resolves the thread.
-  suggestedText?: string | null;
-  suggestionAppliedAt?: Date | string | null;
-  suggestionAppliedById?: string | null;
   // Server-normalized "agent avatar stack" provenance (#300), present only when
   // createdSource === "agent": `agent` is the front identity, `launcher` the
   // human behind it (null for an external MCP agent).
@@ -60,15 +53,6 @@ export interface IResolveComment {
   resolved: boolean;
 }
 
-// Result of applying or dismissing an ephemeral suggested edit (#329). The
-// server hard-deletes the comment (`deleted`) unless the thread has replies, in
-// which case it is resolved (`resolved`). The returned comment fields carry the
-// resolved-branch state; `outcome` tells the client which optimistic action to
-// take (drop the comment vs. move it to the resolved tab).
-export type ISuggestionOutcome = IComment & {
-  outcome?: "deleted" | "resolved";
-};
-
 export interface ICommentParams extends QueryParams {
   pageId: string;
 }

apps/client/src/features/comment/utils/suggestion.test.ts

@@ -1,102 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { computeSuggestionDiff, Segment } from "@/features/comment/utils/suggestion";
-
-// Reconstruct the plain string from a segment stream — the diff must be
-// lossless (concatenating every fragment yields the original input).
-const join = (segments: Segment[]): string =>
-  segments.map((s) => s.text).join("");
-
-// The subset of segments (in order) that the UI would emphasise.
-const changed = (segments: Segment[]): string[] =>
-  segments.filter((s) => s.changed).map((s) => s.text);
-
-// Find the segment that contains a substring, to assert its `changed` flag.
-const segmentWith = (segments: Segment[], needle: string): Segment | undefined =>
-  segments.find((s) => s.text.includes(needle));
-
-describe("computeSuggestionDiff", () => {
-  it("highlights only the single changed letter in a one-letter edit", () => {
-    const { old, new: neu } = computeSuggestionDiff("заведем", "заведём");
-
-    // Lossless.
-    expect(join(old)).toBe("заведем");
-    expect(join(neu)).toBe("заведём");
-
-    // Old side: exactly the `е` is changed, the rest is common.
-    expect(changed(old)).toEqual(["е"]);
-    expect(old).toEqual([
-      { text: "завед", changed: false },
-      { text: "е", changed: true },
-      { text: "м", changed: false },
-    ]);
-
-    // New side: exactly the `ё` is changed.
-    expect(changed(neu)).toEqual(["ё"]);
-    expect(neu).toEqual([
-      { text: "завед", changed: false },
-      { text: "ё", changed: true },
-      { text: "м", changed: false },
-    ]);
-  });
-
-  it("marks the differing words changed but keeps the shared word common", () => {
-    const { old, new: neu } = computeSuggestionDiff(
-      "привет мир",
-      "здравствуй мир",
-    );
-
-    // Lossless.
-    expect(join(old)).toBe("привет мир");
-    expect(join(neu)).toBe("здравствуй мир");
-
-    // The shared trailing word stays common on both sides (no per-letter noise
-    // leaking across the differing words into `мир`).
-    expect(segmentWith(old, "мир")?.changed).toBe(false);
-    expect(segmentWith(neu, "мир")?.changed).toBe(false);
-
-    // The differing words are emphasised somewhere on each side.
-    expect(changed(old).length).toBeGreaterThan(0);
-    expect(changed(neu).length).toBeGreaterThan(0);
-    expect(changed(old).join("")).toContain("п"); // from `привет`
-    expect(changed(neu).join("")).toContain("зд"); // from `здравствуй`
-
-    // No changed fragment on either side touches the word `мир`.
-    expect(changed(old).some((t) => t.includes("мир"))).toBe(false);
-    expect(changed(neu).some((t) => t.includes("мир"))).toBe(false);
-  });
-
-  it("marks a whole inserted word changed and leaves the old line common", () => {
-    const { old, new: neu } = computeSuggestionDiff("a c", "a b c");
-
-    expect(join(old)).toBe("a c");
-    expect(join(neu)).toBe("a b c");
-
-    // Old line has no changed fragment (nothing was removed).
-    expect(changed(old)).toEqual([]);
-    // The inserted word is the only changed fragment on the new side.
-    expect(neu).toContainEqual({ text: "b ", changed: true });
-    expect(changed(neu)).toEqual(["b "]);
-  });
-
-  it("marks a whole deleted word changed and leaves the new line common", () => {
-    const { old, new: neu } = computeSuggestionDiff("a b c", "a c");
-
-    expect(join(old)).toBe("a b c");
-    expect(join(neu)).toBe("a c");
-
-    // The deleted word is the only changed fragment on the old side.
-    expect(old).toContainEqual({ text: "b ", changed: true });
-    expect(changed(old)).toEqual(["b "]);
-    // New line has no changed fragment (nothing was added).
-    expect(changed(neu)).toEqual([]);
-  });
-
-  it("marks everything common for identical strings", () => {
-    const { old, new: neu } = computeSuggestionDiff("hello", "hello");
-
-    expect(old).toEqual([{ text: "hello", changed: false }]);
-    expect(neu).toEqual([{ text: "hello", changed: false }]);
-    expect(changed(old)).toEqual([]);
-    expect(changed(neu)).toEqual([]);
-  });
-});

apps/client/src/features/comment/utils/suggestion.ts

@@ -1,139 +0,0 @@
-import { diffWordsWithSpace, diffChars } from "diff";
-import { IComment } from "@/features/comment/types/comment.types";
-
-// Whether the suggested-edit (#315) "Apply" button should be shown for a
-// comment: it must carry a suggestion, not already be applied or resolved, be a
-// top-level comment, and the viewer must be able to edit the page.
-export function canShowApply(comment: IComment, canEdit?: boolean): boolean {
-  return Boolean(
-    canEdit &&
-      comment.suggestedText &&
-      !comment.suggestionAppliedAt &&
-      !comment.resolvedAt &&
-      !comment.parentCommentId,
-  );
-}
-
-// One contiguous run of text within a suggestion's "before" or "after" line.
-// `changed` marks the fragment that actually differs from the other side, so
-// the UI can emphasise only the intraline delta (git/GitHub-style) instead of
-// the whole line.
-export interface Segment {
-  text: string;
-  changed: boolean;
-}
-
-// A pure "before -> after" intraline diff (#331): the old line split into
-// common vs. removed-and-changed fragments, and the new line split into common
-// vs. added-and-changed fragments. Concatenating each side's `text` reproduces
-// the original strings.
-export interface SuggestionDiff {
-  old: Segment[];
-  new: Segment[];
-}
-
-// Push a segment, coalescing runs of the same `changed` flag on the same side
-// so the render emits as few spans as possible and tests stay predictable.
-function pushSegment(segments: Segment[], text: string, changed: boolean): void {
-  if (text === "") return;
-  const last = segments[segments.length - 1];
-  if (last && last.changed === changed) {
-    last.text += text;
-  } else {
-    segments.push({ text, changed });
-  }
-}
-
-// Compute an intraline diff between the old `selection` and the new
-// `suggestedText` of a suggestion. PURE — no React, no DOM, no I/O.
-//
-// Hybrid word + char algorithm (per #331):
-//   1. `diffWordsWithSpace` yields word-granular parts [{value, added, removed}].
-//   2. An ADJACENT removed+added pair (a word replacement) is refined with
-//      `diffChars`: shared characters stay common, differing characters are
-//      marked `changed` on their respective side. This is what keeps a
-//      one-letter edit (заведем -> заведём) from highlighting the whole word.
-//   3. A lone `added` (insertion) or lone `removed` (deletion) marks the whole
-//      fragment `changed`.
-//   4. An unchanged part is `common` on both sides.
-//
-// Rejected alternatives: pure `diffChars` is noisy on word swaps; pure
-// `diffWordsWithSpace` highlights the whole word rather than the changed letter.
-export function computeSuggestionDiff(
-  oldStr: string,
-  newStr: string,
-): SuggestionDiff {
-  const oldSegments: Segment[] = [];
-  const newSegments: Segment[] = [];
-
-  const parts = diffWordsWithSpace(oldStr, newStr);
-
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i];
-    const next = parts[i + 1];
-
-    // A word replacement: a removed part immediately followed by an added part
-    // (or the reverse). Refine it character-by-character so only the differing
-    // letters are highlighted while shared letters stay common.
-    const isReplacementPair =
-      next &&
-      ((part.removed && next.added) || (part.added && next.removed));
-
-    if (isReplacementPair) {
-      const removedPart = part.removed ? part : next;
-      const addedPart = part.added ? part : next;
-
-      const charParts = diffChars(removedPart.value, addedPart.value);
-      for (const cp of charParts) {
-        if (cp.added) {
-          pushSegment(newSegments, cp.value, true);
-        } else if (cp.removed) {
-          pushSegment(oldSegments, cp.value, true);
-        } else {
-          // Shared character: common on both sides.
-          pushSegment(oldSegments, cp.value, false);
-          pushSegment(newSegments, cp.value, false);
-        }
-      }
-
-      i++; // consume the paired part as well
-      continue;
-    }
-
-    if (part.added) {
-      // Lone insertion: only present in the new line, wholly changed.
-      pushSegment(newSegments, part.value, true);
-    } else if (part.removed) {
-      // Lone deletion: only present in the old line, wholly changed.
-      pushSegment(oldSegments, part.value, true);
-    } else {
-      // Unchanged: common on both sides.
-      pushSegment(oldSegments, part.value, false);
-      pushSegment(newSegments, part.value, false);
-    }
-  }
-
-  return { old: oldSegments, new: newSegments };
-}
-
-// Whether the suggested-edit (#329) "Не применять" (Dismiss) button should be
-// shown. Dismiss does NOT change the page text (so it needs only canComment, not
-// canEdit), BUT a childless dismiss IRREVERSIBLY hard-deletes the comment, so the
-// server gates it on comment-owner-OR-space-admin (#338 F5). The button must
-// mirror that authz or a non-owner non-admin sees a live Dismiss that always
-// 403s → red error. Hence isOwnerOrAdmin is required IN ADDITION to canComment.
-// Same not-applied/not-resolved/top-level conditions as Apply.
-export function canShowDismiss(
-  comment: IComment,
-  canComment?: boolean,
-  isOwnerOrAdmin?: boolean,
-): boolean {
-  return Boolean(
-    canComment &&
-      isOwnerOrAdmin &&
-      comment.suggestedText &&
-      !comment.suggestionAppliedAt &&
-      !comment.resolvedAt &&
-      !comment.parentCommentId,
-  );
-}

apps/client/src/features/dictation/components/mic-button.test.tsx

@@ -1,92 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { render, screen } from "@testing-library/react";
-import { MantineProvider } from "@mantine/core";
-
-// A disabled mic must explain WHY it is unavailable rather than silently saying
-// "Start dictation". This renders MicButton in its idle+disabled state with a
-// forwarded reason and asserts the accessible label resolves to that reason's
-// text via the shared resolver (dictation-status.resolveUnavailableLabel).
-
-// matchMedia (read by MantineProvider) is stubbed globally in vitest.setup.ts.
-
-// Pass i18n keys through verbatim so we assert the exact resolved string.
-vi.mock("react-i18next", () => ({
-  useTranslation: () => ({ t: (s: string) => s }),
-}));
-
-// Keep both controllers inert and idle so MicButton renders the idle branch.
-const idleCtl = {
-  status: "idle" as const,
-  start: vi.fn(async () => {}),
-  stop: vi.fn(),
-  cancel: vi.fn(),
-  audioLevel: 0,
-  errorMessage: null,
-};
-vi.mock("@/features/dictation/hooks/use-dictation", () => ({
-  useDictation: () => idleCtl,
-}));
-vi.mock("@/features/dictation/hooks/use-streaming-dictation", () => ({
-  useStreamingDictation: () => idleCtl,
-}));
-
-import { MicButton } from "./mic-button";
-
-function renderButton(props: React.ComponentProps<typeof MicButton>) {
-  render(
-    <MantineProvider>
-      <MicButton {...props} />
-    </MantineProvider>,
-  );
-}
-
-describe("MicButton — disabled reason label", () => {
-  // jsdom has no MediaRecorder / mediaDevices, so isDictationSupported() would
-  // report "unsupported" and mask the forwarded reason. Stub both so the button
-  // is considered supported and the availability reason is what surfaces.
-  beforeEach(() => {
-    (globalThis as unknown as { MediaRecorder: unknown }).MediaRecorder =
-      class {};
-    Object.defineProperty(navigator, "mediaDevices", {
-      configurable: true,
-      value: { getUserMedia: vi.fn() },
-    });
-  });
-  afterEach(() => {
-    delete (globalThis as unknown as { MediaRecorder?: unknown }).MediaRecorder;
-  });
-
-  it("shows the cause-specific reason instead of 'Start dictation' when disabled with a reason", () => {
-    renderButton({ onText: () => {}, disabled: true, unavailableReason: "offline" });
-    const expected =
-      "No connection to the collaboration server — dictation unavailable";
-    // The reason surfaces as the accessible label (and the tooltip text).
-    const button = screen.getByRole("button", { name: expected });
-    expect(button).toBeDefined();
-    // It is marked disabled the Mantine way (data-disabled), NOT the native
-    // `disabled` attribute — otherwise pointer-events:none would kill the tooltip.
-    expect(button.getAttribute("data-disabled")).toBe("true");
-    expect(button.hasAttribute("disabled")).toBe(false);
-    // And it no longer silently reads "Start dictation".
-    expect(screen.queryByRole("button", { name: "Start dictation" })).toBeNull();
-  });
-
-  it("reads 'Start dictation' when enabled with no reason", () => {
-    renderButton({ onText: () => {} });
-    expect(
-      screen.getByRole("button", { name: "Start dictation" }),
-    ).toBeDefined();
-  });
-
-  it("does not advertise 'Start dictation' when disabled with no reason", () => {
-    // A consumer passing bare `disabled` (e.g. the AI chat's isStreaming) with no
-    // unavailableReason must not get a hoverable mic whose tooltip invites
-    // "Start dictation" on a click that is rejected.
-    renderButton({ onText: () => {}, disabled: true });
-    expect(
-      screen.queryByRole("button", { name: "Start dictation" }),
-    ).toBeNull();
-    const button = screen.getByRole("button");
-    expect(button.getAttribute("data-disabled")).toBe("true");
-  });
-});

apps/client/src/features/dictation/components/mic-button.tsx

@@ -4,11 +4,6 @@ import { IconMicrophone, IconPlayerStopFilled } from "@tabler/icons-react";
 import { useTranslation } from "react-i18next";
 import { useDictation } from "@/features/dictation/hooks/use-dictation";
 import { useStreamingDictation } from "@/features/dictation/hooks/use-streaming-dictation";
-import {
-  isDictationSupported,
-  resolveUnavailableLabel,
-  type DictationUnavailableReason,
-} from "@/features/dictation/dictation-status";
 import classes from "./mic-button.module.css";
 
 interface MicButtonProps {
@@ -26,9 +21,6 @@ interface MicButtonProps {
   // When true, use the streaming (Silero-VAD) dictation controller, which emits
   // text progressively as the user pauses; otherwise use the batch controller.
   streaming?: boolean;
-  // When the mic is disabled for an availability reason, this is the cause the
-  // idle tooltip explains (e.g. pre-sync "connecting", "offline", "read-only").
-  unavailableReason?: DictationUnavailableReason;
 }
 
 /**
@@ -45,7 +37,6 @@ export const MicButton: FC<MicButtonProps> = ({
   color,
   iconSize,
   streaming = false,
-  unavailableReason,
 }) => {
   const { t } = useTranslation();
   // Call BOTH hooks unconditionally to respect the rules of hooks: which one is
@@ -55,7 +46,7 @@ export const MicButton: FC<MicButtonProps> = ({
   const batchCtl = useDictation({ onText, onStart });
   const streamingCtl = useStreamingDictation({ onText, onStart });
   const ctl = streaming ? streamingCtl : batchCtl;
-  const { status, start, stop, audioLevel, errorMessage } = ctl;
+  const { status, start, stop, audioLevel } = ctl;
   const resolvedIconSize = iconSize ?? (size === "lg" ? 18 : 16);
 
   if (status === "recording") {
@@ -91,28 +82,15 @@ export const MicButton: FC<MicButtonProps> = ({
   ) {
     // "loading" (streaming hook fetching the VAD model on first use) shows the
     // same spinner+disabled state so the first click is visibly acknowledged and
-    // a confusing second click can't fire while the model loads. The error case
+    // a confusing second click can't fire while the model loads.
-    // explains the failure via the hook's resolved errorMessage instead of the
+    const label = status === "loading" ? t("Preparing…") : t("Transcribing…");
-    // transient "Transcribing…" label.
-    const label =
-      status === "error"
-        ? (errorMessage ?? t("Transcription failed"))
-        : status === "loading"
-          ? t("Preparing…")
-          : t("Transcribing…");
     return (
       <Tooltip label={label} withArrow>
         <ActionIcon
           size={size}
           variant="subtle"
           color={color}
-          // Mark disabled the Mantine way (data-disabled/aria-disabled) rather
+          disabled
-          // than the native `disabled` attribute: native `disabled` sets
-          // `pointer-events:none`, which suppresses hover so the Tooltip never
-          // fires. This is a status display with no click action to guard, so
-          // keeping it hoverable simply lets the error reason be read on hover.
-          data-disabled
-          aria-disabled
           aria-label={label}
         >
           <Loader size="xs" />
@@ -121,56 +99,18 @@ export const MicButton: FC<MicButtonProps> = ({
     );
   }
 
-  // Idle branch. A grey/disabled mic must explain WHY it can't record. An
+  return (
-  // unsupported browser/context is detected here; otherwise the parent forwards
+    <Tooltip label={t("Start dictation")} withArrow>
-  // a cause-specific reason. We must NOT pass the native `disabled` prop: Mantine
-  // renders `<button disabled>` with `pointer-events:none`, which suppresses
-  // hover so the Tooltip never fires. Instead mark it disabled the Mantine way
-  // (data-disabled/aria-disabled) — keeping it hoverable and in the a11y tree —
-  // and guard the click ourselves.
-  const unsupported = !isDictationSupported();
-  const isDisabled = disabled || unsupported;
-  const reason: DictationUnavailableReason | undefined = unsupported
-    ? "unsupported"
-    : unavailableReason;
-  const reasonLabel = reason ? resolveUnavailableLabel(reason, t) : undefined;
-  // A disabled mic with a known reason surfaces it on hover; an enabled mic
-  // invites "Start dictation". But a mic disabled with NO reason (e.g. a
-  // consumer that passes bare `disabled` — the AI chat's isStreaming, with no
-  // unavailableReason) must NOT hover a misleading, actionable "Start dictation"
-  // tooltip on a control that rejects the click. In that case we render the icon
-  // without a Tooltip and give it a neutral accessible label instead.
-  const ariaLabel = reasonLabel ?? (isDisabled ? t("Dictation") : t("Start dictation"));
-  const icon = (
       <ActionIcon
         size={size}
         variant="subtle"
         color={color}
-      onClick={(e) => {
+        onClick={() => void start()}
-        if (isDisabled) {
+        disabled={disabled}
-          e.preventDefault();
+        aria-label={t("Start dictation")}
-          return;
-        }
-        void start();
-      }}
-      data-disabled={isDisabled || undefined}
-      aria-disabled={isDisabled}
-      aria-label={ariaLabel}
       >
         <IconMicrophone size={resolvedIconSize} />
       </ActionIcon>
-  );
-  // Suppress the tooltip on a disabled mic that has nothing to explain — hovering
-  // a grey, unclickable mic should not advertise "Start dictation".
-  if (isDisabled && !reasonLabel) {
-    return icon;
-  }
-  return (
-    <Tooltip
-      label={reasonLabel ?? t("Start dictation")}
-      withArrow
-    >
-      {icon}
     </Tooltip>
   );
 };

apps/client/src/features/dictation/dictation-status.test.ts

@@ -1,156 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  classifyGetUserMediaError,
-  classifyTranscriptionError,
-  dictationErrorMessage,
-  resolveUnavailableLabel,
-  isDictationSupported,
-} from "./dictation-status";
-
-// Unit tests for the shared dictation-status resolvers (dictation-status.ts).
-// Both dictation hooks and the mic button form their user-facing strings here,
-// so a regression in the classification or message mapping would silently swap
-// what a user reads when the mic is grey or a recording fails. A fake `t`
-// returns its key verbatim so we assert the exact i18n key each branch selects.
-const t = (k: string) => k;
-
-describe("classifyGetUserMediaError", () => {
-  it("maps NotAllowedError / SecurityError to mic-denied", () => {
-    expect(classifyGetUserMediaError({ name: "NotAllowedError" })).toBe(
-      "mic-denied",
-    );
-    expect(classifyGetUserMediaError({ name: "SecurityError" })).toBe(
-      "mic-denied",
-    );
-  });
-
-  it("maps NotFoundError / OverconstrainedError to no-mic", () => {
-    expect(classifyGetUserMediaError({ name: "NotFoundError" })).toBe("no-mic");
-    expect(classifyGetUserMediaError({ name: "OverconstrainedError" })).toBe(
-      "no-mic",
-    );
-  });
-
-  it("maps NotReadableError / AbortError to mic-in-use", () => {
-    expect(classifyGetUserMediaError({ name: "NotReadableError" })).toBe(
-      "mic-in-use",
-    );
-    expect(classifyGetUserMediaError({ name: "AbortError" })).toBe(
-      "mic-in-use",
-    );
-  });
-
-  it("maps anything else / undefined to unknown", () => {
-    expect(classifyGetUserMediaError({ name: "WeirdError" })).toBe("unknown");
-    expect(classifyGetUserMediaError(undefined)).toBe("unknown");
-    expect(classifyGetUserMediaError({})).toBe("unknown");
-  });
-});
-
-describe("classifyTranscriptionError", () => {
-  it("returns the verbatim server message when present", () => {
-    const err = { response: { status: 500, data: { message: "provider 404" } } };
-    expect(classifyTranscriptionError(err)).toEqual({
-      code: "transcription-failed",
-      serverMessage: "provider 404",
-    });
-  });
-
-  it("maps 503 / 403 (no server message) to stt-not-configured", () => {
-    expect(classifyTranscriptionError({ response: { status: 503 } })).toEqual({
-      code: "stt-not-configured",
-    });
-    expect(classifyTranscriptionError({ response: { status: 403 } })).toEqual({
-      code: "stt-not-configured",
-    });
-  });
-
-  it("falls back to transcription-failed with no server message otherwise", () => {
-    expect(classifyTranscriptionError({ response: { status: 500 } })).toEqual({
-      code: "transcription-failed",
-    });
-    expect(classifyTranscriptionError(new Error("network"))).toEqual({
-      code: "transcription-failed",
-    });
-    // Blank server message is ignored (does not win as verbatim text).
-    expect(
-      classifyTranscriptionError({ response: { data: { message: "   " } } }),
-    ).toEqual({ code: "transcription-failed" });
-  });
-});
-
-describe("dictationErrorMessage", () => {
-  it("maps each code to the expected i18n key", () => {
-    expect(dictationErrorMessage("mic-denied", t)).toBe(
-      "Microphone access denied",
-    );
-    expect(dictationErrorMessage("no-mic", t)).toBe("No microphone found");
-    expect(dictationErrorMessage("mic-in-use", t)).toBe(
-      "Microphone is unavailable or already in use",
-    );
-    expect(dictationErrorMessage("no-media-devices", t)).toBe(
-      "Audio recording is not available in this browser/context",
-    );
-    expect(dictationErrorMessage("stt-not-configured", t)).toBe(
-      "Voice dictation is not configured",
-    );
-    expect(dictationErrorMessage("transcription-failed", t)).toBe(
-      "Transcription failed",
-    );
-    expect(dictationErrorMessage("recorder-failed", t)).toBe(
-      "Could not start recording",
-    );
-    expect(dictationErrorMessage("vad-init-failed", t)).toBe(
-      "Could not start recording",
-    );
-    expect(dictationErrorMessage("unknown", t)).toBe(
-      "Could not start recording",
-    );
-  });
-
-  it("returns the server message verbatim for transcription-failed (not the t key)", () => {
-    expect(
-      dictationErrorMessage("transcription-failed", t, {
-        serverMessage: "quota exceeded",
-      }),
-    ).toBe("quota exceeded");
-  });
-
-  it("appends the detail to recorder-failed / unknown", () => {
-    expect(
-      dictationErrorMessage("recorder-failed", t, { detail: "boom" }),
-    ).toBe("Could not start recording: boom");
-    expect(dictationErrorMessage("unknown", t, { detail: "nope" })).toBe(
-      "Could not start recording: nope",
-    );
-  });
-
-  it("appends the detail to transcription-failed when there is no server message", () => {
-    expect(
-      dictationErrorMessage("transcription-failed", t, { detail: "timeout" }),
-    ).toBe("Transcription failed: timeout");
-  });
-});
-
-describe("resolveUnavailableLabel", () => {
-  it("maps each reason to its expected i18n key", () => {
-    expect(resolveUnavailableLabel("connecting", t)).toBe(
-      "Dictation becomes available once the page finishes connecting",
-    );
-    expect(resolveUnavailableLabel("offline", t)).toBe(
-      "No connection to the collaboration server — dictation unavailable",
-    );
-    expect(resolveUnavailableLabel("read-only", t)).toBe(
-      "This page is read-only",
-    );
-    expect(resolveUnavailableLabel("unsupported", t)).toBe(
-      "Audio recording is not available in this browser/context",
-    );
-  });
-});
-
-describe("isDictationSupported", () => {
-  it("returns a boolean", () => {
-    expect(typeof isDictationSupported()).toBe("boolean");
-  });
-});

apps/client/src/features/dictation/dictation-status.ts

@@ -1,110 +0,0 @@
-// Single source of truth for "why dictation is unavailable" and "why it failed".
-// Both dictation hooks and the mic button pull their user-facing strings from
-// the resolvers here so the wording lives in exactly one place.
-
-export type DictationUnavailableReason =
-  | "connecting"
-  | "offline"
-  | "read-only"
-  | "unsupported";
-
-export type DictationErrorCode =
-  | "no-media-devices"
-  | "mic-denied"
-  | "no-mic"
-  | "mic-in-use"
-  | "recorder-failed"
-  | "vad-init-failed"
-  | "stt-not-configured"
-  | "transcription-failed"
-  | "unknown";
-
-// True if this browser/context can record audio.
-export function isDictationSupported(): boolean {
-  return (
-    typeof MediaRecorder !== "undefined" &&
-    typeof navigator !== "undefined" &&
-    !!navigator.mediaDevices?.getUserMedia
-  );
-}
-
-// getUserMedia / VAD.start rejection -> code, by DOMException .name.
-export function classifyGetUserMediaError(err: unknown): DictationErrorCode {
-  const name = (err as { name?: string })?.name;
-  if (name === "NotAllowedError" || name === "SecurityError")
-    return "mic-denied";
-  if (name === "NotFoundError" || name === "OverconstrainedError")
-    return "no-mic";
-  if (name === "NotReadableError" || name === "AbortError") return "mic-in-use";
-  return "unknown";
-}
-
-// Transcription HTTP failure -> code (+ verbatim server message when present).
-export function classifyTranscriptionError(err: unknown): {
-  code: DictationErrorCode;
-  serverMessage?: string;
-} {
-  const resp = (
-    err as { response?: { status?: number; data?: { message?: string } } }
-  )?.response;
-  const serverMessage = resp?.data?.message;
-  if (serverMessage && serverMessage.trim().length > 0)
-    return { code: "transcription-failed", serverMessage };
-  if (resp?.status === 503 || resp?.status === 403)
-    return { code: "stt-not-configured" };
-  return { code: "transcription-failed" };
-}
-
-type TFn = (key: string) => string;
-
-// Code -> user text. The ONE place runtime error strings are formed.
-// serverMessage (verbatim) wins for transcription-failed; detail is appended
-// to the generic "could not start"/"transcription failed" strings.
-export function dictationErrorMessage(
-  code: DictationErrorCode,
-  t: TFn,
-  extra?: { serverMessage?: string; detail?: string },
-): string {
-  const detail = extra?.detail;
-  switch (code) {
-    case "mic-denied":
-      return t("Microphone access denied");
-    case "no-mic":
-      return t("No microphone found");
-    case "mic-in-use":
-      return t("Microphone is unavailable or already in use");
-    case "no-media-devices":
-      return t("Audio recording is not available in this browser/context");
-    case "stt-not-configured":
-      return t("Voice dictation is not configured");
-    case "transcription-failed":
-      if (extra?.serverMessage && extra.serverMessage.trim().length > 0)
-        return extra.serverMessage;
-      return `${t("Transcription failed")}${detail ? `: ${detail}` : ""}`;
-    case "recorder-failed":
-    case "vad-init-failed":
-    case "unknown":
-    default:
-      return `${t("Could not start recording")}${detail ? `: ${detail}` : ""}`;
-  }
-}
-
-// Unavailable reason -> tooltip text (the ONE place these strings are formed).
-export function resolveUnavailableLabel(
-  r: DictationUnavailableReason,
-  t: TFn,
-): string {
-  switch (r) {
-    case "connecting":
-      return t("Dictation becomes available once the page finishes connecting");
-    case "offline":
-      return t(
-        "No connection to the collaboration server — dictation unavailable",
-      );
-    case "read-only":
-      return t("This page is read-only");
-    case "unsupported":
-    default:
-      return t("Audio recording is not available in this browser/context");
-  }
-}

apps/client/src/features/dictation/hooks/use-dictation.ts

@@ -2,11 +2,6 @@ import { useCallback, useEffect, useRef, useState } from "react";
 import { notifications } from "@mantine/notifications";
 import { useTranslation } from "react-i18next";
 import { transcribeAudio } from "@/features/dictation/services/dictation-service";
-import {
-  classifyGetUserMediaError,
-  classifyTranscriptionError,
-  dictationErrorMessage,
-} from "@/features/dictation/dictation-status";
 
 // "loading" is set only by the streaming hook while it lazily loads the VAD
 // model on first use; the batch hook never sets it. It exists so the streaming
@@ -31,8 +26,6 @@ interface UseDictationResult {
   cancel: () => void;
   // Smoothed live microphone level in the 0..1 range while recording (0 when idle).
   audioLevel: number;
-  // The last error shown to the user (null until one occurs / on a new start).
-  errorMessage: string | null;
 }
 
 // Candidate container/codec combinations in preference order. The first one the
@@ -74,8 +67,6 @@ export function useDictation(
   const { t } = useTranslation();
   const [status, setStatus] = useState<DictationStatus>("idle");
   const [audioLevel, setAudioLevel] = useState(0);
-  // Last error message shown to the user; the mic button reads it for its tooltip.
-  const [errorMessage, setErrorMessage] = useState<string | null>(null);
 
   // Keep the latest callbacks in a ref so the recorder's onstop closure always
   // calls the current handlers without re-creating the recorder.
@@ -203,16 +194,15 @@ export function useDictation(
     if (startingRef.current || recorderRef.current || streamRef.current) return;
     if (status !== "idle") return;
     startingRef.current = true;
-    // Clear any stale error from a previous attempt.
-    setErrorMessage(null);
 
     if (!navigator.mediaDevices?.getUserMedia) {
       const reason =
         "navigator.mediaDevices.getUserMedia is unavailable in this context";
       console.error("[dictation] " + reason);
-      const message = dictationErrorMessage("no-media-devices", t);
+      notifications.show({
-      notifications.show({ color: "red", message });
+        color: "red",
-      setErrorMessage(message);
+        message: t("Audio recording is not available in this browser/context"),
+      });
       setStatus("idle");
       startingRef.current = false;
       return;
@@ -225,16 +215,19 @@ export function useDictation(
       // Always log the full error for diagnosis (name, message, stack).
       console.error("[dictation] getUserMedia failed", err);
       const name = (err as { name?: string })?.name;
-      const rawDetail = (err as { message?: string })?.message ?? String(err);
+      const detail = (err as { message?: string })?.message ?? String(err);
-      // Prefix the DOMException name (e.g. "TypeError: …") so the generic
+      let message: string;
-      // resolver branch reproduces this hook's original "Could not start
+      if (name === "NotAllowedError" || name === "SecurityError") {
-      // recording: <name>: <detail>" text. Each caller owns its own detail; the
+        message = t("Microphone access denied");
-      // streaming hook intentionally does not add the name.
+      } else if (name === "NotFoundError" || name === "OverconstrainedError") {
-      const detail = `${name ? `${name}: ` : ""}${rawDetail}`;
+        message = t("No microphone found");
-      const code = classifyGetUserMediaError(err);
+      } else if (name === "NotReadableError" || name === "AbortError") {
-      const message = dictationErrorMessage(code, t, { detail });
+        message = t("Microphone is unavailable or already in use");
+      } else {
+        // Unknown failure: show the real reason instead of a generic string.
+        message = `${t("Could not start recording")}: ${name ? `${name}: ` : ""}${detail}`;
+      }
       notifications.show({ color: "red", message });
-      setErrorMessage(message);
       setStatus("idle");
       startingRef.current = false;
       return;
@@ -256,10 +249,10 @@ export function useDictation(
       // The stream was acquired but the recorder failed to construct; stop the
       // tracks so the MediaStream does not leak before bailing out.
       stopTracks();
-      const detail = (err as { message?: string })?.message ?? String(err);
+      notifications.show({
-      const message = dictationErrorMessage("recorder-failed", t, { detail });
+        color: "red",
-      notifications.show({ color: "red", message });
+        message: `${t("Could not start recording")}: ${(err as { message?: string })?.message ?? String(err)}`,
-      setErrorMessage(message);
+      });
       setStatus("idle");
       startingRef.current = false;
       return;
@@ -300,14 +293,21 @@ export function useDictation(
         .catch((err: unknown) => {
           // Log the full error for diagnosis (status + body + stack).
           console.error("[dictation] transcription failed", err);
-          const { code, serverMessage } = classifyTranscriptionError(err);
+          const resp = (
-          const detail = (err as { message?: string })?.message ?? String(err);
+            err as { response?: { status?: number; data?: { message?: string } } }
-          const message = dictationErrorMessage(code, t, {
+          )?.response;
-            serverMessage,
+          const serverMsg = resp?.data?.message;
-            detail,
+          let message: string;
-          });
+          if (serverMsg && serverMsg.trim().length > 0) {
+            // The server already explains the cause (e.g. provider 404, bad
+            // format, STT not configured) — show it verbatim.
+            message = serverMsg;
+          } else if (resp?.status === 503 || resp?.status === 403) {
+            message = t("Voice dictation is not configured");
+          } else {
+            message = `${t("Transcription failed")}: ${(err as { message?: string })?.message ?? String(err)}`;
+          }
           notifications.show({ color: "red", message });
-          setErrorMessage(message);
           setStatus("error");
           if (errorTimerRef.current !== null) {
             clearTimeout(errorTimerRef.current);
@@ -332,10 +332,10 @@ export function useDictation(
       stopTracks();
       recorderRef.current = null;
       startingRef.current = false;
-      const detail = (err as { message?: string })?.message ?? String(err);
+      notifications.show({
-      const message = dictationErrorMessage("recorder-failed", t, { detail });
+        color: "red",
-      notifications.show({ color: "red", message });
+        message: `${t("Could not start recording")}: ${(err as { message?: string })?.message ?? String(err)}`,
-      setErrorMessage(message);
+      });
       setStatus("idle");
       return;
     }
@@ -405,5 +405,5 @@ export function useDictation(
     };
   }, [clearTimer, stopTracks, stopMeter]);
 
-  return { status, start, stop, cancel, audioLevel, errorMessage };
+  return { status, start, stop, cancel, audioLevel };
 }

apps/client/src/features/dictation/hooks/use-streaming-dictation.ts

@@ -4,11 +4,6 @@ import { useTranslation } from "react-i18next";
 import { transcribeAudio } from "@/features/dictation/services/dictation-service";
 import { encodeWavPcm16 } from "@/features/dictation/utils/encode-wav";
 import type { DictationStatus } from "@/features/dictation/hooks/use-dictation";
-import {
-  classifyGetUserMediaError,
-  classifyTranscriptionError,
-  dictationErrorMessage,
-} from "@/features/dictation/dictation-status";
 
 // Lazily-imported MicVAD type. The runtime import happens inside start() so the
 // heavy onnxruntime-web / Silero model is code-split out of the main bundle and
@@ -32,8 +27,6 @@ interface UseStreamingDictationResult {
   cancel: () => void;
   // Smoothed live speech level in the 0..1 range while recording (0 when idle).
   audioLevel: number;
-  // The last error shown to the user (null until one occurs / on a new start).
-  errorMessage: string | null;
 }
 
 // Sample rate of the audio MicVAD hands to onSpeechEnd (Silero VAD runs at 16k).
@@ -67,8 +60,6 @@ export function useStreamingDictation(
   const { t } = useTranslation();
   const [status, setStatus] = useState<DictationStatus>("idle");
   const [audioLevel, setAudioLevel] = useState(0);
-  // Last error message shown to the user; the mic button reads it for its tooltip.
-  const [errorMessage, setErrorMessage] = useState<string | null>(null);
 
   // Keep the latest callbacks in a ref so async VAD/HTTP closures always call the
   // current handlers without re-creating the VAD.
@@ -167,6 +158,26 @@ export function useStreamingDictation(
     }
   }, []);
 
+  // Map a transcription error to a user-facing message, mirroring the batch hook.
+  const transcriptionErrorMessage = useCallback(
+    (err: unknown): string => {
+      const resp = (
+        err as { response?: { status?: number; data?: { message?: string } } }
+      )?.response;
+      const serverMsg = resp?.data?.message;
+      if (serverMsg && serverMsg.trim().length > 0) {
+        // The server already explains the cause (e.g. provider 404, bad format,
+        // STT not configured) — show it verbatim.
+        return serverMsg;
+      }
+      if (resp?.status === 503 || resp?.status === 403) {
+        return t("Voice dictation is not configured");
+      }
+      return `${t("Transcription failed")}: ${(err as { message?: string })?.message ?? String(err)}`;
+    },
+    [t],
+  );
+
   // Handle one ended speech segment: encode to WAV and transcribe. Results are
   // buffered by seq and flushed in order. A single failed segment does NOT kill
   // the session: log + one notification, then advance past that seq so later
@@ -193,14 +204,10 @@ export function useStreamingDictation(
           if (epoch !== epochRef.current) return;
           // Log the full error for diagnosis (status + body + stack).
           console.error("[dictation] segment transcription failed", err);
-          const { code, serverMessage } = classifyTranscriptionError(err);
+          notifications.show({
-          const detail = (err as { message?: string })?.message ?? String(err);
+            color: "red",
-          const message = dictationErrorMessage(code, t, {
+            message: transcriptionErrorMessage(err),
-            serverMessage,
-            detail,
           });
-          notifications.show({ color: "red", message });
-          setErrorMessage(message);
           // Skip this seq so later segments can still flush in order.
           if (nextEmitSeqRef.current === seq) {
             nextEmitSeqRef.current += 1;
@@ -219,7 +226,7 @@ export function useStreamingDictation(
           }
         });
     },
-    [drainResults, t],
+    [drainResults, transcriptionErrorMessage],
   );
 
   const start = useCallback(async (): Promise<void> => {
@@ -229,8 +236,6 @@ export function useStreamingDictation(
     if (startingRef.current || vadRef.current || activeRef.current) return;
     if (status !== "idle") return;
     startingRef.current = true;
-    // Clear any stale error from a previous attempt.
-    setErrorMessage(null);
 
     // Notify the caller right when dictation begins (before any async work) so the
     // editor can snapshot the caret position.
@@ -349,9 +354,10 @@ export function useStreamingDictation(
       // actually runs.)
       console.error("[dictation] VAD init failed", err);
       const detail = (err as { message?: string })?.message ?? String(err);
-      const message = dictationErrorMessage("vad-init-failed", t, { detail });
+      notifications.show({
-      notifications.show({ color: "red", message });
+        color: "red",
-      setErrorMessage(message);
+        message: `${t("Could not start recording")}: ${detail}`,
+      });
       // Defensive: if MicVAD.new partially succeeded before throwing, make sure we
       // don't leak it.
       destroyVad();
@@ -373,11 +379,19 @@ export function useStreamingDictation(
     } catch (err) {
       // Always log the full error for diagnosis (name, message, stack).
       console.error("[dictation] VAD.start failed", err);
+      const name = (err as { name?: string })?.name;
       const detail = (err as { message?: string })?.message ?? String(err);
-      const code = classifyGetUserMediaError(err);
+      let message: string;
-      const message = dictationErrorMessage(code, t, { detail });
+      if (name === "NotAllowedError" || name === "SecurityError") {
+        message = t("Microphone access denied");
+      } else if (name === "NotFoundError" || name === "OverconstrainedError") {
+        message = t("No microphone found");
+      } else if (name === "NotReadableError" || name === "AbortError") {
+        message = t("Microphone is unavailable or already in use");
+      } else {
+        message = `${t("Could not start recording")}: ${detail}`;
+      }
       notifications.show({ color: "red", message });
-      setErrorMessage(message);
       activeRef.current = false;
       destroyVad();
       setStatus("idle");
@@ -456,5 +470,5 @@ export function useStreamingDictation(
     };
   }, [clearTimer, destroyVad]);
 
-  return { status, start, stop, cancel, audioLevel, errorMessage };
+  return { status, start, stop, cancel, audioLevel };
 }

apps/client/src/features/editor/atoms/editor-atoms.ts

@@ -1,7 +1,6 @@
 import { atom } from "jotai";
 import { Editor } from "@tiptap/core";
 import { PageEditMode } from "@/features/user/types/user.types.ts";
-import type { DictationUnavailableReason } from "@/features/dictation/dictation-status";
 
 export const pageEditorAtom = atom<Editor | null>(null);
 
@@ -16,15 +15,3 @@ export const showLinkMenuAtom = atom(false);
 // Current page's edit mode — initialized from the user's saved preference on
 // first load, can be toggled locally without persisting to the server.
 export const currentPageEditModeAtom = atom<PageEditMode>(PageEditMode.Edit);
-
-// Whether the dictation mic can start, and (when it can't) the cause-specific
-// reason the mic button surfaces as a tooltip. Published by the page editor,
-// consumed by DictationGroup -> MicButton.
-export type DictationAvailability = {
-  isEditable: boolean;
-  reason: DictationUnavailableReason | null;
-};
-export const dictationAvailabilityAtom = atom<DictationAvailability>({
-  isEditable: false,
-  reason: null,
-});

apps/client/src/features/editor/components/fixed-toolbar/groups/dictation-group.test.tsx

@@ -1,60 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { render, act } from "@testing-library/react";
-import { Provider, createStore } from "jotai";
-import { dictationAvailabilityAtom } from "@/features/editor/atoms/editor-atoms.ts";
-
-// Regression test for the byline mic staying stuck disabled (#311 / #309): on a
-// page the user can edit, the mic must un-grey once the body becomes editable.
-// #311 first fixed this by reading `editor.isEditable` via `useEditorState`; #309
-// superseded that with a reactive `dictationAvailabilityAtom` that page-editor
-// publishes (carrying both the editable gate AND the unavailable reason). The mic
-// now gates on `dictationAvailability.isEditable`, so a change to that atom must
-// re-render the group and flip the disabled state (jotai drives the subscription).
-
-// Detectable stand-in that surfaces the `disabled` prop the component computes.
-vi.mock("@/features/dictation/components/mic-button", () => ({
-  MicButton: ({ disabled }: any) => (
-    <button data-testid="mic" disabled={disabled} />
-  ),
-}));
-
-import { DictationGroup } from "./dictation-group";
-
-// Minimal editor stand-in matching the surface DictationGroup uses (handleStart /
-// handleText). The disabled gate no longer reads this — it reads the atom.
-function makeFakeEditor() {
-  return {
-    isEditable: false,
-    isDestroyed: false,
-    state: { selection: { from: 0, to: 0 }, doc: { content: { size: 0 } } },
-  } as any;
-}
-
-describe("DictationGroup editable reactivity (#309 atom / #311)", () => {
-  it("re-enables the mic when dictationAvailability flips isEditable false -> true", () => {
-    const editor = makeFakeEditor();
-    const store = createStore();
-    // Pre-sync: page editor publishes not-editable (with a reason).
-    store.set(dictationAvailabilityAtom, {
-      isEditable: false,
-      reason: "connecting",
-    });
-
-    const { getByTestId } = render(
-      <Provider store={store}>
-        <DictationGroup editor={editor} />
-      </Provider>,
-    );
-
-    // Not editable yet -> disabled (preserves the #218 pre-sync intent).
-    expect(getByTestId("mic").hasAttribute("disabled")).toBe(true);
-
-    // Collab sync -> page editor republishes editable; the atom change must
-    // re-render the group and enable the mic.
-    act(() => {
-      store.set(dictationAvailabilityAtom, { isEditable: true, reason: null });
-    });
-
-    expect(getByTestId("mic").hasAttribute("disabled")).toBe(false);
-  });
-});

apps/client/src/features/editor/components/fixed-toolbar/groups/dictation-group.tsx

@@ -1,8 +1,7 @@
 import { FC, useRef } from "react";
-import { Editor } from "@tiptap/react";
+import type { Editor } from "@tiptap/react";
 import { useAtomValue } from "jotai";
 import { workspaceAtom } from "@/features/user/atoms/current-user-atom.ts";
-import { dictationAvailabilityAtom } from "@/features/editor/atoms/editor-atoms.ts";
 import { MicButton } from "@/features/dictation/components/mic-button";
 
 interface Props {
@@ -17,8 +16,6 @@ export const DictationGroup: FC<Props> = ({ editor, color, iconSize }) => {
   const workspace = useAtomValue(workspaceAtom);
   const streamingDictation =
     workspace?.settings?.ai?.dictationStreaming === true;
-  // Cause-specific reason the mic is unavailable (published by the page editor).
-  const dictationAvailability = useAtomValue(dictationAvailabilityAtom);
   // Caret snapshot taken when dictation starts (where the first segment lands).
   const rangeRef = useRef<{ from: number; to: number } | null>(null);
   // Running insertion point: after each inserted segment we remember the caret
@@ -83,8 +80,7 @@ export const DictationGroup: FC<Props> = ({ editor, color, iconSize }) => {
       streaming={streamingDictation}
       onStart={handleStart}
       onText={handleText}
-      disabled={!dictationAvailability.isEditable}
+      disabled={!editor.isEditable}
-      unavailableReason={dictationAvailability.reason ?? undefined}
       color={color}
       iconSize={iconSize}
     />

apps/client/src/features/editor/components/mention/mention-view.tsx

@@ -11,19 +11,9 @@ import {
 import { extractPageSlugId } from "@/lib";
 import classes from "./mention.module.css";
 
-interface MentionAttrs {
+export default function MentionView(props: NodeViewProps) {
-  label?: string;
+  const { node } = props;
-  entityType?: string;
+  const { label, entityType, entityId, slugId, anchorId } = node.attrs;
-  entityId?: string;
-  slugId?: string;
-  anchorId?: string;
-}
-
-// Presentational mention renderer (no NodeViewWrapper). Shared by the editor
-// NodeView (MentionView) and the static comment renderer (CommentContentView)
-// so mention click/nav/icon behavior stays identical outside of an editor.
-export function MentionContent({ attrs }: { attrs: MentionAttrs }) {
-  const { label, entityType, slugId, anchorId } = attrs;
   const isPageMention = entityType === "page";
   const { spaceSlug, pageSlug } = useParams();
   const { shareId } = useParams();
@@ -66,7 +56,7 @@ export function MentionContent({ attrs }: { attrs: MentionAttrs }) {
   });
 
   return (
-    <>
+    <NodeViewWrapper style={{ display: "inline" }} data-drag-handle>
       {entityType === "user" && (
         <Text className={classes.userMention} component="span">
           @{label}
@@ -149,14 +139,6 @@ export function MentionContent({ attrs }: { attrs: MentionAttrs }) {
           </span>
         </Anchor>
       )}
-    </>
-  );
-}
-
-export default function MentionView(props: NodeViewProps) {
-  return (
-    <NodeViewWrapper style={{ display: "inline" }} data-drag-handle>
-      <MentionContent attrs={props.node.attrs} />
     </NodeViewWrapper>
   );
 }

apps/client/src/features/editor/editor-sync-state.test.ts

@@ -1,10 +1,6 @@
 import { describe, it, expect } from "vitest";
 import { WebSocketStatus } from "@hocuspocus/provider";
-import {
+import { isCollabSynced, isBodyEditable } from "./editor-sync-state";
-  isCollabSynced,
-  isBodyEditable,
-  computeDictationAvailability,
-} from "./editor-sync-state";
 
 describe("isCollabSynced", () => {
   it("is true only when Connected and synced", () => {
@@ -34,77 +30,3 @@ describe("isBodyEditable (pre-sync data-loss gate, #218)", () => {
     expect(isBodyEditable({ ...base, inEditMode: false })).toBe(false);
   });
 });
-
-describe("computeDictationAvailability (mic reason precedence, #309)", () => {
-  const base = {
-    editable: true,
-    inEditMode: true,
-    showStatic: false,
-    isDisconnected: false,
-  };
-
-  it("is available with no reason once synced (showStatic false)", () => {
-    expect(computeDictationAvailability(base)).toEqual({
-      isEditable: true,
-      reason: null,
-    });
-  });
-
-  it("reports 'offline' during pre-sync while disconnected", () => {
-    expect(
-      computeDictationAvailability({
-        ...base,
-        showStatic: true,
-        isDisconnected: true,
-      }),
-    ).toEqual({ isEditable: false, reason: "offline" });
-  });
-
-  it("reports 'connecting' during pre-sync while still connecting", () => {
-    expect(
-      computeDictationAvailability({
-        ...base,
-        showStatic: true,
-        isDisconnected: false,
-      }),
-    ).toEqual({ isEditable: false, reason: "connecting" });
-  });
-
-  it("reports 'read-only' without edit permission", () => {
-    expect(
-      computeDictationAvailability({ ...base, editable: false }),
-    ).toEqual({ isEditable: false, reason: "read-only" });
-  });
-
-  it("reports 'read-only' when not in edit mode", () => {
-    expect(
-      computeDictationAvailability({ ...base, inEditMode: false }),
-    ).toEqual({ isEditable: false, reason: "read-only" });
-  });
-
-  // Lack of edit permission takes precedence over the pre-sync reason: a
-  // read-only viewer who is ALSO inside the pre-sync window (showStatic) must
-  // still read "read-only", never "offline"/"connecting". This pins the
-  // `opts.editable &&` guard on the pre-sync branch.
-  it("prefers 'read-only' over pre-sync when a read-only viewer is disconnected", () => {
-    expect(
-      computeDictationAvailability({
-        editable: false,
-        inEditMode: true,
-        showStatic: true,
-        isDisconnected: true,
-      }),
-    ).toEqual({ isEditable: false, reason: "read-only" });
-  });
-
-  it("prefers 'read-only' over pre-sync when a read-only viewer is still connecting", () => {
-    expect(
-      computeDictationAvailability({
-        editable: false,
-        inEditMode: true,
-        showStatic: true,
-        isDisconnected: false,
-      }),
-    ).toEqual({ isEditable: false, reason: "read-only" });
-  });
-});

apps/client/src/features/editor/editor-sync-state.ts

@@ -1,5 +1,4 @@
 import { WebSocketStatus } from "@hocuspocus/provider";
-import type { DictationUnavailableReason } from "@/features/dictation/dictation-status";
 
 /**
  * The collab document is usable only once the provider is Connected AND has
@@ -31,32 +30,3 @@ export function isBodyEditable(opts: {
 }): boolean {
   return opts.editable && opts.inEditMode && !opts.showStatic;
 }
-
-/**
- * Whether dictation can start and, when it can't, the cause-specific reason the
- * mic button surfaces. Derives editability from `isBodyEditable` (the single,
- * tested gate) so the published `isEditable` can never diverge from the actual
- * body-editable state and make the tooltip lie (#309).
- *
- * `isDisconnected` is the caller's own boolean (collab connection is in the
- * Disconnected state), passed in so this module stays free of the collab enum.
- */
-export function computeDictationAvailability(opts: {
-  editable: boolean;
-  inEditMode: boolean;
-  showStatic: boolean;
-  isDisconnected: boolean;
-}): { isEditable: boolean; reason: DictationUnavailableReason | null } {
-  const isEditable = isBodyEditable({
-    editable: opts.editable,
-    inEditMode: opts.inEditMode,
-    showStatic: opts.showStatic,
-  });
-  if (isEditable) return { isEditable, reason: null };
-  // Permitted to edit and in edit mode but not yet synced (showStatic) → pre-sync.
-  if (opts.editable && opts.inEditMode && opts.showStatic) {
-    return { isEditable, reason: opts.isDisconnected ? "offline" : "connecting" };
-  }
-  // No edit permission or not in edit mode.
-  return { isEditable, reason: "read-only" };
-}

apps/client/src/features/editor/hooks/use-scroll-position.test.ts

@@ -93,9 +93,10 @@ describe("useScrollPosition", () => {
     // Restore still scrolls to 500 (the captured target), NOT the clobbered 0.
     // If the capture were moved into an effect (after handlers register), it
     // would read the clobbered 0 and this assertion would fail.
-    setScrollHeight(2000); // maxScroll = 1200 >= 500
+    setScrollHeight(2000); // maxScroll = 1200 >= 500, held steady -> settles
     act(() => {
       result.current.restoreScrollPosition();
+      vi.advanceTimersByTime(500);
     });
     expect(window.scrollTo).toHaveBeenCalledWith({ top: 500, behavior: "auto" });
   });
@@ -103,11 +104,12 @@ describe("useScrollPosition", () => {
   it("(a3) is idempotent: re-asserting the same target does not scroll again", () => {
     vi.useFakeTimers();
     window.sessionStorage.setItem(`${KEY_PREFIX}once`, "500");
-    setScrollHeight(2000); // tall enough to restore synchronously
+    setScrollHeight(2000); // tall enough + steady -> settles
 
     const { result } = renderHook(() => useScrollPosition("once"));
     act(() => {
       result.current.restoreScrollPosition();
+      vi.advanceTimersByTime(500);
     });
     expect(window.scrollTo).toHaveBeenCalledTimes(1);
 
@@ -119,6 +121,7 @@ describe("useScrollPosition", () => {
     // the window is already at the target and does nothing.
     act(() => {
       result.current.restoreScrollPosition();
+      vi.advanceTimersByTime(500);
     });
     expect(window.scrollTo).toHaveBeenCalledTimes(1);
   });
@@ -126,10 +129,10 @@ describe("useScrollPosition", () => {
   it("(b) does not restore when the URL has a #hash anchor", () => {
     vi.useFakeTimers();
     window.sessionStorage.setItem(`${KEY_PREFIX}p2`, "500");
-    // Content is ALREADY tall enough (maxScroll = 2000 - 800 = 1200 >= 500), so
+    // Content is ALREADY tall enough (maxScroll = 2000 - 800 = 1200 >= 500) and
-    // without the hash guard tryRestore would call scrollTo synchronously on the
+    // steady, so without the hash guard the wait would settle and scroll to the
-    // first tick. The assertion below therefore genuinely proves the hash guard
+    // target. The assertion below therefore genuinely proves the hash guard
-    // short-circuits before any scroll (not just that the poll has not fired).
+    // short-circuits before any scroll (not just that the wait has not fired).
     setScrollHeight(2000);
     window.location.hash = "#some-heading";
 
@@ -168,7 +171,7 @@ describe("useScrollPosition", () => {
 
   it("(g) does not restore if the reader scrolled (wheel) before restore fires", () => {
     window.sessionStorage.setItem(`${KEY_PREFIX}g1`, "500");
-    setScrollHeight(2000); // tall enough to restore synchronously
+    setScrollHeight(2000); // tall enough (would settle and restore, absent the wheel)
 
     const { result } = renderHook(() => useScrollPosition("g1"));
 
@@ -210,8 +213,9 @@ describe("useScrollPosition", () => {
   });
 
   it("(i) a non-scroll keydown does NOT abort restore", () => {
+    vi.useFakeTimers();
     window.sessionStorage.setItem(`${KEY_PREFIX}i1`, "500");
-    setScrollHeight(2000); // tall enough to restore synchronously
+    setScrollHeight(2000); // tall enough + steady -> settles
 
     const { result } = renderHook(() => useScrollPosition("i1"));
 
@@ -221,6 +225,7 @@ describe("useScrollPosition", () => {
     });
     act(() => {
       result.current.restoreScrollPosition();
+      vi.advanceTimersByTime(500);
     });
 
     // Restore still happens: the innocuous keypress did not disable it.
@@ -229,7 +234,7 @@ describe("useScrollPosition", () => {
 
   it("(j) a scroll keydown (Space) DOES abort restore", () => {
     window.sessionStorage.setItem(`${KEY_PREFIX}j1`, "500");
-    setScrollHeight(2000); // tall enough to restore synchronously
+    setScrollHeight(2000); // tall enough (would settle and restore, absent the scroll key)
 
     const { result } = renderHook(() => useScrollPosition("j1"));
 
@@ -261,7 +266,7 @@ describe("useScrollPosition", () => {
     expect(window.scrollTo).not.toHaveBeenCalled();
   });
 
-  it("(d) scrolls to the saved Y once the content is tall enough", () => {
+  it("(d) scrolls to the saved Y once the height settles tall enough", () => {
     vi.useFakeTimers();
     window.sessionStorage.setItem(`${KEY_PREFIX}p4`, "500");
     setInnerHeight(800);
@@ -270,20 +275,53 @@ describe("useScrollPosition", () => {
     const { result } = renderHook(() => useScrollPosition("p4"));
     act(() => {
       result.current.restoreScrollPosition();
+      vi.advanceTimersByTime(300);
     });
 
-    // Still polling: content not laid out yet.
+    // Still waiting: content not laid out tall enough yet.
     expect(window.scrollTo).not.toHaveBeenCalled();
 
-    // Content becomes tall enough: maxScroll = 2000 - 800 = 1200 >= 500.
+    // Content becomes tall enough and then holds steady past the stable window:
+    // maxScroll = 2000 - 800 = 1200 >= 500.
     setScrollHeight(2000);
     act(() => {
-      vi.advanceTimersByTime(100);
+      vi.advanceTimersByTime(500);
     });
 
     expect(window.scrollTo).toHaveBeenCalledWith({ top: 500, behavior: "auto" });
   });
 
+  it("(d3) waits for the height to STOP changing before restoring", () => {
+    vi.useFakeTimers();
+    window.sessionStorage.setItem(`${KEY_PREFIX}p4b`, "500");
+    setInnerHeight(800);
+    setScrollHeight(2000); // reachable from the start (maxScroll 1200 >= 500)...
+
+    const { result } = renderHook(() => useScrollPosition("p4b"));
+    act(() => {
+      result.current.restoreScrollPosition();
+    });
+
+    // ...but the height keeps changing every tick, so it never settles.
+    act(() => {
+      vi.advanceTimersByTime(100);
+      setScrollHeight(2500);
+      vi.advanceTimersByTime(100);
+      setScrollHeight(3000);
+      vi.advanceTimersByTime(100);
+      setScrollHeight(3500);
+      vi.advanceTimersByTime(100);
+    });
+    expect(window.scrollTo).not.toHaveBeenCalled(); // reachable, but not settled
+
+    // Height now holds steady past HEIGHT_STABLE_MS -> restore fires (to the
+    // fixed target, unaffected by the taller document).
+    act(() => {
+      vi.advanceTimersByTime(500);
+    });
+    expect(window.scrollTo).toHaveBeenCalledWith({ top: 500, behavior: "auto" });
+  });
+
   it("(d2) clamps to the max reachable position after the timeout", () => {
     vi.useFakeTimers();
     window.sessionStorage.setItem(`${KEY_PREFIX}p5`, "5000");
@@ -303,53 +341,39 @@ describe("useScrollPosition", () => {
     expect(window.scrollTo).toHaveBeenCalledWith({ top: 200, behavior: "auto" });
   });
 
-  it("(k) shares ONE timeout budget across re-triggers (does not restart the clock)", () => {
+  it("(k) a re-trigger while the wait is running does not start a second concurrent poll", () => {
-    // The static->live editor swap re-invokes restore. The shared budget
+    // Both triggers (early on-mount + post-swap) call restore. The
-    // (restoreStartRef) must measure the MAX_RESTORE_WAIT_MS (5000) deadline
+    // `if (pollTimerRef.current !== null) return` guard makes a re-trigger during
-    // from the FIRST trigger, not restart it on every re-trigger. This pins
+    // an in-flight wait a no-op, so exactly ONE poll runs and scrolls exactly once.
-    // the `if (restoreStartRef.current === null)` guard: a mutant that resets
+    // A mutant dropping that guard would start a second parallel poll; since the
-    // `restoreStartRef.current = Date.now()` on every trigger would push the
+    // stubbed scrollTo never moves window.scrollY, the second poll would scroll
-    // deadline out to t=8000 (3000 + 5000) and fail the t=5000 assertion below.
+    // again (redundancy guard sees scrollY still 0 != target) -> two calls, and
+    // this assertion would fail.
     vi.useFakeTimers();
-    vi.setSystemTime(0);
+    window.sessionStorage.setItem(`${KEY_PREFIX}k1`, "500");
-    window.sessionStorage.setItem(`${KEY_PREFIX}k1`, "5000");
     setInnerHeight(800);
-    setScrollHeight(1000); // maxScroll = 200, never reaches 5000 -> it polls.
+    setScrollHeight(100); // too short -> the first wait keeps polling (no scroll yet)
 
     const { result } = renderHook(() => useScrollPosition("k1"));
 
-    // First trigger at t=0: starts the shared budget and begins polling.
+    // First trigger: starts the wait.
     act(() => {
       result.current.restoreScrollPosition();
     });
-    expect(window.scrollTo).not.toHaveBeenCalled();
+    // Second trigger while the first wait is still running: the guard suppresses it.
-
-    // Advance to t=3000 (still polling: content short, not yet timed out).
-    act(() => {
-      vi.advanceTimersByTime(3000);
-    });
-    expect(window.scrollTo).not.toHaveBeenCalled();
-
-    // Second trigger at t=3000 (the swap re-assert). Under the real code the
-    // budget is shared, so `start` stays 0; under the reset-mutant it becomes 3000.
     act(() => {
       result.current.restoreScrollPosition();
     });
 
-    // At t=4900 the FIRST budget has not yet elapsed (4900 - 0 < 5000): no clamp.
+    // Content becomes reachable and holds steady past the stable window.
+    setScrollHeight(2000);
     act(() => {
-      vi.advanceTimersByTime(1900);
+      vi.advanceTimersByTime(500);
     });
-    expect(window.scrollTo).not.toHaveBeenCalled();
 
-    // At t=5000 the shared budget (measured from t=0) times out and clamps to the
+    // Exactly one scroll — the guard prevented a second concurrent poll.
-    // furthest reachable position (maxScroll = 200). The reset-mutant, measuring
+    expect(window.scrollTo).toHaveBeenCalledTimes(1);
-    // from t=3000, would still be waiting (5000 - 3000 = 2000 < 5000) and would
+    expect(window.scrollTo).toHaveBeenCalledWith({ top: 500, behavior: "auto" });
-    // NOT have scrolled here -> this assertion fails against that mutant.
-    act(() => {
-      vi.advanceTimersByTime(100);
-    });
-    expect(window.scrollTo).toHaveBeenCalledWith({ top: 200, behavior: "auto" });
   });
 
   it("(e) never throws when storage access throws", () => {

apps/client/src/features/editor/hooks/use-scroll-position.ts

@@ -8,6 +8,11 @@ const SAVE_THROTTLE_MS = 250;
 const MAX_RESTORE_WAIT_MS = 5000;
 // How often to re-check the document height while waiting for content to load.
 const RESTORE_POLL_MS = 100;
+// The document height must stay unchanged this long before we treat the layout
+// as settled and safe to restore against — restoring while content is still
+// rendering in lets scroll-anchoring drift the saved offset (and re-fire, which
+// is the residual reload "jitter" this replaces).
+const HEIGHT_STABLE_MS = 400;
 
 // sessionStorage key prefix. sessionStorage survives an F5 in the same tab and
 // is cleared on tab close, which is exactly the lifetime we want for an MVP
@@ -73,10 +78,13 @@ export function hasSavedReadingPosition(pageId: string): boolean {
  * their place across a reload (F5) or reopening the document.
  *
  * Returns `restoreScrollPosition`, which the page editor calls from two triggers
- * (early, while the static/cached content is laid out, and again after the
+ * (early on mount + after the static->live editor swap). It WAITS for the
- * static->live editor swap); it is idempotent, so re-asserting the same target is
+ * document height to stop changing (the layout to settle) and then scrolls once
- * a no-op. The two scroll mechanisms are mutually exclusive: if the URL has a
+ * to the saved offset — so it never fires mid-render, where scroll-anchoring
- * `#hash` anchor, the existing anchor-scroll logic wins and restore is a no-op.
+ * would drift the position. It is idempotent: a running wait suppresses a second
+ * trigger, and once positioned re-asserting is a no-op. The two scroll mechanisms
+ * are mutually exclusive: if the URL has a `#hash` anchor, the existing
+ * anchor-scroll logic wins and restore is a no-op.
  */
 export function useScrollPosition(pageId: string): {
   restoreScrollPosition: () => void;
@@ -104,9 +112,6 @@ export function useScrollPosition(pageId: string): {
   // this, a fast SPA navigation away mid-poll would let the old page's poll fire
   // window.scrollTo against the NEW page's document (visible wrong-page scroll).
   const pollTimerRef = useRef<number | null>(null);
-  // Timestamp of the FIRST restore attempt so re-triggers (e.g. the static→live
-  // editor swap) share ONE bounded timeout budget instead of restarting it.
-  const restoreStartRef = useRef<number | null>(null);
 
   // Capture the previously-saved value synchronously during render, before the
   // effect below registers handlers that would persist the current (0) scrollY.
@@ -209,36 +214,43 @@ export function useScrollPosition(pageId: string): {
     // Nothing meaningful to restore to.
     if (targetY <= 0) return;
 
-    // Cancel any in-flight poll before (re)starting, so overlapping triggers can
+    // Idempotent: if a restore poll is already running, do not start a second.
-    // never run two concurrent polls against the same target.
+    // Both triggers (early + post-swap) share it; a running poll suppresses the
-    if (pollTimerRef.current !== null) {
+    // second, and once positioned the redundancy guard makes it a no-op.
-      window.clearTimeout(pollTimerRef.current);
+    if (pollTimerRef.current !== null) return;
-      pollTimerRef.current = null;
-    }
 
-    // Share one timeout budget across re-triggers instead of restarting it.
+    const start = Date.now();
-    if (restoreStartRef.current === null) {
+    let lastHeight = -1;
-      restoreStartRef.current = Date.now();
+    let stableSince = start;
-    }
-    const start = restoreStartRef.current;
 
-    const tryRestore = () => {
+    // Restore ONCE the document height has been stable for HEIGHT_STABLE_MS AND
-      // Bail mid-poll if the reader started scrolling while we were waiting.
+    // the target is reachable, so the saved pixel offset lands on the same content
+    // the reader left. Restoring earlier — while the doc is still rendering in
+    // (progressive content / static->live swap) — lets scroll-anchoring drift the
+    // position and makes the restore re-fire (the reload jitter). The timeout is
+    // the only fallback that clamps to the furthest reachable position.
+    const tick = () => {
+      // Bail mid-wait if the reader started scrolling.
       if (userInteractedRef.current) {
         pollTimerRef.current = null;
         return;
       }
 
-      const maxScroll =
+      const now = Date.now();
-        document.documentElement.scrollHeight - window.innerHeight;
+      const height = document.documentElement.scrollHeight;
-      const timedOut = Date.now() - start >= MAX_RESTORE_WAIT_MS;
+      if (height !== lastHeight) {
+        lastHeight = height;
+        stableSince = now;
+      }
+      const maxScroll = height - window.innerHeight;
+      const settled = now - stableSince >= HEIGHT_STABLE_MS;
+      const reachable = maxScroll >= targetY;
+      const timedOut = now - start >= MAX_RESTORE_WAIT_MS;
 
-      // Restore once the content is tall enough to reach the target, or bail out
+      if ((settled && reachable) || timedOut) {
-      // after the timeout and scroll as far as currently possible.
-      if (maxScroll >= targetY || timedOut) {
         const top = Math.min(targetY, Math.max(maxScroll, 0));
-        // Redundancy guard: re-asserting the SAME target when already positioned
+        // No-op when already there — avoids a redundant scroll and keeps the two
-        // is a no-op, so this hook can be called from multiple triggers safely.
+        // triggers from double-scrolling.
         if (Math.abs(window.scrollY - top) > 1) {
           window.scrollTo({ top, behavior: "auto" });
         }
@@ -247,10 +259,10 @@ export function useScrollPosition(pageId: string): {
       }
 
       // Stored in a ref so the effect cleanup can cancel it on unmount.
-      pollTimerRef.current = window.setTimeout(tryRestore, RESTORE_POLL_MS);
+      pollTimerRef.current = window.setTimeout(tick, RESTORE_POLL_MS);
     };
 
-    tryRestore();
+    tick();
   }, []);
 
   return { restoreScrollPosition };
@@ -261,8 +273,9 @@ export function useScrollPosition(pageId: string): {
  *
  * Extracted from PageEditor so the exact restore triggers (their deps and the
  * post-swap `&& editor` guard) are directly unit-testable rather than mirrored.
- * Behaviour is unchanged: `restoreScrollPosition` is idempotent, so re-asserting
+ * `restoreScrollPosition` waits for the layout to settle and is idempotent, so
- * the same target from either trigger is a no-op.
+ * both triggers together produce a single restore (a running wait suppresses the
+ * second; once positioned re-asserting is a no-op).
  *
  * @param pageId      the page whose scroll position is persisted/restored.
  * @param editor      the tiptap editor instance, or `null` until it is ready.
@@ -275,16 +288,18 @@ export function useScrollRestoreOnSwap(
 ): void {
   const { restoreScrollPosition } = useScrollPosition(pageId);
 
-  // Restore as early as the static (cached) content is laid out, before paint,
+  // Early trigger: start the restore wait on mount, so a reload that never
-  // so the reader's position is applied without a visible jump. Aborts itself if
+  // reaches the live editor (offline / collab never syncs — the static cache
-  // the reader has already started scrolling (handled inside the hook).
+  // stays shown) still restores once the static layout settles. The wait itself
+  // holds off scrolling until the height is stable, and aborts if the reader
+  // starts scrolling (handled inside the hook).
   useLayoutEffect(() => {
     restoreScrollPosition();
   }, [restoreScrollPosition]);
 
-  // Re-assert once after the static -> live editor swap in case the swap reset
+  // Post-swap trigger: after the static -> live swap, (re)start the wait so it
-  // the window scroll. Idempotent: a no-op when the position is already correct,
+  // measures the final live layout. Idempotent: a no-op while the early wait is
-  // and a no-op after the reader has interacted.
+  // still running, and a no-op once already positioned or the reader interacted.
   useLayoutEffect(() => {
     if (!showStatic && editor) restoreScrollPosition();
   }, [showStatic, editor, restoreScrollPosition]);

apps/client/src/features/editor/hooks/use-swap-height-reservation.test.ts

@@ -1,164 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { renderHook, act } from "@testing-library/react";
-import type { RefObject } from "react";
-import { useSwapHeightReservation } from "./use-swap-height-reservation";
-
-// Controllable fake requestAnimationFrame. jsdom's rAF is timer-driven and hard
-// to step deterministically, so we install a manual queue: `tickRaf()` drains the
-// callbacks scheduled so far (a callback that reschedules enqueues a new one for
-// the NEXT tick), letting each test advance the release loop frame by frame.
-let rafQueue: Array<{ id: number; cb: FrameRequestCallback }> = [];
-let nextRafId = 1;
-let realRaf: typeof globalThis.requestAnimationFrame;
-let realCancel: typeof globalThis.cancelAnimationFrame;
-
-function tickRaf(): void {
-  const current = rafQueue;
-  rafQueue = [];
-  for (const { cb } of current) cb(0);
-}
-
-// A mutable stand-in for the live-content container. The hook only reads
-// `scrollHeight`, so tests drive the release condition by mutating this.
-function makeMenuRef(): {
-  ref: RefObject<HTMLElement | null>;
-  setScrollHeight: (h: number) => void;
-} {
-  const el = { scrollHeight: 0 };
-  return {
-    ref: { current: el } as unknown as RefObject<HTMLElement | null>,
-    setScrollHeight: (h: number) => {
-      el.scrollHeight = h;
-    },
-  };
-}
-
-const H = 1000;
-
-describe("useSwapHeightReservation", () => {
-  beforeEach(() => {
-    rafQueue = [];
-    nextRafId = 1;
-    realRaf = globalThis.requestAnimationFrame;
-    realCancel = globalThis.cancelAnimationFrame;
-    globalThis.requestAnimationFrame = ((cb: FrameRequestCallback) => {
-      const id = nextRafId++;
-      rafQueue.push({ id, cb });
-      return id;
-    }) as typeof globalThis.requestAnimationFrame;
-    globalThis.cancelAnimationFrame = ((id: number) => {
-      rafQueue = rafQueue.filter((e) => e.id !== id);
-    }) as typeof globalThis.cancelAnimationFrame;
-  });
-
-  afterEach(() => {
-    globalThis.requestAnimationFrame = realRaf;
-    globalThis.cancelAnimationFrame = realCancel;
-    vi.useRealTimers();
-    vi.restoreAllMocks();
-  });
-
-  // (a) reserve-on-swap: the captured height becomes `reservedHeight`, the value
-  // that drives the swap wrapper's minHeight. Captured while static is still up,
-  // then the swap flips showStatic; before any release frame runs the reservation
-  // is held at exactly H.
-  it("(a) holds the captured height as reservedHeight after the swap (drives minHeight)", () => {
-    const { ref, setScrollHeight } = makeMenuRef();
-    setScrollHeight(0); // live content not laid out yet -> release cannot fire.
-    const { result, rerender } = renderHook(
-      ({ showStatic }) => useSwapHeightReservation(showStatic, ref),
-      { initialProps: { showStatic: true } },
-    );
-
-    // Capture happens synchronously at the swap point (static still shown).
-    act(() => {
-      result.current.captureReservation(H);
-    });
-    // The swap flips to the live branch.
-    rerender({ showStatic: false });
-
-    expect(result.current.reservedHeight).toBe(H);
-  });
-
-  // (b) release when the live content is tall enough. Guard is `>=`: with
-  // liveHeight === H the reservation releases. This FAILS if the guard direction
-  // were `<` (liveHeight === H is not `< H`, so it would never release).
-  it("(b) releases once live content reaches the reserved height", () => {
-    const { ref, setScrollHeight } = makeMenuRef();
-    setScrollHeight(0);
-    const { result, rerender } = renderHook(
-      ({ showStatic }) => useSwapHeightReservation(showStatic, ref),
-      { initialProps: { showStatic: true } },
-    );
-
-    act(() => {
-      result.current.captureReservation(H);
-    });
-    rerender({ showStatic: false });
-    expect(result.current.reservedHeight).toBe(H); // still reserved (short live doc)
-
-    // Live editor finishes laying out to the reserved height.
-    setScrollHeight(H);
-    act(() => {
-      tickRaf();
-    });
-
-    expect(result.current.reservedHeight).toBeNull();
-  });
-
-  // (c) cap escape: the live content never reaches the reserved height, so the
-  // height match never fires; the reservation must still release at the 4000ms
-  // cap (no stuck reservation / dead space). This FAILS if there were no cap: the
-  // loop would poll forever while scrollHeight stays below H.
-  it("(c) releases at the 4000ms cap when live content stays too short", () => {
-    // Only fake Date so `Date.now()` (the cap clock) is controllable; leave our
-    // manual rAF queue in place (default fake timers would replace it).
-    vi.useFakeTimers({ toFake: ["Date"] });
-    vi.setSystemTime(0);
-    const { ref, setScrollHeight } = makeMenuRef();
-    setScrollHeight(H - 100); // always shorter than reserved -> height match never fires.
-    const { result, rerender } = renderHook(
-      ({ showStatic }) => useSwapHeightReservation(showStatic, ref),
-      { initialProps: { showStatic: true } },
-    );
-
-    act(() => {
-      result.current.captureReservation(H);
-    });
-    rerender({ showStatic: false });
-
-    // A few frames pass but time has not reached the cap: still reserved.
-    act(() => {
-      tickRaf();
-    });
-    act(() => {
-      tickRaf();
-    });
-    expect(result.current.reservedHeight).toBe(H);
-
-    // Advance past the cap; the next frame releases even though the live content
-    // is still shorter than the reservation.
-    vi.setSystemTime(4001);
-    act(() => {
-      tickRaf();
-    });
-
-    expect(result.current.reservedHeight).toBeNull();
-  });
-
-  // (d) non-swap: without a capture (and while static is shown) there is no
-  // reservation and the release loop never arms, so no rAF is scheduled.
-  it("(d) reserves nothing and arms no loop when the swap never happens", () => {
-    const { ref } = makeMenuRef();
-    const { result } = renderHook(() =>
-      useSwapHeightReservation(true, ref),
-    );
-
-    expect(result.current.reservedHeight).toBeNull();
-    expect(rafQueue.length).toBe(0); // release loop never armed
-    act(() => {
-      tickRaf();
-    });
-    expect(result.current.reservedHeight).toBeNull();
-  });
-});

apps/client/src/features/editor/hooks/use-swap-height-reservation.ts

@@ -1,79 +0,0 @@
-import { RefObject, useCallback, useEffect, useState } from "react";
-
-// Last-resort release deadline. The primary release is the live-content height
-// match below; this cap only exists so a slow/short live doc can never pin the
-// reservation forever. It is generous (well past when the live content normally
-// reaches the reserved height — it renders the SAME content as the static copy)
-// so a slow load doesn't release mid-render and reintroduce the collapse.
-const RELEASE_CAP_MS = 4000;
-
-/**
- * Reserves the document height across the static -> live editor swap.
- *
- * The live editor lays out its content over a few frames, so replacing the
- * (full-height) static copy with it momentarily shrinks the document; the
- * browser then clamps window scroll to the top, which yanked the reader off
- * their restored reading position (and threw their scroll to 0 if they were
- * scrolling at that moment). Pinning a min-height on the swap wrapper keeps the
- * document tall through the swap so the scroll position simply survives (#266).
- * `reservedHeight === null` means no reservation is active.
- *
- * The capture is intentionally a CALLBACK the page editor invokes, NOT something
- * this hook derives by watching `showStatic`. The height MUST be read
- * synchronously while the static content is still mounted (full natural height),
- * right before the flip to the live branch. By the time any post-transition
- * effect here could run, `showStatic` is already false and the wrapper shows the
- * live/collapsed content, so `offsetHeight` would be wrong. So page-editor calls
- * `captureReservation(wrapper.offsetHeight)` inside its collab-sync effect,
- * before `setShowStatic(false)`, preserving that exact timing.
- *
- * @param showStatic       whether the static (cached) content is still shown.
- * @param menuContainerRef the live-branch content container. It is a descendant
- *   of the swap wrapper inside the live branch, so its `scrollHeight` is the live
- *   content height (not inflated by the ancestor min-height reservation).
- */
-export function useSwapHeightReservation(
-  showStatic: boolean,
-  menuContainerRef: RefObject<HTMLElement | null>,
-): {
-  reservedHeight: number | null;
-  captureReservation: (height: number | null) => void;
-} {
-  const [reservedHeight, setReservedHeight] = useState<number | null>(null);
-
-  // Capture the current (static, full-height) content height BEFORE the swap so
-  // the wrapper can reserve it while the live editor lays out — otherwise the
-  // transient shrink clamps window scroll to the top. The caller reads
-  // `offsetHeight` synchronously at the swap point and hands it here.
-  const captureReservation = useCallback(
-    (height: number | null) => setReservedHeight(height),
-    [],
-  );
-
-  // Release the reserved height once the live editor's content has laid out to
-  // at least the reserved height (so removing the reservation cannot collapse
-  // the document). The primary release is that height match; the cap is only a
-  // last-resort so we never pin forever. A shorter-than-reserved live doc (rare:
-  // stale/longer cache) releases at the cap, leaving only harmless bottom dead
-  // space until then.
-  useEffect(() => {
-    if (showStatic || reservedHeight == null) return;
-    let raf = 0;
-    const startedAt = Date.now();
-    const check = () => {
-      const liveHeight = menuContainerRef.current?.scrollHeight ?? 0;
-      if (
-        liveHeight >= reservedHeight ||
-        Date.now() - startedAt > RELEASE_CAP_MS
-      ) {
-        setReservedHeight(null);
-        return;
-      }
-      raf = requestAnimationFrame(check);
-    };
-    raf = requestAnimationFrame(check);
-    return () => cancelAnimationFrame(raf);
-  }, [showStatic, reservedHeight, menuContainerRef]);
-
-  return { reservedHeight, captureReservation };
-}

apps/client/src/features/editor/page-editor.test.tsx

@@ -28,9 +28,11 @@ const KEY_PREFIX = "gitmost:scroll-position:";
 // guard the production code directly (verified: removing `&& editor` reddens the
 // first test).
 //
-// Both tests observe the real effect via `window.scrollTo`. The stubbed
+// Both tests observe the real effect via `window.scrollTo`. Restore is NOT
-// `window.scrollTo` never mutates `window.scrollY`, and the target is left
+// synchronous: it waits for the document height to settle (HEIGHT_STABLE_MS)
-// unreached, so every restore invocation that passes the guard yields exactly one
+// before scrolling, so the tests use fake timers and advance them with a steady,
+// reachable height to let the wait fire. The stubbed `window.scrollTo` never
+// mutates `window.scrollY`, so every restore that settles yields exactly one
 // `scrollTo` call — making the call count a faithful proxy for restore invocations.
 
 function setScrollY(value: number): void {
@@ -80,61 +82,69 @@ describe("PageEditor scroll-restore wiring (useScrollRestoreOnSwap)", () => {
     window.location.hash = "";
   });
 
-  it("re-invokes restore after the swap, with the [showStatic, editor] deps/guard", () => {
+  it("early trigger restores once the layout settles; post-swap re-assert gated by && editor", () => {
-    // Target is immediately reachable, so each restore that passes the guard
+    // Restore WAITS for the document height to settle (HEIGHT_STABLE_MS), so tests
-    // scrolls synchronously. `window.scrollY` stays 0 (stubbed scrollTo never
+    // advance fake timers. `window.scrollY` stays 0 (stubbed scrollTo never updates
-    // updates it), so scrollTo is called once per effective restore — a proxy for
+    // it), so scrollTo's call count proxies the number of effective restores.
-    // the restore invocation count.
+    vi.useFakeTimers();
     window.sessionStorage.setItem(`${KEY_PREFIX}guard`, "500");
     setInnerHeight(800);
-    setScrollHeight(2000); // maxScroll = 1200 >= 500: reachable, no polling.
+    setScrollHeight(2000); // reachable + held steady -> the wait settles
 
-    // Pre-swap: static content shown, live editor not ready. Only the early
+    // Pre-swap: the early on-mount trigger's wait settles and restores once — this
-    // pre-paint restore fires; the post-swap effect's guard (!showStatic) blocks it.
+    // is the offline / collab-never-syncs path (no swap needed).
     const { rerender } = render(
       <Host pageId="guard" showStatic={true} editor={null} />,
     );
+    act(() => {
+      vi.advanceTimersByTime(500);
+    });
     expect(window.scrollTo).toHaveBeenCalledTimes(1);
 
-    // Collab reports synced (showStatic flips false) but the editor is not ready
+    // showStatic flips false but the editor is still null: the post-swap effect
-    // yet: the swap effect re-runs (deps [showStatic, editor] changed) but the
+    // re-runs (deps [showStatic, editor] changed) but its `&& editor` guard must
-    // `&& editor` guard must keep it a no-op. The early effect does NOT re-fire
+    // keep it a no-op. (Dropping `&& editor` would start a fresh wait against a
-    // (its dep [restoreScrollPosition] is a stable useCallback([])).
+    // null editor and produce a 2nd scrollTo, failing this expectation.)
-    // (Pins the guard: dropping `&& editor` would restore against a null editor,
-    // producing a 2nd scrollTo and failing this expectation.)
     rerender(<Host pageId="guard" showStatic={false} editor={null} />);
+    act(() => {
+      vi.advanceTimersByTime(500);
+    });
     expect(window.scrollTo).toHaveBeenCalledTimes(1);
 
     // The static -> live swap completes (showStatic false AND editor present): the
-    // post-swap effect re-asserts the restore exactly once more, driven solely by
+    // post-swap effect re-invokes restore, whose fresh wait settles and re-asserts.
-    // the [showStatic, editor] deps changing.
     rerender(<Host pageId="guard" showStatic={false} editor={fakeEditor} />);
+    act(() => {
+      vi.advanceTimersByTime(500);
+    });
     expect(window.scrollTo).toHaveBeenCalledTimes(2);
   });
 
-  it("the post-swap re-assert drives a REAL restore (window.scrollTo) via the hook", () => {
+  it("restore waits for the height to settle before scrolling (end-to-end via the hook)", () => {
-    // End-to-end through the real useScrollPosition (inside the hook): the swap
-    // re-invocation is the CAUSE of the scroll (nothing scrolls before it).
     vi.useFakeTimers();
     window.sessionStorage.setItem(`${KEY_PREFIX}peg`, "500");
     setInnerHeight(800);
-    setScrollHeight(100); // maxScroll = -700: target not reachable yet -> polls.
+    setScrollHeight(100); // maxScroll = -700: target not reachable yet.
 
-    // Pre-swap: the early restore runs but content is too short, so it starts
+    // Mount + swap while the content is still too short: nothing scrolls, even as
-    // polling (a pending timer) without scrolling. We never advance timers, so the
+    // time passes — restore never fires against an unsettled/unreachable layout.
-    // early poll cannot fire on its own — isolating the swap as the sole cause.
     const { rerender } = render(
       <Host pageId="peg" showStatic={true} editor={null} />,
     );
-    expect(window.scrollTo).not.toHaveBeenCalled();
+    act(() => {
-
+      vi.advanceTimersByTime(500);
-    // The live content is now laid out tall enough to reach the target.
+    });
-    setScrollHeight(2000); // maxScroll = 1200 >= 500
-
-    // The static -> live swap: the post-swap useLayoutEffect re-invokes the real
-    // hook, whose synchronous tryRestore now reaches the target and scrolls.
     act(() => {
       rerender(<Host pageId="peg" showStatic={false} editor={fakeEditor} />);
+      vi.advanceTimersByTime(500);
+    });
+    expect(window.scrollTo).not.toHaveBeenCalled();
+
+    // The live content finally lays out tall enough and holds steady past the
+    // stable window -> restore fires exactly to the saved target.
+    setScrollHeight(2000);
+    act(() => {
+      vi.advanceTimersByTime(500);
     });
     expect(window.scrollTo).toHaveBeenCalledWith({ top: 500, behavior: "auto" });
   });

apps/client/src/features/editor/page-editor.tsx

@@ -27,12 +27,11 @@ import {
   collabExtensions,
   mainExtensions,
 } from "@/features/editor/extensions/extensions";
-import { useAtom, useAtomValue, useSetAtom } from "jotai";
+import { useAtom, useAtomValue } from "jotai";
 import useCollaborationUrl from "@/features/editor/hooks/use-collaboration-url";
 import { currentUserAtom } from "@/features/user/atoms/current-user-atom";
 import {
   currentPageEditModeAtom,
-  dictationAvailabilityAtom,
   pageEditorAtom,
   yjsConnectionStatusAtom,
 } from "@/features/editor/atoms/editor-atoms";
@@ -80,7 +79,6 @@ import { jwtDecode } from "jwt-decode";
 import { searchSpotlight } from "@/features/search/constants.ts";
 import { useEditorScroll } from "./hooks/use-editor-scroll";
 import { useScrollRestoreOnSwap } from "./hooks/use-scroll-position";
-import { useSwapHeightReservation } from "./hooks/use-swap-height-reservation";
 import { EditorLinkMenu } from "@/features/editor/components/link/link-menu";
 import ColumnsMenu from "@/features/editor/components/columns/columns-menu.tsx";
 import { TransclusionLookupProvider } from "@/features/editor/components/transclusion/transclusion-lookup-context";
@@ -89,15 +87,9 @@ import { PageEmbedAncestryProvider } from "@/features/editor/components/page-emb
 import PageEmbedPicker from "@/features/editor/components/page-embed/page-embed-picker";
 import { useTranslation } from "react-i18next";
 import {
-  computeDictationAvailability,
   isBodyEditable,
   isCollabSynced,
 } from "@/features/editor/editor-sync-state";
-import {
-  isVitalsActive,
-  measurePageOpen,
-  reportEditorTx,
-} from "@/lib/telemetry/vitals";
 
 interface PageEditorProps {
   pageId: string;
@@ -146,7 +138,6 @@ export default function PageEditor({
   const { pageSlug } = useParams();
   const slugId = extractPageSlugId(pageSlug);
   const currentPageEditMode = useAtomValue(currentPageEditModeAtom);
-  const setDictationAvailability = useSetAtom(dictationAvailabilityAtom);
   const canScroll = useCallback(
     () => Boolean(isComponentMounted.current && editorRef.current),
     [isComponentMounted],
@@ -356,40 +347,6 @@ export default function PageEditor({
           editor.storage.pageId = pageId;
           handleScrollTo(editor);
           editorRef.current = editor;
-
-          // #355 — perf instrumentation. Skip ALL of it when telemetry is
-          // disabled (F1 flag off) or this session isn't sampled: no page-open
-          // measure, and crucially NO dispatch wrapping, so a non-collecting
-          // session pays zero per-transaction cost.
-          if (isVitalsActive()) {
-            // page_open_ms: this is the first editor-content render, so measure
-            // against any page-open mark set on the tree-row/link click.
-            measurePageOpen();
-
-            // editor_tx_ms: time the SYNCHRONOUS part of applying each
-            // transaction (state.apply + updateState) by wrapping the view's
-            // dispatch. Only slow syncs (>8ms) are reported (see reportEditorTx),
-            // so the common path adds just one performance.now() pair. Passive:
-            // the original dispatch still runs unchanged.
-            try {
-              const view = editor.view as unknown as {
-                dispatch: (tr: unknown) => void;
-              };
-              const originalDispatch = view.dispatch.bind(view);
-              view.dispatch = (tr: unknown) => {
-                const started = performance.now();
-                originalDispatch(tr);
-                const elapsed = performance.now() - started;
-                try {
-                  reportEditorTx(elapsed, editor.state.doc.content.size);
-                } catch {
-                  // never let telemetry break editing
-                }
-              };
-            } catch {
-              // if the view shape changes, skip editor_tx instrumentation
-            }
-          }
         }
       },
       onUpdate({ editor }) {
@@ -492,22 +449,6 @@ export default function PageEditor({
   const hasConnectedOnceRef = useRef(false);
   const [showStatic, setShowStatic] = useState(true);
 
-  // Reserved height held across the static -> live editor swap. The live editor
-  // lays out its content over a few frames, so replacing the (full-height) static
-  // copy with it momentarily shrinks the document; the browser then clamps window
-  // scroll to the top, which yanked the reader off their restored reading position
-  // (and threw their scroll to 0 if they were scrolling at that moment). Pinning a
-  // min-height on the swap wrapper keeps the document tall through the swap so the
-  // scroll position simply survives. `null` = no reservation active.
-  const swapWrapperRef = useRef<HTMLDivElement | null>(null);
-  // Reserve/release wiring lives in the hook so its capture trigger and release
-  // guard/cap are directly unit-testable. Capture stays synchronous at the swap
-  // point (see the collab-sync effect below); the hook only owns the release.
-  const { reservedHeight, captureReservation } = useSwapHeightReservation(
-    showStatic,
-    menuContainerRef,
-  );
-
   useEffect(() => {
     const timeout = setTimeout(() => {
       if (yjsConnectionStatus === WebSocketStatus.Connecting || !isSynced) {
@@ -530,36 +471,12 @@ export default function PageEditor({
     );
   }, [currentPageEditMode, editor, editable, showStatic]);
 
-  // Publish whether dictation can start and, if not, the cause-specific reason
-  // the mic button surfaces. Recomputed on the same signals that drive body
-  // editability so the tooltip never lies about the current state.
-  useEffect(() => {
-    setDictationAvailability(
-      computeDictationAvailability({
-        editable,
-        inEditMode: currentPageEditMode === PageEditMode.Edit,
-        showStatic,
-        isDisconnected: yjsConnectionStatus === WebSocketStatus.Disconnected,
-      }),
-    );
-  }, [
-    editable,
-    currentPageEditMode,
-    showStatic,
-    yjsConnectionStatus,
-    setDictationAvailability,
-  ]);
-
   useEffect(() => {
     if (
       !hasConnectedOnceRef.current &&
       isCollabSynced(yjsConnectionStatus, isSynced)
     ) {
       hasConnectedOnceRef.current = true;
-      // Capture the current (static, full-height) content height BEFORE the swap
-      // so the wrapper can reserve it while the live editor lays out — otherwise
-      // the transient shrink clamps window scroll to the top.
-      captureReservation(swapWrapperRef.current?.offsetHeight ?? null);
       setShowStatic(false);
     }
   }, [yjsConnectionStatus, isSynced]);
@@ -573,12 +490,6 @@ export default function PageEditor({
     <TransclusionLookupProvider>
       <PageEmbedLookupProvider>
         <PageEmbedAncestryProvider hostPageId={pageId}>
-      <div
-        ref={swapWrapperRef}
-        style={
-          reservedHeight != null ? { minHeight: reservedHeight } : undefined
-        }
-      >
       {showStatic ? (
         <div style={{ position: "relative" }}>
           {/* Surface the pre-sync read-only window so edits typed before the
@@ -666,7 +577,6 @@ export default function PageEditor({
           ></div>
         </div>
       )}
-      </div>
         </PageEmbedAncestryProvider>
       </PageEmbedLookupProvider>
     </TransclusionLookupProvider>

apps/client/src/features/page/components/temporary-note-banner.tsx

@@ -1,11 +1,4 @@
-import {
+import { Button, Group, Paper, Text } from "@mantine/core";
-  ActionIcon,
-  Button,
-  Group,
-  Paper,
-  Text,
-  Tooltip,
-} from "@mantine/core";
 import { IconClockHour4, IconTrash } from "@tabler/icons-react";
 import { useState } from "react";
 import { Trans, useTranslation } from "react-i18next";
@@ -77,14 +70,7 @@ export function TemporaryNoteBanner({ slugId }: TemporaryNoteBannerProps) {
   return (
     <Paper radius="sm" mb="md" px="md" py="xs" bg="orange.0">
       <Group justify="space-between" wrap="wrap" gap="sm">
-        {/* A non-zero flex-basis lets the outer wrap="wrap" drop the buttons to
+        <Group gap="xs" wrap="nowrap" style={{ flex: 1, minWidth: 0 }}>
-            their own row on narrow screens; flex:1 (basis 0) never wraps and
-            instead crushes the text into a one-word-per-line ladder. */}
-        <Group
-          gap="xs"
-          wrap="nowrap"
-          style={{ flex: "1 1 16rem", minWidth: 0 }}
-        >
           <IconClockHour4
             size={18}
             stroke={1.5}
@@ -101,9 +87,7 @@ export function TemporaryNoteBanner({ slugId }: TemporaryNoteBannerProps) {
           </Text>
         </Group>
         {canEdit && (
-          <>
+          <Group gap="xs" wrap="nowrap">
-            {/* Desktop: full labeled buttons. */}
-            <Group gap="xs" wrap="nowrap" visibleFrom="sm">
             <Button
               size="xs"
               variant="subtle"
@@ -125,34 +109,6 @@ export function TemporaryNoteBanner({ slugId }: TemporaryNoteBannerProps) {
               {t("Make permanent")}
             </Button>
           </Group>
-            {/* Mobile: icon-only actions so they never overflow the narrow row. */}
-            <Group gap="xs" wrap="nowrap" hiddenFrom="sm">
-              <Tooltip label={t("Move to trash")} withArrow>
-                <ActionIcon
-                  size="lg"
-                  variant="subtle"
-                  color="red"
-                  onClick={handleTrashNow}
-                  loading={isDeleting}
-                  aria-label={t("Move to trash")}
-                >
-                  <IconTrash size={18} />
-                </ActionIcon>
-              </Tooltip>
-              <Tooltip label={t("Make permanent")} withArrow>
-                <ActionIcon
-                  size="lg"
-                  variant="light"
-                  color="orange"
-                  onClick={handleMakePermanent}
-                  loading={toggleTemporary.isPending}
-                  aria-label={t("Make permanent")}
-                >
-                  <IconClockHour4 size={18} />
-                </ActionIcon>
-              </Tooltip>
-            </Group>
-          </>
         )}
       </Group>
     </Paper>

apps/client/src/features/page/tree/hooks/use-tree-mutation.ts

@@ -1,5 +1,5 @@
 import { useCallback } from "react";
-import { useAtom, useSetAtom, useStore } from "jotai";
+import { useAtom, useStore } from "jotai";
 import { notifications } from "@mantine/notifications";
 import { useTranslation } from "react-i18next";
 import { useNavigate, useParams } from "react-router-dom";
@@ -20,7 +20,6 @@ import {
 } from "@/features/page/queries/page-query.ts";
 import { buildPageUrl } from "@/features/page/page.utils.ts";
 import { getSpaceUrl } from "@/lib/config.ts";
-import { mobileSidebarAtom } from "@/components/layouts/global/hooks/atoms/sidebar-atom.ts";
 
 export type UseTreeMutation = {
   handleMove: (sourceId: string, op: DropOp) => Promise<void>;
@@ -44,7 +43,6 @@ export function useTreeMutation(spaceId: string): UseTreeMutation {
   const removePageMutation = useRemovePageMutation();
   const movePageMutation = useMovePageMutation();
   const navigate = useNavigate();
-  const setMobileSidebar = useSetAtom(mobileSidebarAtom);
   const { spaceSlug, pageSlug } = useParams();
 
   const handleMove = useCallback(
@@ -203,23 +201,8 @@ export function useTreeMutation(spaceId: string): UseTreeMutation {
         createdPage.title,
       );
       navigate(pageUrl);
-      // On mobile the create action is triggered from inside the off-canvas
-      // sidebar drawer (space sidebar "+", tree-row "add subpage"). Navigating
-      // alone leaves that drawer open on top of the freshly created page, so the
-      // editor stays hidden behind the tree. Close it here so the new page opens
-      // in the editor — mirrors the row-click drawer-close in space-tree-row.
-      // No-op on desktop, where the mobile drawer atom is already false.
-      setMobileSidebar(false);
     },
-    [
+    [spaceId, createPageMutation, setData, store, navigate, spaceSlug],
-      spaceId,
-      createPageMutation,
-      setData,
-      store,
-      navigate,
-      spaceSlug,
-      setMobileSidebar,
-    ],
   );
 
   const handleRename = useCallback(

apps/client/src/features/workspace/components/settings/components/ai-provider-settings.tsx

@@ -394,10 +394,6 @@ export default function AiProviderSettings() {
     useState<boolean>(
       workspace?.settings?.ai?.publicShareAssistant ?? false,
     );
-  // #184: detached/autonomous agent runs (settings.ai.autonomousRuns).
-  const [autonomousRunsEnabled, setAutonomousRunsEnabled] = useState<boolean>(
-    workspace?.settings?.ai?.autonomousRuns ?? false,
-  );
   const [chatToggleLoading, setChatToggleLoading] = useState(false);
   const [searchToggleLoading, setSearchToggleLoading] = useState(false);
   const [dictationToggleLoading, setDictationToggleLoading] = useState(false);
@@ -407,8 +403,6 @@ export default function AiProviderSettings() {
     publicShareAssistantToggleLoading,
     setPublicShareAssistantToggleLoading,
   ] = useState(false);
-  const [autonomousRunsToggleLoading, setAutonomousRunsToggleLoading] =
-    useState(false);
 
   // Whether a key is currently stored server-side (drives the placeholder).
   const [hasApiKey, setHasApiKey] = useState(false);
@@ -736,37 +730,6 @@ export default function AiProviderSettings() {
     }
   }
 
-  // Optimistic toggle for detached/autonomous agent runs
-  // (settings.ai.autonomousRuns). When on, a chat turn becomes a server-side run
-  // that survives a browser disconnect and can be reconnected to / live-followed;
-  // only an explicit Stop ends it. Off by default; single-instance-only in phase 1.
-  async function handleToggleAutonomousRuns(value: boolean) {
-    setAutonomousRunsToggleLoading(true);
-    const previous = autonomousRunsEnabled;
-    setAutonomousRunsEnabled(value);
-    try {
-      const updated = await updateWorkspace({ autonomousRuns: value });
-      setWorkspace({
-        ...updated,
-        settings: {
-          ...updated.settings,
-          ai: { ...updated.settings?.ai, autonomousRuns: value },
-        },
-      });
-      notifications.show({ message: t("Updated successfully") });
-    } catch (err) {
-      setAutonomousRunsEnabled(previous);
-      const message = (err as { response?: { data?: { message?: string } } })
-        ?.response?.data?.message;
-      notifications.show({
-        message: message ?? t("Failed to update data"),
-        color: "red",
-      });
-    } finally {
-      setAutonomousRunsToggleLoading(false);
-    }
-  }
-
   // Admins only — match the previous behavior.
   if (!isAdmin) {
     return (
@@ -997,31 +960,6 @@ export default function AiProviderSettings() {
           {...form.getInputProps("publicShareAssistantRoleId")}
         />
 
-        {/* Detached/autonomous agent runs: a chat turn becomes a server-side run
-            that survives a browser disconnect; only an explicit Stop ends it.
-            Single-instance-only in phase 1. */}
-        <Group justify="space-between" align="center" wrap="nowrap" mt="md">
-          <Stack gap={0}>
-            <Text fw={600} size="sm">
-              {t("Autonomous agent runs")}
-            </Text>
-            <Text size="xs" c="dimmed">
-              {t(
-                "Keep an agent turn running server-side even if the browser disconnects; reconnect and follow it on reopen. Single-instance deployments only.",
-              )}
-            </Text>
-          </Stack>
-          <Switch
-            label={t("Enabled")}
-            labelPosition="left"
-            checked={autonomousRunsEnabled}
-            disabled={autonomousRunsToggleLoading}
-            onChange={(e) =>
-              handleToggleAutonomousRuns(e.currentTarget.checked)
-            }
-          />
-        </Group>
-
         <Group mt="md" align="center">
           <Button
             variant="default"

apps/client/src/features/workspace/types/workspace.types.ts

@@ -26,9 +26,6 @@ export interface IWorkspace {
   aiDictation?: boolean;
   aiDictationStreaming?: boolean;
   aiPublicShareAssistant?: boolean;
-  // Write-only field for updateWorkspace({ autonomousRuns }). Read state lives at
-  // settings.ai.autonomousRuns.
-  autonomousRuns?: boolean;
   trashRetentionDays?: number;
   // Default lifetime (HOURS) for new temporary notes; frozen per-note at creation.
   temporaryNoteHours?: number;
@@ -68,9 +65,6 @@ export interface IWorkspaceAiSettings {
   dictation?: boolean;
   dictationStreaming?: boolean;
   publicShareAssistant?: boolean;
-  // #184: detached agent runs (a run survives a browser disconnect and can be
-  // reconnected to / live-followed on reopen). Gates the run-reconnect polling.
-  autonomousRuns?: boolean;
 }
 
 export interface IWorkspaceSharingSettings {

apps/client/src/lib/avatar-palette.test.ts

@@ -1,107 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  PALETTE,
-  avatarStyle,
-  avatarBackgroundCss,
-  normalizeName,
-  minPairwiseDistance,
-  relativeLuminance,
-  contrastRatio,
-  oklchToSrgb,
-  isInGamut,
-} from "./avatar-palette";
-
-/** Parse "#rrggbb" into sRGB components on the 0..1 scale relativeLuminance expects. */
-function hexToRgb01(hex: string): [number, number, number] {
-  return [
-    parseInt(hex.slice(1, 3), 16) / 255,
-    parseInt(hex.slice(3, 5), 16) / 255,
-    parseInt(hex.slice(5, 7), 16) / 255,
-  ];
-}
-
-describe("avatar-palette validation", () => {
-  it("palette colors stay distinguishable", () => {
-    // 0.06 in OKLab is ~4-5 JNDs — safely distinct at avatar size. If a future
-    // RINGS tweak drops this, "almost identical" colors would reappear.
-    expect(minPairwiseDistance().distance).toBeGreaterThanOrEqual(0.06);
-    expect(PALETTE.length).toBe(20);
-  });
-
-  it("every palette entry is WCAG-readable and in sRGB gamut", () => {
-    // white text = luminance 1, black text = luminance 0 (per buildPalette).
-    const textLum = { white: 1, black: 0 } as const;
-    for (const entry of PALETTE) {
-      expect(entry.hex).toMatch(/^#[0-9a-f]{6}$/);
-
-      // (a) The chosen text color really clears the code's 3:1 threshold on the
-      // actual background hex — recomputed independently from the hex, not from
-      // the build-time luminance. A slot that picked the wrong text (or a color
-      // too dim for either text) would fail here.
-      const hexLum = relativeLuminance(hexToRgb01(entry.hex));
-      const chosen = contrastRatio(textLum[entry.text], hexLum);
-      expect(chosen).toBeGreaterThanOrEqual(3);
-      // buildPalette prefers white and only falls back to black when white
-      // fails 3:1. Mirror that decision: black is used *only* when white would
-      // not clear the threshold — so a mis-assigned "black" on a dark color
-      // (where white was fine) fails here.
-      if (entry.text === "black") {
-        expect(contrastRatio(textLum.white, hexLum)).toBeLessThan(3);
-      }
-
-      // (b) The entry's OKLCH is inside the sRGB gamut after chroma clamping;
-      // an out-of-gamut slot (e.g. un-clamped chroma) would produce components
-      // outside [0,1] and fail here.
-      expect(isInGamut(oklchToSrgb(entry.L, entry.C, entry.h))).toBe(true);
-    }
-  });
-});
-
-describe("avatarStyle", () => {
-  it("name-to-avatar mapping is frozen (golden values)", () => {
-    // Golden slice: if this breaks, all existing avatars change — make sure
-    // that is intentional (a config change in avatar-palette.ts).
-    const s = avatarStyle("Backend Developer");
-    expect([s.bg, s.bg2, s.angleDeg]).toEqual(["#a55795", "#90355e", 150]);
-    expect(s.text).toBe("white");
-  });
-
-  it("is deterministic and normalizes the name", () => {
-    expect(avatarStyle("Researcher")).toEqual(avatarStyle("Researcher"));
-    // Casing, surrounding and repeated whitespace must not change the avatar.
-    expect(avatarStyle("  RESEARCHER ")).toEqual(avatarStyle("researcher"));
-    expect(avatarStyle("Backend   Developer")).toEqual(
-      avatarStyle("backend developer"),
-    );
-    expect(normalizeName("  PM ")).toBe("pm");
-  });
-
-  it("returns a valid base color, angle and matching text", () => {
-    const s = avatarStyle("Нарратор");
-    const idx = PALETTE.findIndex((e) => e.hex === s.bg);
-    expect(idx).toBe(s.paletteIndex);
-    expect(idx).toBeGreaterThanOrEqual(0); // bg is a palette entry
-    // Text color comes from the chosen palette entry.
-    expect(s.text).toBe(PALETTE[idx].text);
-    // Split angle is one of the SPLIT_ANGLE_STEPS (24) directions → multiples of 15.
-    expect(s.angleDeg % 15).toBe(0);
-    expect(s.angleDeg).toBeGreaterThanOrEqual(0);
-    expect(s.angleDeg).toBeLessThan(360);
-  });
-
-  it("distinguishes the agents that used to collide as violet", () => {
-    // "Структурный редактор" and "Фактчекер" looked identically violet before.
-    expect(avatarStyle("Структурный редактор")).not.toEqual(
-      avatarStyle("Фактчекер"),
-    );
-  });
-});
-
-describe("avatarBackgroundCss", () => {
-  it("renders a two-stop gradient with a soft boundary", () => {
-    const s = avatarStyle("Backend Developer");
-    expect(avatarBackgroundCss(s)).toBe(
-      "linear-gradient(150deg, #a55795 42%, #90355e 58%)",
-    );
-  });
-});

apps/client/src/lib/avatar-palette.ts

@@ -1,267 +0,0 @@
-/**
- * Deterministic avatar backgrounds for agent roles.
- *
- * The palette is generated from scratch at module load in OKLCH (a perceptually
- * uniform color space), so every value below is tunable: change the ring
- * configuration or the partner shifts and the whole palette regenerates.
- *
- * Pipeline: name -> normalize -> cyrb53 hash -> split into independent fields:
- *   - base color index (one of the validated palette colors)
- *   - partner hue shift: analogous 20..45deg (either side), complementary 180deg,
- *     or triadic +/-120deg — classic color-wheel schemes; partner is also darker
- *   - split angle (SPLIT_ANGLE_STEPS directions, soft boundary)
- * The same name always yields the same avatar, on any platform, forever.
- */
-
-// ------------------------- Tunable configuration -------------------------
-
-export interface RingConfig {
-  /** OKLCH lightness, 0..1 */
-  L: number;
-  /** OKLCH chroma target; clamped down per-hue to fit the sRGB gamut */
-  C: number;
-  /** Hue of the first color in the ring, degrees */
-  hueStart: number;
-  /** Number of evenly spaced hues in the ring */
-  count: number;
-}
-
-/**
- * Two lightness rings. 12 light + 8 dark = 20 base colors with a validated
- * min pairwise deltaE-OK of ~0.066 (clearly distinguishable at avatar size).
- * Don't add more hues per ring without re-checking minPairwiseDistance():
- * beyond ~20-24 colors humans stop telling them apart reliably.
- */
-const RINGS: readonly RingConfig[] = [
-  { L: 0.70, C: 0.14, hueStart: 15, count: 12 }, // light ring
-  { L: 0.57, C: 0.13, hueStart: 20, count: 8 },  // darker ring
-];
-
-/** Partner color: lightness shifted by this much (negative = darker) */
-const PARTNER_L_SHIFT = -0.10;
-/** Analogous scheme: hue shift magnitude range, degrees (inclusive, 5-deg steps) */
-const ANALOG_MIN_SHIFT = 20;
-const ANALOG_SHIFT_STEP = 5;
-const ANALOG_SHIFT_STEPS = 6; // 20, 25, 30, 35, 40, 45
-/** Complementary scheme: fixed hue shift, degrees */
-const COMPLEMENTARY_SHIFT = 180;
-/** Triadic scheme: fixed hue shift magnitude, degrees (either side) */
-const TRIADIC_SHIFT = 120;
-/** Number of split directions (24 -> 15deg per step) */
-const SPLIT_ANGLE_STEPS = 24;
-/** Position of the color boundary, percent of the gradient axis */
-const SPLIT_PERCENT = 50;
-/** Width of the soft transition zone around the boundary, percent (0 = hard edge) */
-const SPLIT_SOFTNESS = 16;
-
-// ------------------------- OKLCH -> sRGB math -------------------------
-// Matrices from Bjorn Ottosson's OKLab reference implementation.
-
-function oklabToLinearSrgb(L: number, a: number, b: number): [number, number, number] {
-  const l_ = L + 0.3963377774 * a + 0.2158037573 * b;
-  const m_ = L - 0.1055613458 * a - 0.0638541728 * b;
-  const s_ = L - 0.0894841775 * a - 1.2914855480 * b;
-  const l = l_ ** 3, m = m_ ** 3, s = s_ ** 3;
-  return [
-    +4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
-    -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
-    -0.0041960863 * l - 0.7034186147 * m + 1.7076147010 * s,
-  ];
-}
-
-function gammaEncode(c: number): number {
-  return c <= 0.0031308 ? 12.92 * c : 1.055 * c ** (1 / 2.4) - 0.055;
-}
-
-export function oklchToSrgb(L: number, C: number, hDeg: number): [number, number, number] {
-  const h = (hDeg * Math.PI) / 180;
-  const [r, g, b] = oklabToLinearSrgb(L, C * Math.cos(h), C * Math.sin(h));
-  return [gammaEncode(r), gammaEncode(g), gammaEncode(b)];
-}
-
-export function isInGamut(rgb: readonly number[]): boolean {
-  return rgb.every((c) => c >= -1e-6 && c <= 1 + 1e-6);
-}
-
-/** Binary-search the max chroma <= C that fits into the sRGB gamut. */
-function clampChroma(L: number, C: number, hDeg: number): number {
-  if (isInGamut(oklchToSrgb(L, C, hDeg))) return C;
-  let lo = 0, hi = C;
-  for (let i = 0; i < 40; i++) {
-    const mid = (lo + hi) / 2;
-    if (isInGamut(oklchToSrgb(L, mid, hDeg))) lo = mid;
-    else hi = mid;
-  }
-  return lo;
-}
-
-function toHex(rgb: readonly number[]): string {
-  return (
-    "#" +
-    rgb
-      .map((c) => Math.round(Math.min(1, Math.max(0, c)) * 255).toString(16).padStart(2, "0"))
-      .join("")
-  );
-}
-
-/** WCAG relative luminance of an sRGB color (components 0..1). */
-export function relativeLuminance(rgb: readonly number[]): number {
-  const lin = rgb.map((c) => (c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4));
-  return 0.2126 * lin[0] + 0.7152 * lin[1] + 0.0722 * lin[2];
-}
-
-export function contrastRatio(l1: number, l2: number): number {
-  return (Math.max(l1, l2) + 0.05) / (Math.min(l1, l2) + 0.05);
-}
-
-// ------------------------- Palette generation -------------------------
-
-export interface PaletteEntry {
-  /** Base background color */
-  hex: string;
-  /** OKLCH coordinates of the base color (used to derive partner colors) */
-  L: number;
-  C: number;
-  h: number;
-  /** Text/icon color with the best WCAG contrast on the base color */
-  text: "white" | "black";
-  /** OKLab coordinates of the base color (kept for validation) */
-  lab: readonly [number, number, number];
-}
-
-function buildPalette(): PaletteEntry[] {
-  const entries: PaletteEntry[] = [];
-  for (const ring of RINGS) {
-    const step = 360 / ring.count;
-    for (let i = 0; i < ring.count; i++) {
-      const h = (ring.hueStart + i * step) % 360;
-      const C = clampChroma(ring.L, ring.C, h);
-      const rgb = oklchToSrgb(ring.L, C, h);
-      const lum = relativeLuminance(rgb);
-      entries.push({
-        hex: toHex(rgb),
-        L: ring.L,
-        C,
-        h,
-        // White text needs >= 3:1 contrast; otherwise fall back to black.
-        text: contrastRatio(lum, 1) >= 3 ? "white" : "black",
-        lab: [
-          ring.L,
-          C * Math.cos((h * Math.PI) / 180),
-          C * Math.sin((h * Math.PI) / 180),
-        ],
-      });
-    }
-  }
-  return entries;
-}
-
-/** Partner color for the split: base hue shifted by shiftDeg, darker by PARTNER_L_SHIFT. */
-function partnerHex(entry: PaletteEntry, shiftDeg: number): string {
-  const h2 = (entry.h + shiftDeg + 360) % 360;
-  const L2 = entry.L + PARTNER_L_SHIFT;
-  return toHex(oklchToSrgb(L2, clampChroma(L2, entry.C, h2), h2));
-}
-
-/** Generated once at module load; regenerates on every build from the config above. */
-export const PALETTE: readonly PaletteEntry[] = buildPalette();
-
-// ------------------------- Name -> avatar style -------------------------
-
-/** Normalize so that "PM ", "pm" and "Pm" map to the same avatar. */
-export function normalizeName(name: string): string {
-  return name.normalize("NFC").trim().toLowerCase().replace(/\s+/g, " ");
-}
-
-/**
- * cyrb53: deterministic 53-bit string hash with good avalanche.
- * Pure JS, cross-platform — never use language built-in hashing here.
- */
-function cyrb53(str: string, seed = 0): number {
-  let h1 = 0xdeadbeef ^ seed;
-  let h2 = 0x41c6ce57 ^ seed;
-  for (let i = 0; i < str.length; i++) {
-    const ch = str.charCodeAt(i);
-    h1 = Math.imul(h1 ^ ch, 2654435761);
-    h2 = Math.imul(h2 ^ ch, 1597334677);
-  }
-  h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909);
-  h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
-  return 4294967296 * (2097151 & h2) + (h1 >>> 0);
-}
-
-export interface AvatarStyle {
-  /** Index of the base color in PALETTE */
-  paletteIndex: number;
-  /** Base color hex */
-  bg: string;
-  /** Second color hex (split partner) */
-  bg2: string;
-  /** Signed hue shift of the partner, degrees (e.g. -35, +45, 180, -120) */
-  hueShift: number;
-  /** Direction of the split, degrees */
-  angleDeg: number;
-  /** Text/icon color for the base color */
-  text: "white" | "black";
-}
-
-/** Pure function: the same (normalized) name always returns the same style. */
-export function avatarStyle(agentName: string): AvatarStyle {
-  const h = cyrb53(normalizeName(agentName));
-  // Slice the hash into independent fields, like digits of a number:
-  const paletteIndex = h % PALETTE.length;
-  let rest = Math.floor(h / PALETTE.length);
-  const angleDeg = (rest % SPLIT_ANGLE_STEPS) * (360 / SPLIT_ANGLE_STEPS);
-  rest = Math.floor(rest / SPLIT_ANGLE_STEPS);
-  // Scheme: 0,1 -> analogous (minus/plus); 2 -> complementary; 3 -> triadic
-  const scheme = rest % 4;
-  rest = Math.floor(rest / 4);
-  let hueShift: number;
-  if (scheme === 2) {
-    hueShift = COMPLEMENTARY_SHIFT;
-  } else if (scheme === 3) {
-    hueShift = rest % 2 ? TRIADIC_SHIFT : -TRIADIC_SHIFT;
-  } else {
-    const magnitude = ANALOG_MIN_SHIFT + (rest % ANALOG_SHIFT_STEPS) * ANALOG_SHIFT_STEP;
-    hueShift = scheme === 0 ? -magnitude : magnitude;
-  }
-  const entry = PALETTE[paletteIndex];
-  return {
-    paletteIndex,
-    bg: entry.hex,
-    bg2: partnerHex(entry, hueShift),
-    hueShift,
-    angleDeg,
-    text: entry.text,
-  };
-}
-
-/** CSS background value: two colors with a slightly blurred boundary. */
-export function avatarBackgroundCss(style: AvatarStyle): string {
-  const from = SPLIT_PERCENT - SPLIT_SOFTNESS / 2;
-  const to = SPLIT_PERCENT + SPLIT_SOFTNESS / 2;
-  return `linear-gradient(${style.angleDeg}deg, ${style.bg} ${from}%, ${style.bg2} ${to}%)`;
-}
-
-// ------------------------- Validation -------------------------
-
-/**
- * Min pairwise deltaE-OK (euclidean distance in OKLab) between base colors.
- * Re-check after tweaking RINGS: keep it >= ~0.06 so no two palette colors
- * look alike. Intended for a unit test or a dev-time assertion.
- */
-export function minPairwiseDistance(): { distance: number; pair: [string, string] } {
-  let min = Infinity;
-  let pair: [string, string] = ["", ""];
-  for (let i = 0; i < PALETTE.length; i++) {
-    for (let j = i + 1; j < PALETTE.length; j++) {
-      const a = PALETTE[i].lab, b = PALETTE[j].lab;
-      const d = Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
-      if (d < min) {
-        min = d;
-        pair = [PALETTE[i].hex, PALETTE[j].hex];
-      }
-    }
-  }
-  return { distance: min, pair };
-}

apps/client/src/lib/config.ts

@@ -47,13 +47,6 @@ export function isCompactPageTreeEnabled(): boolean {
   return castToBoolean(getConfigValue("COMPACT_PAGE_TREE", "true"));
 }
 
-// #355 — operator toggle for client perf-telemetry. DEFAULT OFF: the server
-// mirrors CLIENT_TELEMETRY_ENABLED into window.CONFIG; when off the client
-// installs no observers and sends nothing (the sink endpoint doesn't exist).
-export function isClientTelemetryEnabled(): boolean {
-  return castToBoolean(getConfigValue("CLIENT_TELEMETRY_ENABLED", "false"));
-}
-
 export function getAvatarUrl(
   avatarUrl: string,
   type: AvatarIconType = AvatarIconType.AVATAR,

apps/client/src/lib/telemetry/route-template.test.ts

@@ -1,35 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { templateRoute } from "./route-template";
-
-describe("templateRoute", () => {
-  it("templates a space page path (never leaks slugs)", () => {
-    const t = templateRoute("/s/engineering/p/design-doc-abc123");
-    expect(t).toBe("/s/:space/p/:slug");
-    expect(t).not.toContain("engineering");
-    expect(t).not.toContain("design-doc");
-  });
-
-  it("templates share, redirect and space paths", () => {
-    expect(templateRoute("/share/abc/p/xyz")).toBe("/share/:shareId/p/:slug");
-    expect(templateRoute("/share/p/xyz")).toBe("/share/p/:slug");
-    expect(templateRoute("/p/some-slug")).toBe("/p/:slug");
-    expect(templateRoute("/s/team")).toBe("/s/:space");
-    expect(templateRoute("/s/team/trash")).toBe("/s/:space/trash");
-    expect(templateRoute("/labels/urgent")).toBe("/labels/:label");
-  });
-
-  it("keeps known static routes verbatim", () => {
-    expect(templateRoute("/home")).toBe("/home");
-    expect(templateRoute("/settings/members")).toBe("/settings/members");
-    expect(templateRoute("/")).toBe("/");
-  });
-
-  it("normalises a trailing slash", () => {
-    expect(templateRoute("/s/team/p/slug/")).toBe("/s/:space/p/:slug");
-  });
-
-  it("collapses unknown paths to 'other' (bounded cardinality)", () => {
-    expect(templateRoute("/weird/unknown/thing")).toBe("other");
-    expect(templateRoute("/s/team/p/slug/extra/segments")).toBe("other");
-  });
-});

apps/client/src/lib/telemetry/route-template.ts

@@ -1,70 +0,0 @@
-/**
- * Map a raw pathname to a BOUNDED route TEMPLATE (#355).
- *
- * Perf metrics must be labelled by route template only — never a raw path with
- * slugs/ids — so the server-side `route` column and any downstream aggregation
- * stay low-cardinality and carry NO page slugs/titles (privacy). Anything that
- * does not match a known pattern collapses to `other`.
- *
- * The template vocabulary mirrors the issue's example (`/s/:space/p/:slug`).
- */
-const ROUTE_PATTERNS: { re: RegExp; template: string }[] = [
-  // Share pages (public).
-  { re: /^\/share\/[^/]+\/p\/[^/]+$/, template: '/share/:shareId/p/:slug' },
-  { re: /^\/share\/p\/[^/]+$/, template: '/share/p/:slug' },
-  { re: /^\/share\/[^/]+$/, template: '/share/:shareId' },
-  // Page redirect.
-  { re: /^\/p\/[^/]+$/, template: '/p/:slug' },
-  // Space + page.
-  { re: /^\/s\/[^/]+\/p\/[^/]+$/, template: '/s/:space/p/:slug' },
-  { re: /^\/s\/[^/]+\/trash$/, template: '/s/:space/trash' },
-  { re: /^\/s\/[^/]+$/, template: '/s/:space' },
-  // Misc dynamic.
-  { re: /^\/labels\/[^/]+$/, template: '/labels/:label' },
-  { re: /^\/invites\/[^/]+$/, template: '/invites/:invitationId' },
-  { re: /^\/settings\/groups\/[^/]+$/, template: '/settings/groups/:groupId' },
-];
-
-// Static routes we accept verbatim (finite set).
-const STATIC_ROUTES = new Set<string>([
-  '/home',
-  '/spaces',
-  '/favorites',
-  '/login',
-  '/forgot-password',
-  '/password-reset',
-  '/setup/register',
-  '/settings/account/profile',
-  '/settings/account/preferences',
-  '/settings/workspace',
-  '/settings/ai',
-  '/settings/members',
-  '/settings/groups',
-  '/settings/spaces',
-  '/settings/sharing',
-]);
-
-export function templateRoute(pathname: string): string {
-  // Normalise a trailing slash (except root).
-  const path =
-    pathname.length > 1 && pathname.endsWith('/')
-      ? pathname.slice(0, -1)
-      : pathname;
-
-  if (path === '' || path === '/') return '/';
-  if (STATIC_ROUTES.has(path)) return path;
-
-  for (const { re, template } of ROUTE_PATTERNS) {
-    if (re.test(path)) return template;
-  }
-  return 'other';
-}
-
-/** Template for the current window location. */
-export function currentRouteTemplate(): string {
-  try {
-    return templateRoute(window.location.pathname);
-  } catch {
-    return 'other';
-  }
-}

apps/client/src/lib/telemetry/vitals.ts

@@ -1,290 +0,0 @@
-import {
-  onCLS,
-  onINP,
-  onLCP,
-  onTTFB,
-  type CLSMetricWithAttribution,
-  type INPMetricWithAttribution,
-  type LCPMetricWithAttribution,
-  type TTFBMetricWithAttribution,
-} from "web-vitals/attribution";
-import { isClientTelemetryEnabled } from "@/lib/config";
-import { currentRouteTemplate } from "./route-template";
-
-/**
- * Client perf-telemetry (#355): web-vitals + custom metrics buffered and posted
- * to POST /api/telemetry/vitals via sendBeacon.
- *
- * Design constraints from the issue:
- *  - Sampling is decided ONCE per session (25%), cached in sessionStorage,
- *    BEFORE any observer is subscribed. Non-sampled sessions send nothing.
- *  - Route labels are TEMPLATES only; attr is truncated to 120 chars; no page
- *    titles/slugs/text ever leave the browser.
- *  - Observers are passive and reporting is best-effort — telemetry must not
- *    degrade the perf it measures.
- */
-
-const ENDPOINT = "/api/telemetry/vitals";
-const SAMPLE_RATE = 0.25;
-const SAMPLE_KEY = "gm_vitals_sampled";
-const FLUSH_INTERVAL_MS = 15_000;
-const MAX_BUFFER = 40; // flush early if the buffer fills between timers
-const MAX_ATTR_LENGTH = 120;
-const EDITOR_TX_MIN_MS = 8; // only report editor transactions slower than this
-
-const ALLOWED_NAMES = new Set([
-  "INP",
-  "LCP",
-  "CLS",
-  "TTFB",
-  "editor_tx_ms",
-  "page_open_ms",
-  "longtask_ms",
-]);
-
-interface VitalEvent {
-  name: string;
-  value: number;
-  rating?: string;
-  route?: string;
-  attr?: string;
-  docSize?: number;
-}
-
-let sampledCache: boolean | null = null;
-let initialised = false;
-let buffer: VitalEvent[] = [];
-let longtaskSum = 0; // accumulated longtask duration (ms) for the current window
-
-/**
- * Decide once per session whether this session is sampled. Cached in
- * sessionStorage so the choice is stable across reloads within the session and
- * identical for every observer/custom-metric caller.
- */
-export function isVitalsSampled(): boolean {
-  if (sampledCache !== null) return sampledCache;
-  try {
-    const stored = sessionStorage.getItem(SAMPLE_KEY);
-    if (stored === "1") return (sampledCache = true);
-    if (stored === "0") return (sampledCache = false);
-    const sampled = Math.random() < SAMPLE_RATE;
-    sessionStorage.setItem(SAMPLE_KEY, sampled ? "1" : "0");
-    return (sampledCache = sampled);
-  } catch {
-    // sessionStorage unavailable (private mode / SSR): default to not sampled.
-    return (sampledCache = false);
-  }
-}
-
-/**
- * True only when telemetry is BOTH enabled by the operator (F1 flag) AND this
- * session is sampled. Callers outside initVitals (e.g. the editor dispatch
- * wrapper) use this to skip ALL instrumentation cost on disabled/non-sampled
- * sessions — no observers, no per-transaction timing.
- */
-export function isVitalsActive(): boolean {
-  return isClientTelemetryEnabled() && isVitalsSampled();
-}
-
-function truncateAttr(value: unknown): string | undefined {
-  if (typeof value !== "string" || value.length === 0) return undefined;
-  return value.slice(0, MAX_ATTR_LENGTH);
-}
-
-function enqueue(event: VitalEvent): void {
-  if (!ALLOWED_NAMES.has(event.name)) return;
-  if (!Number.isFinite(event.value)) return;
-  buffer.push(event);
-  if (buffer.length >= MAX_BUFFER) flush();
-}
-
-function flush(): void {
-  // Fold any pending longtask total into the batch first.
-  if (longtaskSum > 0) {
-    buffer.push({
-      name: "longtask_ms",
-      value: Math.round(longtaskSum),
-      route: currentRouteTemplate(),
-    });
-    longtaskSum = 0;
-  }
-  if (buffer.length === 0) return;
-
-  const payload = JSON.stringify({ events: buffer });
-  buffer = [];
-
-  try {
-    const blob = new Blob([payload], { type: "application/json" });
-    if (navigator.sendBeacon && navigator.sendBeacon(ENDPOINT, blob)) return;
-    // Fallback for browsers without sendBeacon: keepalive fetch.
-    void fetch(ENDPOINT, {
-      method: "POST",
-      body: payload,
-      headers: { "Content-Type": "application/json" },
-      keepalive: true,
-    }).catch(() => undefined);
-  } catch {
-    // Best-effort: never throw out of telemetry.
-  }
-}
-
-/**
- * Report a custom client metric (editor_tx_ms, page_open_ms). No-op unless the
- * session is sampled. Route is always the current TEMPLATE.
- */
-export function reportClientMetric(
-  name: "editor_tx_ms" | "page_open_ms",
-  value: number,
-  extra?: { docSize?: number },
-): void {
-  if (!isVitalsActive()) return;
-  if (!Number.isFinite(value)) return;
-  enqueue({
-    name,
-    value,
-    route: currentRouteTemplate(),
-    docSize: extra?.docSize,
-  });
-}
-
-/** Threshold-gated editor transaction reporter (only reports slow syncs). */
-export function reportEditorTx(ms: number, docSize: number): void {
-  if (ms <= EDITOR_TX_MIN_MS) return;
-  reportClientMetric("editor_tx_ms", ms, { docSize });
-}
-
-const PAGE_OPEN_MARK = "gm_page_open_start";
-
-/** Mark the start of a page-open interaction (tree-row / link click). */
-export function markPageOpenStart(): void {
-  try {
-    performance.clearMarks(PAGE_OPEN_MARK);
-    performance.mark(PAGE_OPEN_MARK);
-  } catch {
-    // ignore
-  }
-}
-
-/**
- * Measure page_open_ms at first editor-content render, if a start mark exists.
- * Consumes the mark so a later render doesn't double-count.
- */
-export function measurePageOpen(): void {
-  try {
-    const marks = performance.getEntriesByName(PAGE_OPEN_MARK, "mark");
-    if (marks.length === 0) return;
-    const started = marks[0].startTime;
-    const elapsed = performance.now() - started;
-    performance.clearMarks(PAGE_OPEN_MARK);
-    if (elapsed > 0 && Number.isFinite(elapsed)) {
-      reportClientMetric("page_open_ms", elapsed);
-    }
-  } catch {
-    // ignore
-  }
-}
-
-function attrTarget(
-  metric:
-    | INPMetricWithAttribution
-    | LCPMetricWithAttribution
-    | CLSMetricWithAttribution,
-): string | undefined {
-  const a = metric.attribution as Record<string, unknown> | undefined;
-  if (!a) return undefined;
-  // Different vitals expose their culprit element under different keys; only a
-  // CSS-selector-ish target string is taken (no text content / titles).
-  return (
-    truncateAttr(a.interactionTarget) ??
-    truncateAttr(a.element) ??
-    truncateAttr(a.largestShiftTarget) ??
-    undefined
-  );
-}
-
-/**
- * Initialise client telemetry. Safe to call multiple times (idempotent). Returns
- * immediately without subscribing when the session is not sampled — so a
- * non-sampled session subscribes to NO observers and sends nothing.
- */
-export function initVitals(): void {
-  if (initialised) return;
-  initialised = true;
-
-  // Operator flag gate (F1, default OFF): when telemetry is disabled the sink
-  // endpoint does not even exist server-side, so install ZERO observers.
-  if (!isClientTelemetryEnabled()) return;
-
-  // Sampling gate is evaluated BEFORE any observer subscription.
-  if (!isVitalsSampled()) return;
-
-  const report = (
-    metric:
-      | INPMetricWithAttribution
-      | LCPMetricWithAttribution
-      | CLSMetricWithAttribution
-      | TTFBMetricWithAttribution,
-  ) => {
-    enqueue({
-      name: metric.name,
-      value: metric.value,
-      rating: metric.rating,
-      route: currentRouteTemplate(),
-      attr:
-        metric.name === "TTFB"
-          ? undefined
-          : attrTarget(
-              metric as
-                | INPMetricWithAttribution
-                | LCPMetricWithAttribution
-                | CLSMetricWithAttribution,
-            ),
-    });
-  };
-
-  onINP(report);
-  onLCP(report);
-  onCLS(report);
-  onTTFB(report);
-
-  // Long tasks: aggregate the total blocking time per flush window (a passive
-  // observer; individual entries are summed, never stored/sent individually).
-  try {
-    if (typeof PerformanceObserver !== "undefined") {
-      const observer = new PerformanceObserver((list) => {
-        for (const entry of list.getEntries()) {
-          longtaskSum += entry.duration;
-        }
-      });
-      observer.observe({ type: "longtask", buffered: true });
-    }
-  } catch {
-    // longtask entry type unsupported: skip silently.
-  }
-
-  // page_open_ms start: mark when the user clicks a page link/tree-row (any
-  // anchor navigating to a page URL). Passive capture listener; the matching
-  // measure fires at first editor-content render (measurePageOpen). No page
-  // titles/slugs are read — only the click timing is marked.
-  document.addEventListener(
-    "click",
-    (event) => {
-      const target = event.target as Element | null;
-      const anchor = target?.closest?.("a[href]") as HTMLAnchorElement | null;
-      if (!anchor) return;
-      const href = anchor.getAttribute("href") ?? "";
-      // A page link is `/s/:space/p/:slug`, `/p/:slug` or a share page path.
-      if (/\/p\//.test(href)) markPageOpenStart();
-    },
-    { capture: true, passive: true },
-  );
-
-  // Flush on tab hide (most reliable delivery point) and periodically.
-  const onHidden = () => {
-    if (document.visibilityState === "hidden") flush();
-  };
-  document.addEventListener("visibilitychange", onHidden);
-  window.addEventListener("pagehide", flush);
-
-  setInterval(flush, FLUSH_INTERVAL_MS);
-}

apps/client/src/main.tsx

@@ -22,7 +22,6 @@ import {
   isPostHogEnabled,
 } from "@/lib/config.ts";
 import posthog from "posthog-js";
-import { initVitals } from "@/lib/telemetry/vitals";
 
 export const queryClient = new QueryClient({
   defaultOptions: {
@@ -44,10 +43,6 @@ if (isCloud() && isPostHogEnabled) {
   });
 }
 
-// #355 — client perf-telemetry. Decides sampling ONCE (25%/session) before
-// subscribing to any observer; non-sampled sessions send nothing.
-initVitals();
-
 const container = document.getElementById("root") as HTMLElement;
 const root = (container as any).__reactRoot ??= ReactDOM.createRoot(container);
 

apps/client/vitest.config.ts

@@ -13,22 +13,5 @@ export default defineConfig({
     environment: 'jsdom',
     globals: true,
     setupFiles: ['./vitest.setup.ts'],
-    // Coverage gate (issue #324). v8 provider (not istanbul) so ESM barrels
-    // like `@docmost/editor-ext` are not re-parsed/instrumented. Thresholds are
-    // set a few points below the level measured on develop, scoped to the files
-    // the suite exercises (`all: false`) rather than the whole app, so the gate
-    // passes today but fails on a genuine coverage regression.
-    coverage: {
-      enabled: true,
-      provider: 'v8',
-      reporter: ['text-summary', 'text'],
-      all: false,
-      thresholds: {
-        statements: 55,
-        branches: 53,
-        functions: 44,
-        lines: 55,
-      },
-    },
   },
 });

apps/server/package.json

@@ -111,7 +111,6 @@
     "pino-pretty": "^13.1.3",
     "postgres": "^3.4.8",
     "postmark": "^4.0.7",
-    "prom-client": "^15.1.3",
     "react": "^18.3.1",
     "react-email": "6.0.8",
     "reflect-metadata": "^0.2.2",

apps/server/src/app.module.ts

@@ -31,8 +31,6 @@ import { McpModule } from './integrations/mcp/mcp.module';
 import { SandboxModule } from './integrations/sandbox/sandbox.module';
 import { AiModule } from './integrations/ai/ai.module';
 import { AiChatModule } from './core/ai-chat/ai-chat.module';
-import { MetricsModule } from './integrations/metrics/metrics.module';
-import { ClientTelemetryModule } from './core/telemetry/client-telemetry.module';
 
 const enterpriseModules = [];
 try {
@@ -95,10 +93,6 @@ try {
     SandboxModule,
     AiModule,
     AiChatModule,
-    MetricsModule,
-    // Gated OFF by default: only registers the public vitals sink controller
-    // when CLIENT_TELEMETRY_ENABLED=true (maintainer decision E1=B).
-    ClientTelemetryModule.register(),
     ...enterpriseModules,
   ],
   controllers: [AppController],

apps/server/src/collaboration/collaboration.gateway.spec.ts

@@ -1,60 +0,0 @@
-import { CollaborationGateway } from './collaboration.gateway';
-import { CollaborationHandler } from './collaboration.handler';
-
-/**
- * Focused test for the COLLAB_DISABLE_REDIS fallback in handleYjsEvent.
- *
- * With Redis disabled the gateway builds no RedisSyncExtension, so the old code
- * (`return this.redisSync?.handleEvent(...)`) returned undefined and every
- * doc-mutation event silently no-opped. The fallback must instead invoke the
- * handler locally against the single hocuspocus instance and return its verdict.
- *
- * We construct the gateway with stub extensions and an EnvironmentService whose
- * isCollabDisableRedis() returns true (redisSync stays null, real hocuspocus is
- * still built), then spy getHandlers so no real direct connection is opened.
- */
-
-const stubExtension = {} as any;
-
-function makeEnv() {
-  return {
-    getRedisUrl: () => 'redis://localhost:6379',
-    isCollabDisableRedis: () => true,
-  } as any;
-}
-
-describe('CollaborationGateway.handleYjsEvent (no-Redis fallback)', () => {
-  it('invokes the handler locally and returns its verdict instead of undefined', async () => {
-    const collabHandler = new CollaborationHandler();
-    const verdict = { applied: true, currentText: 'new' };
-    const fakeHandler = jest.fn().mockResolvedValue(verdict);
-    // Bypass the real direct-connection code path — assert dispatch only.
-    jest
-      .spyOn(collabHandler, 'getHandlers')
-      .mockReturnValue({ applyCommentSuggestion: fakeHandler } as any);
-
-    const gateway = new CollaborationGateway(
-      stubExtension,
-      stubExtension,
-      stubExtension,
-      makeEnv(),
-      collabHandler,
-    );
-
-    const payload = {
-      commentId: 'c1',
-      expectedText: 'old',
-      newText: 'new',
-      user: { id: 'u1' } as any,
-    };
-    const result = await gateway.handleYjsEvent(
-      'applyCommentSuggestion' as any,
-      'doc-1',
-      payload as any,
-    );
-
-    expect(fakeHandler).toHaveBeenCalledWith('doc-1', payload);
-    expect(result).toEqual(verdict);
-    expect(result).not.toBeUndefined();
-  });
-});

apps/server/src/collaboration/collaboration.gateway.ts

@@ -147,41 +147,8 @@ export class CollaborationGateway {
     eventName: TName,
     documentName: string,
     payload: Parameters<CollabEventHandlers[TName]>[1],
-  ): ReturnType<CollabEventHandlers[TName]> {
+  ) {
-    if (this.redisSync) {
+    return this.redisSync?.handleEvent(eventName, documentName, payload);
-      // Normal path: the Redis bridge routes the event to the instance that owns
-      // the document (local or another worker) and carries the handler's return
-      // value back to us (customEventComplete + replyId).
-      return this.redisSync.handleEvent(
-        eventName,
-        documentName,
-        payload,
-      ) as ReturnType<CollabEventHandlers[TName]>;
-    }
-
-    // COLLAB_DISABLE_REDIS: there is no cross-process bridge, so a single local
-    // hocuspocus instance owns every document. Invoke the handler directly
-    // against it instead of returning undefined — otherwise doc-mutation events
-    // (setCommentMark / resolveCommentMark / applyCommentSuggestion) would
-    // silently no-op and, for suggestions, the caller could never learn the
-    // verdict. openDirectConnection loads the doc via the persistence extension
-    // if it is not already in memory.
-    if (this.hocuspocus) {
-      const handlers = this.collabEventsService.getHandlers(this.hocuspocus);
-      const handler = handlers[eventName] as (
-        documentName: string,
-        payload: unknown,
-      ) => ReturnType<CollabEventHandlers[TName]>;
-      return handler(documentName, payload);
-    }
-
-    // Collaboration was never initialized (no live instance). Fail loudly rather
-    // than silently dropping a mutation; phase 4's caller maps this to a 5xx.
-    throw new Error(
-      `Cannot handle collaboration event "${String(
-        eventName,
-      )}": requires a live collaboration instance`,
-    );
   }
 
   openDirectConnection(documentName: string, context?: any) {

apps/server/src/collaboration/collaboration.handler.spec.ts

@@ -1,188 +0,0 @@
-import * as Y from 'yjs';
-import { CollaborationHandler } from './collaboration.handler';
-import * as yjsUtil from './yjs.util';
-import { User } from '@docmost/db/types/entity.types';
-
-/**
- * Unit tests for the `applyCommentSuggestion` collab handler (phase 3 of #315).
- *
- * The handler runs `replaceYjsMarkedText` inside the owning instance's Y
- * transaction and returns the verdict to the caller. We exercise it against a
- * REAL in-memory Y.Doc carrying a marked comment run, driven through a FAKE
- * hocuspocus whose openDirectConnection().transact(fn) simply runs fn(doc) —
- * mirroring how the real hocuspocus DirectConnection invokes the callback with
- * the shared document (it does not forward the callback's return value, which is
- * exactly why withYdocConnection captures it via a closure).
- */
-
-// Build a Y.Doc with a single paragraph whose text carries a `comment` mark for
-// the given commentId — the shape `replaceYjsMarkedText` walks in production.
-function buildDocWithComment(text: string, commentId: string) {
-  const doc = new Y.Doc();
-  const fragment = doc.getXmlFragment('default');
-  const paragraph = new Y.XmlElement('paragraph');
-  const xmlText = new Y.XmlText();
-  xmlText.insert(0, text);
-  xmlText.format(0, text.length, { comment: { commentId, resolved: false } });
-  paragraph.insert(0, [xmlText]);
-  fragment.insert(0, [paragraph]);
-  return doc;
-}
-
-// Fake hocuspocus exposing only what withYdocConnection needs: a direct
-// connection whose transact() runs the callback against `doc`.
-function fakeHocuspocus(doc: Y.Doc) {
-  const connection = {
-    transact: jest.fn(async (fn: (d: Y.Doc) => void) => {
-      fn(doc);
-    }),
-    disconnect: jest.fn(async () => {}),
-  };
-  const hocuspocus = {
-    openDirectConnection: jest.fn(async () => connection),
-  } as any;
-  return { hocuspocus, connection };
-}
-
-const user = { id: 'u1' } as unknown as User;
-
-describe('CollaborationHandler.applyCommentSuggestion', () => {
-  it('applies the replacement and returns the verdict when the marked text matches', async () => {
-    const doc = buildDocWithComment('Hello world', 'c1');
-    const { hocuspocus, connection } = fakeHocuspocus(doc);
-    const handler = new CollaborationHandler();
-    const handlers = handler.getHandlers(hocuspocus);
-
-    const result = await handlers.applyCommentSuggestion('doc-1', {
-      commentId: 'c1',
-      expectedText: 'Hello world',
-      newText: 'Goodbye world',
-      user,
-    });
-
-    expect(result).toEqual({ applied: true, currentText: 'Goodbye world' });
-    // The mutation ran inside the transaction and hit the real doc.
-    expect(connection.transact).toHaveBeenCalledTimes(1);
-    expect(connection.disconnect).toHaveBeenCalledTimes(1);
-    expect(doc.getXmlFragment('default').toString()).toContain(
-      'Goodbye world',
-    );
-  });
-
-  it('rejects (applied=false) and returns the current text when it changed', async () => {
-    const doc = buildDocWithComment('Hello world', 'c1');
-    const { hocuspocus } = fakeHocuspocus(doc);
-    const handler = new CollaborationHandler();
-    const handlers = handler.getHandlers(hocuspocus);
-
-    const result = await handlers.applyCommentSuggestion('doc-1', {
-      commentId: 'c1',
-      expectedText: 'Stale expected text',
-      newText: 'Goodbye world',
-      user,
-    });
-
-    expect(result).toEqual({ applied: false, currentText: 'Hello world' });
-    // Nothing was replaced.
-    expect(doc.getXmlFragment('default').toString()).toContain(
-      'Hello world',
-    );
-  });
-
-  it('forwards the exact args to replaceYjsMarkedText and returns its result', async () => {
-    const doc = buildDocWithComment('abc', 'c9');
-    const { hocuspocus } = fakeHocuspocus(doc);
-    const spy = jest
-      .spyOn(yjsUtil, 'replaceYjsMarkedText')
-      .mockReturnValue({ applied: true, currentText: 'xyz' });
-    const handler = new CollaborationHandler();
-    const handlers = handler.getHandlers(hocuspocus);
-
-    const result = await handlers.applyCommentSuggestion('doc-1', {
-      commentId: 'c9',
-      expectedText: 'abc',
-      newText: 'xyz',
-      user,
-    });
-
-    expect(spy).toHaveBeenCalledWith(
-      doc.getXmlFragment('default'),
-      'c9',
-      'abc',
-      'xyz',
-    );
-    expect(result).toEqual({ applied: true, currentText: 'xyz' });
-    spy.mockRestore();
-  });
-
-  it('withYdocConnection returns the callback result (transact does not forward it)', async () => {
-    const doc = new Y.Doc();
-    const { hocuspocus } = fakeHocuspocus(doc);
-    const handler = new CollaborationHandler();
-
-    const value = await handler.withYdocConnection(
-      hocuspocus,
-      'doc-1',
-      {},
-      () => 42,
-    );
-
-    expect(value).toBe(42);
-  });
-});
-
-describe('CollaborationHandler.deleteCommentMark', () => {
-  it('strips the comment mark for the given commentId (ephemeral suggestion #329)', async () => {
-    const doc = buildDocWithComment('Hello world', 'c1');
-    const { hocuspocus, connection } = fakeHocuspocus(doc);
-    const handler = new CollaborationHandler();
-    const handlers = handler.getHandlers(hocuspocus);
-
-    await handlers.deleteCommentMark('doc-1', { commentId: 'c1', user });
-
-    // The mark is gone; the text itself stays (deleting the anchor, not the run).
-    const xmlText = (
-      doc.getXmlFragment('default').get(0) as Y.XmlElement
-    ).get(0) as Y.XmlText;
-    expect(xmlText.toDelta()).toEqual([{ insert: 'Hello world' }]);
-    expect(connection.transact).toHaveBeenCalledTimes(1);
-    expect(connection.disconnect).toHaveBeenCalledTimes(1);
-  });
-
-  it('routes the removal through removeYjsMarkByAttribute with the right args', async () => {
-    const doc = buildDocWithComment('abc', 'c9');
-    const { hocuspocus } = fakeHocuspocus(doc);
-    const spy = jest.spyOn(yjsUtil, 'removeYjsMarkByAttribute');
-    const handler = new CollaborationHandler();
-    const handlers = handler.getHandlers(hocuspocus);
-
-    await handlers.deleteCommentMark('doc-1', { commentId: 'c9', user });
-
-    expect(spy).toHaveBeenCalledWith(
-      doc.getXmlFragment('default'),
-      'comment',
-      'commentId',
-      'c9',
-    );
-    spy.mockRestore();
-  });
-
-  it('leaves a different comment\'s mark intact', async () => {
-    const doc = buildDocWithComment('keep me', 'other');
-    const { hocuspocus } = fakeHocuspocus(doc);
-    const handler = new CollaborationHandler();
-    const handlers = handler.getHandlers(hocuspocus);
-
-    await handlers.deleteCommentMark('doc-1', { commentId: 'c1', user });
-
-    const xmlText = (
-      doc.getXmlFragment('default').get(0) as Y.XmlElement
-    ).get(0) as Y.XmlText;
-    expect(xmlText.toDelta()).toEqual([
-      {
-        insert: 'keep me',
-        attributes: { comment: { commentId: 'other', resolved: false } },
-      },
-    ]);
-  });
-});

apps/server/src/collaboration/collaboration.handler.ts

@@ -5,13 +5,7 @@ import {
   prosemirrorNodeToYElement,
   tiptapExtensions,
 } from './collaboration.util';
-import {
+import { setYjsMark, updateYjsMarkAttribute, YjsSelection } from './yjs.util';
-  removeYjsMarkByAttribute,
-  replaceYjsMarkedText,
-  setYjsMark,
-  updateYjsMarkAttribute,
-  YjsSelection,
-} from './yjs.util';
 import * as Y from 'yjs';
 import { User } from '@docmost/db/types/entity.types';
 
@@ -79,69 +73,6 @@ export class CollaborationHandler {
           },
         );
       },
-      deleteCommentMark: async (
-        documentName: string,
-        payload: {
-          commentId: string;
-          user: User;
-        },
-      ) => {
-        const { commentId, user } = payload;
-        // Ephemeral suggestions (#329): when a suggestion-edit is dismissed or an
-        // applied one has no replies, the comment is hard-deleted and its inline
-        // anchor must vanish too. Mirror resolveCommentMark exactly, but instead
-        // of flipping the mark's `resolved` attribute we STRIP the `comment` mark
-        // entirely via removeYjsMarkByAttribute so no orphan highlight remains in
-        // the collaborative document.
-        //
-        // Routing this through collaboration.gateway's handleYjsEvent means the
-        // COLLAB_DISABLE_REDIS path invokes this handler directly (never a silent
-        // no-op) and a missing live instance is a hard error — the same guarantee
-        // applyCommentSuggestion/resolveCommentMark rely on.
-        await this.withYdocConnection(
-          hocuspocus,
-          documentName,
-          { user },
-          (doc) => {
-            const fragment = doc.getXmlFragment('default');
-            removeYjsMarkByAttribute(
-              fragment,
-              'comment',
-              'commentId',
-              commentId,
-            );
-          },
-        );
-      },
-      applyCommentSuggestion: async (
-        documentName: string,
-        payload: {
-          commentId: string;
-          expectedText: string;
-          newText: string;
-          user: User;
-        },
-      ): Promise<{ applied: boolean; currentText: string | null }> => {
-        const { commentId, expectedText, newText, user } = payload;
-        // Run the check-and-replace inside the owning instance's Y transaction so
-        // the delete+insert are atomic. The verdict from replaceYjsMarkedText is
-        // returned to the API-server caller (cross-process via the Redis bridge,
-        // or locally when Redis is disabled — see collaboration.gateway.ts).
-        return this.withYdocConnection(
-          hocuspocus,
-          documentName,
-          { user },
-          (doc) => {
-            const fragment = doc.getXmlFragment('default');
-            return replaceYjsMarkedText(
-              fragment,
-              commentId,
-              expectedText,
-              newText,
-            );
-          },
-        );
-      },
       updatePageContent: async (
         documentName: string,
         payload: {
@@ -184,28 +115,18 @@ export class CollaborationHandler {
     };
   }
 
-  async withYdocConnection<T>(
+  async withYdocConnection(
     hocuspocus: Hocuspocus,
     documentName: string,
     context: any = {},
-    // `fn` MUST be synchronous: hocuspocus `connection.transact(fn)` runs fn
+    fn: (doc: Document) => void,
-    // synchronously and does NOT await it, so any mutations after an `await`
+  ): Promise<void> {
-    // inside fn would execute OUTSIDE the Yjs transaction and lose atomicity.
-    fn: (doc: Document) => T,
-  ): Promise<T> {
     const connection = await hocuspocus.openDirectConnection(
       documentName,
       context,
     );
     try {
-      // hocuspocus `connection.transact(fn)` invokes fn(document) but does NOT
+      await connection.transact(fn);
-      // forward fn's return value, so we capture it in a closure and return it
-      // after the transaction (and its storeDocument hooks) resolve.
-      let result: T;
-      await connection.transact((doc) => {
-        result = fn(doc);
-      });
-      return result!;
     } finally {
       await connection.disconnect();
     }

apps/server/src/collaboration/extensions/persistence.extension.ts

@@ -41,7 +41,6 @@ import {
   HISTORY_INTERVAL,
 } from '../constants';
 import { TransclusionService } from '../../core/page/transclusion/transclusion.service';
-import { observeCollabStore } from '../../integrations/metrics/metrics.registry';
 
 /**
  * #251 — wire format of the client→server stateless message that signals a
@@ -193,17 +192,6 @@ export class PersistenceExtension implements Extension {
   }
 
   async onStoreDocument(data: onStoreDocumentPayload) {
-    // #355 — time the full store (persist + post-store side effects) into
-    // collab_store_duration_seconds. No-op when METRICS_PORT is unset.
-    const startedAt = performance.now();
-    try {
-      await this.storeDocument(data);
-    } finally {
-      observeCollabStore((performance.now() - startedAt) / 1000);
-    }
-  }
-
-  private async storeDocument(data: onStoreDocumentPayload) {
     const { documentName, document, context } = data;
 
     const pageId = getPageId(documentName);

apps/server/src/collaboration/yjs.util.spec.ts

@@ -10,7 +10,6 @@ import {
   setYjsMark,
   removeYjsMarkByAttribute,
   updateYjsMarkAttribute,
-  replaceYjsMarkedText,
   type YjsSelection,
 } from './yjs.util';
 
@@ -277,256 +276,3 @@ describe('updateYjsMarkAttribute', () => {
     expect(text.toDelta()).toEqual(before);
   });
 });
-
-describe('replaceYjsMarkedText', () => {
-  // Build a single-paragraph XmlText from runs. Insert the whole string as
-  // plain text FIRST, then format only the marked ranges — otherwise text
-  // inserted right after a marked run inherits its comment mark (Yjs carries
-  // formatting from the left insertion boundary).
-  function buildRuns(
-    runs: Array<{
-      text: string;
-      comment?: { commentId: string; resolved: boolean };
-    }>,
-  ): { fragment: Y.XmlFragment; text: Y.XmlText } {
-    const ydoc = new Y.Doc();
-    const fragment = ydoc.getXmlFragment('default');
-    const para = new Y.XmlElement('paragraph');
-    fragment.insert(0, [para]);
-    const text = new Y.XmlText();
-    para.insert(0, [text]);
-    text.insert(0, runs.map((r) => r.text).join(''));
-    let offset = 0;
-    for (const run of runs) {
-      if (run.comment) {
-        text.format(offset, run.text.length, { comment: run.comment });
-      }
-      offset += run.text.length;
-    }
-    return { fragment, text };
-  }
-
-  // Two paragraphs, each with its own XmlText, both marked with the same
-  // commentId — mirrors a suggestion anchor that got split across blocks.
-  function buildTwoParagraphs(
-    a: { text: string; comment?: { commentId: string; resolved: boolean } },
-    b: { text: string; comment?: { commentId: string; resolved: boolean } },
-  ): { fragment: Y.XmlFragment; textA: Y.XmlText; textB: Y.XmlText } {
-    const ydoc = new Y.Doc();
-    const fragment = ydoc.getXmlFragment('default');
-    const build = (seg: typeof a) => {
-      const para = new Y.XmlElement('paragraph');
-      const text = new Y.XmlText();
-      para.insert(0, [text]);
-      text.insert(0, seg.text);
-      if (seg.comment) {
-        text.format(0, seg.text.length, { comment: seg.comment });
-      }
-      return { para, text };
-    };
-    const pa = build(a);
-    const pb = build(b);
-    fragment.insert(0, [pa.para, pb.para]);
-    return { fragment, textA: pa.text, textB: pb.text };
-  }
-
-  it('happy path: replaces marked text with newText and keeps the comment mark', () => {
-    const { fragment, text } = buildRuns([
-      { text: 'Hello ' },
-      { text: 'world', comment: { commentId: 'c1', resolved: false } },
-      { text: '!' },
-    ]);
-
-    const result = replaceYjsMarkedText(fragment, 'c1', 'world', 'planet');
-
-    expect(result).toEqual({ applied: true, currentText: 'planet' });
-    // New text carries the SAME comment mark; surrounding text is untouched.
-    expect(text.toDelta()).toEqual([
-      { insert: 'Hello ' },
-      {
-        insert: 'planet',
-        attributes: { comment: { commentId: 'c1', resolved: false } },
-      },
-      { insert: '!' },
-    ]);
-  });
-
-  it('matches by commentId even when the mark is resolved', () => {
-    const { fragment, text } = buildWithComments([
-      { text: 'foo', comment: { commentId: 'c9', resolved: true } },
-    ]);
-
-    const result = replaceYjsMarkedText(fragment, 'c9', 'foo', 'bar');
-
-    expect(result).toEqual({ applied: true, currentText: 'bar' });
-    expect(text.toDelta()).toEqual([
-      {
-        insert: 'bar',
-        attributes: { comment: { commentId: 'c9', resolved: true } },
-      },
-    ]);
-  });
-
-  it('changed text: marked text differs from expected → no-op, doc unchanged', () => {
-    const { fragment, text } = buildWithComments([
-      { text: 'abc', comment: { commentId: 'c1', resolved: false } },
-    ]);
-    const before = text.toDelta();
-
-    const result = replaceYjsMarkedText(fragment, 'c1', 'expected', 'new');
-
-    expect(result).toEqual({ applied: false, currentText: 'abc' });
-    expect(text.toDelta()).toEqual(before);
-  });
-
-  // F1 regression: the marked doc text is TYPOGRAPHIC (smart quotes / em-dash)
-  // and expectedText equals that raw typographic text — as it now does, because
-  // the MCP client stores the RAW anchored substring (getAnchoredText) rather
-  // than the agent's ASCII input. The strict `joinedText !== expectedText`
-  // compare must therefore MATCH and the suggestion apply (not a spurious 409).
-  it('typographic marked text applies when expectedText is the raw typographic text', () => {
-    const marked = '“hello”—world';
-    const { fragment, text } = buildRuns([
-      { text: 'say ' },
-      { text: marked, comment: { commentId: 'c1', resolved: false } },
-      { text: '!' },
-    ]);
-
-    const result = replaceYjsMarkedText(fragment, 'c1', marked, 'bye');
-
-    expect(result).toEqual({ applied: true, currentText: 'bye' });
-    expect(text.toDelta()).toEqual([
-      { insert: 'say ' },
-      {
-        insert: 'bye',
-        attributes: { comment: { commentId: 'c1', resolved: false } },
-      },
-      { insert: '!' },
-    ]);
-  });
-
-  it('anchor deleted: no mark with that commentId → { applied: false, currentText: null }', () => {
-    const { fragment, text } = buildWithComments([
-      { text: 'abc', comment: { commentId: 'c1', resolved: false } },
-    ]);
-    const before = text.toDelta();
-
-    const result = replaceYjsMarkedText(fragment, 'missing', 'abc', 'new');
-
-    expect(result).toEqual({ applied: false, currentText: null });
-    expect(text.toDelta()).toEqual(before);
-  });
-
-  it('paragraph split: same commentId in two XmlText nodes → no-op, doc unchanged', () => {
-    const { fragment, textA, textB } = buildTwoParagraphs(
-      { text: 'Hello ', comment: { commentId: 'c1', resolved: false } },
-      { text: 'world', comment: { commentId: 'c1', resolved: false } },
-    );
-    const beforeA = textA.toDelta();
-    const beforeB = textB.toDelta();
-
-    const result = replaceYjsMarkedText(fragment, 'c1', 'Hello world', 'new');
-
-    expect(result).toEqual({ applied: false, currentText: 'Hello world' });
-    expect(textA.toDelta()).toEqual(beforeA);
-    expect(textB.toDelta()).toEqual(beforeB);
-  });
-
-  it('interleaved unmarked text: marked run not contiguous → no-op, doc unchanged', () => {
-    const { fragment, text } = buildRuns([
-      { text: 'abc', comment: { commentId: 'c1', resolved: false } },
-      { text: 'X' },
-      { text: 'def', comment: { commentId: 'c1', resolved: false } },
-    ]);
-    const before = text.toDelta();
-
-    const result = replaceYjsMarkedText(fragment, 'c1', 'abcdef', 'new');
-
-    // Joined marked text ("abcdef") is returned, but the run is not contiguous.
-    expect(result).toEqual({ applied: false, currentText: 'abcdef' });
-    expect(text.toDelta()).toEqual(before);
-  });
-
-  it('preserves surrounding text and merges adjacent marked segments on apply', () => {
-    // The marked run itself is split into two adjacent delta segments; they must
-    // be treated as one contiguous run and replaced as a whole.
-    const { fragment, text } = buildRuns([
-      { text: 'pre ' },
-      { text: 'ab', comment: { commentId: 'c1', resolved: false } },
-      { text: 'cd', comment: { commentId: 'c1', resolved: false } },
-      { text: ' post' },
-    ]);
-
-    const result = replaceYjsMarkedText(fragment, 'c1', 'abcd', 'Z');
-
-    expect(result).toEqual({ applied: true, currentText: 'Z' });
-    expect(text.toDelta()).toEqual([
-      { insert: 'pre ' },
-      {
-        insert: 'Z',
-        attributes: { comment: { commentId: 'c1', resolved: false } },
-      },
-      { insert: ' post' },
-    ]);
-  });
-
-  it('embed before the marked run: offset accounts for the embed unit → replaces the right text, embed intact', () => {
-    // "AB", then a Yjs embed (1 index unit), then marked "world". Before the
-    // fix the embed was skipped WITHOUT advancing offset, so the computed start
-    // for "world" was too low by 1 → delete/insert would have hit the embed/text
-    // instead of "world", mangling the embed. With the fix offset is correct.
-    const ydoc = new Y.Doc();
-    const fragment = ydoc.getXmlFragment('default');
-    const para = new Y.XmlElement('paragraph');
-    fragment.insert(0, [para]);
-    const text = new Y.XmlText();
-    para.insert(0, [text]);
-    text.insert(0, 'AB');
-    text.insertEmbed(2, { image: { src: 'x' } });
-    text.insert(3, 'world');
-    text.format(3, 'world'.length, {
-      comment: { commentId: 'c1', resolved: false },
-    });
-
-    const result = replaceYjsMarkedText(fragment, 'c1', 'world', 'planet');
-
-    expect(result).toEqual({ applied: true, currentText: 'planet' });
-    // "AB" untouched, embed still present and intact, "world" → "planet"
-    // carrying the SAME comment mark.
-    expect(text.toDelta()).toEqual([
-      { insert: 'AB' },
-      { insert: { image: { src: 'x' } } },
-      {
-        insert: 'planet',
-        attributes: { comment: { commentId: 'c1', resolved: false } },
-      },
-    ]);
-  });
-
-  it('embed inside the marked run: embed splits the run → non-contiguous → no-op, doc unchanged', () => {
-    // marked "abc", an embed, marked "def" — same commentId. The embed occupies
-    // one index unit between the two marked segments, so they are not contiguous
-    // → the guard rejects it and nothing is mutated (embed intact).
-    const ydoc = new Y.Doc();
-    const fragment = ydoc.getXmlFragment('default');
-    const para = new Y.XmlElement('paragraph');
-    fragment.insert(0, [para]);
-    const text = new Y.XmlText();
-    para.insert(0, [text]);
-    text.insert(0, 'abc');
-    text.insertEmbed(3, { image: { src: 'y' } });
-    text.insert(4, 'def');
-    text.format(0, 'abc'.length, {
-      comment: { commentId: 'c1', resolved: false },
-    });
-    text.format(4, 'def'.length, {
-      comment: { commentId: 'c1', resolved: false },
-    });
-    const before = text.toDelta();
-
-    const result = replaceYjsMarkedText(fragment, 'c1', 'abcdef', 'new');
-
-    expect(result).toEqual({ applied: false, currentText: 'abcdef' });
-    expect(text.toDelta()).toEqual(before);
-  });
-});

apps/server/src/collaboration/yjs.util.ts

@@ -133,137 +133,6 @@ export function removeYjsMarkByAttribute(
   }
 }
 
-/**
- * A single marked delta segment collected during the walk, together with the
- * Y.XmlText node that owns it, the segment's start offset within that node,
- * and the full `comment` mark attributes object (needed to re-attach the mark
- * to the replacement text).
- */
-type MarkedSegment = {
-  node: Y.XmlText;
-  offset: number;
-  length: number;
-  text: string;
-  markAttrs: Record<string, any>;
-};
-
-/**
- * Atomically check-and-replace the text currently under a comment mark.
- *
- * Walks the fragment collecting every delta segment whose `comment` mark has the
- * given commentId. The replacement is applied ONLY if the marked run is intact:
- * it lives in a single Y.XmlText node, is contiguous (no unmarked text spliced
- * into the middle), and its joined text still equals `expectedText`. On success
- * the run is deleted and `newText` is inserted at the same offset carrying the
- * SAME comment attributes, so the comment thread stays anchored to the new text.
- *
- * This mutates the passed fragment/text directly and does NOT open its own Y
- * transaction — the caller is expected to wrap the call in connection.transact()
- * so the delete+insert are atomic (mirrors updateYjsMarkAttribute's direct
- * mutation style).
- *
- * @returns `{ applied: true, currentText: newText }` on replacement, otherwise
- * `{ applied: false, currentText }` where currentText is the text currently
- * under the mark (or null when the mark/anchor no longer exists).
- */
-export function replaceYjsMarkedText(
-  fragment: Y.XmlFragment,
-  commentId: string,
-  expectedText: string,
-  newText: string,
-): { applied: boolean; currentText: string | null } {
-  // 1. Collect every marked segment in document order.
-  const segments: MarkedSegment[] = [];
-
-  const processItem = (item: any) => {
-    if (item instanceof Y.XmlText) {
-      const deltas = item.toDelta();
-      let offset = 0;
-
-      for (const delta of deltas) {
-        const insert = delta.insert;
-        // Non-string inserts (embeds) carry no text length we can splice on.
-        if (typeof insert !== 'string') {
-          // A Yjs embed occupies one unit in the index space used by delete/
-          // insert/format — advance offset so a marked segment after an embed
-          // gets the right position (and an embed inside a marked run creates a
-          // gap → the contiguity guard rejects it as a changed anchor).
-          offset += 1;
-          continue;
-        }
-        const length = insert.length;
-        const attributes = delta.attributes ?? {};
-        const markAttr = attributes['comment'];
-
-        if (markAttr && markAttr.commentId === commentId) {
-          segments.push({
-            node: item,
-            offset,
-            length,
-            text: insert,
-            markAttrs: markAttr,
-          });
-        }
-        offset += length;
-      }
-    } else if (item instanceof Y.XmlElement) {
-      for (let i = 0; i < item.length; i++) {
-        processItem(item.get(i));
-      }
-    }
-  };
-
-  for (let i = 0; i < fragment.length; i++) {
-    processItem(fragment.get(i));
-  }
-
-  const joinedText = segments.map((s) => s.text).join('');
-
-  // 2a. No segments — the mark/anchor was deleted.
-  if (segments.length === 0) {
-    return { applied: false, currentText: null };
-  }
-
-  // 2b. Segments span more than one Y.XmlText node (paragraph split by Enter,
-  // or the mark bled across blocks) — treat as changed.
-  const node = segments[0].node;
-  const sameNode = segments.every((s) => s.node === node);
-  if (!sameNode) {
-    return { applied: false, currentText: joinedText };
-  }
-
-  // 2c. Non-contiguous within the single node: unmarked text is spliced between
-  // the first and last marked segment. Since collected segments are in document
-  // order, contiguity holds iff each segment starts where the previous ended.
-  let contiguous = true;
-  for (let i = 1; i < segments.length; i++) {
-    if (segments[i].offset !== segments[i - 1].offset + segments[i - 1].length) {
-      contiguous = false;
-      break;
-    }
-  }
-  if (!contiguous) {
-    return { applied: false, currentText: joinedText };
-  }
-
-  // 2d. The text under the mark changed.
-  if (joinedText !== expectedText) {
-    return { applied: false, currentText: joinedText };
-  }
-
-  // 3. All guards passed: delete the marked run and re-insert newText with the
-  // same comment attributes at the same offset. Atomic within the caller's
-  // transaction.
-  const start = segments[0].offset;
-  const len = segments.reduce((sum, s) => sum + s.length, 0);
-  const markAttrs = segments[0].markAttrs;
-
-  node.delete(start, len);
-  node.insert(start, newText, { comment: markAttrs });
-
-  return { applied: true, currentText: newText };
-}
-
 /**
  * Updates a mark's attributes for all text that has the specified attribute value.
  * Useful for resolving/unresolving comments by commentId.

apps/server/src/common/events/audit-events.ts

@@ -51,8 +51,6 @@ export const AuditEvent = {
   COMMENT_UPDATED: 'comment.updated',
   COMMENT_RESOLVED: 'comment.resolved',
   COMMENT_REOPENED: 'comment.reopened',
-  COMMENT_SUGGESTION_APPLIED: 'comment.suggestion_applied',
-  COMMENT_SUGGESTION_DISMISSED: 'comment.suggestion_dismissed',
 
   // Page
   PAGE_CREATED: 'page.created',

apps/server/src/core/ai-chat/ai-chat-run.service.spec.ts

@@ -1,527 +0,0 @@
-import { Logger } from '@nestjs/common';
-import {
-  AiChatRunService,
-  RunAlreadyActiveError,
-  ONE_ACTIVE_RUN_PER_CHAT_INDEX,
-  mapTurnStatusToRun,
-} from './ai-chat-run.service';
-
-/** Shape a Postgres unique-violation the way the postgres.js driver surfaces it:
- *  SQLSTATE 23505 + the offending index in `constraint_name`. */
-function uniqueViolation(constraintName: string): Error & {
-  code: string;
-  constraint_name: string;
-} {
-  return Object.assign(
-    new Error('duplicate key value violates unique constraint'),
-    {
-      code: '23505',
-      constraint_name: constraintName,
-    },
-  );
-}
-
-/**
- * Unit coverage for the #184 phase-1 run lifecycle (AiChatRunService) with a
- * hand-rolled mock repo — no Nest graph, no DB. The invariant under test is the
- * one that makes a run "autonomous": a run keeps going when its SUBSCRIBER (the
- * browser) detaches, and ONLY an explicit stop aborts it. We assert that at the
- * abort-signal level (the signal the agent loop actually consumes).
- */
-
-/** Minimal EnvironmentService stub. Single-instance (CLOUD unset) by default. */
-function makeEnv(isCloud = false) {
-  return { isCloud: () => isCloud };
-}
-
-function makeRepo(overrides: Record<string, jest.Mock> = {}) {
-  return {
-    insert: jest.fn(async (v: any) => ({
-      id: 'run-1',
-      status: v.status ?? 'running',
-      chatId: v.chatId,
-      workspaceId: v.workspaceId,
-    })),
-    update: jest.fn(async () => ({ id: 'run-1' })),
-    markStopRequested: jest.fn(async () => ({ id: 'run-1' })),
-    findActiveByChat: jest.fn(async () => undefined),
-    findLatestByChat: jest.fn(async () => undefined),
-    findById: jest.fn(async () => undefined),
-    sweepRunning: jest.fn(async () => 0),
-    ...overrides,
-  };
-}
-
-describe('mapTurnStatusToRun', () => {
-  it('maps the turn terminal status to the run terminal status', () => {
-    expect(mapTurnStatusToRun('completed')).toBe('succeeded');
-    expect(mapTurnStatusToRun('error')).toBe('failed');
-    expect(mapTurnStatusToRun('aborted')).toBe('aborted');
-  });
-});
-
-describe('AiChatRunService.onModuleInit (startup sweep)', () => {
-  afterEach(() => jest.restoreAllMocks());
-
-  it('calls sweepRunning and resolves; logs when > 0', async () => {
-    const repo = makeRepo({ sweepRunning: jest.fn(async () => 2) });
-    const logSpy = jest
-      .spyOn(Logger.prototype, 'log')
-      .mockImplementation(() => undefined);
-    const svc = new AiChatRunService(repo as never, makeEnv() as never);
-    await expect(svc.onModuleInit()).resolves.toBeUndefined();
-    expect(repo.sweepRunning).toHaveBeenCalledTimes(1);
-    expect(logSpy).toHaveBeenCalledTimes(1);
-    expect(String(logSpy.mock.calls[0][0])).toContain('2');
-  });
-
-  it('a sweep failure is swallowed (never blocks startup)', async () => {
-    const repo = makeRepo({
-      sweepRunning: jest.fn(async () => {
-        throw new Error('db down');
-      }),
-    });
-    const warnSpy = jest
-      .spyOn(Logger.prototype, 'warn')
-      .mockImplementation(() => undefined);
-    const svc = new AiChatRunService(repo as never, makeEnv() as never);
-    await expect(svc.onModuleInit()).resolves.toBeUndefined();
-    // The first warn is the sweep failure (the multi-instance warn never fires
-    // single-instance), so the message is the db error.
-    expect(String(warnSpy.mock.calls[0][0])).toContain('db down');
-  });
-
-  it('F1 (DECISION C): the boot sweep is UNCONDITIONAL — sweepRunning is called with NO staleness window, so a fresh running run (updatedAt = now) is settled, not skipped', async () => {
-    // The bug: a fast restart (deploy/OOM within minutes of the last step) left a
-    // run stuck 'running' under the old 10-min window, 409ing every later turn in
-    // the chat. The fix settles ALL pending|running on boot. We assert the service
-    // invokes sweepRunning with no `staleMs` (the unconditional path); the repo's
-    // own spec proves no-window => no updatedAt filter.
-    const repo = makeRepo({ sweepRunning: jest.fn(async () => 1) });
-    jest.spyOn(Logger.prototype, 'log').mockImplementation(() => undefined);
-    const svc = new AiChatRunService(repo as never, makeEnv() as never);
-    await svc.onModuleInit();
-    expect(repo.sweepRunning).toHaveBeenCalledTimes(1);
-    const callArgs = repo.sweepRunning.mock.calls[0] as unknown[];
-    const firstArg = callArgs[0] as { staleMs?: number } | undefined;
-    // Either no opts at all, or opts without a staleMs window => unconditional.
-    expect(firstArg?.staleMs).toBeUndefined();
-  });
-
-  it('F2 (DECISION A): warns at startup that autonomousRuns is single-instance-only when a horizontally-scaled deployment (CLOUD) is detected', async () => {
-    const repo = makeRepo();
-    const warnSpy = jest
-      .spyOn(Logger.prototype, 'warn')
-      .mockImplementation(() => undefined);
-    const svc = new AiChatRunService(repo as never, makeEnv(true) as never);
-    await svc.onModuleInit();
-    const warned = warnSpy.mock.calls.some((c) =>
-      /single-instance-only/i.test(String(c[0])),
-    );
-    expect(warned).toBe(true);
-  });
-
-  it('F2: does NOT warn about multi-instance on a single-instance (CLOUD unset) deployment', async () => {
-    const repo = makeRepo();
-    const warnSpy = jest
-      .spyOn(Logger.prototype, 'warn')
-      .mockImplementation(() => undefined);
-    const svc = new AiChatRunService(repo as never, makeEnv(false) as never);
-    await svc.onModuleInit();
-    const warned = warnSpy.mock.calls.some((c) =>
-      /single-instance-only/i.test(String(c[0])),
-    );
-    expect(warned).toBe(false);
-  });
-});
-
-describe('AiChatRunService run lifecycle', () => {
-  it('beginRun inserts a running row and registers a live abort controller', async () => {
-    const repo = makeRepo();
-    const svc = new AiChatRunService(repo as never, makeEnv() as never);
-    const handle = await svc.beginRun({
-      chatId: 'chat-1',
-      workspaceId: 'ws-1',
-      userId: 'user-1',
-    });
-    expect(repo.insert).toHaveBeenCalledWith(
-      expect.objectContaining({
-        chatId: 'chat-1',
-        workspaceId: 'ws-1',
-        createdBy: 'user-1',
-        status: 'running',
-        trigger: 'user',
-      }),
-    );
-    expect(handle.runId).toBe('run-1');
-    expect(handle.signal.aborted).toBe(false);
-    expect(svc.isLocallyActive('run-1')).toBe(true);
-  });
-
-  it('beginRun REJECTS the racer: a 23505 on the one-active-per-chat index throws RunAlreadyActiveError (not swallowed) and registers no controller', async () => {
-    // The race: the controller's cheap pre-check passed for BOTH concurrent
-    // turns, so the loser's INSERT hits the partial unique index. That rejection
-    // is the authoritative gate — it must surface, not be swallowed into an
-    // untracked turn.
-    const repo = makeRepo({
-      insert: jest.fn(async () => {
-        throw uniqueViolation(ONE_ACTIVE_RUN_PER_CHAT_INDEX);
-      }),
-    });
-    const svc = new AiChatRunService(repo as never, makeEnv() as never);
-    await expect(
-      svc.beginRun({ chatId: 'chat-1', workspaceId: 'ws-1', userId: 'user-1' }),
-    ).rejects.toBeInstanceOf(RunAlreadyActiveError);
-    // No controller leaked for a rejected start.
-    expect(svc.isLocallyActive('run-1')).toBe(false);
-  });
-
-  it('beginRun does NOT mask an unrelated unique violation as already-active', async () => {
-    // A 23505 on some OTHER constraint is a real bug, not the race — it must
-    // propagate unchanged so it is never silently treated as "already active".
-    const other = uniqueViolation('ai_chat_runs_pkey');
-    const repo = makeRepo({
-      insert: jest.fn(async () => {
-        throw other;
-      }),
-    });
-    const svc = new AiChatRunService(repo as never, makeEnv() as never);
-    await expect(
-      svc.beginRun({ chatId: 'chat-1', workspaceId: 'ws-1', userId: 'user-1' }),
-    ).rejects.toBe(other);
-  });
-
-  it('beginRun propagates a non-unique insert failure unchanged', async () => {
-    const boom = new Error('connection reset');
-    const repo = makeRepo({
-      insert: jest.fn(async () => {
-        throw boom;
-      }),
-    });
-    const svc = new AiChatRunService(repo as never, makeEnv() as never);
-    await expect(
-      svc.beginRun({ chatId: 'chat-1', workspaceId: 'ws-1', userId: 'user-1' }),
-    ).rejects.toBe(boom);
-  });
-
-  it('two concurrent begins on one chat: exactly one wins, the other is rejected as already-active', async () => {
-    // Integration-style: model the DB partial unique index with a one-shot slot.
-    // The first insert claims it; the second hits a 23505 on the active index.
-    let slotTaken = false;
-    const repo = makeRepo({
-      insert: jest.fn(async (v: any) => {
-        if (slotTaken) throw uniqueViolation(ONE_ACTIVE_RUN_PER_CHAT_INDEX);
-        slotTaken = true;
-        return { id: 'run-win', status: v.status, chatId: v.chatId };
-      }),
-    });
-    const svc = new AiChatRunService(repo as never, makeEnv() as never);
-    const results = await Promise.allSettled([
-      svc.beginRun({ chatId: 'chat-1', workspaceId: 'ws-1', userId: 'user-1' }),
-      svc.beginRun({ chatId: 'chat-1', workspaceId: 'ws-1', userId: 'user-1' }),
-    ]);
-    const fulfilled = results.filter((r) => r.status === 'fulfilled');
-    const rejected = results.filter((r) => r.status === 'rejected');
-    expect(fulfilled).toHaveLength(1);
-    expect(rejected).toHaveLength(1);
-    expect((rejected[0] as PromiseRejectedResult).reason).toBeInstanceOf(
-      RunAlreadyActiveError,
-    );
-    // Exactly the winner is locally active.
-    expect(svc.isLocallyActive('run-win')).toBe(true);
-  });
-
-  it('a SUBSCRIBER detaching does NOT abort the run (only an explicit stop does)', async () => {
-    const repo = makeRepo();
-    const svc = new AiChatRunService(repo as never, makeEnv() as never);
-    const handle = await svc.beginRun({
-      chatId: 'chat-1',
-      workspaceId: 'ws-1',
-      userId: 'user-1',
-    });
-    // Model a browser disconnect: nothing in the run service is told to stop.
-    // The signal the agent loop consumes must stay un-aborted and the run stays
-    // locally active — i.e. it keeps running server-side.
-    expect(handle.signal.aborted).toBe(false);
-    expect(svc.isLocallyActive('run-1')).toBe(true);
-    // markStopRequested was never called by a mere detach.
-    expect(repo.markStopRequested).not.toHaveBeenCalled();
-  });
-
-  it('requestStop aborts the live controller, marks the row, and reports true', async () => {
-    const repo = makeRepo();
-    const svc = new AiChatRunService(repo as never, makeEnv() as never);
-    const handle = await svc.beginRun({
-      chatId: 'chat-1',
-      workspaceId: 'ws-1',
-      userId: 'user-1',
-    });
-    const aborted = jest.fn();
-    handle.signal.addEventListener('abort', aborted);
-
-    const result = await svc.requestStop('run-1', 'ws-1');
-
-    expect(result).toBe(true);
-    expect(handle.signal.aborted).toBe(true);
-    expect(aborted).toHaveBeenCalledTimes(1);
-    expect(repo.markStopRequested).toHaveBeenCalledWith('run-1', 'ws-1');
-  });
-
-  it('requestStop on a run this replica does NOT hold still marks the row (true)', async () => {
-    // e.g. after a restart, or a sibling replica owns the controller. The row is
-    // marked so the owning replica/sweep settles it; we report a stop took effect.
-    const repo = makeRepo({
-      markStopRequested: jest.fn(async () => ({ id: 'run-9' })),
-    });
-    const svc = new AiChatRunService(repo as never, makeEnv() as never);
-    const result = await svc.requestStop('run-9', 'ws-1');
-    expect(result).toBe(true);
-    expect(svc.isLocallyActive('run-9')).toBe(false);
-  });
-
-  it('requestStop still aborts the live controller when markStopRequested rejects (transient DB error)', async () => {
-    // F15: the in-memory abort is the ONLY thing that stops a run and must not be
-    // hostage to the audit write of stop_requested_at. A transient failure on
-    // markStopRequested must NOT prevent abort() nor make requestStop throw.
-    const warnSpy = jest
-      .spyOn(Logger.prototype, 'warn')
-      .mockImplementation(() => undefined);
-    const repo = makeRepo({
-      markStopRequested: jest.fn(async () => {
-        throw new Error('pool exhausted');
-      }),
-    });
-    const svc = new AiChatRunService(repo as never, makeEnv() as never);
-    const handle = await svc.beginRun({
-      chatId: 'chat-1',
-      workspaceId: 'ws-1',
-      userId: 'user-1',
-    });
-    const aborted = jest.fn();
-    handle.signal.addEventListener('abort', aborted);
-
-    // Does NOT throw despite the DB write rejecting.
-    const result = await svc.requestStop('run-1', 'ws-1');
-
-    // The live turn was aborted even though the audit write failed...
-    expect(handle.signal.aborted).toBe(true);
-    expect(aborted).toHaveBeenCalledTimes(1);
-    expect(repo.markStopRequested).toHaveBeenCalledWith('run-1', 'ws-1');
-    // ...the catch branch logged the swallowed failure...
-    expect(warnSpy).toHaveBeenCalledTimes(1);
-    // ...and a stop is reported as having taken effect (the entry existed).
-    expect(result).toBe(true);
-    warnSpy.mockRestore();
-  });
-
-  it('requestStop on an already-settled run (nothing active) reports false', async () => {
-    const repo = makeRepo({
-      markStopRequested: jest.fn(async () => undefined),
-    });
-    const svc = new AiChatRunService(repo as never, makeEnv() as never);
-    const result = await svc.requestStop('run-done', 'ws-1');
-    expect(result).toBe(false);
-  });
-
-  it('finalizeRun settles the row to the mapped status with finishedAt and drops the in-memory entry', async () => {
-    const repo = makeRepo();
-    const svc = new AiChatRunService(repo as never, makeEnv() as never);
-    await svc.beginRun({
-      chatId: 'chat-1',
-      workspaceId: 'ws-1',
-      userId: 'user-1',
-    });
-    expect(svc.isLocallyActive('run-1')).toBe(true);
-
-    await svc.finalizeRun('run-1', 'ws-1', 'error', 'provider blew up');
-
-    expect(svc.isLocallyActive('run-1')).toBe(false);
-    expect(repo.update).toHaveBeenCalledWith(
-      'run-1',
-      'ws-1',
-      expect.objectContaining({
-        status: 'failed',
-        error: 'provider blew up',
-        finishedAt: expect.any(Date),
-      }),
-    );
-  });
-
-  it('finalizeRun is IDEMPOTENT: a second settle no-ops (single terminal write)', async () => {
-    // The #184 review fix: AiChatService.stream wraps the turn in a safety-net
-    // catch that settles a failed turn AND streamText's terminal callback may
-    // also settle — both routes call finalizeRun. Only the FIRST may write the
-    // terminal row; the second must no-op so a late settle can never clobber the
-    // real terminal status or double-write the row.
-    const repo = makeRepo();
-    const svc = new AiChatRunService(repo as never, makeEnv() as never);
-    await svc.beginRun({
-      chatId: 'chat-1',
-      workspaceId: 'ws-1',
-      userId: 'user-1',
-    });
-
-    await svc.finalizeRun('run-1', 'ws-1', 'error', 'first');
-    expect(svc.isLocallyActive('run-1')).toBe(false);
-    // A second settle (e.g. a streamText callback firing after the catch) no-ops.
-    await svc.finalizeRun('run-1', 'ws-1', 'completed', undefined);
-
-    expect(repo.update).toHaveBeenCalledTimes(1);
-    expect(repo.update).toHaveBeenCalledWith(
-      'run-1',
-      'ws-1',
-      expect.objectContaining({ status: 'failed', error: 'first' }),
-    );
-  });
-
-  it('CONCURRENCY: two simultaneous finalizeRun on the same run write the terminal row EXACTLY ONCE (the 2nd caller exits synchronously at the atomic claim)', async () => {
-    // The CRITICAL race: AiChatService.stream's safety-net catch settles the turn
-    // to 'error' while a streamText terminal callback also settles it — both call
-    // finalizeRun for the SAME runId. The once-gate must close ATOMICALLY: a
-    // `settled.has` check alone is read BEFORE the awaited UPDATE, so both callers
-    // would pass it and BOTH write the row (last-write-wins clobber + double
-    // write). The fix claims the run with a SYNCHRONOUS `active.delete` before any
-    // await, so the second caller returns in the same tick, before the UPDATE.
-    //
-    // We force the two calls to overlap by making `update` return a promise we
-    // resolve only AFTER both finalizeRun calls have run their synchronous bodies.
-    let resolveUpdate!: (v: unknown) => void;
-    const updateGate = new Promise((res) => {
-      resolveUpdate = res;
-    });
-    const update = jest.fn(() => updateGate);
-    const repo = makeRepo({ update });
-    const svc = new AiChatRunService(repo as never, makeEnv() as never);
-    await svc.beginRun({
-      chatId: 'chat-1',
-      workspaceId: 'ws-1',
-      userId: 'user-1',
-    });
-
-    // Fire both before the (pending) update resolves. The first synchronously
-    // claims the entry (active.delete) and awaits update; the second, started in
-    // the same macrotask, finds the entry already gone and returns at the claim
-    // WITHOUT ever calling update.
-    const p1 = svc.finalizeRun('run-1', 'ws-1', 'completed');
-    const p2 = svc.finalizeRun('run-1', 'ws-1', 'error', 'safety-net');
-
-    // The decisive assertion: exactly one caller reached the terminal UPDATE.
-    expect(update).toHaveBeenCalledTimes(1);
-
-    // Let the single in-flight update land; both calls resolve cleanly.
-    resolveUpdate({ id: 'run-1' });
-    await Promise.all([p1, p2]);
-
-    expect(update).toHaveBeenCalledTimes(1);
-    // The winner is the FIRST caller ('completed' -> 'succeeded'); the late
-    // 'error' settle never wrote, so it could not clobber the real status.
-    expect(update).toHaveBeenCalledWith(
-      'run-1',
-      'ws-1',
-      expect.objectContaining({ status: 'succeeded' }),
-    );
-    expect(svc.isLocallyActive('run-1')).toBe(false);
-  });
-
-  it('F6: a TRANSIENT terminal-write failure is ridden out by the bounded retry — the run is settled, not stranded', async () => {
-    // The bug: finalizeRun used to DROP the in-memory entry BEFORE the terminal
-    // UPDATE, then only warn-log a failure. A single transient blip (pool
-    // exhaustion / deadlock / connection hiccup) on that PK UPDATE left the row
-    // 'running' with nothing left to recover it -> every later turn in that chat
-    // 409s until a restart. The fix updates FIRST and retries.
-    let calls = 0;
-    const repo = makeRepo({
-      update: jest.fn(async () => {
-        calls += 1;
-        if (calls === 1) throw new Error('deadlock detected');
-        return { id: 'run-1' };
-      }),
-    });
-    jest.spyOn(Logger.prototype, 'warn').mockImplementation(() => undefined);
-    const svc = new AiChatRunService(repo as never, makeEnv() as never);
-    await svc.beginRun({
-      chatId: 'chat-1',
-      workspaceId: 'ws-1',
-      userId: 'user-1',
-    });
-
-    await svc.finalizeRun('run-1', 'ws-1', 'completed');
-
-    // The retry landed the terminal write: the entry is dropped (slot freed) and
-    // the row carries the real terminal status — NOT stranded at 'running'.
-    expect(svc.isLocallyActive('run-1')).toBe(false);
-    expect(repo.update).toHaveBeenCalledTimes(2);
-    expect(repo.update).toHaveBeenLastCalledWith(
-      'run-1',
-      'ws-1',
-      expect.objectContaining({ status: 'succeeded' }),
-    );
-  });
-
-  it('F6: if the terminal write keeps failing, the entry is RETAINED and a LATER settle completes it (chat not permanently 409d)', async () => {
-    // Worst case: the DB is down for the whole first finalize (all attempts fail).
-    // The run must NOT be silently lost — the entry stays so a subsequent settle
-    // (a streamText callback, requestStop -> onAbort, or a future sweep) can retry.
-    let healthy = false;
-    const repo = makeRepo({
-      update: jest.fn(async () => {
-        if (!healthy) throw new Error('pool exhausted');
-        return { id: 'run-1' };
-      }),
-    });
-    jest.spyOn(Logger.prototype, 'warn').mockImplementation(() => undefined);
-    const errorSpy = jest
-      .spyOn(Logger.prototype, 'error')
-      .mockImplementation(() => undefined);
-    const svc = new AiChatRunService(repo as never, makeEnv() as never);
-    await svc.beginRun({
-      chatId: 'chat-1',
-      workspaceId: 'ws-1',
-      userId: 'user-1',
-    });
-
-    // First settle: every bounded attempt fails -> entry retained, NOT settled.
-    await svc.finalizeRun('run-1', 'ws-1', 'completed');
-    expect(svc.isLocallyActive('run-1')).toBe(true);
-    // F12: the give-up emits ONE explicit, greppable ERROR (run + chat context)
-    // so an operator can tell "gave up, run held in memory" from a per-attempt
-    // blip — distinct from the per-attempt warns.
-    const gaveUp = errorSpy.mock.calls.some(
-      (c) =>
-        /NON-TERMINAL/.test(String(c[0])) &&
-        /run-1/.test(String(c[0])) &&
-        /chat-1/.test(String(c[0])),
-    );
-    expect(gaveUp).toBe(true);
-
-    // The DB recovers; a later settle now succeeds and frees the slot.
-    healthy = true;
-    await svc.finalizeRun('run-1', 'ws-1', 'completed');
-    expect(svc.isLocallyActive('run-1')).toBe(false);
-    expect(repo.update).toHaveBeenLastCalledWith(
-      'run-1',
-      'ws-1',
-      expect.objectContaining({ status: 'succeeded' }),
-    );
-
-    // And it is now idempotent: a further settle no-ops (terminal row already
-    // written), so a double-settle can never clobber the real status.
-    const callsBefore = repo.update.mock.calls.length;
-    await svc.finalizeRun('run-1', 'ws-1', 'error', 'late');
-    expect(repo.update).toHaveBeenCalledTimes(callsBefore);
-  });
-
-  it('recordStep / linkAssistantMessage are best-effort: a repo failure is swallowed', async () => {
-    const repo = makeRepo({
-      update: jest.fn(async () => {
-        throw new Error('transient');
-      }),
-    });
-    jest.spyOn(Logger.prototype, 'warn').mockImplementation(() => undefined);
-    const svc = new AiChatRunService(repo as never, makeEnv() as never);
-    await expect(svc.recordStep('run-1', 'ws-1', 3)).resolves.toBeUndefined();
-    await expect(
-      svc.linkAssistantMessage('run-1', 'ws-1', 'msg-1'),
-    ).resolves.toBeUndefined();
-  });
-});

apps/server/src/core/ai-chat/ai-chat-run.service.ts

@@ -1,452 +0,0 @@
-import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
-import { AiChatRunRepo } from '@docmost/db/repos/ai-chat/ai-chat-run.repo';
-import { AiChatRun } from '@docmost/db/types/entity.types';
-import { isUniqueViolation, violatedConstraint } from '@docmost/db/utils';
-import { EnvironmentService } from '../../integrations/environment/environment.service';
-
-/** Name of the partial unique index enforcing "one active run per chat" (see the
- *  ai_chat_runs migration). A 23505 on THIS constraint is the race-safe signal
- *  that a concurrent turn already owns the chat — distinct from any other unique
- *  collision, which must NOT be silently treated as "already active". */
-export const ONE_ACTIVE_RUN_PER_CHAT_INDEX = 'ai_chat_runs_one_active_per_chat';
-
-/**
- * Thrown by {@link AiChatRunService.beginRun} when the run-row INSERT loses the
- * race for a chat's single active slot (the partial unique index rejects it with
- * a 23505). This is the AUTHORITATIVE concurrency gate: the controller's cheap
- * pre-check is only a fast-path, and a request that slips past it must NOT run
- * untracked. The caller (AiChatService.stream) translates this into a 409 and
- * aborts the turn BEFORE any AI/provider call.
- */
-export class RunAlreadyActiveError extends Error {
-  constructor(public readonly chatId: string) {
-    super(`An agent run is already in progress for chat ${chatId}`);
-    this.name = 'RunAlreadyActiveError';
-  }
-}
-
-/**
- * The terminal status of a TURN (the #183 assistant-row lifecycle) maps onto the
- * terminal status of a RUN (#184). A turn that completed -> the run succeeded; a
- * turn that errored -> the run failed; a turn aborted (explicit user stop) -> the
- * run aborted. Pure + unit-testable.
- */
-export type TurnTerminalStatus = 'completed' | 'error' | 'aborted';
-export type RunTerminalStatus = 'succeeded' | 'failed' | 'aborted';
-
-export function mapTurnStatusToRun(
-  status: TurnTerminalStatus,
-): RunTerminalStatus {
-  switch (status) {
-    case 'completed':
-      return 'succeeded';
-    case 'error':
-      return 'failed';
-    case 'aborted':
-      return 'aborted';
-  }
-}
-
-/** An in-flight run held in process memory: its AbortController is the ONLY thing
- *  that can stop the turn (an explicit user stop), independent of the browser
- *  socket. A mere disconnect never touches it, so the run keeps going. */
-interface ActiveRun {
-  controller: AbortController;
-  chatId: string;
-  workspaceId: string;
-}
-
-/** The live handle the streaming path drives a run through (returned by
- *  {@link AiChatRunService.beginRun}). The `signal` governs the agent loop's
- *  abort — wired to the run, NOT to the HTTP socket. */
-export interface RunHandle {
-  runId: string;
-  signal: AbortSignal;
-}
-
-/**
- * AiChatRunService (#184 phase 1) — owns the agent RUN as a first-class,
- * server-side lifecycle object detached from the HTTP request / browser window.
- *
- * Responsibilities:
- *  - create a run row when a turn starts (inserted directly as 'running'; the
- *    'pending' status is only the column default + a reserved value, never
- *    written by code in phase 1) and register an in-memory AbortController for it
- *    (the explicit-stop lever);
- *  - finalize the run row (succeeded / failed / aborted) and unregister it;
- *  - service an EXPLICIT user stop (`requestStop`) — the ONLY thing that aborts a
- *    run; a browser disconnect deliberately does NOT;
- *  - crash-recovery sweep of dangling runs on startup.
- *
- * The agent loop itself still runs in AiChatService.stream (reusing #183's
- * step-granular durable write path, `consumeStream` already drains it independent
- * of the socket); this service only wraps it in a durable lifecycle and an
- * abort handle that outlives the subscriber.
- */
-@Injectable()
-export class AiChatRunService implements OnModuleInit {
-  private readonly logger = new Logger(AiChatRunService.name);
-
-  // runId -> ActiveRun. Process-local on purpose (phase 1 is single-process /
-  // in-memory transport; a cross-process BullMQ runner + Redis stop-signal is
-  // deferred to phase 2). A stop for a runId not in this map (e.g. after a
-  // restart) still records `stop_requested_at` on the row.
-  private readonly active = new Map<string, ActiveRun>();
-
-  // runIds whose TERMINAL row write has SUCCEEDED — the idempotency once-gate
-  // (F6). A finalize must short-circuit only AFTER the terminal write has landed,
-  // NOT merely after the in-memory entry was dropped: a transient UPDATE failure
-  // has to stay retryable, so "already settled" means "row already terminal", not
-  // "entry already gone". Grows by one short UUID per finished run over process
-  // uptime — negligible in phase 1's single process.
-  private readonly settled = new Set<string>();
-
-  // Bounded retry for the terminal write (F6): a single PK UPDATE can fail
-  // transiently under many fire-and-forget writes (pool exhaustion, deadlock, a
-  // brief connection blip). Riding out that blip in-place matters because the
-  // dominant success path (streamText onFinish) settles exactly ONCE — if that
-  // write is dropped and never retried, the row is stranded 'running' and the
-  // one-active-run gate 409s every future turn in the chat until a restart (no
-  // periodic sweep in phase 1).
-  private static readonly FINALIZE_MAX_ATTEMPTS = 3;
-  private static readonly FINALIZE_RETRY_BASE_MS = 50;
-
-  constructor(
-    private readonly runRepo: AiChatRunRepo,
-    private readonly environment: EnvironmentService,
-  ) {}
-
-  /**
-   * Crash-recovery sweep on server start: settle EVERY run still left
-   * pending/running to 'aborted' (F1 / DECISION C). The boot sweep is
-   * UNCONDITIONAL — no staleness window — because phase 1 is single-process: on a
-   * fresh boot any pending|running run is definitionally hung (no live runner owns
-   * it), so even a fast restart (deploy/OOM within minutes of the last step) can
-   * no longer leave a run stuck 'running' forever (which would make the
-   * one-active-run gate 409 every future turn in that chat). The staleness window
-   * is reintroduced only for the phase-2 multi-instance timer sweep, where a
-   * booting replica must not abort a run another replica is actively executing.
-   * Best-effort — a sweep failure is logged but MUST NOT block startup (mirrors
-   * AiChatService.onModuleInit for #183).
-   */
-  async onModuleInit(): Promise<void> {
-    this.warnIfMultiInstance();
-    try {
-      // No `staleMs`: unconditional boot sweep (F1). See AiChatRunRepo.sweepRunning.
-      const swept = await this.runRepo.sweepRunning();
-      if (swept > 0) {
-        this.logger.log(
-          `Startup sweep: marked ${swept} dangling agent run(s) as 'aborted'.`,
-        );
-      }
-    } catch (err) {
-      this.logger.warn(
-        `Startup sweep of dangling runs failed: ${
-          err instanceof Error ? err.message : 'unknown error'
-        }`,
-      );
-    }
-  }
-
-  /**
-   * F2 (DECISION A): autonomous runs are SINGLE-INSTANCE-ONLY in phase 1. An
-   * explicit Stop, and the in-memory AbortController that backs it, are
-   * process-local: a Stop only aborts the live turn if it lands on the SAME
-   * replica that owns the run (it still stamps `stop_requested_at` cross-instance,
-   * but nothing reads that flag during an active run yet). Cross-instance pub/sub
-   * stop is phase 2. So if the deployment is horizontally scaled, warn loudly at
-   * startup that a Stop may not reach a run executing on another replica.
-   *
-   * DETECTION: this codebase always wires the socket.io Redis adapter (REDIS_URL
-   * is mandatory), so the adapter alone is NOT a horizontal-scaling signal. The
-   * authoritative signal the codebase has is `CLOUD=true` (EnvironmentService
-   * .isCloud()), the Docmost-cloud multi-replica deployment. We warn whenever that
-   * is set, because any workspace could enable settings.ai.autonomousRuns. A
-   * self-hosted operator running multiple replicas behind a load balancer is also
-   * multi-instance; the deploy docs (.env.example / AGENTS.md) spell out the
-   * single-instance constraint for that case.
-   */
-  private warnIfMultiInstance(): void {
-    if (this.environment.isCloud()) {
-      this.logger.warn(
-        'Autonomous agent runs (settings.ai.autonomousRuns) are SINGLE-INSTANCE-ONLY ' +
-          'in phase 1: a horizontally-scaled deployment was detected (CLOUD=true). ' +
-          'An explicit Stop only aborts a run executing on the same replica that owns ' +
-          'it (cross-instance Stop is not yet reliable — phase 2). Run a single ' +
-          'instance if you enable autonomousRuns, or keep the flag off.',
-      );
-    }
-  }
-
-  /**
-   * Start a run for a turn: insert the run row (status 'running', startedAt now),
-   * register a fresh AbortController for it, and return a {@link RunHandle} whose
-   * `signal` the agent loop uses. The DB partial unique index guarantees at most
-   * one active run per chat — a second concurrent start on the same chat REJECTS
-   * at the insert (a 23505 on {@link ONE_ACTIVE_RUN_PER_CHAT_INDEX}). That
-   * rejection is the AUTHORITATIVE race gate: it is surfaced as a distinct
-   * {@link RunAlreadyActiveError} (NOT swallowed), so the caller turns it into a
-   * 409 and never streams an untracked turn. The controller is registered AFTER a
-   * successful insert so a rejected start leaks nothing.
-   */
-  async beginRun(args: {
-    chatId: string;
-    workspaceId: string;
-    userId: string;
-    trigger?: string;
-  }): Promise<RunHandle> {
-    let run: AiChatRun;
-    try {
-      run = await this.runRepo.insert({
-        chatId: args.chatId,
-        workspaceId: args.workspaceId,
-        createdBy: args.userId,
-        trigger: args.trigger ?? 'user',
-        status: 'running',
-        startedAt: new Date(),
-      });
-    } catch (err) {
-      // The race backstop: a concurrent turn already holds this chat's single
-      // active slot, so the partial unique index rejected our insert. Surface a
-      // distinct signal — the caller MUST reject this turn (409), not run it
-      // untracked. Any OTHER error propagates unchanged.
-      if (
-        isUniqueViolation(err) &&
-        violatedConstraint(err) === ONE_ACTIVE_RUN_PER_CHAT_INDEX
-      ) {
-        throw new RunAlreadyActiveError(args.chatId);
-      }
-      throw err;
-    }
-    const controller = new AbortController();
-    this.active.set(run.id, {
-      controller,
-      chatId: args.chatId,
-      workspaceId: args.workspaceId,
-    });
-    return { runId: run.id, signal: controller.signal };
-  }
-
-  /** Link the assistant message (the #183 projection) to its run. Best-effort. */
-  async linkAssistantMessage(
-    runId: string,
-    workspaceId: string,
-    assistantMessageId: string,
-  ): Promise<void> {
-    try {
-      await this.runRepo.update(runId, workspaceId, { assistantMessageId });
-    } catch (err) {
-      this.logger.warn(
-        `Failed to link assistant message to run ${runId}: ${
-          err instanceof Error ? err.message : 'unknown error'
-        }`,
-      );
-    }
-  }
-
-  /** Persist progress: bump the run's finished-step count. Best-effort (never
-   *  blocks or breaks the stream). */
-  async recordStep(
-    runId: string,
-    workspaceId: string,
-    stepCount: number,
-  ): Promise<void> {
-    try {
-      await this.runRepo.update(runId, workspaceId, { stepCount });
-    } catch (err) {
-      this.logger.warn(
-        `Failed to record step for run ${runId}: ${
-          err instanceof Error ? err.message : 'unknown error'
-        }`,
-      );
-    }
-  }
-
-  /**
-   * Finalize a run to its terminal status (succeeded / failed / aborted),
-   * stamping finishedAt + any error. Best-effort, but ROBUST against a transient
-   * terminal-write failure (F6) AND atomically safe against a concurrent settle.
-   *
-   * ATOMIC ONCE-CLAIM (the gate must close in ONE synchronous tick): two
-   * finalizeRun calls for the SAME run can race — the documented real path is
-   * AiChatService.stream's safety-net catch settling the turn to 'error' while a
-   * streamText terminal callback (onFinish/onAbort/onError) ALSO settles it. The
-   * `settled.has` check alone is NOT a gate: it is read BEFORE the awaited UPDATE,
-   * so two callers can both see `false` and both write the row (last-write-wins
-   * clobbers the real terminal status, and the bounded retry only widens that
-   * window). The claim therefore happens via `active.delete`, a SYNCHRONOUS
-   * check-and-clear with NO await between the gate and the entry removal: the
-   * second concurrent caller finds the entry already gone and returns in the same
-   * tick, before any UPDATE. The transition "nobody is finalizing" -> "I am
-   * finalizing" is thus a single atomic step.
-   *
-   * ORDER MATTERS (F6): once we own the claim, the terminal UPDATE happens FIRST;
-   * only once it SUCCEEDS do we record the run as settled. If the UPDATE fails on
-   * every bounded attempt we RESTORE the in-memory entry, leave the run UNsettled,
-   * and emit an ERROR signal that the row is left non-terminal 'running' (which
-   * would 409 every future turn in the chat until recovery). An in-process retry
-   * by a LATER settle is only POSSIBLE, never guaranteed: it needs (a) the entry
-   * to have been restored at the give-up path AND (b) a fresh settler to arrive
-   * AFTER that restore. A concurrent settler that arrives DURING the retry window
-   * — while the entry is deleted for backoff and not yet restored — is consumed at
-   * the synchronous `active.delete` claim (it finds nothing to delete and returns
-   * a no-op), so it does NOT become an in-process retrier. The NO-streamText path
-   * (the turn threw before streamText was wired, so ONLY the safety-net ever
-   * settles) likewise has no second in-process settler at all. The UNCONDITIONAL
-   * backstop in every case is the boot sweep on the next restart (phase 1 has no
-   * periodic in-process sweep); the retained entry is bounded (cleared on restart)
-   * and harmless meanwhile.
-   *
-   * IDEMPOTENT on SUCCESS (#184 review): the terminal write happens AT MOST ONCE
-   * per run. After a successful write the once-gate keys off {@link settled} (the
-   * terminal row already written) so a settle arriving AFTER the entry was already
-   * dropped-and-settled returns early; a settle racing the in-flight write is
-   * stopped earlier still, by the `active.delete` claim. Either way a genuine
-   * double-settle collapses to a single write and a late settle can never clobber
-   * the real terminal status or double-write the row.
-   */
-  async finalizeRun(
-    runId: string,
-    workspaceId: string,
-    turnStatus: TurnTerminalStatus,
-    error?: string,
-  ): Promise<void> {
-    // ---- Atomic once-claim (synchronous; NO await before the gate closes) ----
-    // Already terminally written -> idempotent no-op.
-    if (this.settled.has(runId)) return;
-    // Capture the entry BEFORE the delete so a total-failure path can restore it.
-    const entry = this.active.get(runId);
-    // SYNCHRONOUS check-and-clear: the FIRST caller deletes (claims) the entry;
-    // any concurrent SECOND caller finds nothing to delete and returns HERE, in
-    // the same tick, before any await — so it can never reach the UPDATE.
-    if (!this.active.delete(runId)) return;
-
-    let lastError: unknown;
-    for (
-      let attempt = 1;
-      attempt <= AiChatRunService.FINALIZE_MAX_ATTEMPTS;
-      attempt++
-    ) {
-      try {
-        await this.runRepo.update(runId, workspaceId, {
-          status: mapTurnStatusToRun(turnStatus),
-          finishedAt: new Date(),
-          error: error ?? null,
-        });
-        // Terminal write landed: arm the once-gate. The entry is already gone
-        // (claimed above); we do NOT restore it. The slot is now free.
-        this.settled.add(runId);
-        return;
-      } catch (err) {
-        lastError = err;
-        this.logger.warn(
-          `Failed to finalize run ${runId} (attempt ${attempt}/${
-            AiChatRunService.FINALIZE_MAX_ATTEMPTS
-          }): ${err instanceof Error ? err.message : 'unknown error'}`,
-        );
-        if (attempt < AiChatRunService.FINALIZE_MAX_ATTEMPTS) {
-          await this.delay(AiChatRunService.FINALIZE_RETRY_BASE_MS * attempt);
-        }
-      }
-    }
-    // Every attempt failed: this is a give-up, materially worse than a per-attempt
-    // blip — the row is left NON-TERMINAL ('running'), so emit ONE explicit,
-    // greppable ERROR so an operator can tell "survived a blip" from "gave up, run
-    // held in memory until recovery" (the last warn alone says only "attempt 3/3").
-    this.logger.error(
-      `Run ${runId} (chat ${entry?.chatId ?? 'unknown'}) left NON-TERMINAL ` +
-        `('running'): terminal write failed after ${
-          AiChatRunService.FINALIZE_MAX_ATTEMPTS
-        } attempts; entry retained in memory, recovery deferred to next settle / ` +
-        `boot sweep`,
-      lastError,
-    );
-    // RESTORE the claimed entry (and leave the run UNsettled) so a LATER settle
-    // that arrives AFTER this restore MAY retry the terminal write — but that
-    // in-process retry is NOT guaranteed (a concurrent settler caught in the retry
-    // window above is consumed at the `active.delete` claim, and the no-streamText
-    // path has no second settler at all). The UNCONDITIONAL backstop in every case
-    // is the boot sweep on the next restart; the restored entry is bounded and
-    // cleared on restart.
-    if (entry) this.active.set(runId, entry);
-  }
-
-  /** Small async backoff between terminal-write retries (F6). Isolated so it is
-   *  trivial to stub/fake-time in tests. */
-  private delay(ms: number): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-
-  /**
-   * Request an EXPLICIT stop of a run (the user pressed Stop). This is the ONLY
-   * thing that aborts a run — distinct from a browser disconnect, which leaves
-   * the run going. Aborts the in-process controller FIRST (the only thing that
-   * actually stops the run, if this replica owns it), then makes a best-effort
-   * attempt to stamp `stop_requested_at` — that audit write stamps only while the
-   * row is active and may be skipped on a DB error or lost to the finalize race,
-   * which is acceptable since the row still settles as 'aborted'. Returns true
-   * when a stop took effect (row marked and/or controller aborted), false when
-   * there was nothing active to stop.
-   */
-  async requestStop(runId: string, workspaceId: string): Promise<boolean> {
-    const entry = this.active.get(runId);
-    if (entry) {
-      // Abort the live turn FIRST -> streamText onAbort fires -> the partial is
-      // persisted (#183) and finalizeRun settles the row as 'aborted'. This is
-      // the ONLY thing that aborts a run, so it MUST NOT be hostage to the audit
-      // write below: a transient failure on `markStopRequested` (pool exhaustion,
-      // deadlock, dropped connection) must never leave the run executing despite
-      // an explicit Stop. At worst only the `stop_requested_at` timestamp is lost.
-      entry.controller.abort();
-    }
-    // Record `stop_requested_at` (best-effort). A transient DB failure here is
-    // logged and treated as `marked = false`; the abort above already took
-    // effect, so we never rethrow and skip stopping the run. Note: because
-    // markStopRequested only stamps while the row is active, aborting first means
-    // even a healthy write can lose the race against the resulting finalize and
-    // skip the stamp — acceptable, as the row still settles as 'aborted' and only
-    // this audit timestamp may be lost.
-    let marked: unknown;
-    try {
-      marked = await this.runRepo.markStopRequested(runId, workspaceId);
-    } catch (err) {
-      marked = undefined;
-      this.logger.warn(
-        `requestStop: markStopRequested failed for run ${runId} ` +
-          `(stop_requested_at not recorded); abort already issued: ` +
-          `${err instanceof Error ? err.message : String(err)}`,
-      );
-    }
-    return Boolean(marked) || Boolean(entry);
-  }
-
-  /** Latest persisted run for a chat — the reconnect target (an in-flight or
-   *  finished run). Pure read-through to the repo. */
-  getLatestForChat(
-    chatId: string,
-    workspaceId: string,
-  ): Promise<AiChatRun | undefined> {
-    return this.runRepo.findLatestByChat(chatId, workspaceId);
-  }
-
-  /** Fetch a run by id (workspace-scoped). Used to resolve + ownership-check an
-   *  explicit stop targeting a runId. */
-  getRun(runId: string, workspaceId: string): Promise<AiChatRun | undefined> {
-    return this.runRepo.findById(runId, workspaceId);
-  }
-
-  /** The active run on a chat, if any (used to reject a concurrent start with a
-   *  clean 409 before committing to the stream). */
-  getActiveForChat(
-    chatId: string,
-    workspaceId: string,
-  ): Promise<AiChatRun | undefined> {
-    return this.runRepo.findActiveByChat(chatId, workspaceId);
-  }
-
-  /** Test/diagnostic seam: whether this replica is holding a live controller for
-   *  the run. */
-  isLocallyActive(runId: string): boolean {
-    return this.active.has(runId);
-  }
-}

apps/server/src/core/ai-chat/ai-chat.controller.bound-chat.spec.ts

@@ -2,92 +2,43 @@ import { AiChatController } from './ai-chat.controller';
 import type { User, Workspace } from '@docmost/db/types/entity.types';
 
 /**
- * Wiring spec for the #191 `POST /ai-chat/bound-chat` endpoint, hardened for
+ * Wiring spec for the #191 `POST /ai-chat/bound-chat` endpoint. It must forward
- * #312. `dto.pageId` carries either a page slugId (10-char nanoid, off a slug
+ * the requesting user + workspace + pageId to findLatestByPage and return the
- * URL) or a page uuid, so the controller must FIRST resolve it to a real page
+ * matched chat's id, or `{ chatId: null }` when there is none. The repo already
- * uuid via PageRepo.findById (which accepts both) — passing the raw slugId into
+ * scopes to the caller's OWN chats, so a foreign pageId simply yields no match
- * the uuid ai_chats.page_id column caused a Postgres 22P02 500. Only then is the
+ * (null) — no extra page-access check is needed. Exercised with hand-rolled
- * caller's most-recent OWN chat for that page looked up (by the resolved uuid),
+ * mocks, no Nest graph and no DB.
- * and a page in a different workspace (or an unknown id) yields { chatId: null }
- * without ever touching the chat lookup. Exercised with hand-rolled mocks, no
- * Nest graph and no DB.
  */
 describe('AiChatController.boundChat', () => {
   const user = { id: 'u1' } as User;
   const workspace = { id: 'ws1' } as Workspace;
 
-  function makeController(opts: { page: unknown; chat?: unknown }) {
+  function makeController(chat: unknown) {
     const aiChatRepo = {
-      findLatestByPage: jest.fn().mockResolvedValue(opts.chat),
+      findLatestByPage: jest.fn().mockResolvedValue(chat),
-    };
-    const pageRepo = {
-      findById: jest.fn().mockResolvedValue(opts.page),
     };
     const controller = new AiChatController(
       {} as never,
-      {} as never, // aiChatRunService
       aiChatRepo as never,
       {} as never,
       {} as never,
-      pageRepo as never,
     );
-    return { controller, aiChatRepo, pageRepo };
+    return { controller, aiChatRepo };
   }
 
-  it('resolves a slugId to the page uuid and returns the owned chat id', async () => {
+  it('returns the owned chat id and scopes the lookup to user + workspace + page', async () => {
-    const { controller, aiChatRepo, pageRepo } = makeController({
+    const { controller, aiChatRepo } = makeController({
-      // findById accepts a slugId and returns the page with its real uuid.
+      id: 'c1',
-      page: { id: 'page-uuid-1', workspaceId: 'ws1' },
+      creatorId: 'u1',
-      chat: { id: 'c1', creatorId: 'u1' },
     });
-    // The client sends a 10-char nanoid slugId, NOT a uuid.
+    const res = await controller.boundChat({ pageId: 'p1' }, user, workspace);
-    const res = await controller.boundChat(
+    expect(aiChatRepo.findLatestByPage).toHaveBeenCalledWith('u1', 'ws1', 'p1');
-      { pageId: 'i82qXsivsx' },
-      user,
-      workspace,
-    );
-    expect(pageRepo.findById).toHaveBeenCalledWith('i82qXsivsx');
-    // findLatestByPage must receive the RESOLVED uuid, never the raw slugId.
-    expect(aiChatRepo.findLatestByPage).toHaveBeenCalledWith(
-      'u1',
-      'ws1',
-      'page-uuid-1',
-    );
     expect(res).toEqual({ chatId: 'c1' });
   });
 
-  it('returns { chatId: null } for a page in a DIFFERENT workspace without a chat lookup', async () => {
+  it('returns { chatId: null } for a page with no owned chat (incl. foreign pageId)', async () => {
-    const { controller, aiChatRepo, pageRepo } = makeController({
+    const { controller } = makeController(undefined);
-      page: { id: 'page-uuid-2', workspaceId: 'other-ws' },
+    const res = await controller.boundChat({ pageId: 'foreign' }, user, workspace);
-    });
-    const res = await controller.boundChat(
-      { pageId: 'foreignSlug' },
-      user,
-      workspace,
-    );
-    expect(pageRepo.findById).toHaveBeenCalledWith('foreignSlug');
-    // No cross-workspace leak: the chat lookup must never run.
-    expect(aiChatRepo.findLatestByPage).not.toHaveBeenCalled();
-    expect(res).toEqual({ chatId: null });
-  });
-
-  it('returns { chatId: null } for an unknown id without throwing or looking up a chat', async () => {
-    const { controller, aiChatRepo } = makeController({ page: undefined });
-    const res = await controller.boundChat(
-      { pageId: 'does-not-exist' },
-      user,
-      workspace,
-    );
-    expect(aiChatRepo.findLatestByPage).not.toHaveBeenCalled();
-    expect(res).toEqual({ chatId: null });
-  });
-
-  it('returns { chatId: null } when the resolved page has no owned chat', async () => {
-    const { controller } = makeController({
-      page: { id: 'page-uuid-3', workspaceId: 'ws1' },
-      chat: undefined,
-    });
-    const res = await controller.boundChat({ pageId: 'p3' }, user, workspace);
     expect(res).toEqual({ chatId: null });
   });
 });

apps/server/src/core/ai-chat/ai-chat.controller.export.spec.ts

@@ -53,11 +53,9 @@ describe('AiChatController.export', () => {
     };
     const controller = new AiChatController(
       {} as never,
-      {} as never, // aiChatRunService
       aiChatRepo as never,
       aiChatMessageRepo as never,
       {} as never,
-      {} as never,
     );
     return { controller, aiChatRepo, aiChatMessageRepo };
   }

apps/server/src/core/ai-chat/ai-chat.controller.run.spec.ts

@@ -1,164 +0,0 @@
-import { BadRequestException, ForbiddenException } from '@nestjs/common';
-import { AiChatController } from './ai-chat.controller';
-import type { User, Workspace } from '@docmost/db/types/entity.types';
-
-/**
- * Wiring spec for the #184 run-reconnect / run-stop endpoints
- * (`POST /ai-chat/run` and `POST /ai-chat/stop`). Both are OWNER-gated via
- * assertOwnedChat (the requesting user must own the chat) and NOT flag-gated.
- * Exercised with hand-rolled mocks — no Nest graph, no DB. The controller's
- * constructor order is (aiChatService, aiChatRunService, aiChatRepo,
- * aiChatMessageRepo, aiTranscription).
- */
-describe('AiChatController run endpoints (#184)', () => {
-  const user = { id: 'u1' } as User;
-  const workspace = { id: 'ws1' } as Workspace;
-
-  function makeController(opts: {
-    chat?: unknown; // what aiChatRepo.findById returns (owner-gate)
-    run?: unknown; // getLatestForChat / getRun result
-    activeRun?: unknown; // getActiveForChat result
-    message?: unknown; // aiChatMessageRepo.findById result
-    stopped?: boolean; // requestStop result
-  }) {
-    const aiChatRunService = {
-      getLatestForChat: jest.fn().mockResolvedValue(opts.run),
-      getRun: jest.fn().mockResolvedValue(opts.run),
-      getActiveForChat: jest.fn().mockResolvedValue(opts.activeRun),
-      requestStop: jest.fn().mockResolvedValue(opts.stopped ?? false),
-    };
-    const aiChatRepo = {
-      findById: jest.fn().mockResolvedValue(opts.chat),
-    };
-    const aiChatMessageRepo = {
-      findById: jest.fn().mockResolvedValue(opts.message),
-    };
-    const controller = new AiChatController(
-      {} as never, // aiChatService
-      aiChatRunService as never,
-      aiChatRepo as never,
-      aiChatMessageRepo as never,
-      {} as never, // aiTranscription
-      {} as never, // pageRepo
-    );
-    return { controller, aiChatRunService, aiChatRepo, aiChatMessageRepo };
-  }
-
-  describe('POST /ai-chat/run (getRun)', () => {
-    it('owner-gates: a chat the user does not own throws ForbiddenException', async () => {
-      const { controller, aiChatRunService } = makeController({
-        chat: { id: 'c1', creatorId: 'someone-else' },
-      });
-      await expect(
-        controller.getRun({ chatId: 'c1' }, user, workspace),
-      ).rejects.toBeInstanceOf(ForbiddenException);
-      // It must NOT reach the run lookup once the owner-gate fails.
-      expect(aiChatRunService.getLatestForChat).not.toHaveBeenCalled();
-    });
-
-    it('returns { run: null, message: null } when the chat has never had a run', async () => {
-      const { controller, aiChatRunService } = makeController({
-        chat: { id: 'c1', creatorId: 'u1' },
-        run: undefined,
-      });
-      const res = await controller.getRun({ chatId: 'c1' }, user, workspace);
-      expect(res).toEqual({ run: null, message: null });
-      expect(aiChatRunService.getLatestForChat).toHaveBeenCalledWith(
-        'c1',
-        'ws1',
-      );
-    });
-
-    it('returns the run and its projected assistant message', async () => {
-      const run = { id: 'run-1', chatId: 'c1', assistantMessageId: 'm1' };
-      const message = { id: 'm1', role: 'assistant' };
-      const { controller, aiChatMessageRepo } = makeController({
-        chat: { id: 'c1', creatorId: 'u1' },
-        run,
-        message,
-      });
-      const res = await controller.getRun({ chatId: 'c1' }, user, workspace);
-      expect(res).toEqual({ run, message });
-      expect(aiChatMessageRepo.findById).toHaveBeenCalledWith('m1', 'ws1');
-    });
-
-    it('returns message: null when the run has no linked assistant message', async () => {
-      const run = { id: 'run-1', chatId: 'c1', assistantMessageId: null };
-      const { controller, aiChatMessageRepo } = makeController({
-        chat: { id: 'c1', creatorId: 'u1' },
-        run,
-      });
-      const res = await controller.getRun({ chatId: 'c1' }, user, workspace);
-      expect(res).toEqual({ run, message: null });
-      expect(aiChatMessageRepo.findById).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('POST /ai-chat/stop (stopRun)', () => {
-    it('throws BadRequestException when neither runId nor chatId is given', async () => {
-      const { controller } = makeController({});
-      await expect(
-        controller.stopRun({}, user, workspace),
-      ).rejects.toBeInstanceOf(BadRequestException);
-    });
-
-    it('stops by runId: owner-gates via the run’s chat, then requests the stop', async () => {
-      const { controller, aiChatRunService, aiChatRepo } = makeController({
-        run: { id: 'run-1', chatId: 'c1' },
-        chat: { id: 'c1', creatorId: 'u1' },
-        stopped: true,
-      });
-      const res = await controller.stopRun({ runId: 'run-1' }, user, workspace);
-      expect(res).toEqual({ stopped: true });
-      expect(aiChatRunService.getRun).toHaveBeenCalledWith('run-1', 'ws1');
-      expect(aiChatRepo.findById).toHaveBeenCalledWith('c1', 'ws1');
-      expect(aiChatRunService.requestStop).toHaveBeenCalledWith('run-1', 'ws1');
-    });
-
-    it('stops by runId: a foreign run’s chat throws ForbiddenException (no stop)', async () => {
-      const { controller, aiChatRunService } = makeController({
-        run: { id: 'run-1', chatId: 'c1' },
-        chat: { id: 'c1', creatorId: 'someone-else' },
-      });
-      await expect(
-        controller.stopRun({ runId: 'run-1' }, user, workspace),
-      ).rejects.toBeInstanceOf(ForbiddenException);
-      expect(aiChatRunService.requestStop).not.toHaveBeenCalled();
-    });
-
-    it('stops by runId: an unknown run reports { stopped: false }', async () => {
-      const { controller, aiChatRunService } = makeController({
-        run: undefined,
-      });
-      const res = await controller.stopRun({ runId: 'gone' }, user, workspace);
-      expect(res).toEqual({ stopped: false });
-      expect(aiChatRunService.requestStop).not.toHaveBeenCalled();
-    });
-
-    it('stops by chatId: owner-gates, resolves the active run, requests the stop', async () => {
-      const { controller, aiChatRunService, aiChatRepo } = makeController({
-        chat: { id: 'c1', creatorId: 'u1' },
-        activeRun: { id: 'run-9' },
-        stopped: true,
-      });
-      const res = await controller.stopRun({ chatId: 'c1' }, user, workspace);
-      expect(res).toEqual({ stopped: true });
-      expect(aiChatRepo.findById).toHaveBeenCalledWith('c1', 'ws1');
-      expect(aiChatRunService.getActiveForChat).toHaveBeenCalledWith(
-        'c1',
-        'ws1',
-      );
-      expect(aiChatRunService.requestStop).toHaveBeenCalledWith('run-9', 'ws1');
-    });
-
-    it('stops by chatId: reports { stopped: false } when no run is active', async () => {
-      const { controller, aiChatRunService } = makeController({
-        chat: { id: 'c1', creatorId: 'u1' },
-        activeRun: undefined,
-      });
-      const res = await controller.stopRun({ chatId: 'c1' }, user, workspace);
-      expect(res).toEqual({ stopped: false });
-      expect(aiChatRunService.requestStop).not.toHaveBeenCalled();
-    });
-  });
-});

apps/server/src/core/ai-chat/ai-chat.controller.ts

@@ -1,7 +1,6 @@
 import {
   BadRequestException,
   Body,
-  ConflictException,
   Controller,
   ForbiddenException,
   HttpCode,
@@ -21,26 +20,14 @@ import { JwtAuthGuard } from '../../common/guards/jwt-auth.guard';
 import { AuthUser } from '../../common/decorators/auth-user.decorator';
 import { AuthWorkspace } from '../../common/decorators/auth-workspace.decorator';
 import { SkipTransform } from '../../common/decorators/skip-transform.decorator';
-import {
+import { AiChat, User, Workspace } from '@docmost/db/types/entity.types';
-  AiChat,
-  AiChatMessage,
-  AiChatRun,
-  User,
-  Workspace,
-} from '@docmost/db/types/entity.types';
 import { PaginationOptions } from '@docmost/db/pagination/pagination-options';
 import { AiChatRepo } from '@docmost/db/repos/ai-chat/ai-chat.repo';
 import { AiChatMessageRepo } from '@docmost/db/repos/ai-chat/ai-chat-message.repo';
-import { PageRepo } from '@docmost/db/repos/page/page.repo';
 import { UserThrottlerGuard } from '../../integrations/throttle/user-throttler.guard';
 import { AI_CHAT_THROTTLER } from '../../integrations/throttle/throttler-names';
 import { FileInterceptor } from '../../common/interceptors/file.interceptor';
-import {
+import { AiChatService, AiChatStreamBody } from './ai-chat.service';
-  AiChatRunHooks,
-  AiChatService,
-  AiChatStreamBody,
-} from './ai-chat.service';
-import { AiChatRunService } from './ai-chat-run.service';
 import { AiTranscriptionService } from './ai-transcription.service';
 import {
   BoundChatDto,
@@ -48,9 +35,7 @@ import {
   ExportChatDto,
   GeneratePageTitleDto,
   GetChatMessagesDto,
-  GetRunDto,
   RenameChatDto,
-  StopRunDto,
 } from './dto/ai-chat.dto';
 import { describeProviderError } from '../../integrations/ai/ai-error.util';
 import { buildChatMarkdown } from './chat-markdown.util';
@@ -67,11 +52,9 @@ export class AiChatController {
 
   constructor(
     private readonly aiChatService: AiChatService,
-    private readonly aiChatRunService: AiChatRunService,
     private readonly aiChatRepo: AiChatRepo,
     private readonly aiChatMessageRepo: AiChatMessageRepo,
     private readonly aiTranscription: AiTranscriptionService,
-    private readonly pageRepo: PageRepo,
   ) {}
 
   /** List the requesting user's chats in this workspace (paginated). */
@@ -88,15 +71,9 @@ export class AiChatController {
   /**
    * Resolve the chat bound to a document for the requesting user: the most-recent
    * non-deleted chat created on that page (ai_chats.page_id). Returns
-   * { chatId: null } when the page has no owned chat (-> a fresh chat).
+   * { chatId: null } when the page has no owned chat (-> a fresh chat). No page
-   *
+   * access check needed: only the caller's OWN chats are matched, so a foreign
-   * `dto.pageId` carries EITHER a page slugId (10-char nanoid, sent by the client
+   * pageId reveals nothing.
-   * off a slug URL) OR a page uuid, so it must be resolved to a real page uuid
-   * before it touches the uuid ai_chats.page_id column — passing a slugId straight
-   * through triggered a Postgres 22P02 "invalid input syntax for type uuid" 500
-   * (#312). PageRepo.findById accepts both forms. The workspace guard rejects an
-   * unknown or cross-workspace page (-> { chatId: null }) so a foreign id cannot
-   * probe another workspace's chats. Only the caller's OWN chats are then matched.
    */
   @HttpCode(HttpStatus.OK)
   @Post('bound-chat')
@@ -105,14 +82,10 @@ export class AiChatController {
     @AuthUser() user: User,
     @AuthWorkspace() workspace: Workspace,
   ): Promise<{ chatId: string | null }> {
-    const page = await this.pageRepo.findById(dto.pageId); // accepts slugId OR uuid
-    if (!page || page.workspaceId !== workspace.id) {
-      return { chatId: null }; // unknown or foreign-workspace page — no binding, no leak
-    }
     const chat = await this.aiChatRepo.findLatestByPage(
       user.id,
       workspace.id,
-      page.id, // the real uuid, never the incoming slugId
+      dto.pageId,
     );
     return { chatId: chat?.id ?? null };
   }
@@ -164,75 +137,6 @@ export class AiChatController {
     return { markdown };
   }
 
-  /**
-   * Reconnect to the latest run of a chat (#184 phase 1). Returns the run's
-   * persisted lifecycle state ({ status, error, stepCount, timings, ... }) plus
-   * the assistant message it projects (the partial/final output) — the DB is the
-   * source of truth, so this works for an in-flight run (the browser dropped, the
-   * run kept going) and a finished one alike. Owner-gated via assertOwnedChat.
-   * `{ run: null }` when the chat has never had a run.
-   */
-  @HttpCode(HttpStatus.OK)
-  @Post('run')
-  async getRun(
-    @Body() dto: GetRunDto,
-    @AuthUser() user: User,
-    @AuthWorkspace() workspace: Workspace,
-  ): Promise<{ run: AiChatRun | null; message: AiChatMessage | null }> {
-    await this.assertOwnedChat(dto.chatId, user, workspace);
-    const run = await this.aiChatRunService.getLatestForChat(
-      dto.chatId,
-      workspace.id,
-    );
-    if (!run) return { run: null, message: null };
-    const message = run.assistantMessageId
-      ? await this.aiChatMessageRepo.findById(
-          run.assistantMessageId,
-          workspace.id,
-        )
-      : undefined;
-    return { run, message: message ?? null };
-  }
-
-  /**
-   * Explicitly STOP an agent run (#184 phase 1) — the user pressed Stop. This is
-   * the ONLY thing that ends a detached run; a browser disconnect deliberately
-   * does not. Target by `runId` (from the streamed start metadata) or by `chatId`
-   * (stop whatever run is active on it). Owner-gated. Returns
-   * `{ stopped }` — false when there was nothing active to stop.
-   */
-  @HttpCode(HttpStatus.OK)
-  @Post('stop')
-  async stopRun(
-    @Body() dto: StopRunDto,
-    @AuthUser() user: User,
-    @AuthWorkspace() workspace: Workspace,
-  ): Promise<{ stopped: boolean }> {
-    let runId = dto.runId;
-    if (!runId && !dto.chatId) {
-      throw new BadRequestException('runId or chatId is required');
-    }
-    if (runId) {
-      // Resolve the run to its chat and owner-gate via that chat.
-      const run = await this.aiChatRunService.getRun(runId, workspace.id);
-      if (!run) return { stopped: false };
-      await this.assertOwnedChat(run.chatId, user, workspace);
-    } else {
-      await this.assertOwnedChat(dto.chatId!, user, workspace);
-      const active = await this.aiChatRunService.getActiveForChat(
-        dto.chatId!,
-        workspace.id,
-      );
-      if (!active) return { stopped: false };
-      runId = active.id;
-    }
-    const stopped = await this.aiChatRunService.requestStop(
-      runId,
-      workspace.id,
-    );
-    return { stopped };
-  }
-
   /** Rename a chat. */
   @HttpCode(HttpStatus.OK)
   @Post('rename')
@@ -284,20 +188,11 @@ export class AiChatController {
     @AuthWorkspace() workspace: Workspace,
   ): Promise<void> {
     // A7 gate: the workspace must have AI chat explicitly enabled.
-    const settings = (workspace.settings ?? {}) as {
+    const settings = (workspace.settings ?? {}) as { ai?: { chat?: boolean } };
-      ai?: { chat?: boolean; autonomousRuns?: boolean };
-    };
     if (settings.ai?.chat !== true) {
       throw new ForbiddenException('AI chat is disabled');
     }
 
-    // #184 phase 1 flag: when ON, the turn becomes a detached, durable RUN — its
-    // lifecycle is tracked in ai_chat_runs, a browser disconnect no longer aborts
-    // it, and only an explicit /ai-chat/stop ends it. When OFF (the default) the
-    // turn is socket-bound exactly as before, so existing deployments are
-    // unaffected.
-    const autonomousRuns = settings.ai?.autonomousRuns === true;
-
     const sessionId = (req.raw as { sessionId?: string }).sessionId;
     if (!sessionId) {
       // The chat requires an interactive session to mint loopback tokens
@@ -321,58 +216,6 @@ export class AiChatController {
     // HttpException) instead of breaking mid-stream.
     const model = await this.aiChatService.getChatModel(workspace.id, role);
 
-    // #184: one active run per chat. For an EXISTING chat reject a concurrent
-    // start with a clean 409 BEFORE hijack (the common double-submit / second-tab
-    // case), so the user gets JSON, not a mid-stream error. A brand-new chat
-    // (no chatId) cannot have a prior run, and the DB partial unique index is the
-    // backstop against any race that slips past this check.
-    if (autonomousRuns && body.chatId) {
-      const active = await this.aiChatRunService.getActiveForChat(
-        body.chatId,
-        workspace.id,
-      );
-      if (active) {
-        throw new ConflictException({
-          message: 'An agent run is already in progress for this chat',
-          code: 'A_RUN_ALREADY_ACTIVE',
-        });
-      }
-    }
-
-    // Run-lifecycle hooks (#184), only when the flag is on. They wrap the turn in
-    // a durable run whose abort is governed by the run (explicit stop), persist
-    // its progress, and settle its terminal status — see AiChatRunService.
-    const runHooks: AiChatRunHooks | undefined = autonomousRuns
-      ? {
-          begin: (chatId) =>
-            this.aiChatRunService.beginRun({
-              chatId,
-              workspaceId: workspace.id,
-              userId: user.id,
-              trigger: 'user',
-            }),
-          onAssistantSeeded: (runId, messageId) =>
-            this.aiChatRunService.linkAssistantMessage(
-              runId,
-              workspace.id,
-              messageId,
-            ),
-          onStep: (runId, stepCount) =>
-            void this.aiChatRunService.recordStep(
-              runId,
-              workspace.id,
-              stepCount,
-            ),
-          onSettled: (runId, status, error) =>
-            this.aiChatRunService.finalizeRun(
-              runId,
-              workspace.id,
-              status,
-              error,
-            ),
-        }
-      : undefined;
-
     // Abort the agent loop when the client disconnects. `close` also fires on
     // normal completion, so only abort when the response has not finished
     // writing (a genuine disconnect). `once` fires at most once and self-removes;
@@ -387,44 +230,18 @@ export class AiChatController {
       // A genuine disconnect leaves the response unfinished (unlike a normal
       // completion, which also fires `close`). Such a drop — e.g. a reverse
       // proxy cutting the SSE mid-answer — is otherwise invisible server-side,
-      // so log it here.
+      // so log it here before aborting the agent loop.
       if (!res.raw.writableEnded) {
-        if (autonomousRuns) {
-          // #184: the turn is a DETACHED run. A disconnect must NOT abort it —
-          // the run keeps executing and persisting server-side; the client
-          // reconnects via /ai-chat/run (or re-stops via /ai-chat/stop). Log only.
-          this.logger.log(
-            `AI chat stream: client disconnected; run continues server-side ` +
-              `(elapsed=${Date.now() - reqStartedAt}ms since request received)`,
-          );
-        } else {
         this.logger.warn(
           `AI chat stream: client disconnected before completion; aborting turn ` +
             `(elapsed=${Date.now() - reqStartedAt}ms since request received)`,
         );
         controller.abort();
       }
-      }
     };
     req.raw.once('close', onClose);
     res.raw.once('finish', () => req.raw.off('close', onClose));
 
-    // #184: in detached mode the turn is NOT aborted on disconnect, so the SDK's
-    // pipe keeps writing to a socket the client may have dropped — for the rest of
-    // the (continuing) run. A write to the dead socket can emit an 'error' on the
-    // raw response; without a listener that surfaces as an unhandled error event.
-    // Swallow it (the run continues server-side regardless). Legacy mode aborts on
-    // disconnect, so it does not need this and keeps its exact prior behavior.
-    if (autonomousRuns) {
-      res.raw.on('error', (err) => {
-        this.logger.debug(
-          `AI chat detached stream: post-disconnect socket error swallowed: ${
-            err instanceof Error ? err.message : String(err)
-          }`,
-        );
-      });
-    }
-
     // Commit to streaming: hijack so Fastify stops managing the response and
     // the AI SDK can write the UI-message stream directly to the Node socket.
     res.hijack();
@@ -439,32 +256,15 @@ export class AiChatController {
         signal: controller.signal,
         model,
         role,
-        // #184: present only when the flag is on; wraps the turn in a durable run.
-        runHooks,
       });
     } catch (err) {
-      // Any failure AFTER hijack can no longer go through Nest's exception
+      // Any failure AFTER hijack can no longer send a clean JSON error, so emit
-      // filter, so emit the error on the raw socket if nothing has been written
+      // a minimal error on the raw socket if nothing has been written yet.
-      // yet. The lost-the-race 409 (RunAlreadyActiveError -> ConflictException)
-      // is raised by stream() BEFORE it writes a byte, so headers are still
-      // unsent here: honor the HttpException's real status + body (a clean 409),
-      // not a blanket 500. Everything else stays a 500.
-      const isHttp = err instanceof HttpException;
-      if (!isHttp) {
       this.logger.error('AI chat stream failed', err as Error);
-      }
       if (!res.raw.headersSent) {
-        const status = isHttp ? err.getStatus() : 500;
+        res.raw.statusCode = 500;
-        const payload = isHttp
-          ? err.getResponse()
-          : { error: 'Internal server error' };
-        res.raw.statusCode = status;
         res.raw.setHeader('Content-Type', 'application/json');
-        res.raw.end(
+        res.raw.end(JSON.stringify({ error: 'Internal server error' }));
-          JSON.stringify(
-            typeof payload === 'string' ? { message: payload } : payload,
-          ),
-        );
       } else if (!res.raw.writableEnded) {
         res.raw.end();
       }

apps/server/src/core/ai-chat/ai-chat.generate-page-title.spec.ts

@@ -57,8 +57,6 @@ describe('AiChatController.generatePageTitle', () => {
     const aiChatService = { generatePageTitle: generate };
     const controller = new AiChatController(
       aiChatService as never,
-      {} as never, // aiChatRunService
-      {} as never,
       {} as never,
       {} as never,
       {} as never,

apps/server/src/core/ai-chat/ai-chat.module.ts

@@ -3,7 +3,6 @@ import { AiModule } from '../../integrations/ai/ai.module';
 import { TokenModule } from '../auth/token.module';
 import { AiChatController } from './ai-chat.controller';
 import { AiChatService } from './ai-chat.service';
-import { AiChatRunService } from './ai-chat-run.service';
 import { AiTranscriptionService } from './ai-transcription.service';
 import { AiChatToolsService } from './tools/ai-chat-tools.service';
 import { EmbeddingModule } from './embedding/embedding.module';
@@ -43,7 +42,6 @@ import { PublicShareChatToolsService } from './tools/public-share-chat-tools.ser
   controllers: [AiChatController, PublicShareChatController],
   providers: [
     AiChatService,
-    AiChatRunService,
     AiTranscriptionService,
     AiChatToolsService,
     PublicShareChatService,