fix(ai-chat): tick the live token counter between agent steps (#163)

The header token badge (and the "Thinking… · N tokens" line) froze between
agent steps and jumped in chunks instead of ticking smoothly. liveTurnTokens
returned the authoritative server `usage` VERBATIM as soon as it appeared, but
the server only attaches usage at a step boundary and it is cumulative over
COMPLETED steps — so during the next (in-flight) step the figure stayed frozen
at the previous boundary and the running text estimate was ignored.

Combine both sources per component via max: always compute the running estimate
(chars/≈4 over the message's reasoning/text parts, which includes the in-flight
step) and take max(authoritativeBase, estimate). Between boundaries the estimate
ticks the number up; at a boundary the authoritative figure snaps it exact; and
because the server usage is cumulative and we only ever take the max, the counter
is monotonic (never drops). Reasoning/output stay split; the #151 reasoning-only
authoritative count is preserved.

Backward compatible: in every existing test the estimate is <= the authoritative
figure, so max returns the same value. +4 tests for the in-flight-step-exceeds-
base case (output + reasoning), the authoritative-wins case, and monotonicity.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

.env.example

@@ -136,32 +136,6 @@ MCP_DOCMOST_PASSWORD=
 # A slow/hung embeddings endpoint fails after this and the batch continues.
 # AI_EMBEDDING_TIMEOUT_MS=120000
 
-# Silence timeout (ms) for streaming chat/agent AI calls AND external-MCP traffic.
-# Bounds time-to-first-byte and the gap BETWEEN chunks (NOT the total turn length),
-# so an arbitrarily long turn that keeps streaming is never cut. Finite so a hung
-# provider is eventually broken instead of leaking forever. Default 900000 (15 min).
-# AI_STREAM_TIMEOUT_MS=900000
-
-# 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`. Lower it if
-# your egress drops idle connections faster than ~10s. Default 10000 (10 s).
-# AI_STREAM_KEEPALIVE_MS=10000
-
-# 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
-# ~5 min instead of 15. Note it also cuts a legitimately long but byte-silent
-# single tool call (a slow crawl that emits nothing until done) and an SSE
-# transport idling >5 min BETWEEN tool calls. Default 300000 (5 min).
-# AI_MCP_STREAM_TIMEOUT_MS=300000
-
-# Total wall-clock cap (ms) for ONE external MCP tool call (app-level, not
-# transport). Aborts a tool that keeps the socket warm (SSE heartbeats / trickle)
-# but never returns a result — which the silence timeout above never breaks.
-# Default 900000 (15 min).
-# AI_MCP_CALL_TIMEOUT_MS=900000
-
 # --- 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
@@ -187,11 +161,3 @@ MCP_DOCMOST_PASSWORD=
 # Per-request output-token ceiling for the anonymous assistant (default: 512).
 # Worst-case output per accepted call = agent steps (5) × this value.
 # SHARE_AI_MAX_OUTPUT_TOKENS=512
-#
-# Second cost backstop: a cluster-wide per-workspace rolling-DAY token budget
-# (input re-sent per step + output, summed across every accepted turn). The
-# hourly request cap above bounds how MANY calls run, not how expensive each is,
-# so this caps the owner's actual provider bill directly. Like the request cap it
-# FAILS CLOSED if Redis is unavailable (default: 1,000,000 tokens per workspace
-# per rolling day).
-# SHARE_AI_WORKSPACE_TOKEN_BUDGET_PER_DAY=1000000

.github/workflows/develop.yml

@@ -56,160 +56,3 @@ jobs:
           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 run on every develop push but DO NOT gate the build/publish above:
-  # `build` stays `needs: test` only, so the :develop image still ships even if
-  # 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
-    env:
-      DATABASE_URL: postgresql://docmost:docmost@localhost:5432/docmost
-      REDIS_URL: redis://localhost:6379
-      APP_SECRET: ci-e2e-secret-change-me-min-32-characters
-      APP_URL: http://localhost:3000
-    services:
-      postgres:
-        image: pgvector/pgvector:pg18
-        env:
-          POSTGRES_DB: docmost
-          POSTGRES_USER: docmost
-          POSTGRES_PASSWORD: docmost
-        ports:
-          - 5432:5432
-        options: >-
-          --health-cmd "pg_isready -U docmost"
-          --health-interval 5s
-          --health-timeout 5s
-          --health-retries 20
-      redis:
-        image: redis:7
-        ports:
-          - 6379:6379
-        options: >-
-          --health-cmd "redis-cli ping"
-          --health-interval 5s
-          --health-timeout 5s
-          --health-retries 20
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Set up pnpm
-        uses: pnpm/action-setup@v4
-
-      - name: Set up Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: 22
-          cache: pnpm
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Build editor-ext
-        run: pnpm --filter @docmost/editor-ext build
-
-      - name: Run migrations
-        run: pnpm --filter ./apps/server migration:latest
-
-      - name: Run server e2e
-        run: pnpm --filter ./apps/server test:e2e
-
-  # 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
-    env:
-      DATABASE_URL: postgresql://docmost:docmost@localhost:5432/docmost
-      REDIS_URL: redis://localhost:6379
-      APP_SECRET: ci-e2e-secret-change-me-min-32-characters
-      APP_URL: http://localhost:3000
-      NODE_ENV: production
-    services:
-      postgres:
-        image: pgvector/pgvector:pg18
-        env:
-          POSTGRES_DB: docmost
-          POSTGRES_USER: docmost
-          POSTGRES_PASSWORD: docmost
-        ports:
-          - 5432:5432
-        options: >-
-          --health-cmd "pg_isready -U docmost"
-          --health-interval 5s
-          --health-timeout 5s
-          --health-retries 20
-      redis:
-        image: redis:7
-        ports:
-          - 6379:6379
-        options: >-
-          --health-cmd "redis-cli ping"
-          --health-interval 5s
-          --health-timeout 5s
-          --health-retries 20
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Set up pnpm
-        uses: pnpm/action-setup@v4
-
-      - name: Set up Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: 22
-          cache: pnpm
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Build editor-ext
-        run: pnpm --filter @docmost/editor-ext build
-
-      - name: Build server
-        run: pnpm server:build
-
-      - name: Build mcp
-        run: pnpm --filter @docmost/mcp build
-
-      - name: Run migrations
-        run: pnpm --filter ./apps/server migration:latest
-
-      - name: Start server (prod)
-        # Capture stdout/stderr so a start-up crash (bind error, stack trace,
-        # migration mismatch) is diagnosable; without this the only signal is
-        # the generic health-loop timeout below, ~120s later.
-        run: pnpm --filter ./apps/server start:prod > /tmp/server.log 2>&1 &
-
-      - name: Wait for server health
-        run: |
-          for i in $(seq 1 60); do
-            if curl -fsS http://localhost:3000/api/health > /dev/null; then
-              echo "Server is healthy"
-              exit 0
-            fi
-            sleep 2
-          done
-          echo "Server did not become healthy in time"
-          exit 1
-
-      - name: Dump server log on failure
-        if: failure()
-        run: cat /tmp/server.log || true
-
-      - name: Seed admin
-        run: |
-          curl -fsS -X POST http://localhost:3000/api/auth/setup \
-            -H "Content-Type: application/json" \
-            -d '{"name":"E2E","email":"e2e@example.com","password":"E2ePassword123","workspaceName":"E2E"}'
-
-      - name: Run mcp e2e
-        env:
-          DOCMOST_API_URL: http://localhost:3000/api
-          DOCMOST_EMAIL: e2e@example.com
-          DOCMOST_PASSWORD: E2ePassword123
-        run: pnpm --filter @docmost/mcp test:e2e

.github/workflows/test.yml

@@ -15,38 +15,6 @@ permissions:
 jobs:
   test:
     runs-on: ubuntu-latest
-    # Real Postgres + Redis so the server integration suite (`*.int-spec.ts`,
-    # behind `pnpm --filter server test:int`) runs in CI (red-team finding #7).
-    # Without it, cost-cap / FK-cascade / jsonb-round-trip / real-apply tests
-    # only ran locally, so regressions in those paths stayed green in CI.
-    # Postgres uses the pgvector image because migrations create vector columns
-    # and global-setup runs `CREATE EXTENSION vector`. Credentials/db match the
-    # defaults in apps/server/test/integration/db.ts + global-setup.ts
-    # (docmost / docmost_dev_pw, maintenance db `docmost`, redis on 6379), so no
-    # TEST_*_URL overrides are needed.
-    services:
-      postgres:
-        image: pgvector/pgvector:pg18
-        env:
-          POSTGRES_USER: docmost
-          POSTGRES_PASSWORD: docmost_dev_pw
-          POSTGRES_DB: docmost
-        ports:
-          - 5432:5432
-        options: >-
-          --health-cmd "pg_isready -U docmost"
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-      redis:
-        image: redis:7
-        ports:
-          - 6379:6379
-        options: >-
-          --health-cmd "redis-cli ping"
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -68,12 +36,5 @@ jobs:
       - name: Build editor-ext
         run: pnpm --filter @docmost/editor-ext build
 
-      - name: Run unit tests
+      - name: Run tests
         run: pnpm -r test
-
-      # Integration suite against the real Postgres/Redis services above. Runs
-      # the FK-cascade, cost-cap, jsonb-round-trip and real-apply specs that the
-      # unit run (mocks only) cannot cover. global-setup drops/recreates the
-      # isolated `docmost_test` DB and migrates it to latest.
-      - name: Run server integration tests
-        run: pnpm --filter server test:int

.gitignore

@@ -42,7 +42,6 @@ lerna-debug.log*
 .nx/installation
 .nx/cache
 .claude/worktrees/
-.claude/tmp/
 
 # TypeScript incremental build artifacts
 *.tsbuildinfo

AGENTS.md

@@ -283,46 +283,37 @@ Vite SPA. Code is organized by feature under `apps/client/src/features/*` (mirro
 
 ### Cutting a release
 
-The git tag is the source of truth for the displayed version (the client UI reads `git describe --tags` via `vite.config.ts`); the `package.json` bump is metadata that backs the server `/version` endpoint (`version.service.ts`).
+The git tag is the source of truth for the displayed version (UI reads `git describe --tags`); the `package.json` bump is metadata only. Steps:
 
-**Golden rule — tag on `develop` first, merge to `main` afterwards.** Cut the version-bump commit on `develop`, put the tag on *that* commit, and push it. Merge `develop` into `main` later (it does not block the tag or the release). Because the tag is in `develop`'s ancestry from the moment it is created, `git describe` on `develop` — and the `ghcr.io/vvzvlad/gitmost:develop` image — reports the new version immediately, with **no back-merge dance**. Do **not** tag `main`'s merge commit; that is the mistake described in the pitfall below (we hit it twice).
-
-Steps:
-
-1. Make sure `develop` is up to date, clean, and pushed to **both** remotes (`git status`; `git push gitea develop && git push github develop`).
+1. Make sure `main` is clean and pushed (`git status`, `git push`).
 2. Pick `vX.Y.Z` (SemVer): **minor** bump for a batch of features, **patch** for fixes only. Review what landed with `git log <last-tag>..HEAD --no-merges`.
-3. Bump `"version"` to `X.Y.Z` in the **root** `package.json`, `apps/client/package.json`, and `apps/server/package.json` (keep all three in sync). Leave `packages/mcp` alone — it is versioned independently. Commit **on `develop`** with the bare version as the subject, e.g. `0.94.1` (matches past bump commits).
-4. For a real release (skip for a bare hotfix tag), update `CHANGELOG.md` (Keep a Changelog format): add a `## [X.Y.Z] - YYYY-MM-DD` section summarising `git log vPREV..HEAD --no-merges` grouped by type (Breaking / Added / Changed / Fixed / Removed), and the `compare/vPREV...vX.Y.Z` link at the bottom. Fold it into the bump commit.
-5. Tag that develop commit with a **lightweight** tag (existing release tags are lightweight): `git tag vX.Y.Z`.
-6. Push the branch **and** the tag to **both** writable remotes — `git push <branch>` does **not** push tags, and tags are per-remote:
-   ```bash
-   git push gitea develop && git push gitea vX.Y.Z
-   git push github develop && git push github vX.Y.Z
-   ```
-   Pushing the `v*` tag to `github` triggers `release.yml` (multi-arch GHCR images + a draft GitHub Release). The tag *must* exist on `github`, because the `:develop` and release images are built there by GitHub Actions and `git describe` on the runner only sees the tags present on `github` (not your local clone or `gitea`).
-7. Merge `develop` into `main` when ready (commonly later — this does not gate the release):
-   ```bash
-   git checkout main
-   git merge --ff-only develop   # or a merge commit if fast-forward is not possible
-   git push gitea main && git push github main
-   ```
-   The tag is already reachable from `main` (it lives in the `develop` history that `main` now contains), so `main` reports `vX.Y.Z` too — no extra tagging needed.
+3. Bump `"version"` to `X.Y.Z` in the **root** `package.json`, `apps/client/package.json`, and `apps/server/package.json` (keep all three in sync). Leave `packages/mcp` alone — it is versioned independently. Commit with the bare version as the subject, e.g. `0.91.0` (matches past bump commits).
+4. Update `CHANGELOG.md` (Keep a Changelog format): add a `## [X.Y.Z] - YYYY-MM-DD` section summarising `git log vPREV..HEAD --no-merges` grouped by type (Breaking / Added / Changed / Fixed / Removed), and add the `compare/vPREV...vX.Y.Z` link at the bottom. Fold the bump + changelog into the release commit.
+5. Tag the release commit with a **lightweight** tag (existing release tags are lightweight): `git tag vX.Y.Z`.
+6. Push commit and tag: `git push origin main && git push origin vX.Y.Z`. Pushing the `v*` tag triggers `release.yml` (multi-arch GHCR images + a draft GitHub Release).
+7. **Back-merge the release into `develop`** so develop builds report the new version: `git checkout develop && git merge --no-ff main && git push origin develop` (push to Gitea as well if that is the canonical remote).
 
-#### Pitfall: tagging `main` instead of `develop` (the mistake to avoid)
+#### Why develop keeps showing the *previous* version (and why step 7 matters)
 
-`git describe --tags --always` (see `vite.config.ts`) walks **backwards from the current commit** and picks the **nearest tag reachable in that commit's ancestry**, then appends `-<commits-since-tag>-g<short-hash>`.
+The UI version is `git describe --tags --always` (see `vite.config.ts`), which walks **backwards from the current commit** and picks the **nearest tag reachable in that commit's ancestry**, then appends `-<commits-since-tag>-g<short-hash>`.
 
-The wrong flow we fell into twice: merge `develop` into `main` *first*, then tag `main`'s **release merge commit**. That merge commit is **not** in `develop`'s history, so `git describe` on `develop` cannot see the new tag and falls back to the *previous* reachable one. Result: every develop build — and the `ghcr.io/vvzvlad/gitmost:develop` image — keeps reporting e.g. `v0.93.0-NNN-g<hash>` even though a release was "cut". Tagging on `develop` (the golden rule above) avoids this entirely: the tag is in `develop`'s ancestry from the start, and `main` still gets it once `develop` is merged in.
+The release tag (`vX.Y.Z`) is created on **`main`'s release merge commit**, and that commit is **not** in `develop`'s history. So until the release is back-merged, `git describe` on `develop` cannot see the new tag and falls back to the *previous* reachable tag. Result: every develop build — and the `ghcr.io/vvzvlad/gitmost:develop` image — keeps reporting e.g. `v0.91.0-NNN-g<hash>` even though `main` is already tagged `v0.93.0`. This is the classic git-flow pitfall: the version on `develop` does **not** advance just because a release was tagged on `main`.
 
-Second gotcha — the tag must exist on the remote CI builds from. `git describe` names a tag **ref**, not just a commit. The `:develop` and release images are built by GitHub Actions (`develop.yml` / `release.yml`, `actions/checkout` with `fetch-depth: 0`), so the version they print depends on which tags exist **on the `github` remote** — not on your local clone or on `gitea`. `git push <branch>` does **not** push tags; push them explicitly to **each** remote (`gitea` and `github`). A tag that only lives on `gitea` is invisible to the GitHub build.
+Back-merging `main → develop` (step 7) pulls the tagged release commit into `develop`'s ancestry, after which develop builds correctly show `vX.Y.Z-NNN-g<hash>`. If `develop` already drifted (release tagged but never back-merged), just run step 7 now — no new tag is needed.
 
-If you already tagged `main` (or `develop` still shows the old version), recover without re-tagging:
+##### The tag must also exist on the remote that CI builds from (multi-remote gotcha)
 
-1. Make the tagged commit reachable from `develop` — either back-merge `main → develop` (`git checkout develop && git merge --no-ff main`), or confirm the tagged commit is already an ancestor of `develop`.
-2. Make sure the tag exists on `github`: compare `git ls-remote --tags github` with `gitea`, and push the missing one (`git push github vX.Y.Z` / `git push gitea vX.Y.Z`). Pushing a `v*` tag to `github` also fires `release.yml` — expected, just be aware.
-3. Re-run the develop build (`gh workflow run Develop`, or push any commit to `develop`) so `git describe` re-resolves with the tag now in scope.
+`git describe` names a tag **ref**, not just a commit — so the back-merge is *necessary but not sufficient*. The develop image is built by GitHub Actions (`develop.yml`, `actions/checkout` with `fetch-depth: 0`, then `git describe --tags --always`), so the version it prints depends on which tags exist **on the `github` remote**, not on your local clone or on `gitea`.
 
-(There is no `origin` remote here — push to `gitea` **and** `github` explicitly, and always push release tags to both.)
+This repo has two writable remotes — `gitea` (canonical, where commits land) and `github` (where the `:develop` and release images are built) — plus `upstream` (docmost, never push). **`git push <branch>` does NOT push tags**; tags must be pushed explicitly and *to each remote separately*. A release tag that only lives on `gitea` is invisible to the GitHub Actions build: even with the tagged commit fully in `develop`'s history (step 7 done), `git describe` on the GitHub runner falls back to the previous tag it *does* have, so the develop image keeps showing e.g. `v0.91.0-NNN` while `git describe` locally already says `v0.93.0-NN`.
+
+Fix / checklist when develop still shows the old version after a back-merge:
+
+1. Confirm the tag is missing on github: `git ls-remote --tags github` (compare with `gitea`).
+2. Push it there: `git push github vX.Y.Z` (and `git push gitea vX.Y.Z` if it is missing on gitea too). Note: pushing a `v*` tag to `github` also triggers `release.yml` (multi-arch GHCR images + draft Release) — expected, but be aware.
+3. Re-run the develop build (`gh workflow run Develop`, or push any commit to `develop`) so `git describe` re-resolves with the tag now present.
+
+(The `git push origin ...` in steps 6–7 above is shorthand — there is no `origin` remote here; substitute `gitea` **and** `github` as appropriate, and always push release tags to both.)
 
 ## Planning docs
 

CHANGELOG.md

@@ -12,140 +12,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-- **Quick-create regular and temporary notes from the Home and Space screens.**
-  The Home screen now shows a second action next to "New note" that creates a
-  *temporary* note (one that auto-moves to Trash after the workspace lifetime),
-  resolving the target space the same way the regular button does — created
-  directly when you can write to a single space, or via a space picker when
-  several. Each space overview screen gains two buttons — "New note" and "New
-  temporary note" — that create the page directly in that space and open it,
-  mirroring the existing space-sidebar actions and shown only to members who can
-  manage pages.
-- **Interrupt the AI agent and send a queued message now.** A queued AI-chat
-  message gains a "send now" action that interrupts the streaming turn and
-  immediately sends that message, keeping the agent's partial output. The
-  follow-up turn is tagged as an interrupt so the model is told its previous
-  answer was cut off and builds on it instead of restarting; the rest of the
-  queue still flushes normally afterward. (#198)
-
-### Fixed
-
-- **A shared page now keeps EXACTLY ONE custom address (`/l/:alias`).** Editing a
-  page's vanity slug previously inserted a second `share_aliases` row instead of
-  renaming the existing one, leaving the old `/l/<old>` link live forever and
-  making the share modal's lookup nondeterministic. Slug edits and confirmed
-  reassigns now rename/retarget the single row, and a new partial unique index on
-  `(workspace_id, page_id)` enforces the invariant in the database. **Upgrade
-  note:** the accompanying migration `20260627T120000` IRREVERSIBLY deletes the
-  orphaned duplicate alias rows the old bug created (keeping the newest per
-  page), so any previously-live duplicate `/l/<old>` link begins returning the
-  generic 404 after upgrade — intended, but not undoable by `down()`. (#226,
-  #227)
-
-## [0.94.0] - 2026-06-26
-
-This release makes AI chat durable and fast: assistant turns are persisted to
-the database step by step and exported server-side, the desktop app no longer
-freezes at 100% CPU on long agent runs, and MCP writes are badged with
-unspoofable AI attribution. It also reworks footnotes (Pandoc-style reuse and
-per-reference back-links), hardens page moves and duplication against cycles
-and lost edits, and caps the anonymous public-share assistant with a
-per-workspace rolling-day token budget.
-
-### Added
-
-- **Custom pretty-links for shared pages (`/l/:alias`).** A page editor can give
-  any publicly shared page a short, memorable, workspace-scoped vanity address
-  backed by a new `share_aliases` table. Hitting `/l/<alias>` issues a `302`
-  (never `301`, since the target is retargetable) to the canonical
-  `/share/<key>/p/<slug>` page; an unknown, dangling, or no-longer-readable alias
-  serves the plain SPA index so that the existence of a name never leaks. An
-  alias can be moved to another page (with a confirm-reassign guard) and the
-  foreign key is `ON DELETE SET NULL`, so deleting the target leaves a dangling
-  alias any workspace member can reclaim. (#205)
-
-- **Temporary notes — auto-move to Trash after a workspace lifetime.** A note can
-  be marked temporary so it auto-moves to Trash once a configurable workspace
-  lifetime elapses (default `DEFAULT_TEMPORARY_NOTE_HOURS` = 24h) unless made
-  permanent first. The deadline is frozen at creation time, so later changes to
-  the workspace setting never reschedule existing notes; an hourly background
-  sweep trashes notes past their deadline (children ride along). An open
-  temporary note shows a banner with a "Make permanent" rescue action; restoring
-  a note from Trash disarms the timer so it is not immediately re-trashed.
-  Operators configure the lifetime per workspace. (#201)
-
-- **Persistent AI-chat history as the source of truth + server-side export.**
-  An assistant turn is now persisted to the database step by step: the row is
-  inserted upfront as `streaming` and updated as each agent step finishes, then
-  finalized once to `completed`/`error`/`aborted`. A process that dies mid-turn
-  keeps every finished step, and a startup sweep flips any dangling `streaming`
-  row (untouched for 10 minutes) to `aborted`. Chat "Copy" now exports
-  server-side from these rows (`POST /ai-chat/export`) rather than from live
-  client state, so the export is identical whether a chat is freshly streaming,
-  just switched to, or reloaded — and is available from the first turn of a new
-  chat. (#183, #174)
-
 - **AI-agent attribution for MCP writes.** Comments (and pages) created through
   the MCP endpoint by a dedicated agent account are now badged as "AI", with
   unspoofable provenance derived from a per-user `is_agent` flag (not from the
-  request body). **Operator setup:** use a _dedicated_ service account for the
+  request body). **Operator setup:** use a *dedicated* service account for the
   MCP fallback and set the flag with SQL —
   `UPDATE users SET is_agent = true WHERE email = '<mcp-account>'`. Never flag a
   human or shared account, or its normal edits get mis-attributed as AI. See the
   AI-agent block in `.env.example`. (#143)
-- **Footnote import diagnostics.** The MCP page-write tools (`create_page`,
-  `update_page`, `import_page_markdown`) now return a `footnoteWarnings` array
-  flagging dangling references, empty or duplicate definitions, and `[^id]`
-  markers inside table rows, so an agent can fix its own markup. The page is
-  still created; the field is omitted when there are no problems. (#166)
-- **AI chat "Protocol" setting (`chatApiStyle`).** A new admin choice in AI
-  settings for the `openai` driver: `openai-compatible` (default) routes chat
-  through `@ai-sdk/openai-compatible`, which surfaces a provider's streamed
-  reasoning (`reasoning_content` → reasoning parts) for z.ai/GLM, DeepSeek,
-  OpenRouter, etc.; `openai` uses the official provider (real-OpenAI
-  reasoning-model request shaping). Chosen explicitly rather than inferred from
-  the base URL, since a custom URL can front real OpenAI too. (#175, #177)
-- **Per-MCP-server instructions in the agent prompt.** Each external MCP server
-  now has an admin-authored `instructions` field ("how/when to use this server's
-  tools") that is injected into the agent's system prompt next to that server's
-  tool descriptions. Trusted text, rendered inside the prompt safety sandwich;
-  shown only for a server that actually connected and contributed ≥1 callable
-  tool. (#180)
-- **Footnote multi-backlinks.** A footnote referenced more than once now shows a
-  back-link per reference (↩ a b c …), each scrolling to its own occurrence, like
-  Pandoc/Wikipedia; a single-reference footnote keeps the plain ↩. (#168)
-- **Generate a page title from its content.** A "sparkles" button in the page
-  byline reads the live editor content (including unsaved edits), generates a
-  title via the workspace AI provider (`POST /ai-chat/generate-page-title`), and
-  applies it through the existing `/pages/update` route — reflecting it in the
-  title field and broadcasting to other clients. Gated by the `settings.ai.generative`
-  flag and throttled per user. (#199)
 
 ### Changed
 
-- **AI chat now feeds the model the full stored transcript.** The per-turn model
-  conversation was rebuilt from a sliding window of the 50 most recent stored
-  rows, which silently dropped the beginning of any longer chat. It is now
-  rebuilt from the complete non-deleted transcript in chronological order, so
-  the model sees every turn (a 5000-row backstop guards process memory — a
-  safety net far above any realistic chat, not a conversational limit). On a
-  very long chat this can eventually reach the model's context window; the
-  client already surfaces that as "start a new chat". (#202)
-
-- **AI chat default provider is now `openai-compatible` (reasoning surfaced).**
-  For the `openai` driver the chat provider defaults to the openai-compatible
-  implementation, so a workspace pointing at z.ai/GLM/DeepSeek now streams the
-  model's reasoning out of the box. An endpoint that is real OpenAI behind a
-  custom base URL should set the new `chatApiStyle` "Protocol" to `openai`. (#177)
-
-- **Footnotes now reuse (Pandoc semantics).** Multiple `[^a]` references to the
-  same id are ONE footnote — one number, one definition, several back-references
-  — instead of being renamed to `a__2`, `a__3`. Duplicate `[^a]:` definitions are
-  first-wins on import (the rest are dropped and reported via `footnoteWarnings`),
-  and a reference with no definition yields a single empty footnote rather than
-  one per occurrence. This supersedes the 0.93.0 "survive duplicate-id
-  definitions" behavior for the import path. (#166)
-
 - **Public share AI: default per-workspace hourly assistant cap lowered
   300 → 100.** The limiter falls back to this default whenever
   `SHARE_AI_WORKSPACE_MAX_PER_HOUR` is unset, so a `0.93.0` deployment that
@@ -155,13 +32,6 @@ per-workspace rolling-day token budget.
 
 ### Fixed
 
-- **AI chat: the desktop app no longer freezes at 100% CPU on long agent runs.**
-  `useChat` re-rendered on every streamed token and `MessageItem`/`ReasoningBlock`
-  re-parsed the whole transcript markdown (marked + DOMPurify) on every delta, so
-  per-turn work grew quadratically and saturated the main thread. The stream is now
-  throttled (`experimental_throttle`) to ~20 Hz and each finalized message row /
-  markdown part / reasoning block is memoized, so a long turn no longer re-parses
-  already-finished content. (#182)
 - **Editor: caret/selection landed on the wrong line when clicking inside code
   blocks and footnotes.** The affected NodeViews rendered their non-editable
   chrome (language menu, footnotes heading, footnote number marker) before the
@@ -171,42 +41,6 @@ per-workspace rolling-day token budget.
   are nudged after a paste to refresh stale hit-testing geometry. The caret
   symptom is macOS-specific and was confirmed manually on macOS; the automated
   guard pins the DOM-order invariant, not the caret behavior itself. (#146, #147)
-- **AI chat: the live token counter now ticks between agent steps.** During a
-  multi-step turn the header token badge (and the "Thinking… · N tokens" line)
-  no longer froze on the previous step's authoritative usage; the current step's
-  estimate is combined per-component with `max`, so the count rises smoothly and
-  never jumps backwards. (#163)
-- **AI chat: "New chat" during a streaming first turn now resets the whole
-  chat, not just the role badge.** Starting a new chat mid-stream cleared the
-  header but left the in-flight turn's messages behind, so the fresh chat opened
-  pre-populated with the previous conversation; it now fully resets. (#161)
-- **AI chat: a dropped tool argument now yields an actionable error.** When the
-  model omitted a required parameter (typically `pageId`) in a parallel/batch
-  tool call, the assistant forwarded zod's raw "expected string, received
-  undefined" text; tool inputs now return a message naming each missing/invalid
-  parameter (the JSON Schema contract is unchanged and nothing is backfilled).
-  (#190)
-- **Page move: cycle checks are now atomic and depth-bounded.** Moving a page
-  under one of its own descendants is rejected in the same transaction as the
-  update (closing a TOCTOU window where two concurrent A→B / B→A moves could
-  form a cycle), and the recursive tree-traversal CTEs carry a cycle/depth guard
-  so a pre-existing cycle can no longer spin a query. (#207)
-- **Page/editor robustness batch.** Duplicating a page now copies shared
-  attachments for every referencing page (not just the first); colliding block
-  ids are de-duplicated on import/normalize so MCP addressed edits can't hit the
-  wrong node; transient collab store failures are retried so autosave edits
-  aren't lost; and an out-of-order tree move no longer drops the moved subtree.
-  (#206)
-
-### Security
-
-- **Public share AI: per-workspace rolling-day token budget.** The anonymous
-  share assistant now caps a workspace's actual token spend (input + output,
-  summed across every accepted turn) over a trailing day, on top of the hourly
-  request cap — so a caller who evades the per-IP throttle still cannot run up
-  the owner's provider bill without bound. Cluster-wide via Redis and FAILS
-  CLOSED if Redis is down; default 1,000,000 tokens/day, overridable via
-  `SHARE_AI_WORKSPACE_TOKEN_BUDGET_PER_DAY`. (#159)
 
 ## [0.93.0] - 2026-06-21
 
@@ -290,7 +124,8 @@ embeds — plus a large batch of security hardening and test coverage.
 - Page templates: import `ThrottleModule` so collab boots, never strand an
   in-flight page-embed id, and add defense-in-depth workspace checks.
 - Pages: `movePage` cycle guard with no phantom `PAGE_MOVED` event.
-- Import: surface the real error cause from `/pages/import` instead of a generic 400.
+- Import: surface the real error cause from `/pages/import` instead of a generic
+  400.
 
 ### Security
 

README.md

@@ -104,7 +104,6 @@ community feature, with no enterprise license. Open it from the page header; the
 - ✅ **Page templates** — flag a page as a template and embed its whole content live into other pages; edits to the template propagate to every place it is inserted (whole-page transclusion on top of the existing synced blocks).
 - ✅ **Public-share AI assistant** — anonymous visitors of a shared page can ask the AI agent, scoped strictly to that share's page tree (read-only, share-scoped search), behind a workspace toggle.
 - ✅ **Footnotes** — academic-style footnotes: a numbered superscript reference inline (read it in place via a hover popover), with the note text living as a real, editable block at the bottom of the page; auto-numbered, collaboration-safe, and round-trips through Markdown export/import and the AI agent / MCP.
-- ✅ **Temporary notes** — mark a note as temporary and it auto-moves to Trash after a configurable per-workspace lifetime (default 24h) unless made permanent first; create one in a click from the Home screen, any space overview, or the space sidebar, with a "Make permanent" rescue banner on the open note.
 
 ### In progress
 
@@ -115,7 +114,7 @@ community feature, with no enterprise license. Open it from the page header; the
 - 🔭 **Viewer comments** — let read-only viewers leave comments.
 - 🔭 **Password-protected pages** — protect individual pages / shares with a password.
 - 🔭 **Windows / Linux app** — native desktop app for Windows and Linux.
-- 🔭 **Mobile app** — mobile apps (iOS first, Android to follow), reusing the existing responsive web UI and editor via a Capacitor wrapper, with offline planned for later. See [issue #195](https://gitea.vvzvlad.xyz/vvzvlad/gitmost/issues/195).
+- 🔭 **Mobile app** — mobile apps (iOS first, Android to follow), reusing the existing responsive web UI and editor via a Capacitor wrapper, with offline planned for later. See [docs/mobile-app-plan.md](docs/mobile-app-plan.md).
 - 🔭 **Offline mode** — offline sync & PWA support.
 - 🔭 **Editor & UX improvements** — blocks inside tables (lists, to-do items), column layout, additional heading levels, highlight blocks, custom emoji in callouts, floating images, anchor links for page mentions, toggles (shared-page width, aside/sidebar, spellcheck, ligatures), sanitized space-tree export, and mentions in breadcrumbs.
 

README.ru.md

@@ -105,7 +105,6 @@ real-time-коллаборации Docmost, поэтому запись нико
 - ✅ **Шаблоны страниц** — пометить страницу шаблоном и вставлять её содержимое живой ссылкой в другие страницы; правки шаблона распространяются на все места вставки (whole-page-транслюзия поверх существующих synced-блоков).
 - ✅ **AI-ассистент на публичных шарах** — анонимный зритель расшаренной страницы может спросить AI-агента, который ищет строго по дереву этой шары (read-only, share-scoped поиск), за тумблером воркспейса.
 - ✅ **Сноски** — сноски академического вида: нумерованная ссылка-надстрочник прямо в тексте (читается на месте во всплывающем окне по наведению), а текст сноски живёт реальным редактируемым блоком внизу страницы; авто-нумерация, безопасна для совместного редактирования, переживает экспорт/импорт Markdown и доступна AI-агенту / MCP.
-- ✅ **Временные заметки** — пометьте заметку временной, и она автоматически уедет в корзину по истечении настраиваемого срока жизни воркспейса (по умолчанию 24 ч), если её предварительно не сделать постоянной; создать такую можно в один клик с домашнего экрана, с обзора любого пространства или из сайдбара пространства, а на открытой заметке есть баннер «Сделать постоянной».
 
 ### В процессе
 
@@ -116,7 +115,7 @@ real-time-коллаборации Docmost, поэтому запись нико
 - 🔭 **Комментарии зрителей** — возможность комментировать для пользователей с доступом только на чтение.
 - 🔭 **Защищённые паролем страницы** — защита отдельных страниц / шар паролем.
 - 🔭 **Приложение для Windows / Linux** — нативное десктоп-приложение для Windows и Linux.
-- 🔭 **Мобильное приложение** — мобильные приложения (iOS обязательно, Android как пойдёт) на базе существующей адаптивной веб-версии и редактора через обёртку Capacitor; оффлайн запланирован на будущее. См. [issue #195](https://gitea.vvzvlad.xyz/vvzvlad/gitmost/issues/195).
+- 🔭 **Мобильное приложение** — мобильные приложения (iOS обязательно, Android как пойдёт) на базе существующей адаптивной веб-версии и редактора через обёртку Capacitor; оффлайн запланирован на будущее. См. [docs/mobile-app-plan.md](docs/mobile-app-plan.md).
 - 🔭 **Офлайн-режим** — офлайн-синхронизация и поддержка PWA.
 - 🔭 **Улучшения редактора и UX** — блоки внутри таблиц (списки, чек-листы), колоночная вёрстка, дополнительные уровни заголовков, highlight-блоки, кастомные эмодзи в callout-ах, плавающие изображения, anchor-ссылки на упоминания страниц, тоглы (ширина шары, aside/сайдбар, spellcheck, лигатуры), санитизация экспорта дерева спейса и mentions в хлебных крошках.
 

apps/client/package.json

@@ -1,7 +1,7 @@
 {
   "name": "client",
   "private": true,
-  "version": "0.94.1",
+  "version": "0.93.0",
   "scripts": {
     "dev": "node scripts/copy-vad-assets.mjs && vite",
     "build": "node scripts/copy-vad-assets.mjs && tsc && vite build",

apps/client/public/locales/de-DE/translation.json

@@ -665,6 +665,9 @@
   "AI-powered search (AI Answers)": "KI-unterstützte Suche (KI-Antworten)",
   "AI search uses vector embeddings to provide semantic search capabilities across your workspace content.": "Die KI-Suche verwendet Vektor-Einbettungen, um semantische Suchfunktionen in Ihrem Arbeitsbereich bereitzustellen.",
   "Toggle AI search": "KI-Suche umschalten",
+  "Generative AI (Ask AI)": "Generative KI (KI fragen)",
+  "Enable AI-powered content generation in the editor. Allows users to generate, improve, translate and transform text.": "Aktivieren Sie die KI-unterstützte Inhaltserstellung im Editor. Ermöglicht Benutzern das Erzeugen, Verbessern, Übersetzen und Transformieren von Text.",
+  "Toggle generative AI": "Generative KI umschalten",
   "Upgrade your plan": "Upgrade Ihres Plans",
   "Available with a paid license": "Verfügbar mit einer kostenpflichtigen Lizenz",
   "Upgrade your license tier.": "Stufen Sie Ihre Lizenz hoch.",

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

@@ -258,7 +258,6 @@
   "Copy to space": "Copy to space",
   "Copy chat": "Copy chat",
   "Copied": "Copied",
-  "Failed to export chat": "Failed to export chat",
   "Duplicate": "Duplicate",
   "Select a user": "Select a user",
   "Select a group": "Select a group",
@@ -598,17 +597,6 @@
   "Are you sure you want to permanently delete '{{title}}'? This action cannot be undone.": "Are you sure you want to permanently delete '{{title}}'? This action cannot be undone.",
   "Restore '{{title}}' and its sub-pages?": "Restore '{{title}}' and its sub-pages?",
   "Move to trash": "Move to trash",
-  "Make temporary": "Make temporary",
-  "Make permanent": "Make permanent",
-  "New temporary note": "New temporary note",
-  "Temporary note": "Temporary note",
-  "Temporary notes": "Temporary notes",
-  "Temporary note — moves to trash unless made permanent": "Temporary note — moves to trash unless made permanent",
-  "Note will move to trash unless made permanent": "Note will move to trash unless made permanent",
-  "Note is now permanent": "Note is now permanent",
-  "Temporary note lifetime (hours)": "Temporary note lifetime (hours)",
-  "A temporary note is automatically moved to trash after this many hours unless it is made permanent. The deadline is fixed when the note is created.": "A temporary note is automatically moved to trash after this many hours unless it is made permanent. The deadline is fixed when the note is created.",
-  "This temporary note moves to trash {{time}} (with its sub-pages) unless made permanent.": "This temporary note moves to trash {{time}} (with its sub-pages) unless made permanent.",
   "Move this page to trash?": "Move this page to trash?",
   "Restore page": "Restore page",
   "Permanently delete": "Permanently delete",
@@ -687,6 +675,9 @@
   "AI-powered search (AI Answers)": "AI-powered search (AI Answers)",
   "AI search uses vector embeddings to provide semantic search capabilities across your workspace content.": "AI search uses vector embeddings to provide semantic search capabilities across your workspace content.",
   "Toggle AI search": "Toggle AI search",
+  "Generative AI (Ask AI)": "Generative AI (Ask AI)",
+  "Enable AI-powered content generation in the editor. Allows users to generate, improve, translate and transform text.": "Enable AI-powered content generation in the editor. Allows users to generate, improve, translate and transform text.",
+  "Toggle generative AI": "Toggle generative AI",
   "Upgrade your plan": "Upgrade your plan",
   "Available with a paid license": "Available with a paid license",
   "Upgrade your license tier.": "Upgrade your license tier.",
@@ -719,12 +710,9 @@
   "Authorization header": "Authorization header",
   "Tool allowlist": "Tool allowlist",
   "Optional. Leave empty to allow all tools the server exposes.": "Optional. Leave empty to allow all tools the server exposes.",
-  "Optional guidance for the agent on how and when to use this server's tools. Injected into the system prompt. The server's tools are namespaced as \"<server name>_*\".": "Optional guidance for the agent on how and when to use this server's tools. Injected into the system prompt. The server's tools are namespaced as \"<server name>_*\".",
   "Test": "Test",
   "Available tools": "Available tools",
   "No tools available": "No tools available",
-  "Failed": "Failed",
-  "OK · {{n}}": "OK · {{n}}",
   "Created successfully": "Created successfully",
   "Deleted successfully": "Deleted successfully",
   "Clear": "Clear",
@@ -1089,8 +1077,6 @@
   "Undo": "Undo",
   "Redo": "Redo",
   "Backlinks": "Backlinks",
-  "Back to references": "Back to references",
-  "Back to reference {{label}}": "Back to reference {{label}}",
   "Last updated by": "Last updated by",
   "Last updated": "Last updated",
   "Stats": "Stats",
@@ -1177,9 +1163,8 @@
   "Pick an agent role whose persona the public assistant adopts. The safety rules always still apply.": "Pick an agent role whose persona the public assistant adopts. The safety rules always still apply.",
   "Built-in assistant persona": "Built-in assistant persona",
   "Minimize": "Minimize",
-  "Context size / model limit": "Context size / model limit",
-  "Context window (tokens)": "Context window (tokens)",
-  "Shown as used / total in the chat header. Leave empty to hide the limit.": "Shown as used / total in the chat header. Leave empty to hide the limit.",
+  "Current context size": "Current context size",
+  "Tokens generated this turn": "Tokens generated this turn",
   "AI agent": "AI agent",
   "Take a look at the current document": "Take a look at the current document",
   "AI agent is typing…": "AI agent is typing…",
@@ -1188,8 +1173,6 @@
   "Send when the agent finishes": "Send when the agent finishes",
   "Queue message": "Queue message",
   "Remove queued message": "Remove queued message",
-  "Send now": "Send now",
-  "Interrupt and send now": "Interrupt and send now",
   "Stop": "Stop",
   "Response stopped.": "Response stopped.",
   "Connection lost — the answer was interrupted.": "Connection lost — the answer was interrupted.",
@@ -1324,27 +1307,5 @@
   "Page tree (child pages, recursive)": "Page tree (child pages, recursive)",
   "Render the full nested tree of all descendant pages": "Render the full nested tree of all descendant pages",
   "Showing {{count}} subpages_one": "Showing {{count}} subpage",
-  "Showing {{count}} subpages_other": "Showing {{count}} subpages",
-  "Protocol": "Protocol",
-  "How chat requests are sent and how reasoning is surfaced": "How chat requests are sent and how reasoning is surfaced",
-  "OpenAI-compatible (surfaces reasoning)": "OpenAI-compatible (surfaces reasoning)",
-  "OpenAI (official)": "OpenAI (official)",
-  "Custom address": "Custom address",
-  "A short, memorable link you can point at any shared page.": "A short, memorable link you can point at any shared page.",
-  "Use 2-60 lowercase letters, digits and hyphens": "Use 2-60 lowercase letters, digits and hyphens",
-  "This address is already in use": "This address is already in use",
-  "Move custom address?": "Move custom address?",
-  "Move here": "Move here",
-  "The address \"{{alias}}\" currently points to \"{{title}}\". Move it to this page?": "The address \"{{alias}}\" currently points to \"{{title}}\". Move it to this page?",
-  "The address \"{{alias}}\" is already in use. Move it to this page?": "The address \"{{alias}}\" is already in use. Move it to this page?",
-  "Failed to set custom address": "Failed to set custom address",
-  "Failed to remove custom address": "Failed to remove custom address",
-  "Generate title with AI": "Generate title with AI",
-  "Title generated": "Title generated",
-  "Failed to generate title": "Failed to generate title",
-  "The note is empty": "The note is empty",
-  "Could not generate a title": "Could not generate a title",
-  "AI title generation is disabled": "AI title generation is disabled",
-  "AI is not configured": "AI is not configured",
-  "Too many requests, please try again later": "Too many requests, please try again later"
+  "Showing {{count}} subpages_other": "Showing {{count}} subpages"
 }

apps/client/public/locales/es-ES/translation.json

@@ -665,6 +665,9 @@
   "AI-powered search (AI Answers)": "Búsqueda impulsada por IA (Respuestas de IA)",
   "AI search uses vector embeddings to provide semantic search capabilities across your workspace content.": "La búsqueda de IA utiliza incrustaciones vectoriales para proporcionar capacidades de búsqueda semántica en todo el contenido de su espacio de trabajo.",
   "Toggle AI search": "Alternar búsqueda de IA",
+  "Generative AI (Ask AI)": "IA generativa (Preguntar a la IA)",
+  "Enable AI-powered content generation in the editor. Allows users to generate, improve, translate and transform text.": "Habilitar la generación de contenido impulsada por IA en el editor. Permite a los usuarios generar, mejorar, traducir y transformar texto.",
+  "Toggle generative AI": "Activar IA generativa",
   "Upgrade your plan": "Mejora tu plan",
   "Available with a paid license": "Disponible con una licencia de pago",
   "Upgrade your license tier.": "Mejora el nivel de tu licencia.",

apps/client/public/locales/fr-FR/translation.json

@@ -665,6 +665,9 @@
   "AI-powered search (AI Answers)": "Recherche propulsée par IA (Réponses IA)",
   "AI search uses vector embeddings to provide semantic search capabilities across your workspace content.": "La recherche IA utilise des incorporations vectorielles pour fournir des capacités de recherche sémantique à travers le contenu de votre espace de travail.",
   "Toggle AI search": "Basculer la recherche IA",
+  "Generative AI (Ask AI)": "IA générative (Demandez à l'IA)",
+  "Enable AI-powered content generation in the editor. Allows users to generate, improve, translate and transform text.": "Activer la génération de contenu assistée par IA dans l'éditeur. Permet aux utilisateurs de générer, améliorer, traduire et transformer du texte.",
+  "Toggle generative AI": "Activer/désactiver l'IA générative",
   "Upgrade your plan": "Mettez à niveau votre forfait",
   "Available with a paid license": "Disponible avec une licence payante",
   "Upgrade your license tier.": "Mettez à niveau votre niveau de licence.",

apps/client/public/locales/it-IT/translation.json

@@ -665,6 +665,9 @@
   "AI-powered search (AI Answers)": "Ricerca con AI (Risposte AI)",
   "AI search uses vector embeddings to provide semantic search capabilities across your workspace content.": "La ricerca AI utilizza embeddings vettoriali per fornire capacità di ricerca semantica nel contenuto della tua area di lavoro.",
   "Toggle AI search": "Attiva/disattiva ricerca AI",
+  "Generative AI (Ask AI)": "AI generativa (Chiedi AI)",
+  "Enable AI-powered content generation in the editor. Allows users to generate, improve, translate and transform text.": "Abilita la generazione di contenuti con AI nell'editor. Consente agli utenti di generare, migliorare, tradurre e trasformare il testo.",
+  "Toggle generative AI": "Attiva/Disattiva AI generativa",
   "Upgrade your plan": "Aggiorna il tuo piano",
   "Available with a paid license": "Disponibile con una licenza a pagamento",
   "Upgrade your license tier.": "Aggiorna il livello della tua licenza.",

apps/client/public/locales/ja-JP/translation.json

@@ -665,6 +665,9 @@
   "AI-powered search (AI Answers)": "AI搭載検索 (AI回答)",
   "AI search uses vector embeddings to provide semantic search capabilities across your workspace content.": "AI検索はベクター埋め込みを使用してワークスペース全体の意味検索を実現します",
   "Toggle AI search": "AI検索を切り替え",
+  "Generative AI (Ask AI)": "生成AI (Ask AI)",
+  "Enable AI-powered content generation in the editor. Allows users to generate, improve, translate and transform text.": "エディターでAIを活用したコンテンツ生成を有効にします。ユーザーがテキストの生成、改善、翻訳、および変換を行うことができます。",
+  "Toggle generative AI": "生成AIを切り替える",
   "Upgrade your plan": "プランをアップグレードする",
   "Available with a paid license": "有料ライセンスで利用可能",
   "Upgrade your license tier.": "ライセンスタイアをアップグレードしてください。",

apps/client/public/locales/ko-KR/translation.json

@@ -665,6 +665,9 @@
   "AI-powered search (AI Answers)": "AI 구동 검색 (AI 답변)",
   "AI search uses vector embeddings to provide semantic search capabilities across your workspace content.": "AI 검색은 벡터 임베딩을 사용하여 작업공간 콘텐츠에 대한 의미 검색 기능을 제공합니다.",
   "Toggle AI search": "AI 검색 전환",
+  "Generative AI (Ask AI)": "생성 AI (Ask AI)",
+  "Enable AI-powered content generation in the editor. Allows users to generate, improve, translate and transform text.": "편집기에서 AI 구동 콘텐츠 생성을 활성화합니다. 사용자가 텍스트를 생성, 개선, 번역 및 변환할 수 있습니다.",
+  "Toggle generative AI": "생성 AI 토글",
   "Upgrade your plan": "요금제를 업그레이드하세요",
   "Available with a paid license": "유료 라이선스에서만 사용 가능합니다",
   "Upgrade your license tier.": "라이선스 등급을 업그레이드하세요.",

apps/client/public/locales/nl-NL/translation.json

@@ -665,6 +665,9 @@
   "AI-powered search (AI Answers)": "AI-gestuurde zoekopdracht (AI Antwoorden)",
   "AI search uses vector embeddings to provide semantic search capabilities across your workspace content.": "AI-zoekopdracht maakt gebruik van vectorembeddings om semantische zoekmogelijkheden te bieden in uw werkruimte-inhoud.",
   "Toggle AI search": "Schakel AI-zoekopdracht in/uit",
+  "Generative AI (Ask AI)": "Generatieve AI (Vraag het AI)",
+  "Enable AI-powered content generation in the editor. Allows users to generate, improve, translate and transform text.": "Schakel AI-gestuurde inhoudsgeneratie in de editor in. Hiermee kunnen gebruikers tekst genereren, verbeteren, vertalen en transformeren.",
+  "Toggle generative AI": "Generatieve AI schakelen",
   "Upgrade your plan": "Upgrade je abonnement",
   "Available with a paid license": "Beschikbaar met een betaalde licentie",
   "Upgrade your license tier.": "Upgrade je licentieniveau.",

apps/client/public/locales/pt-BR/translation.json

@@ -665,6 +665,9 @@
   "AI-powered search (AI Answers)": "Pesquisa com IA (Respostas de IA)",
   "AI search uses vector embeddings to provide semantic search capabilities across your workspace content.": "A pesquisa IA usa vetores de incorporação para fornecer capacidades de pesquisa semântica em todo o conteúdo do seu espaço de trabalho.",
   "Toggle AI search": "Alternar pesquisa de IA",
+  "Generative AI (Ask AI)": "IA generativa (Perguntar à IA)",
+  "Enable AI-powered content generation in the editor. Allows users to generate, improve, translate and transform text.": "Habilitar geração de conteúdo com IA no editor. Permite aos usuários gerar, melhorar, traduzir e transformar texto.",
+  "Toggle generative AI": "Alternar IA generativa",
   "Upgrade your plan": "Faça upgrade do seu plano",
   "Available with a paid license": "Disponível com uma licença paga",
   "Upgrade your license tier.": "Faça upgrade do seu nível de licença.",

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

@@ -257,7 +257,6 @@
   "Copy": "Копировать",
   "Copy to space": "Копировать в пространство",
   "Copied": "Скопировано",
-  "Failed to export chat": "Не удалось экспортировать чат",
   "Duplicate": "Дублировать",
   "Select a user": "Выберите пользователя",
   "Select a group": "Выберите группу",
@@ -406,8 +405,6 @@
   "Footnote {{number}}": "Сноска {{number}}",
   "Go to footnote": "Перейти к сноске",
   "Back to reference": "Вернуться к ссылке",
-  "Back to references": "Вернуться к ссылкам",
-  "Back to reference {{label}}": "Вернуться к ссылке {{label}}",
   "Empty footnote": "Пустая сноска",
   "Math inline": "Строчная формула",
   "Insert inline math equation.": "Вставить математическое выражение в строку.",
@@ -607,17 +604,6 @@
   "Are you sure you want to permanently delete '{{title}}'? This action cannot be undone.": "Вы уверены, что хотите окончательно удалить '{{title}}'? Это действие невозможно отменить.",
   "Restore '{{title}}' and its sub-pages?": "Восстановить '{{title}}' и её подстраницы?",
   "Move to trash": "Переместить в корзину",
-  "Make temporary": "Сделать временной",
-  "Make permanent": "Сделать постоянной",
-  "New temporary note": "Новая временная заметка",
-  "Temporary note": "Временная заметка",
-  "Temporary notes": "Временные заметки",
-  "Temporary note — moves to trash unless made permanent": "Временная заметка — уедет в корзину, если не сделать постоянной",
-  "Note will move to trash unless made permanent": "Заметка уедет в корзину, если не сделать её постоянной",
-  "Note is now permanent": "Заметка теперь постоянная",
-  "Temporary note lifetime (hours)": "Время жизни временной заметки (часы)",
-  "A temporary note is automatically moved to trash after this many hours unless it is made permanent. The deadline is fixed when the note is created.": "Временная заметка автоматически уезжает в корзину через указанное число часов, если не сделать её постоянной. Дедлайн фиксируется при создании заметки.",
-  "This temporary note moves to trash {{time}} (with its sub-pages) unless made permanent.": "Эта временная заметка уедет в корзину {{time}} (вместе с подстраницами), если не сделать её постоянной.",
   "Move this page to trash?": "Переместить эту страницу в корзину?",
   "Restore page": "Восстановить страницу",
   "Permanently delete": "Удалить навсегда",
@@ -715,27 +701,19 @@
   "Ask the AI agent…": "Спросите AI-агента…",
   "Copy chat": "Копировать чат",
   "Created successfully": "Успешно создано",
-  "Context size / model limit": "Размер контекста / лимит модели",
-  "Context window (tokens)": "Окно контекста (токены)",
-  "Shown as used / total in the chat header. Leave empty to hide the limit.": "Показывается в шапке чата как использовано / всего. Пусто — лимит скрыт.",
+  "Current context size": "Текущий размер контекста",
+  "Tokens generated this turn": "Токенов сгенерировано за ход",
   "Delete this chat?": "Удалить этот чат?",
   "Deleted successfully": "Успешно удалено",
   "Edited by AI agent on behalf of {{name}}": "Отредактировано AI-агентом от имени {{name}}",
   "Failed to delete chat": "Не удалось удалить чат",
   "Failed to rename chat": "Не удалось переименовать чат",
-  "Failed": "Ошибка",
-  "OK · {{n}}": "OK · {{n}}",
-  "Test": "Тест",
-  "No tools available": "Инструменты недоступны",
-  "Available tools": "Доступные инструменты",
   "Minimize": "Свернуть",
   "No chats yet.": "Чатов пока нет.",
   "Send": "Отправить",
   "Send when the agent finishes": "Отправить, когда агент закончит",
   "Queue message": "Поставить в очередь",
   "Remove queued message": "Убрать из очереди",
-  "Send now": "Отправить сейчас",
-  "Interrupt and send now": "Прервать и отправить сейчас",
   "Something went wrong": "Что-то пошло не так",
   "Stop": "Стоп",
   "The AI agent could not respond. Please try again.": "AI-агент не смог ответить. Попробуйте ещё раз.",
@@ -749,6 +727,9 @@
   "AI-powered search (AI Answers)": "Поиск на базе ИИ (Ответы ИИ)",
   "AI search uses vector embeddings to provide semantic search capabilities across your workspace content.": "Поиск ИИ использует векторные встраивания для обеспечения семантического поиска по содержимому вашего рабочего пространства.",
   "Toggle AI search": "Переключить поиск ИИ",
+  "Generative AI (Ask AI)": "Генеративный ИИ (Спросить ИИ)",
+  "Enable AI-powered content generation in the editor. Allows users to generate, improve, translate and transform text.": "Включите создание контента на базе ИИ в редакторе. Позволяет пользователям генерировать, улучшать, переводить и преобразовывать текст.",
+  "Toggle generative AI": "Переключить генеративный ИИ",
   "Upgrade your plan": "Обновите свой тарифный план",
   "Available with a paid license": "Доступно с платной лицензией",
   "Upgrade your license tier.": "Обновите уровень вашей лицензии.",
@@ -768,8 +749,6 @@
   "Manage API keys for all users in the workspace. View the <anchor>API documentation</anchor> for usage details.": "Управляйте API-ключами для всех пользователей в рабочем пространстве. Смотрите <anchor>документацию по API</anchor> для получения информации об использовании.",
   "View the <anchor>API documentation</anchor> for usage details.": "Смотрите <anchor>документацию по API</anchor> для получения информации об использовании.",
   "View the <anchor>MCP documentation</anchor>.": "Смотрите <anchor>документацию по MCP</anchor>.",
-  "Instructions": "Инструкции",
-  "Optional guidance for the agent on how and when to use this server's tools. Injected into the system prompt. The server's tools are namespaced as \"<server name>_*\".": "Необязательное указание агенту, как и когда использовать инструменты этого сервера. Добавляется в системный промпт. Инструменты сервера именуются с префиксом «<имя сервера>_*».",
   "Sources": "Источники",
   "AI Answers not available for attachments": "Ответы ИИ недоступны для вложений",
   "No answer available": "Ответ недоступен",
@@ -1181,27 +1160,5 @@
   "Render the full nested tree of all descendant pages": "Показать полное вложенное дерево всех дочерних страниц",
   "Showing {{count}} subpages_one": "Показано {{count}} подстраница",
   "Showing {{count}} subpages_few": "Показано {{count}} подстраницы",
-  "Showing {{count}} subpages_many": "Показано {{count}} подстраниц",
-  "Protocol": "Протокол",
-  "How chat requests are sent and how reasoning is surfaced": "Как отправляются запросы чата и как показывается reasoning",
-  "OpenAI-compatible (surfaces reasoning)": "OpenAI-совместимый (показывает reasoning)",
-  "OpenAI (official)": "OpenAI (официальный)",
-  "Custom address": "Пользовательский адрес",
-  "A short, memorable link you can point at any shared page.": "Короткая запоминающаяся ссылка, которую можно направить на любую опубликованную страницу.",
-  "Use 2-60 lowercase letters, digits and hyphens": "Используйте 2–60 строчных букв, цифр и дефисов",
-  "This address is already in use": "Этот адрес уже занят",
-  "Move custom address?": "Переместить пользовательский адрес?",
-  "Move here": "Переместить сюда",
-  "The address \"{{alias}}\" currently points to \"{{title}}\". Move it to this page?": "Адрес «{{alias}}» сейчас указывает на «{{title}}». Переместить его на эту страницу?",
-  "The address \"{{alias}}\" is already in use. Move it to this page?": "Адрес «{{alias}}» уже используется. Переместить его на эту страницу?",
-  "Failed to set custom address": "Не удалось задать пользовательский адрес",
-  "Failed to remove custom address": "Не удалось удалить пользовательский адрес",
-  "Generate title with AI": "Сгенерировать название через AI",
-  "Title generated": "Название сгенерировано",
-  "Failed to generate title": "Не удалось сгенерировать название",
-  "The note is empty": "Заметка пустая",
-  "Could not generate a title": "Не удалось придумать название",
-  "AI title generation is disabled": "Генерация названий через AI отключена",
-  "AI is not configured": "AI не настроен",
-  "Too many requests, please try again later": "Слишком много запросов, попробуйте позже"
+  "Showing {{count}} subpages_many": "Показано {{count}} подстраниц"
 }

apps/client/public/locales/uk-UA/translation.json

@@ -665,6 +665,9 @@
   "AI-powered search (AI Answers)": "Пошук на базі ШІ (Відповіді ШІ)",
   "AI search uses vector embeddings to provide semantic search capabilities across your workspace content.": "Пошук з ШІ використовує векторні вбудовування для надання можливостей семантичного пошуку у вашому робочому вмісті.",
   "Toggle AI search": "Переключити пошук з ШІ",
+  "Generative AI (Ask AI)": "Генеративний ШІ (Запитати ШІ)",
+  "Enable AI-powered content generation in the editor. Allows users to generate, improve, translate and transform text.": "Увімкнути генерацію контенту за допомогою ШІ в редакторі. Дозволяє користувачам генерувати, покращувати, перекладати та трансформувати текст.",
+  "Toggle generative AI": "Переключити генеративний ШІ",
   "Upgrade your plan": "Оновіть свій тарифний план",
   "Available with a paid license": "Доступно за платною ліцензією",
   "Upgrade your license tier.": "Оновіть рівень своєї ліцензії.",

apps/client/public/locales/zh-CN/translation.json

@@ -665,6 +665,9 @@
   "AI-powered search (AI Answers)": "AI驱动的搜索 (AI答案)",
   "AI search uses vector embeddings to provide semantic search capabilities across your workspace content.": "AI搜索使用向量嵌入提供跨工作空间内容的语义搜索功能。",
   "Toggle AI search": "切换AI搜索",
+  "Generative AI (Ask AI)": "生成型AI (询问AI)",
+  "Enable AI-powered content generation in the editor. Allows users to generate, improve, translate and transform text.": "在编辑器中启用AI驱动的内容生成。允许用户生成、改进、翻译和转换文本。",
+  "Toggle generative AI": "切换生成型AI",
   "Upgrade your plan": "升级您的方案",
   "Available with a paid license": "需付费许可才可用",
   "Upgrade your license tier.": "升级您的许可等级。",

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

@@ -6,6 +6,7 @@ import {
   useRef,
   useState,
 } from "react";
+import { type UIMessage } from "@ai-sdk/react";
 import { Group, Loader, Tooltip } from "@mantine/core";
 import {
   IconArrowsDiagonal,
@@ -39,13 +40,12 @@ import {
 } from "@/features/ai-chat/queries/ai-chat-query.ts";
 import ConversationList from "@/features/ai-chat/components/conversation-list.tsx";
 import ChatThread from "@/features/ai-chat/components/chat-thread.tsx";
-import { exportAiChat } from "@/features/ai-chat/services/ai-chat-service.ts";
+import { buildChatMarkdown } from "@/features/ai-chat/utils/chat-markdown.ts";
 import { useChatSession } from "@/features/ai-chat/hooks/use-chat-session.ts";
 import {
   shouldCollapseOnOutsidePointer,
   isHeaderClick,
 } from "@/features/ai-chat/utils/collapse-helpers.ts";
-import { selectContextBadge } from "@/features/ai-chat/utils/context-badge.ts";
 import { useClipboard } from "@/hooks/use-clipboard";
 import { notifications } from "@mantine/notifications";
 import classes from "@/features/ai-chat/components/ai-chat-window.module.css";
@@ -80,31 +80,17 @@ function computeInitialGeom() {
     Math.min(DEFAULT_HEIGHT, window.innerHeight - 2 * EDGE_MARGIN),
   );
   const left = Math.max(EDGE_MARGIN, window.innerWidth - width - 24);
-  const maxTop = Math.max(
-    EDGE_MARGIN,
-    window.innerHeight - height - EDGE_MARGIN,
-  );
+  const maxTop = Math.max(EDGE_MARGIN, window.innerHeight - height - EDGE_MARGIN);
   const top = Math.min(60, maxTop);
   return { left, top, width, height };
 }
 
 // Clamp a geometry so the window stays within the current viewport.
-function clampGeom(g: {
-  left: number;
-  top: number;
-  width: number;
-  height: number;
-}) {
+function clampGeom(g: { left: number; top: number; width: number; height: number }) {
   const effWidth = Math.max(g.width, MIN_WIDTH);
   const effHeight = Math.max(g.height, MIN_HEIGHT);
-  const maxLeft = Math.max(
-    EDGE_MARGIN,
-    window.innerWidth - effWidth - EDGE_MARGIN,
-  );
-  const maxTop = Math.max(
-    EDGE_MARGIN,
-    window.innerHeight - effHeight - EDGE_MARGIN,
-  );
+  const maxLeft = Math.max(EDGE_MARGIN, window.innerWidth - effWidth - EDGE_MARGIN);
+  const maxTop = Math.max(EDGE_MARGIN, window.innerHeight - effHeight - EDGE_MARGIN);
   return {
     ...g,
     left: Math.min(Math.max(EDGE_MARGIN, g.left), maxLeft),
@@ -121,7 +107,7 @@ function clampGeom(g: {
  * ported from the GitmostAgent.jsx design.
  */
 export default function AiChatWindow() {
-  const { t, i18n } = useTranslation();
+  const { t } = useTranslation();
   const clipboard = useClipboard({ timeout: 500 });
   const queryClient = useQueryClient();
   const [windowOpen, setWindowOpen] = useAtom(aiChatWindowOpenAtom);
@@ -162,6 +148,20 @@ export default function AiChatWindow() {
   const { data: messageRows, isLoading: messagesLoading } =
     useAiChatMessagesQuery(activeChatId ?? undefined);
 
+  // Live snapshot of the active thread's useChat state, kept up to date by
+  // ChatThread. Lets the export include the in-progress (not-yet-persisted)
+  // streaming turn. A ref avoids re-rendering this window on every token.
+  const liveThreadRef = useRef<{ messages: UIMessage[]; isStreaming: boolean }>({
+    messages: [],
+    isStreaming: false,
+  });
+
+  // Live turn-token total (reasoning + output) for the in-flight turn, pushed up
+  // (THROTTLED to ~8 Hz inside ChatThread) so the header badge ticks mid-stream.
+  // `null` means no turn is in flight -> the badge falls back to the persisted
+  // context size below.
+  const [liveTurnTokens, setLiveTurnTokens] = useState<number | null>(null);
+
   // 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"
@@ -185,23 +185,17 @@ export default function AiChatWindow() {
   // The invalidate closures are passed inline: `onTurnFinished` is read live by
   // useChat's onFinish (never in an effect dep array), so their identity does not
   // matter — no memoization ceremony needed.
-  const {
-    threadKey,
-    waitingForHistory,
-    startFreshThread,
-    onTurnFinished,
-    onServerChatId,
-    cancelPendingAdoption,
-  } = useChatSession({
-    activeChatId,
-    setActiveChatId,
-    chats,
-    messagesLoading,
-    onInvalidateChatList: () =>
-      queryClient.invalidateQueries({ queryKey: AI_CHATS_RQ_KEY }),
-    onInvalidateChatMessages: (id) =>
-      queryClient.invalidateQueries({ queryKey: AI_CHAT_MESSAGES_RQ_KEY(id) }),
-  });
+  const { threadKey, waitingForHistory, onTurnFinished, cancelPendingAdoption } =
+    useChatSession({
+      activeChatId,
+      setActiveChatId,
+      chats,
+      messagesLoading,
+      onInvalidateChatList: () =>
+        queryClient.invalidateQueries({ queryKey: AI_CHATS_RQ_KEY }),
+      onInvalidateChatMessages: (id) =>
+        queryClient.invalidateQueries({ queryKey: AI_CHAT_MESSAGES_RQ_KEY(id) }),
+    });
 
   // startNewChat/selectChat set the public atom; the hook's render-phase
   // reconciler handles the remount when activeChatId actually CHANGES. But
@@ -211,25 +205,12 @@ export default function AiChatWindow() {
   // just-failed chat after they chose a fresh one.
   const startNewChat = useCallback((): void => {
     cancelPendingAdoption();
-    // Force a fresh, empty thread UNCONDITIONALLY (#161). Pressing "New chat"
-    // while a brand-new chat's first turn is still streaming leaves activeChatId
-    // null (the real id is adopted only at turn end), so setActiveChatId(null)
-    // alone is a no-op and the reconciler never remounts — the chat/stream/history
-    // would persist and only the role badge would drop. This always remounts the
-    // thread into a clean new chat.
-    startFreshThread();
     setActiveChatId(null);
     setHistoryOpen(false);
     setDraft("");
     // Default the picker back to "Universal assistant" for the fresh chat.
     setSelectedRoleId(null);
-  }, [
-    cancelPendingAdoption,
-    startFreshThread,
-    setActiveChatId,
-    setDraft,
-    setSelectedRoleId,
-  ]);
+  }, [cancelPendingAdoption, setActiveChatId, setDraft, setSelectedRoleId]);
 
   const selectChat = useCallback(
     (chatId: string): void => {
@@ -244,28 +225,19 @@ export default function AiChatWindow() {
     [cancelPendingAdoption, setActiveChatId, setDraft, setSelectedRoleId],
   );
 
-  // The active chat object (for its title) and an export gate. The export is now
-  // SERVER-sourced (the DB is the single source of truth — #183): the assistant
-  // row is persisted upfront + per step, so even a brand-new chat whose first
-  // turn is streaming/interrupted has a server row to render. Enable the button
-  // whenever a persisted chat is active (`activeChatId` is set). For a BRAND-NEW
-  // chat that id is adopted EARLY — at the stream's `start` chunk via
-  // onServerChatId (#174) — so the Copy button is available during the first
-  // turn's stream, not only after it terminates.
+  // The active chat object (for its title) and an export gate: only enable the
+  // export button when an existing chat with loaded persisted rows is active.
   const activeChat = useMemo(
     () => chats?.items?.find((c) => c.id === activeChatId) ?? null,
     [chats, activeChatId],
   );
-  const canExport = !!activeChatId;
+  const canExport = !!activeChatId && !!messageRows && messageRows.length > 0;
 
   // The role to display in the header and as the assistant's name. Prefer the
   // persisted role of an existing chat (chat-list JOIN); fall back to the role
   // picked via a card click for a brand-new or just-adopted chat. selectChat
   // resets selectedRoleId, so this fallback never leaks into an unrelated chat.
-  const currentRole = useMemo<{
-    name: string;
-    emoji: string | null;
-  } | null>(() => {
+  const currentRole = useMemo<{ name: string; emoji: string | null } | null>(() => {
     if (activeChat?.roleName) {
       return { name: activeChat.roleName, emoji: activeChat.roleEmoji ?? null };
     }
@@ -273,21 +245,37 @@ export default function AiChatWindow() {
     return picked ? { name: picked.name, emoji: picked.emoji } : null;
   }, [activeChat, enabledRoles, selectedRoleId]);
 
-  // Fetch the server-rendered Markdown export and copy it to the clipboard. The
-  // server is the single source of truth (#183): it renders the transcript from
-  // the persisted rows — including an interrupted turn's in-progress row — so the
-  // export is identical whether the chat is freshly streaming, just switched to,
-  // or reloaded. The `lang` of the active i18n drives the few localized labels.
-  const handleCopy = useCallback(async () => {
-    if (!activeChatId) return;
-    try {
-      const markdown = await exportAiChat(activeChatId, i18n.language);
-      clipboard.copy(markdown);
-      notifications.show({ message: t("Copied") });
-    } catch {
-      notifications.show({ message: t("Failed to export chat"), color: "red" });
-    }
-  }, [activeChatId, clipboard, t, i18n.language]);
+  // Build a Markdown export from the already-loaded persisted rows (no network
+  // call) and copy it to the clipboard. The "Copied" notification is the
+  // feedback.
+  const handleCopy = useCallback(() => {
+    if (!activeChatId || !messageRows || messageRows.length === 0) return;
+    // While the active thread is streaming, the current user message and the
+    // in-progress assistant reply are NOT yet in messageRows (the persisted
+    // query is only refetched after the turn finishes). Pull the live tail —
+    // messages whose id is not among the persisted rows — and append them,
+    // flagging the streaming assistant message as still generating.
+    const live = liveThreadRef.current;
+    const rowIds = new Set(messageRows.map((r) => r.id));
+    const pending = live.isStreaming
+      ? live.messages
+          .filter((m) => !rowIds.has(m.id))
+          .map((m) => ({
+            role: m.role,
+            parts: (m.parts ?? []) as { type: string; text?: string }[],
+            generating: m.role === "assistant",
+          }))
+      : [];
+    const markdown = buildChatMarkdown({
+      title: activeChat?.title ?? null,
+      chatId: activeChatId,
+      rows: messageRows,
+      pending,
+      t,
+    });
+    clipboard.copy(markdown);
+    notifications.show({ message: t("Copied") });
+  }, [activeChatId, messageRows, activeChat, clipboard, t]);
 
   // Current context size for the active chat: how much the conversation now
   // occupies in the model's context window — NOT the cumulative tokens spent.
@@ -296,19 +284,24 @@ export default function AiChatWindow() {
   // shipped; older rows fall back to that turn's `usage` total. NOTE: reflects
   // PERSISTED rows (updates on chat open/switch); it does not tick live
   // mid-stream — acceptable for v1.
-  //
-  // The denominator `maxContextTokens` (the model's configured max window) is
-  // derived in the SAME backward scan: it is stamped alongside `contextTokens`
-  // on a completed turn, but the numerator and denominator are taken from the
-  // most recent row carrying EACH value independently — they may land on
-  // different rows (e.g. a fresh error row can carry contextTokens but not
-  // maxContextTokens), so we keep scanning for whichever is still unset. 0 when
-  // no row has it (older rows, or no admin-configured limit) — the badge then
-  // shows just the current size with no denominator.
-  const { contextTokens, maxContextTokens } = useMemo(
-    () => selectContextBadge(activeChatId ? messageRows : undefined),
-    [activeChatId, messageRows],
-  );
+  const contextTokens = useMemo(() => {
+    if (!activeChatId || !messageRows) return 0;
+    for (let i = messageRows.length - 1; i >= 0; i--) {
+      const meta = messageRows[i].metadata;
+      if (!meta) continue;
+      if (typeof meta.contextTokens === "number" && meta.contextTokens > 0) {
+        return meta.contextTokens;
+      }
+      const usage = meta.usage;
+      if (usage) {
+        const fallback =
+          usage.totalTokens ??
+          (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0);
+        if (fallback > 0) return fallback;
+      }
+    }
+    return 0;
+  }, [activeChatId, messageRows]);
 
   // On (re)open, settle the geometry before paint (useLayoutEffect → no
   // first-frame jump): compute an initial top-right placement the first time,
@@ -358,8 +351,7 @@ export default function AiChatWindow() {
       const width = el.offsetWidth;
       const height = el.offsetHeight;
       setGeom((prev) => {
-        if (!prev || (prev.width === width && prev.height === height))
-          return prev;
+        if (!prev || (prev.width === width && prev.height === height)) return prev;
         return { ...prev, width, height };
       });
     });
@@ -499,18 +491,17 @@ export default function AiChatWindow() {
         )}
 
         <div style={{ flex: 1, display: "flex", justifyContent: "center" }}>
-          {/* Always show the persisted "current / max" context. The denominator
-              (the admin-configured model limit) is appended only when known;
-              not clamped when current > max (shown as-is, e.g. "210k / 200k").
-              Hidden entirely until a turn has recorded a context figure. */}
-          {contextTokens > 0 ? (
-            <Tooltip label={t("Context size / model limit")} withArrow>
-              <span className={classes.badge}>
-                {formatTokens(contextTokens)}
-                {maxContextTokens > 0
-                  ? ` / ${formatTokens(maxContextTokens)}`
-                  : ""}
-              </span>
+          {/* While a turn streams, show the LIVE turn-token count (ticks ~8 Hz);
+              once it finishes, fall back to the persisted context size. Require
+              > 0 so the very first emit (an empty tail message, count 0) does not
+              flash a "0" badge before any token streams in (#151 review). */}
+          {liveTurnTokens !== null && liveTurnTokens > 0 ? (
+            <Tooltip label={t("Tokens generated this turn")} withArrow>
+              <span className={classes.badge}>{formatTokens(liveTurnTokens)}</span>
+            </Tooltip>
+          ) : contextTokens > 0 ? (
+            <Tooltip label={t("Current context size")} withArrow>
+              <span className={classes.badge}>{formatTokens(contextTokens)}</span>
             </Tooltip>
           ) : null}
         </div>
@@ -524,11 +515,7 @@ export default function AiChatWindow() {
               aria-label={t("Copy chat")}
               onClick={handleCopy}
             >
-              {clipboard.copied ? (
-                <IconCheck size={14} />
-              ) : (
-                <IconCopy size={14} />
-              )}
+              {clipboard.copied ? <IconCheck size={14} /> : <IconCopy size={14} />}
             </button>
           )}
           <button
@@ -623,7 +610,6 @@ export default function AiChatWindow() {
           ) : (
             <ChatThread
               key={threadKey}
-              threadKey={threadKey}
               chatId={activeChatId}
               initialRows={activeChatId ? messageRows : []}
               openPage={openPage}
@@ -635,7 +621,8 @@ export default function AiChatWindow() {
               onRolePicked={(role) => setSelectedRoleId(role.id)}
               assistantName={currentRole?.name}
               onTurnFinished={onTurnFinished}
-              onServerChatId={onServerChatId}
+              liveStateRef={liveThreadRef}
+              onLiveTurnTokens={setLiveTurnTokens}
             />
           )}
         </div>

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

@@ -55,45 +55,6 @@
     padding-inline-start: 1.4em;
 }
 
-/* GFM tables in assistant markdown. The chat lives in a NARROW side panel, so a
-   wide LLM table must scroll horizontally instead of collapsing its columns:
-   `.markdown` sets `word-break: break-word`, which (with the default table
-   layout) shrinks columns to a single glyph and wraps headers mid-word
-   ("Секция" -> "Секци / я"). Make the table a horizontally scrollable block,
-   give cells a readable minimum width, and restore word-boundary wrapping. */
-.markdown table {
-    display: block;
-    /* lets the table scroll horizontally on its own */
-    max-width: 100%;
-    overflow-x: auto;
-    border-collapse: collapse;
-    margin-block-end: 0.5em;
-}
-
-.markdown th,
-.markdown td {
-    border: 1px solid light-dark(var(--mantine-color-gray-3), var(--mantine-color-dark-4));
-    padding: 3px 8px;
-    /* readable floor; the block scrolls when the row exceeds the panel */
-    min-width: 6em;
-    text-align: left;
-    vertical-align: top;
-    /* cancel the inherited break-word so words don't split mid-glyph */
-    word-break: normal;
-    /* still wrap genuinely long words / URLs at the cell edge */
-    overflow-wrap: break-word;
-}
-
-.markdown th {
-    background: light-dark(var(--mantine-color-gray-1), var(--mantine-color-dark-5));
-    font-weight: 600;
-}
-
-/* GFM wraps cell text in <p>; drop its default block margin inside cells. */
-.markdown table p {
-    margin: 0;
-}
-
 /* Animated three-dot "typing" indicator shown while the agent is thinking but
    has not yet produced any visible text/tool parts. */
 .typingDots {
@@ -161,11 +122,7 @@
     margin-top: 4px;
     font-size: var(--mantine-font-size-xs);
     color: light-dark(var(--mantine-color-gray-7), var(--mantine-color-dark-1));
-    /* 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 plain-text fallback <Text> that needs pre-wrap sets it
-       inline itself (see reasoning-block.tsx). */
+    white-space: pre-wrap;
 }
 
 .reasoningText p {

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

@@ -1,142 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-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
-// above the imports) can expose the captured useChat callbacks / transport and
-// the spies back to the test body.
-const h = vi.hoisted(() => ({
-  state: {
-    status: "streaming" as string,
-    onFinish: null as null | ((arg: Record<string, unknown>) => void),
-    sendMessage: vi.fn(),
-    stop: vi.fn(),
-    transport: null as null | {
-      prepareSendMessagesRequest: (arg: {
-        messages: unknown[];
-        body: Record<string, unknown>;
-      }) => { body: Record<string, unknown> };
-    },
-  },
-}));
-
-// Mock useChat: capture onFinish, return the spies and the controllable status.
-vi.mock("@ai-sdk/react", () => ({
-  useChat: (opts: { onFinish?: (arg: Record<string, unknown>) => void }) => {
-    h.state.onFinish = opts.onFinish ?? null;
-    return {
-      messages: [],
-      sendMessage: h.state.sendMessage,
-      status: h.state.status,
-      stop: h.state.stop,
-      error: null,
-    };
-  },
-}));
-
-// Mock "ai": deterministic ids + a transport that records its options so the test
-// can invoke prepareSendMessagesRequest and assert the `interrupted` flag.
-vi.mock("ai", () => {
-  let counter = 0;
-  return {
-    generateId: () => `gid-${counter++}`,
-    DefaultChatTransport: class {
-      constructor(opts: {
-        prepareSendMessagesRequest: (arg: {
-          messages: unknown[];
-          body: Record<string, unknown>;
-        }) => { body: Record<string, unknown> };
-      }) {
-        h.state.transport = opts;
-      }
-    },
-  };
-});
-
-// Stub the heavy children: MessageList (markdown/render) and ChatInput (the
-// composer). The ChatInput stub exposes a button that queues a message, the only
-// interaction this test needs to populate the queue while "streaming".
-vi.mock("@/features/ai-chat/components/message-list.tsx", () => ({
-  default: () => <div data-testid="message-list" />,
-}));
-vi.mock("@/features/ai-chat/components/chat-input.tsx", () => ({
-  default: ({ onQueue }: { onQueue: (text: string) => void }) => (
-    <button data-testid="queue-btn" onClick={() => onQueue("queued text")}>
-      queue
-    </button>
-  ),
-}));
-
-import ChatThread from "./chat-thread";
-
-function renderThread() {
-  const onTurnFinished = vi.fn();
-  render(
-    <MantineProvider>
-      <ChatThread chatId="c1" initialRows={[]} onTurnFinished={onTurnFinished} />
-    </MantineProvider>,
-  );
-  return { onTurnFinished };
-}
-
-describe("ChatThread — send now (#198)", () => {
-  beforeEach(() => {
-    h.state.status = "streaming";
-    h.state.onFinish = null;
-    h.state.sendMessage.mockClear();
-    h.state.stop.mockClear();
-    h.state.transport = null;
-  });
-
-  it("aborts the current turn and resends the queued message on the abort", () => {
-    renderThread();
-
-    // Queue a message while the turn is streaming.
-    fireEvent.click(screen.getByTestId("queue-btn"));
-    const sendNowBtn = screen.getByLabelText("Send now");
-    expect(sendNowBtn).toBeTruthy();
-
-    // "Send now" interrupts the current turn (stop), but does NOT send yet —
-    // the resend happens once the abort lands in onFinish.
-    fireEvent.click(sendNowBtn);
-    expect(h.state.stop).toHaveBeenCalledTimes(1);
-    expect(h.state.sendMessage).not.toHaveBeenCalled();
-
-    // The abort we triggered reaches onFinish: the promoted head is flushed.
-    act(() => {
-      h.state.onFinish?.({
-        message: { id: "a", role: "assistant", parts: [] },
-        isAbort: true,
-        isDisconnect: false,
-        isError: false,
-      });
-    });
-    expect(h.state.sendMessage).toHaveBeenCalledWith({ text: "queued text" });
-  });
-
-  it("tags exactly the next send as interrupted (one-shot flag)", () => {
-    renderThread();
-    fireEvent.click(screen.getByTestId("queue-btn"));
-    fireEvent.click(screen.getByLabelText("Send now"));
-
-    const prep = h.state.transport!.prepareSendMessagesRequest;
-    // The send right after "send now" carries interrupted: true...
-    expect(prep({ messages: [], body: {} }).body.interrupted).toBe(true);
-    // ...and only that one (the flag is read-and-cleared).
-    expect(prep({ messages: [], body: {} }).body.interrupted).toBe(false);
-  });
-
-  it("sends immediately without an interrupt when not streaming", () => {
-    h.state.status = "ready";
-    renderThread();
-
-    fireEvent.click(screen.getByTestId("queue-btn"));
-    fireEvent.click(screen.getByLabelText("Send now"));
-
-    // No turn to interrupt: sent straight away, no abort, not flagged.
-    expect(h.state.stop).not.toHaveBeenCalled();
-    expect(h.state.sendMessage).toHaveBeenCalledWith({ text: "queued text" });
-    const prep = h.state.transport!.prepareSendMessagesRequest;
-    expect(prep({ messages: [], body: {} }).body.interrupted).toBe(false);
-  });
-});

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

@@ -1,11 +1,14 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { generateId } from "ai";
-import { ActionIcon, Box, Group, Stack, Text, Tooltip } from "@mantine/core";
 import {
-  IconClockHour4,
-  IconPlayerPlayFilled,
-  IconX,
-} from "@tabler/icons-react";
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  type MutableRefObject,
+} from "react";
+import { generateId } from "ai";
+import { ActionIcon, Box, Group, Stack, Text } from "@mantine/core";
+import { IconClockHour4, IconX } from "@tabler/icons-react";
 import { useTranslation } from "react-i18next";
 import { useChat, type UIMessage } from "@ai-sdk/react";
 import { DefaultChatTransport } from "ai";
@@ -24,23 +27,15 @@ 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 { liveTurnTokens } from "@/features/ai-chat/utils/count-stream-tokens.ts";
 import {
   dequeue,
   enqueueMessage,
-  promoteToHead,
   removeQueuedById,
   type QueuedMessage,
 } from "@/features/ai-chat/utils/queue-helpers.ts";
 import classes from "@/features/ai-chat/components/ai-chat.module.css";
 
-// Throttle how often the streamed `messages` state triggers a re-render. Without
-// it, useChat updates state on EVERY token, so the whole transcript's markdown
-// (marked + DOMPurify) is re-parsed per token — on a long agent run that grows
-// into a quadratic CPU storm that pins the main thread and freezes the UI.
-// ~50ms (20 Hz) keeps streaming visually smooth while decoupling re-render cost
-// from the token rate.
-const STREAM_THROTTLE_MS = 50;
-
 /** The page the user is currently viewing, sent as chat context. */
 export interface OpenPageContext {
   id: string;
@@ -50,11 +45,6 @@ export interface OpenPageContext {
 interface ChatThreadProps {
   /** The open chat id, or null for a brand-new (not-yet-created) chat. */
   chatId: string | null;
-  /** This thread's mount key (the same value the parent uses as React `key`).
-   *  Forwarded to onTurnFinished so the session can tell a turn finishing on the
-   *  CURRENT thread from one ABANDONED by New chat mid-stream — whose onFinish/
-   *  onError still fire after unmount and must not adopt the abandoned chat (#161). */
-  threadKey?: string;
   /** Persisted rows to seed initial messages (existing chats only). */
   initialRows?: IAiChatMessageRow[];
   /** The page currently open in the workspace, or null on a non-page route.
@@ -76,16 +66,20 @@ interface ChatThreadProps {
   /** Called when a turn finishes; the parent refreshes the chat list and, for a
    *  new chat, adopts the freshly created chat id. `serverChatId` is the
    *  authoritative id the server streamed on the assistant message metadata, or
-   *  undefined on a failed turn — see adopt-chat-id.ts for the full #137 design.
-   *  `finishingThreadKey` (this thread's mount key) lets the session ignore a turn
-   *  finishing on a thread already abandoned by New chat mid-stream (#161). */
-  onTurnFinished: (serverChatId?: string, finishingThreadKey?: string) => void;
-  /** Called EARLY (at the stream's `start` chunk) with the authoritative server
-   *  chat id streamed on the assistant message metadata, so a brand-new chat
-   *  adopts its real id WHILE the first turn is still streaming (#174 — makes the
-   *  Copy/export button available mid-stream). Distinct from onTurnFinished,
-   *  which fires only at the terminal outcome. */
-  onServerChatId?: (serverChatId?: string) => void;
+   *  undefined on a failed turn — see adopt-chat-id.ts for the full #137 design. */
+  onTurnFinished: (serverChatId?: string) => void;
+  /** Parent-owned ref that this thread keeps updated with its live useChat
+   *  snapshot (full message list + streaming flag), so the header's
+   *  "Copy chat" export can include the in-progress, not-yet-persisted
+   *  assistant message. A ref (not state) avoids re-rendering the parent on
+   *  every streamed delta. */
+  liveStateRef?: MutableRefObject<{ messages: UIMessage[]; isStreaming: boolean }>;
+  /** Reports the live turn-token total (reasoning + output) for the in-flight
+   *  turn so the parent can show a header badge that ticks mid-stream. THROTTLED
+   *  here (~8 Hz) so the parent re-renders a handful of times a second, not on
+   *  every streamed delta. Called with `null` when no turn is in flight (the
+   *  parent then reverts the badge to the persisted context size). */
+  onLiveTurnTokens?: (tokens: number | null) => void;
 }
 
 /**
@@ -122,7 +116,6 @@ function rowToUiMessage(row: IAiChatMessageRow): UIMessage {
  */
 export default function ChatThread({
   chatId,
-  threadKey,
   initialRows,
   openPage,
   roleId,
@@ -130,7 +123,8 @@ export default function ChatThread({
   onRolePicked,
   assistantName,
   onTurnFinished,
-  onServerChatId,
+  liveStateRef,
+  onLiveTurnTokens,
 }: ChatThreadProps) {
   const { t } = useTranslation();
 
@@ -206,25 +200,12 @@ export default function ChatThread({
   // helper can call the current instance from the stable `onFinish` callback.
   const sendMessageRef = useRef<((m: { text: string }) => void) | null>(null);
 
-  // "Send now" single-flight flags. Kept in refs (not state) so they are read
-  // inside the stable `onFinish` callback and the transport closure WITHOUT a
-  // re-render or a stale closure. Both are one-shot (read-and-clear).
-  // - flushOnAbortRef: flush the promoted head on the abort WE triggered, even
-  //   though an aborted turn normally keeps the queue intact.
-  // - interruptNextSendRef: tag the next send as a user interrupt so the server
-  //   injects the "your previous answer was interrupted" note for that turn only.
-  const flushOnAbortRef = useRef(false);
-  const interruptNextSendRef = 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.
   const flushNext = useCallback(() => {
     const { head, rest } = dequeue(queuedRef.current);
-    if (!head) return false;
+    if (!head) return;
     setQueue(rest);
     sendMessageRef.current?.({ text: head.text });
-    return true;
   }, [setQueue]);
 
   const enqueue = useCallback(
@@ -250,26 +231,17 @@ export default function ChatThread({
         // when null) and tell the agent which page "this page" refers to. Both
         // are read live from refs so changing chats/pages does NOT recreate the
         // transport. `openPage` is null on a non-page route.
-        prepareSendMessagesRequest: ({ messages, body }) => {
-          // Read-and-clear the interrupt flag so the "you were interrupted" note
-          // is carried by ONLY this request (the one resending the promoted
-          // message right after we aborted the previous turn). The server still
-          // confirms it against history before acting on it.
-          const interrupted = interruptNextSendRef.current;
-          interruptNextSendRef.current = false; // one-shot
-          return {
-            body: {
-              ...body,
-              chatId: chatIdRef.current,
-              openPage: openPageRef.current,
-              // Honoured by the server only when creating a new chat; null =>
-              // universal assistant.
-              roleId: roleIdRef.current,
-              interrupted,
-              messages,
-            },
-          };
-        },
+        prepareSendMessagesRequest: ({ messages, body }) => ({
+          body: {
+            ...body,
+            chatId: chatIdRef.current,
+            openPage: openPageRef.current,
+            // Honoured by the server only when creating a new chat; null =>
+            // universal assistant.
+            roleId: roleIdRef.current,
+            messages,
+          },
+        }),
       }),
     [],
   );
@@ -281,8 +253,6 @@ export default function ChatThread({
     id: chatStoreId,
     messages: initialMessages,
     transport,
-    // See STREAM_THROTTLE_MS — bounds re-render/markdown-reparse frequency.
-    experimental_throttle: STREAM_THROTTLE_MS,
     // `onFinish` (ai@6 useChat) fires from a `finally` on EVERY terminal outcome
     // — success, user Stop/abort (`isAbort`), network drop (`isDisconnect`), and
     // stream error (`isError`). Keep calling `onTurnFinished()` on all of them
@@ -294,31 +264,14 @@ export default function ChatThread({
     onFinish: ({ message, isAbort, isDisconnect, isError }) => {
       // Forward the authoritative server chatId (streamed on the assistant
       // message metadata) so the parent adopts the REAL created chat id for a new
-      // chat — see adopt-chat-id.ts for the full #137 design. `threadKey` lets the
-      // session ignore this finish if it belongs to a thread abandoned by New chat
-      // mid-stream (#161).
-      onTurnFinished(extractServerChatId(message), threadKey);
+      // chat — see adopt-chat-id.ts for the full #137 design.
+      onTurnFinished(extractServerChatId(message));
       // Show a neutral "stopped" marker for an aborted turn; the red error banner
       // (via `error`) already covers isError, and a clean finish clears any marker.
       if (isError) setStopNotice(null);
       else if (isAbort) setStopNotice("manual");
       else if (isDisconnect) setStopNotice("disconnect");
       else setStopNotice(null);
-      // "Send now": WE triggered this abort to interrupt the current turn and
-      // immediately send the promoted head. Flush it even though the turn was
-      // aborted (the normal abort path below keeps the queue intact). The
-      // interrupt note travels with this send via interruptNextSendRef.
-      if (flushOnAbortRef.current) {
-        flushOnAbortRef.current = false;
-        // Suppress the "Response stopped." flash for an intentional interrupt.
-        setStopNotice(null);
-        // If the promoted head vanished (e.g. the user removed it before the
-        // abort landed) flushNext sends nothing — clear the one-shot interrupt
-        // tag so it can't leak onto the next unrelated send. On a real send the
-        // tag is consumed by prepareSendMessagesRequest and stays untouched.
-        if (!flushNext()) interruptNextSendRef.current = false;
-        return;
-      }
       if (isAbort || isDisconnect || isError) return;
       flushNext();
     },
@@ -333,40 +286,13 @@ export default function ChatThread({
       // Surface the raw failure in the browser console (devtools) for debugging;
       // the UI separately shows a friendly classified banner (see errorView).
       console.error("AI chat stream error:", streamError);
-      onTurnFinished(undefined, threadKey);
+      onTurnFinished();
     },
   });
 
   // Keep the flush helper pointed at the latest sendMessage instance.
   sendMessageRef.current = sendMessage;
 
-  // Mirror the live turn status in a ref so event handlers (sendNow) branch on the
-  // CURRENT status rather than a value captured in a stale render closure — a turn
-  // can finish between render and click, and arming the interrupt refs against a
-  // no-op stop() would leave them set to leak into a later, unrelated Stop.
-  const statusRef = useRef(status);
-  statusRef.current = status;
-
-  // EARLY chat-id adoption (#174): the server streams the authoritative chat id
-  // on the assistant message metadata at the `start` chunk (message.metadata.
-  // chatId — see adopt-chat-id.ts / chatStreamMetadata). Forward it to the parent
-  // AS SOON AS it appears (mid-stream), so a brand-new chat adopts its real id
-  // WHILE the first turn is still streaming and activeChatId-gated affordances
-  // (the Copy/export button) light up immediately, instead of only at onFinish.
-  // Keyed by the last-seen id so we forward each distinct id exactly once. The
-  // parent's onServerChatId is idempotent and a no-op once the chat has an id.
-  const lastForwardedChatIdRef = useRef<string | undefined>(undefined);
-  useEffect(() => {
-    if (!onServerChatId) return;
-    const tail = messages[messages.length - 1];
-    if (tail?.role !== "assistant") return;
-    const serverChatId = extractServerChatId(tail);
-    if (!serverChatId || serverChatId === lastForwardedChatIdRef.current)
-      return;
-    lastForwardedChatIdRef.current = serverChatId;
-    onServerChatId(serverChatId);
-  }, [messages, onServerChatId]);
-
   // Live "turn was interrupted" marker for the CURRENT session. The red error
   // banner (driven by `error`) covers the error case; this covers an aborted
   // turn, distinguishing a manual Stop (`isAbort`) from a dropped connection
@@ -378,55 +304,75 @@ export default function ChatThread({
 
   const isStreaming = status === "submitted" || status === "streaming";
 
-  // "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
-  // queue/flush machinery: promote the target to the head, then abort — the
-  // onFinish flush-on-abort branch sends exactly that head, tagged as an
-  // interrupt so the server notes the previous answer was cut off.
-  const sendNow = useCallback(
-    (id: string) => {
-      // Branch on the LIVE status (statusRef), NOT the closure-captured isStreaming:
-      // the turn may have finished between this render and the click, in which case
-      // stop() is a no-op and arming the interrupt refs would strand them for a
-      // later, unrelated Stop. Reading the ref always sees the current status.
-      const liveStreaming =
-        statusRef.current === "submitted" || statusRef.current === "streaming";
-      if (liveStreaming) {
-        // Promote to head so the onFinish -> flushNext path sends exactly it.
-        setQueue(promoteToHead(queuedRef.current, id));
-        flushOnAbortRef.current = true;
-        interruptNextSendRef.current = true;
-        stop(); // -> onFinish({ isAbort: true }) flushes the promoted head
-      } else {
-        // Nothing to interrupt: just send it now (no interrupt note).
-        const msg = queuedRef.current.find((m) => m.id === id);
-        if (!msg) return;
-        setQueue(removeQueuedById(queuedRef.current, id));
-        sendMessageRef.current?.({ text: msg.text });
-      }
-    },
-    [setQueue, stop],
-  );
-
-  // 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
-  // this effect runs, so clearing here is a no-op for it; its purpose is to defuse
-  // the race where a flag was armed but the expected abort never fired (the turn
-  // finished in the same tick as the click), so it cannot leak into a later turn.
+  // Clear the stopped marker as soon as a new turn begins streaming.
   useEffect(() => {
-    if (isStreaming) {
-      setStopNotice(null);
-      flushOnAbortRef.current = false;
-      interruptNextSendRef.current = false;
-    }
+    if (isStreaming) setStopNotice(null);
   }, [isStreaming]);
 
+  // Mirror the live useChat snapshot into the parent-owned ref so the export
+  // (handled in AiChatWindow) can include the in-progress streaming turn. The
+  // cleanup clears the ref on unmount so a thread torn down by `key` on chat
+  // switch can't leak its (possibly still-streaming) tail into the next chat's
+  // export before the new thread's effect repopulates the ref.
+  useEffect(() => {
+    if (!liveStateRef) return;
+    liveStateRef.current = { messages, isStreaming };
+    return () => {
+      liveStateRef.current = { messages: [], isStreaming: false };
+    };
+  }, [liveStateRef, messages, isStreaming]);
+
+  // Report the live turn-token total to the parent header badge, THROTTLED to
+  // ~8 Hz so the parent re-renders a few times a second instead of on every
+  // streamed delta. The tail assistant message's reasoning+output (estimate while
+  // streaming, authoritative once a step reports usage) is the live figure. When
+  // the turn ends we emit a final exact value, then `null` so the parent reverts
+  // the badge to the persisted context size.
+  const lastEmitRef = useRef(0);
+  const emitTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  useEffect(() => {
+    if (!onLiveTurnTokens) return;
+    if (!isStreaming) {
+      // Turn ended (or never started): clear any pending throttle and revert.
+      if (emitTimerRef.current) {
+        clearTimeout(emitTimerRef.current);
+        emitTimerRef.current = null;
+      }
+      lastEmitRef.current = 0;
+      onLiveTurnTokens(null);
+      return;
+    }
+    const tail = messages[messages.length - 1];
+    const live =
+      tail?.role === "assistant" ? liveTurnTokens(tail) : null;
+    const total = live ? live.reasoning + live.output : 0;
+    const now = Date.now();
+    const MIN_INTERVAL = 120; // ms (~8 Hz)
+    const elapsed = now - lastEmitRef.current;
+    if (elapsed >= MIN_INTERVAL) {
+      lastEmitRef.current = now;
+      onLiveTurnTokens(total);
+    } else if (!emitTimerRef.current) {
+      // Schedule a trailing emit so the FINAL value of a burst is not dropped.
+      emitTimerRef.current = setTimeout(() => {
+        emitTimerRef.current = null;
+        lastEmitRef.current = Date.now();
+        onLiveTurnTokens(total);
+      }, MIN_INTERVAL - elapsed);
+    }
+  }, [messages, isStreaming, onLiveTurnTokens]);
+
+  // Clear any pending throttle timer on unmount (chat switch via `key`) so a
+  // trailing emit can't fire into a torn-down thread's parent.
+  useEffect(() => {
+    return () => {
+      if (emitTimerRef.current) clearTimeout(emitTimerRef.current);
+    };
+  }, []);
+
   // Classify the turn error into a heading + detail so the banner names the cause
   // (connection reset, timeout, rate limit, context overflow, quota, ...) instead
-  // of a generic "Something went wrong". Computed here (not only in the JSX) so
-  // the SAME on-screen banner text can be mirrored into the export (issue #160).
+  // of a generic "Something went wrong".
   const errorView = error ? describeChatError(error.message ?? "", t) : null;
 
   // A role was picked with autoStart=false: the role is bound but NOTHING was
@@ -512,17 +458,6 @@ export default function ChatThread({
                 <Text size="xs" lineClamp={2} className={classes.queuedText}>
                   {m.text}
                 </Text>
-                <Tooltip label={t("Interrupt and send now")} withArrow>
-                  <ActionIcon
-                    size="xs"
-                    variant="subtle"
-                    color="blue"
-                    onClick={() => sendNow(m.id)}
-                    aria-label={t("Send now")}
-                  >
-                    <IconPlayerPlayFilled size={12} />
-                  </ActionIcon>
-                </Tooltip>
                 <ActionIcon
                   size="xs"
                   variant="subtle"

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

@@ -1,116 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { render } from "@testing-library/react";
-import { MantineProvider } from "@mantine/core";
-import type { UIMessage } from "@ai-sdk/react";
-
-// Stub react-i18next (the component reads `useTranslation`). Mirrors the stub in
-// reasoning-block.test.tsx.
-vi.mock("react-i18next", () => ({
-  useTranslation: () => ({ t: (key: string) => key }),
-}));
-
-// Spy on `renderChatMarkdown` so we can count parse calls per text. We keep every
-// OTHER named export of markdown.ts intact via `importActual`, and override only
-// `renderChatMarkdown` with a `vi.fn()` that returns simple HTML so the component
-// still renders. This is the seam that proves the MarkdownPart memo works: a
-// finalized text part must NOT be re-parsed on a later streamed delta.
-// `vi.hoisted` so the spy exists when the hoisted `vi.mock` factory runs.
-const { renderChatMarkdownSpy } = vi.hoisted(() => ({
-  renderChatMarkdownSpy: vi.fn((text: string) => `<p>${text}</p>`),
-}));
-vi.mock("@/features/ai-chat/utils/markdown.ts", async () => {
-  const actual = await vi.importActual<
-    typeof import("@/features/ai-chat/utils/markdown.ts")
-  >("@/features/ai-chat/utils/markdown.ts");
-  return { ...actual, renderChatMarkdown: renderChatMarkdownSpy };
-});
-
-import MessageItem from "./message-item";
-import { messageSignature } from "@/features/ai-chat/utils/message-signature.ts";
-
-// matchMedia (read by MantineProvider) is stubbed globally in vitest.setup.ts.
-
-const msg = (parts: UIMessage["parts"]): UIMessage =>
-  ({ id: "m1", role: "assistant", parts }) as UIMessage;
-
-// Mirror MessageList: snapshot the signature at (parent) render time and pass it
-// as the memo key. The signature must NOT be recomputed inside the memo from the
-// live (mutable) message — see message-item.tsx.
-const renderRow = (message: UIMessage) =>
-  render(
-    <MantineProvider>
-      <MessageItem message={message} signature={messageSignature(message)} />
-    </MantineProvider>,
-  );
-
-/** Count how many spy calls parsed exactly `text` (filtering by the first arg). */
-const callsFor = (text: string) =>
-  renderChatMarkdownSpy.mock.calls.filter((c) => c[0] === text).length;
-
-describe("MessageItem markdown memoization", () => {
-  it("does not re-parse finalized text parts when only a tail part grows", () => {
-    renderChatMarkdownSpy.mockClear();
-
-    // Two finalized text parts.
-    const first = msg([
-      { type: "text", text: "alpha" },
-      { type: "text", text: "beta" },
-    ]);
-    const { rerender } = renderRow(first);
-
-    // Both finalized parts parsed exactly once on the initial render.
-    expect(callsFor("alpha")).toBe(1);
-    expect(callsFor("beta")).toBe(1);
-
-    // A streamed delta: a NEW message object where only a third tail part grows;
-    // the first two parts' text is byte-identical.
-    const next = msg([
-      { type: "text", text: "alpha" },
-      { type: "text", text: "beta" },
-      { type: "text", text: "gamm" },
-    ]);
-    rerender(
-      <MantineProvider>
-        <MessageItem message={next} signature={messageSignature(next)} />
-      </MantineProvider>,
-    );
-
-    // The finalized parts hit the MarkdownPart memo: still parsed at most once
-    // each across BOTH renders (the resilient invariant). The only new parse is
-    // for the changed/added tail part.
-    expect(callsFor("alpha")).toBe(1);
-    expect(callsFor("beta")).toBe(1);
-    expect(callsFor("gamm")).toBe(1);
-  });
-
-  // REGRESSION (empty-render bug): the AI SDK streams a turn by MUTATING the same
-  // `parts` IN PLACE and reusing the message object. A row that mounted empty
-  // (reasoning-first providers render nothing at first) must still stream its text
-  // in once the parent hands down a fresh signature snapshot. Before the fix the
-  // memo recomputed the signature from the (mutated) message — identical on both
-  // sides — and froze the row at its empty render, so the answer never appeared.
-  it("streams text in after the row mounted empty and parts mutated in place", () => {
-    renderChatMarkdownSpy.mockClear();
-    // Reuse ONE message object across renders (as the SDK does).
-    const message = msg([{ type: "text", text: "" }]);
-    const { rerender, queryByText } = render(
-      <MantineProvider>
-        <MessageItem message={message} signature={messageSignature(message)} />
-      </MantineProvider>,
-    );
-    // Empty text part: nothing visible rendered yet.
-    expect(queryByText("streamed answer")).toBeNull();
-
-    // SDK delta: mutate the SAME part in place, then re-render with a NEW snapshot.
-    (message.parts[0] as { text: string }).text = "streamed answer";
-    rerender(
-      <MantineProvider>
-        <MessageItem message={message} signature={messageSignature(message)} />
-      </MantineProvider>,
-    );
-
-    // The grown text now renders (the memo did NOT freeze the empty mount).
-    expect(callsFor("streamed answer")).toBe(1);
-    expect(queryByText("streamed answer")).not.toBeNull();
-  });
-});

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

@@ -1,112 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import type { UIMessage } from "@ai-sdk/react";
-
-// Stub react-i18next: importing the component module pulls in `useTranslation`,
-// and we only exercise the pure `arePropsEqual` comparator (no rendering), so a
-// minimal `t` that echoes the key is enough. Mirrors the stub in
-// reasoning-block.test.tsx.
-vi.mock("react-i18next", () => ({
-  useTranslation: () => ({ t: (key: string) => key }),
-}));
-
-import { arePropsEqual } from "./message-item";
-import { messageSignature } from "@/features/ai-chat/utils/message-signature.ts";
-
-/**
- * Tests for `arePropsEqual`, the `React.memo` comparator for MessageItem. It must
- * return false on any visible prop/content change (so the row re-renders) and
- * true when nothing visible changed (so a finalized row is skipped). The memo key
- * is the `signature` PROP — an immutable snapshot the PARENT (MessageList) takes
- * per render via `messageSignature(message)`. A FIXED message id is used so a
- * content-identical clone yields an equal signature.
- */
-const msg = (parts: UIMessage["parts"]): UIMessage =>
-  ({ id: "m1", role: "assistant", parts }) as UIMessage;
-
-// Build the props the parent would pass, INCLUDING the snapshot signature it
-// computes during its own render (the load-bearing part — see message-item.tsx:
-// the signature must never be recomputed inside arePropsEqual).
-const props = (
-  message: UIMessage,
-  over: Record<string, unknown> = {},
-) => ({
-  message,
-  signature: messageSignature(message),
-  showCitations: true,
-  neutralizeInternalLinks: false,
-  assistantName: "AI",
-  ...over,
-});
-
-describe("arePropsEqual", () => {
-  it("returns false when showCitations differs", () => {
-    const m = msg([{ type: "text", text: "answer" }]);
-    expect(
-      arePropsEqual(props(m), props(m, { showCitations: false })),
-    ).toBe(false);
-  });
-
-  it("returns false when neutralizeInternalLinks differs", () => {
-    const m = msg([{ type: "text", text: "answer" }]);
-    expect(
-      arePropsEqual(props(m), props(m, { neutralizeInternalLinks: true })),
-    ).toBe(false);
-  });
-
-  it("returns false when assistantName differs", () => {
-    const m = msg([{ type: "text", text: "answer" }]);
-    expect(
-      arePropsEqual(props(m), props(m, { assistantName: "Other" })),
-    ).toBe(false);
-  });
-
-  it("returns true for equal snapshot + equal props (finalized row skipped)", () => {
-    const m = msg([{ type: "text", text: "answer" }]);
-    expect(arePropsEqual(props(m), props(m))).toBe(true);
-  });
-
-  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" }]);
-    expect(a).not.toBe(b);
-    expect(arePropsEqual(props(a), props(b))).toBe(true);
-  });
-
-  it("returns false when content changed in a different message object", () => {
-    const a = msg([{ type: "text", text: "answer" }]);
-    const b = msg([{ type: "text", text: "answer grown" }]);
-    expect(arePropsEqual(props(a), props(b))).toBe(false);
-  });
-
-  // REGRESSION (empty-render bug): the AI SDK streams deltas by mutating the SAME
-  // `parts` in place and handing back a message wrapper that SHARES them. So the
-  // PREVIOUS and NEXT props can carry the SAME (mutated) message object, and
-  // recomputing `messageSignature(message)` inside the comparator would read
-  // identical (latest) content on BOTH sides → always "equal" → the memo skips
-  // every streamed update and the assistant row freezes at its initial empty
-  // render. The comparator MUST instead trust the immutable `signature` SNAPSHOT
-  // the parent captured at each render. This fails against the old implementation
-  // (a `prev.message === next.message` fast path + a signature recomputed from the
-  // live objects).
-  it("re-renders when parts were mutated in place but the snapshot changed", () => {
-    const message = msg([{ type: "text", text: "" }]); // empty (renders null)
-    const prevSig = messageSignature(message); // snapshot BEFORE the delta
-    // SDK streams a delta by mutating the shared part IN PLACE:
-    (message.parts[0] as { text: string }).text = "hello world";
-    const nextSig = messageSignature(message); // snapshot AFTER the delta
-    expect(prevSig).not.toBe(nextSig);
-    // Same object reference on both sides (the SDK reuses it), differing snapshots.
-    const base = {
-      message,
-      showCitations: true,
-      neutralizeInternalLinks: false,
-      assistantName: "AI",
-    };
-    expect(
-      arePropsEqual(
-        { ...base, signature: prevSig },
-        { ...base, signature: nextSig },
-      ),
-    ).toBe(false);
-  });
-});

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

@@ -1,4 +1,3 @@
-import { memo } from "react";
 import { Box, Text } from "@mantine/core";
 import { useTranslation } from "react-i18next";
 import type { UIMessage } from "@ai-sdk/react";
@@ -16,25 +15,6 @@ import classes from "@/features/ai-chat/components/ai-chat.module.css";
 
 interface MessageItemProps {
   message: UIMessage;
-  /**
-   * Immutable content signature for `message`, computed by the PARENT
-   * (MessageList) during its render via `messageSignature(message)`. This is the
-   * memo key (see `arePropsEqual`): it MUST be a snapshot captured at render time,
-   * NOT recomputed from `message` inside `arePropsEqual`.
-   *
-   * WHY (load-bearing): the AI SDK streams deltas by mutating the SAME `parts`
-   * array/objects in place and handing back a message wrapper that SHARES those
-   * mutated parts. So inside `arePropsEqual`, `prev.message` and `next.message`
-   * both reflect the CURRENT (latest) parts — `messageSignature(prev.message) ===
-   * messageSignature(next.message)` is therefore ALWAYS true, the memo skips every
-   * post-mount render, and the assistant row freezes at its initial empty (null)
-   * render — i.e. the streamed answer + tool cards never appear (reasoning-first
-   * providers start empty, so NOTHING shows). Snapshotting the signature into this
-   * immutable string prop in the parent fixes that: `prev.signature` holds the
-   * value from the previous render (old content) and `next.signature` the new
-   * content, so they differ as the turn streams in and the row re-renders.
-   */
-  signature: string;
   /**
    * Forwarded to ToolCallCard: whether tool cards render page citation links.
    * Defaults to true (internal chat). The public share passes false.
@@ -54,39 +34,6 @@ interface MessageItemProps {
   assistantName?: string;
 }
 
-/**
- * One assistant text part rendered as sanitized markdown. Memoized on its inputs
- * so a finalized text part is NOT re-parsed on every streamed delta: during a
- * turn only the actively-growing tail part changes its `text`, so every earlier
- * part hits the memo and skips the expensive marked + DOMPurify pass. Props are
- * primitives, so React.memo's default shallow compare is exactly right (the
- * `text` string is compared by value).
- */
-const MarkdownPart = memo(function MarkdownPart({
-  text,
-  neutralizeInternalLinks,
-}: {
-  text: string;
-  neutralizeInternalLinks: boolean;
-}) {
-  const html = renderChatMarkdown(text, { neutralizeInternalLinks });
-  if (html) {
-    return (
-      <div
-        className={classes.markdown}
-        // Sanitized by renderChatMarkdown (DOMPurify) before insertion.
-        dangerouslySetInnerHTML={{ __html: html }}
-      />
-    );
-  }
-  // Fallback when markdown could not render synchronously: raw text.
-  return (
-    <Text className={classes.markdown} style={{ whiteSpace: "pre-wrap" }}>
-      {text}
-    </Text>
-  );
-});
-
 /**
  * Render a single UIMessage by iterating its `parts`:
  *  - `text` parts -> sanitized markdown.
@@ -94,20 +41,17 @@ const MarkdownPart = memo(function MarkdownPart({
  * Other part kinds (reasoning, sources, files, step-start) are ignored for v1.
  * User messages render their text as a right-aligned plain bubble.
  *
- * This component is memoized (see `arePropsEqual` at the bottom) on a cheap
- * per-message content signature: the streaming TAIL message's signature changes
- * on each delta so it still re-renders and streams in, while finalized rows are
- * skipped. Each text part's markdown is itself memoized via `MarkdownPart`, so a
- * long turn no longer re-parses the whole transcript on every token.
+ * This component is intentionally NOT memoized: `useChat` replaces the streaming
+ * assistant message with a freshly cloned object on every streamed delta, so the
+ * `message` prop identity (and its `parts`) changes each tick. Re-rendering the
+ * text parts on each delta is what makes the answer stream in progressively.
  */
-function MessageItem({
+export default function MessageItem({
   message,
   showCitations = true,
   neutralizeInternalLinks = false,
   assistantName,
 }: MessageItemProps) {
-  // `signature` is intentionally not read in the body — it exists solely as the
-  // memo key (see arePropsEqual). The render reads `message` directly.
   const { t } = useTranslation();
   const isUser = message.role === "user";
 
@@ -165,12 +109,24 @@ function MessageItem({
           // starts with an empty text part before the first token arrives); the
           // typing indicator covers that gap until real content streams in.
           if (!part.text.trim()) return null;
+          const html = renderChatMarkdown(part.text, {
+            neutralizeInternalLinks,
+          });
+          if (html) {
+            return (
+              <div
+                key={index}
+                className={classes.markdown}
+                // Sanitized by renderChatMarkdown (DOMPurify) before insertion.
+                dangerouslySetInnerHTML={{ __html: html }}
+              />
+            );
+          }
+          // Fallback when markdown could not render synchronously: raw text.
           return (
-            <MarkdownPart
-              key={index}
-              text={part.text}
-              neutralizeInternalLinks={neutralizeInternalLinks}
-            />
+            <Text key={index} className={classes.markdown} style={{ whiteSpace: "pre-wrap" }}>
+              {part.text}
+            </Text>
           );
         }
 
@@ -221,32 +177,3 @@ function MessageItem({
     </Box>
   );
 }
-
-/** Skip re-rendering a message whose visible content is unchanged. The streaming
- *  TAIL message gets a fresh `signature` snapshot each delta (computed by the
- *  parent), so it still re-renders and streams in; every FINALIZED message keeps
- *  the same signature and is skipped, turning a per-token whole-transcript
- *  re-render into a tail-only one.
- *
- *  CRITICAL: compare the `signature` PROP (an immutable snapshot the parent took
- *  at its own render), NEVER `messageSignature(prev.message)` vs
- *  `messageSignature(next.message)`. The AI SDK mutates the shared `parts` in
- *  place, so both `prev.message` and `next.message` reflect the latest content
- *  here — recomputing the signature from them yields equal strings every time and
- *  freezes the row at its initial empty render (the bug this guards against). See
- *  the `signature` prop doc. Likewise there is NO `prev.message === next.message`
- *  fast path: same-reference-but-mutated must still re-render when the snapshot
- *  signature changed. */
-export function arePropsEqual(
-  prev: MessageItemProps,
-  next: MessageItemProps,
-): boolean {
-  return (
-    prev.signature === next.signature &&
-    prev.showCitations === next.showCitations &&
-    prev.neutralizeInternalLinks === next.neutralizeInternalLinks &&
-    prev.assistantName === next.assistantName
-  );
-}
-
-export default memo(MessageItem, arePropsEqual);

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

@@ -1,119 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { render } from "@testing-library/react";
-import { MantineProvider } from "@mantine/core";
-import type { UIMessage } from "@ai-sdk/react";
-
-// Stub react-i18next (MessageList and TypingIndicator read `useTranslation`).
-// Mirrors the t-mock pattern used by the other component tests in this folder
-// (reasoning-block.test.tsx, message-item-memo.test.tsx).
-vi.mock("react-i18next", () => ({
-  useTranslation: () => ({ t: (key: string) => key }),
-}));
-
-// Spy on `renderChatMarkdown` exactly as message-item-memo.test.tsx does: keep
-// every OTHER named export of markdown.ts intact via `importActual`, and override
-// only `renderChatMarkdown` with a `vi.fn()` that returns simple HTML. This makes
-// assertions synchronous (no async marked + DOMPurify pass) and lets us count
-// parses by argument. `vi.hoisted` so the spy exists when the hoisted `vi.mock`
-// factory runs.
-const { renderChatMarkdownSpy } = vi.hoisted(() => ({
-  renderChatMarkdownSpy: vi.fn((text: string) => `<p>${text}</p>`),
-}));
-vi.mock("@/features/ai-chat/utils/markdown.ts", async () => {
-  const actual = await vi.importActual<
-    typeof import("@/features/ai-chat/utils/markdown.ts")
-  >("@/features/ai-chat/utils/markdown.ts");
-  return { ...actual, renderChatMarkdown: renderChatMarkdownSpy };
-});
-
-// IMPORTANT: do NOT mock MessageItem and do NOT mock messageSignature — exercising
-// the REAL MessageList -> real MessageItem -> real messageSignature wiring is the
-// whole point of this file (it closes the parent-side coverage gap left by the
-// memo tests, which simulate the parent by hardcoding `signature={...}` in their
-// harness). Use the relative import for the component under test, mirroring how
-// message-list.tsx itself imports `MessageItem from "./message-item"`.
-import MessageList from "./message-list";
-
-// matchMedia / localStorage / sessionStorage (read by MantineProvider and app
-// code) are stubbed globally in vitest.setup.ts — do NOT re-stub those here.
-//
-// MessageList renders Mantine's ScrollArea, which constructs a `ResizeObserver`.
-// jsdom does not implement it, so install a minimal no-op stub BEFORE rendering.
-vi.stubGlobal(
-  "ResizeObserver",
-  class {
-    observe() {}
-    unobserve() {}
-    disconnect() {}
-  },
-);
-
-// 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.
-const msg = (parts: UIMessage["parts"]): UIMessage =>
-  ({ id: "m1", role: "assistant", parts }) as UIMessage;
-
-describe("MessageList", () => {
-  it("wires the real MessageItem and supplies a valid signature end-to-end", () => {
-    renderChatMarkdownSpy.mockClear();
-    const { queryByText } = render(
-      <MantineProvider>
-        <MessageList
-          messages={[msg([{ type: "text", text: "hello world" }])]}
-          isStreaming={false}
-        />
-      </MantineProvider>,
-    );
-    // The assistant text renders, which proves MessageList mounted the real
-    // MessageItem and handed it a valid `signature` prop (computed from the real
-    // `messageSignature`) — the full parent -> child -> markdown path is live.
-    expect(queryByText("hello world")).not.toBeNull();
-  });
-
-  // REGRESSION (PR #224, the empty-render freeze). The AI SDK streams a turn by
-  // MUTATING the same `parts` array IN PLACE and handing back a NEW array each
-  // delta that REUSES the same message object. The fix moved the content signature
-  // to the PARENT: MessageList must recompute `messageSignature(message)` FRESH on
-  // every render and forward it as the immutable `signature` prop, so MessageItem's
-  // memo (which compares that prop snapshot) sees it change and re-renders the row.
-  //
-  // This test exercises the PARENT half that the memo tests only simulate: if
-  // MessageList ever cached/memoized the signature keyed on the message object's
-  // identity (which stays stable across deltas while its `parts` mutate in place),
-  // the snapshot would never change, MessageItem's memo would skip every delta, and
-  // the row would freeze at its empty mount — exactly the regression class. That
-  // would make this test fail. See message-item.tsx (`signature` prop +
-  // `arePropsEqual`) and message-list.tsx (the `signature={messageSignature(...)}`
-  // snapshot at render time).
-  it("reflects in-place part mutation of a reused message object across renders", () => {
-    renderChatMarkdownSpy.mockClear();
-    // Reuse ONE message object across renders (as the SDK does). The empty text
-    // part means MessageItem renders nothing visible initially.
-    const message = msg([{ type: "text", text: "" }]);
-    const { rerender, queryByText } = render(
-      <MantineProvider>
-        <MessageList messages={[message]} isStreaming />
-      </MantineProvider>,
-    );
-    // Nothing streamed yet.
-    expect(queryByText("streamed answer")).toBeNull();
-
-    // SDK delta: mutate the SAME part in place on the SAME message object...
-    (message.parts[0] as { text: string }).text = "streamed answer";
-    // ...then re-render with a NEW array literal that still holds the SAME mutated
-    // message object (this mirrors useChat handing back a fresh array of reused
-    // message objects on each delta).
-    rerender(
-      <MantineProvider>
-        <MessageList messages={[message]} isStreaming />
-      </MantineProvider>,
-    );
-
-    // The grown text now renders: MessageList re-snapshotted the signature, so the
-    // row re-rendered instead of freezing at its empty mount.
-    expect(queryByText("streamed answer")).not.toBeNull();
-    expect(
-      renderChatMarkdownSpy.mock.calls.some((c) => c[0] === "streamed answer"),
-    ).toBe(true);
-  });
-});

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

@@ -6,7 +6,7 @@ import MessageItem from "@/features/ai-chat/components/message-item.tsx";
 import TypingIndicator from "@/features/ai-chat/components/typing-indicator.tsx";
 import { isToolPart, toolRunState, ToolUiPart } from "@/features/ai-chat/utils/tool-parts.tsx";
 import { assistantMessageHasVisibleContent } from "@/features/ai-chat/utils/message-content.ts";
-import { messageSignature } from "@/features/ai-chat/utils/message-signature.ts";
+import { liveTurnTokens } from "@/features/ai-chat/utils/count-stream-tokens.ts";
 import classes from "@/features/ai-chat/components/ai-chat.module.css";
 
 interface MessageListProps {
@@ -51,9 +51,7 @@ const BOTTOM_THRESHOLD = 40;
  * assistant message's LAST part is not live output:
  *  - the last message is still the user's (assistant hasn't started a row), or
  *  - the assistant row has no parts yet, or
- *  - its last part is an empty/whitespace text part, or a finished ("done")
- *    text part while the turn continues (the model paused after some narration
- *    and is thinking about its next step), or
+ *  - its last part is an empty/whitespace text part, or
  *  - its last part is a finished/errored tool (the model is thinking about the
  *    next step between tool calls).
  * It hides only while output is actively rendering: a non-empty streaming text
@@ -67,19 +65,7 @@ export function showTypingIndicator(messages: UIMessage[], isStreaming: boolean)
   const lastPart = last.parts[last.parts.length - 1];
   if (!lastPart) return true; // assistant row exists but has no parts yet.
   // The answer text is actively streaming in -> MessageItem renders it; no dots.
-  // Only while it is STILL streaming, though: once a non-empty text part is
-  // finalized ("done") but the turn is still in flight, the model has paused
-  // after some narration and is working on its next step (e.g. about to call a
-  // tool) — nothing is visibly progressing, so the dots must show. A text part
-  // without a `state` is treated as still-rendering (kept suppressed); this
-  // branch only runs while streaming, where live parts always carry a state.
-  if (
-    lastPart.type === "text" &&
-    lastPart.text.trim().length > 0 &&
-    (lastPart as { state?: "streaming" | "done" }).state !== "done"
-  ) {
-    return false;
-  }
+  if (lastPart.type === "text" && lastPart.text.trim().length > 0) return false;
   // A tool still in flight shows its own Loader in ToolCallCard -> no dots.
   if (
     isToolPart(lastPart.type) &&
@@ -109,6 +95,19 @@ export function typingIndicatorShowsName(messages: UIMessage[]): boolean {
   return !assistantMessageHasVisibleContent(last);
 }
 
+/**
+ * The live thinking-token count to show on the standalone typing indicator. It
+ * is the reasoning split of the tail assistant message (estimate while streaming,
+ * authoritative once the server attaches usage at a step/turn boundary). Returns
+ * 0 when the turn has produced no reasoning yet — the indicator then shows the
+ * plain "Thinking…" line.
+ */
+export function tailThinkingTokens(messages: UIMessage[]): number {
+  const last = messages[messages.length - 1];
+  if (!last || last.role !== "assistant") return 0;
+  return liveTurnTokens(last).reasoning;
+}
+
 /**
  * Scrollable transcript. Auto-scrolls to the newest message as it streams in,
  * but only while the user is pinned to the bottom — if they scrolled up to read
@@ -197,16 +196,9 @@ export default function MessageList({
     <ScrollArea className={classes.messages} viewportRef={viewportRef} scrollbarSize={6} type="scroll">
       <Stack gap={0} pr="xs">
         {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
-          // shared `parts` in place, so prev/next message objects both read the
-          // latest content there and the memo would skip every streamed update
-          // (freezing the row at its empty render). See message-item.tsx.
           <MessageItem
             key={message.id}
             message={message}
-            signature={messageSignature(message)}
             showCitations={showCitations}
             neutralizeInternalLinks={neutralizeInternalLinks}
             assistantName={assistantName}
@@ -216,6 +208,7 @@ export default function MessageList({
           <TypingIndicator
             assistantName={assistantName}
             showName={typingIndicatorShowsName(messages)}
+            thinkingTokens={tailThinkingTokens(messages)}
           />
         )}
       </Stack>

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

@@ -1,9 +1,8 @@
-import { memo, useMemo, useState } from "react";
+import { useState } from "react";
 import { Box, Collapse, Group, Text, UnstyledButton } from "@mantine/core";
 import { IconChevronDown } from "@tabler/icons-react";
 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 classes from "@/features/ai-chat/components/ai-chat.module.css";
 
@@ -27,23 +26,14 @@ 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 }: ReasoningBlockProps) {
+export default 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();
-  // Memoize the markdown render so toggling `open` (or a parent re-render caused
-  // by an unrelated streamed delta) does not re-parse the reasoning text; it
-  // recomputes only when the reasoning text itself changes (while it streams in).
-  // collapseBlankLines collapses the blank-line gaps the model emits between every
-  // list item / paragraph so the reasoning renders compactly (tight lists, joined
-  // paragraphs) — ONLY here, not in the normal answer.
-  const html = useMemo(
-    () => (trimmed ? renderChatMarkdown(collapseBlankLines(trimmed), {}) : ""),
-    [trimmed],
-  );
+  const html = trimmed ? renderChatMarkdown(trimmed, {}) : "";
 
   return (
     <Box className={classes.reasoningBlock} mb={6}>
@@ -91,8 +81,3 @@ function ReasoningBlock({ text, tokens }: ReasoningBlockProps) {
     </Box>
   );
 }
-
-// Memoized: re-renders only when `text`/`tokens` change (primitive props, default
-// shallow compare), so a parent re-render during streaming of OTHER content does
-// not re-run the markdown parse for an already-finalized reasoning block.
-export default memo(ReasoningBlock);

apps/client/src/features/ai-chat/components/show-typing-indicator.test.ts

@@ -82,14 +82,4 @@ describe("showTypingIndicator", () => {
       showTypingIndicator([msg("assistant", [doneTool, text])], true),
     ).toBe(false);
   });
-
-  it("shows while streaming after a text part is finalized (paused before the next step)", () => {
-    const doneText = { type: "text", text: "Now creating the page in", state: "done" } as unknown as UIMessage["parts"][number];
-    expect(showTypingIndicator([msg("assistant", [doneText])], true)).toBe(true);
-  });
-
-  it("hides while a text part is actively streaming (state: streaming)", () => {
-    const streamingText = { type: "text", text: "Now writ", state: "streaming" } as unknown as UIMessage["parts"][number];
-    expect(showTypingIndicator([msg("assistant", [streamingText])], true)).toBe(false);
-  });
 });

apps/client/src/features/ai-chat/components/tail-thinking-tokens.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+import type { UIMessage } from "@ai-sdk/react";
+import { tailThinkingTokens } from "@/features/ai-chat/components/message-list.tsx";
+
+/**
+ * Pure-helper tests for `tailThinkingTokens`: the live thinking-token count the
+ * standalone typing indicator shows. It is the reasoning split of the tail
+ * assistant message (estimate while streaming, authoritative once usage arrives).
+ */
+const msg = (
+  role: "user" | "assistant",
+  parts: unknown[],
+  metadata?: unknown,
+): UIMessage =>
+  ({ id: Math.random().toString(), role, parts, metadata }) as UIMessage;
+
+describe("tailThinkingTokens", () => {
+  it("is 0 when there are no messages", () => {
+    expect(tailThinkingTokens([])).toBe(0);
+  });
+
+  it("is 0 when the tail message is the user's", () => {
+    expect(tailThinkingTokens([msg("user", [{ type: "text", text: "q" }])])).toBe(0);
+  });
+
+  it("is 0 when the assistant has produced no reasoning yet", () => {
+    expect(
+      tailThinkingTokens([msg("assistant", [{ type: "text", text: "answer" }])]),
+    ).toBe(0);
+  });
+
+  it("estimates reasoning tokens from streamed reasoning text", () => {
+    // 8 chars -> 2 tokens.
+    expect(
+      tailThinkingTokens([
+        msg("assistant", [{ type: "reasoning", text: "12345678" }]),
+      ]),
+    ).toBe(2);
+  });
+
+  it("uses authoritative usage.reasoningTokens once the server attaches it", () => {
+    expect(
+      tailThinkingTokens([
+        msg("assistant", [{ type: "reasoning", text: "x" }], {
+          usage: { outputTokens: 100, reasoningTokens: 42 },
+        }),
+      ]),
+    ).toBe(42);
+  });
+});

apps/client/src/features/ai-chat/components/typing-indicator.tsx

@@ -16,6 +16,12 @@ interface TypingIndicatorProps {
    * assistant row above already shows the same name, to avoid a duplicate label.
    */
   showName?: boolean;
+  /**
+   * Live thinking/reasoning token count for the in-flight turn. When > 0 the
+   * typing line becomes `Thinking… · {count} tokens` (like Claude Code). Omitted
+   * / 0 keeps the plain `Thinking…` line.
+   */
+  thinkingTokens?: number;
 }
 
 /**
@@ -26,20 +32,23 @@ interface TypingIndicatorProps {
  *
  * Mirrors the assistant row layout in MessageItem (the dimmed label), so it reads
  * as the assistant's bubble taking shape. The dimmed label uses the configured
- * identity name when provided (otherwise the generic "AI agent"); below it the
- * animated dots stand in for the nascent bubble until content arrives.
+ * identity name when provided (otherwise the generic "AI agent"), while the
+ * typing line is always the generic "Thinking…" (it never includes the
+ * role/identity name).
  */
-export default function TypingIndicator({ assistantName, showName = true }: TypingIndicatorProps) {
+export default function TypingIndicator({ assistantName, showName = true, thinkingTokens }: TypingIndicatorProps) {
   const { t } = useTranslation();
   const name = resolveAssistantName(assistantName);
+  // Show the running thinking-token count only once there is something to count.
+  const thinkingLine =
+    thinkingTokens && thinkingTokens > 0
+      ? t("Thinking… · {{count}} tokens", { count: thinkingTokens })
+      : t("Thinking…");
 
   return (
     <Box className={classes.messageRow}>
       {showName !== false && (
-        // Extra bottom gap (vs MessageItem's mb={4}) gives the small bouncing
-        // dots room below the name label; without it they crowd the label. Only
-        // applies when the name is shown — the nameless case spaces fine on its own.
-        <Text size="xs" c="dimmed" mb={8}>
+        <Text size="xs" c="dimmed" mb={4}>
           {name ?? t("AI agent")}
         </Text>
       )}
@@ -49,6 +58,9 @@ export default function TypingIndicator({ assistantName, showName = true }: Typi
           <span />
           <span />
         </span>
+        <Text size="sm" c="dimmed">
+          {thinkingLine}
+        </Text>
       </Group>
     </Box>
   );

apps/client/src/features/ai-chat/hooks/use-chat-session.test.tsx

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
-import { renderHook, act } from "@testing-library/react";
+import { renderHook } from "@testing-library/react";
 import { useChatSession } from "./use-chat-session";
 import type { UseChatSessionOptions } from "./use-chat-session";
 
@@ -64,10 +64,7 @@ describe("useChatSession", () => {
     result.current.onTurnFinished(undefined);
     expect(setActiveChatId).not.toHaveBeenCalled();
     // The refetch lands with the new row => adopt it.
-    rerender({
-      activeChatId: null,
-      chats: { items: [{ id: "x" }, { id: "new" }] },
-    });
+    rerender({ activeChatId: null, chats: { items: [{ id: "x" }, { id: "new" }] } });
     expect(setActiveChatId).toHaveBeenCalledWith("new");
   });
 
@@ -91,10 +88,7 @@ describe("useChatSession", () => {
     });
     result.current.onTurnFinished(undefined);
     // a was deleted, new was added — same length, but membership changed.
-    rerender({
-      activeChatId: null,
-      chats: { items: [{ id: "b" }, { id: "new" }] },
-    });
+    rerender({ activeChatId: null, chats: { items: [{ id: "b" }, { id: "new" }] } });
     expect(setActiveChatId).toHaveBeenCalledWith("new");
   });
 
@@ -177,40 +171,6 @@ describe("useChatSession", () => {
     expect(setActiveChatId).not.toHaveBeenCalledWith("late");
   });
 
-  it("#174 early adopt: onServerChatId adopts the streamed id mid-stream (Copy button available during the first turn)", () => {
-    // Brand-new chat: no id yet. The server streams the real chat id "A" on the
-    // `start` chunk WHILE the first turn is still streaming (before onTurnFinished
-    // fires at the terminal outcome). The hook must adopt it immediately so the
-    // window's activeChatId-gated Copy/export button lights up during the stream.
-    const { result, setActiveChatId } = setup({
-      activeChatId: null,
-      chats: { items: [] },
-    });
-    result.current.onServerChatId("A");
-    expect(setActiveChatId).toHaveBeenCalledWith("A");
-  });
-
-  it("#174 early adopt is in-place: threadKey stays stable (live stream not torn down)", () => {
-    const chats = { items: [] };
-    const { result, rerender } = setup({ activeChatId: null, chats });
-    const keyBefore = result.current.threadKey;
-    result.current.onServerChatId("A");
-    // Parent reflects the adopted id back in; the SAME mount key is kept so the
-    // in-flight useChat store (the streaming turn) is preserved.
-    rerender({ activeChatId: "A", chats });
-    expect(result.current.threadKey).toBe(keyBefore);
-  });
-
-  it("#174 early adopt: no-op for an existing chat and for a missing id", () => {
-    const { result, setActiveChatId } = setup({
-      activeChatId: "chat-1",
-      chats: { items: [{ id: "chat-1" }] },
-    });
-    result.current.onServerChatId("chat-1"); // already has an id
-    result.current.onServerChatId(undefined); // no streamed id
-    expect(setActiveChatId).not.toHaveBeenCalled();
-  });
-
   it("in-place adopt keeps threadKey stable; an external switch remounts", () => {
     const chats = { items: [{ id: "B" }] };
     const { result, rerender } = setup({ activeChatId: null, chats });
@@ -227,50 +187,6 @@ describe("useChatSession", () => {
     expect(result.current.threadKey).toBe("C");
   });
 
-  it("#161: New chat during a streaming first turn forces a fresh thread (remount), not just a no-op", () => {
-    // Brand-new chat whose first turn is still streaming: the id is adopted only
-    // at turn end, so activeChatId AND thread.chatId are both null. Pressing "New
-    // chat" must still remount to a clean thread even though the atom is unchanged
-    // — the render-phase reconciler (null === null) would otherwise do nothing,
-    // leaving the old chat/stream/history in place (the bug: only the role badge
-    // dropped).
-    const { result } = setup({ activeChatId: null, chats: { items: [] } });
-    const keyBefore = result.current.threadKey;
-    act(() => result.current.startFreshThread());
-    expect(result.current.threadKey).not.toBe(keyBefore);
-  });
-
-  it("#161: an abandoned thread's late onTurnFinished does NOT adopt its chat (thread-aware guard)", () => {
-    // New chat mid-stream remounts to a fresh thread, but @ai-sdk/react does not
-    // abort the abandoned stream on unmount: its onFinish still fires later with
-    // the real server id, tagged with the OLD (abandoned) mount key. That must not
-    // adopt — it would yank the user back into the chat they just left.
-    const { result, setActiveChatId, onInvalidateChatList } = setup({
-      activeChatId: null,
-      chats: { items: [] },
-    });
-    const abandonedKey = result.current.threadKey;
-    act(() => result.current.startFreshThread());
-    expect(result.current.threadKey).not.toBe(abandonedKey);
-    // The abandoned turn finishes in the background, streaming its real id "A".
-    result.current.onTurnFinished("A", abandonedKey);
-    expect(setActiveChatId).not.toHaveBeenCalledWith("A");
-    // It still refreshes the chat list so the left-behind chat shows in history.
-    expect(onInvalidateChatList).toHaveBeenCalled();
-  });
-
-  it("#161: a turn finishing on the CURRENT thread still adopts (guard is key-scoped, not blanket)", () => {
-    // The happy path must keep working: onTurnFinished tagged with the mounted
-    // thread's own key adopts in place as before.
-    const { result, setActiveChatId } = setup({
-      activeChatId: null,
-      chats: { items: [] },
-    });
-    const currentKey = result.current.threadKey;
-    result.current.onTurnFinished("A", currentKey);
-    expect(setActiveChatId).toHaveBeenCalledWith("A");
-  });
-
   it("waitingForHistory gates the loader only while opening an unloaded existing chat", () => {
     // Open an existing chat whose history is still loading => loader on.
     const { result, rerender } = setup({

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

@@ -31,26 +31,9 @@ export interface UseChatSessionResult {
   threadKey: string;
   /** Show the history loader instead of the live thread. */
   waitingForHistory: boolean;
-  /** Force a brand-new, empty thread (new mount key, no chat id) UNCONDITIONALLY,
-   *  even when `activeChatId` is unchanged. The window calls this from
-   *  startNewChat so "New chat" pressed WHILE a brand-new chat's first turn is
-   *  still streaming (activeChatId still null, nothing to diverge) actually
-   *  resets the chat instead of only dropping the role badge (#161). */
-  startFreshThread: () => void;
   /** Call when a turn finishes; `serverChatId` is the authoritative streamed id
-   *  (undefined on a failed turn). `finishingThreadKey` is the mount key of the
-   *  thread that produced the turn (omit => "current thread", back-compatible):
-   *  a turn ABANDONED by New chat mid-stream still fires this after its thread
-   *  unmounted, so adoption is gated to the still-mounted thread (#161). Handles
-   *  new-chat id adoption + invalidations. */
-  onTurnFinished: (serverChatId?: string, finishingThreadKey?: string) => void;
-  /** Call EARLY (at the stream's `start` chunk) with the authoritative streamed
-   *  chat id so a brand-new chat adopts its real id WHILE its first turn is still
-   *  streaming — making `activeChatId`-gated affordances (e.g. the Copy/export
-   *  button, #174) available immediately. In-place adoption only (same mount key,
-   *  no list/messages invalidation — that is left to onTurnFinished at the end).
-   *  Idempotent and a no-op once the chat already has an id. */
-  onServerChatId: (serverChatId?: string) => void;
+   *  (undefined on a failed turn). Handles new-chat id adoption + invalidations. */
+  onTurnFinished: (serverChatId?: string) => void;
   /** Disarm any pending error-path new-chat fallback. The window calls this from
    *  startNewChat/selectChat so a late refetch can't yank the user back into a
    *  just-failed chat after they explicitly moved on. */
@@ -102,21 +85,15 @@ export function useChatSession(
   // `newThread`/`switchThread` to (re)mount, `adoptThread` for in-place adoption.
   // Initial: a non-null activeChatId switches to it; a null one gets a fresh
   // session key with no chat id yet.
-  const [thread, dispatch] = useReducer(threadSessionReducer, undefined, () =>
-    activeChatId === null
-      ? newThread(`new-${generateId()}`)
-      : switchThread(activeChatId),
+  const [thread, dispatch] = useReducer(
+    threadSessionReducer,
+    undefined,
+    () =>
+      activeChatId === null
+        ? newThread(`new-${generateId()}`)
+        : switchThread(activeChatId),
   );
 
-  // Live mirror of the mounted thread's mount key, read by onTurnFinished to tell
-  // the CURRENT thread from one ABANDONED by New chat mid-stream. @ai-sdk/react
-  // does not abort a stream on unmount and proxies callbacks through a ref, so an
-  // abandoned turn's onFinish/onError still fires AFTER its ChatThread unmounted;
-  // matching its key against this ref keeps that late finish from adopting the
-  // abandoned chat and yanking the user out of the fresh chat they opened (#161).
-  const threadKeyRef = useRef(thread.key);
-  threadKeyRef.current = thread.key;
-
   // Error-path fallback for new-chat id adoption. When a brand-new chat's first
   // turn errors BEFORE the server's `start` chunk, no authoritative chatId ever
   // reaches the client, so the primary metadata adoption cannot run. We then ARM
@@ -134,23 +111,7 @@ export function useChatSession(
   // yet) we adopt the server's AUTHORITATIVE streamed id (never the newest in the
   // list, which races a second tab — #137; see adopt-chat-id.ts).
   const onTurnFinished = useCallback(
-    (serverChatId?: string, finishingThreadKey?: string) => {
-      // Thread-aware guard (#161). A turn ABANDONED by "New chat" mid-stream still
-      // fires onFinish/onError after its ChatThread unmounted (@ai-sdk/react does
-      // not abort on unmount and proxies callbacks through a ref). If that late
-      // finish ran the adoption path it would set activeChatId to the abandoned
-      // chat's real id and yank the user out of the fresh chat they just opened.
-      // So adopt / arm the fallback ONLY for the still-mounted thread; an
-      // abandoned one merely refreshes the chat list (so the left-behind chat
-      // surfaces in history) and does nothing else. A missing key (undefined)
-      // means "current thread" — keeps old call sites/tests working.
-      if (
-        finishingThreadKey !== undefined &&
-        finishingThreadKey !== threadKeyRef.current
-      ) {
-        onInvalidateChatList();
-        return;
-      }
+    (serverChatId?: string) => {
       // Read the live id from the ref, not the closure: on a failed turn this can
       // run twice in one turn (onFinish + onError) before any re-render, and the
       // primary branch below updates the ref so the second call sees the adopted id.
@@ -189,31 +150,6 @@ export function useChatSession(
     [chats, setActiveChatId, onInvalidateChatList, onInvalidateChatMessages],
   );
 
-  // EARLY adoption (#174): adopt the authoritative streamed chat id the moment
-  // the server emits it on the `start` chunk, so a brand-new chat gets its real
-  // `activeChatId` WHILE its first turn streams — not only at terminal
-  // onTurnFinished. This makes the activeChatId-gated Copy/export button
-  // available during the first turn. Pure in-place adoption (same mount key, like
-  // the primary path) with NO invalidation: the list/messages refresh stays on
-  // onTurnFinished at the end of the turn. Reads the live id from the ref so a
-  // repeat call after adoption is a no-op (resolveAdoptedChatId only fires for a
-  // still-new chat).
-  const onServerChatId = useCallback(
-    (serverChatId?: string) => {
-      const adopted = resolveAdoptedChatId(
-        activeChatIdRef.current,
-        serverChatId,
-      );
-      if (!adopted) return;
-      activeChatIdRef.current = adopted;
-      setActiveChatId(adopted);
-      dispatch({ type: "adopt", chatId: adopted });
-      // Early adoption beat the error-path fallback to it — disarm.
-      pendingNewChatRef.current = null;
-    },
-    [setActiveChatId],
-  );
-
   // FALLBACK resolver. Armed only by onTurnFinished when a brand-new chat's first
   // turn errored before the `start` chunk (no authoritative id streamed). Once
   // the per-user list refetch lands with the just-created row, adopt the SINGLE
@@ -293,30 +229,10 @@ export function useChatSession(
     pendingNewChatRef.current = null;
   }, []);
 
-  // Force a fresh, empty thread regardless of `activeChatId` (#161). The render-
-  // phase reconciler only remounts when activeChatId diverges from thread.chatId,
-  // so "New chat" pressed while a brand-new chat's first turn is still streaming
-  // (activeChatId AND thread.chatId both null — the real id is adopted only at the
-  // end of the turn) is a no-op for it and the abandoned thread/stream/history
-  // would persist. Dispatching reconcile with a fresh key and chatId:null here
-  // always produces a new mount key, so React remounts ChatThread (a clean useChat
-  // store) and the post-dispatch state (activeChatId null === thread.chatId null)
-  // keeps the reconciler from interfering. Also disarms any pending fallback.
-  const startFreshThread = useCallback(() => {
-    pendingNewChatRef.current = null;
-    dispatch({
-      type: "reconcile",
-      chatId: null,
-      newKey: `new-${generateId()}`,
-    });
-  }, []);
-
   return {
     threadKey: thread.key,
     waitingForHistory,
-    startFreshThread,
     onTurnFinished,
-    onServerChatId,
     cancelPendingAdoption,
   };
 }

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

@@ -50,37 +50,6 @@ export async function deleteAiChat(chatId: string): Promise<void> {
   await api.post("/ai-chat/delete", { chatId });
 }
 
-/**
- * Export a chat to Markdown (#183). The server renders the transcript from the
- * persisted rows (the DB is the single source of truth — including an
- * interrupted turn's in-progress row, persisted upfront + per step), so the
- * client just copies the returned string. `lang` localizes the few fixed
- * role/tool labels; defaults to English server-side when omitted.
- */
-export async function exportAiChat(
-  chatId: string,
-  lang?: string,
-): Promise<string> {
-  const req = await api.post<{ markdown: string }>("/ai-chat/export", {
-    chatId,
-    lang,
-  });
-  return req.data.markdown;
-}
-
-/**
- * Generate a page title from note content (markdown). One-shot, non-streaming
- * (#199): the server only summarizes the supplied text and returns a suggestion;
- * it never writes the page. The caller applies the title via /pages/update.
- */
-export async function generatePageTitle(content: string): Promise<string> {
-  const req = await api.post<{ title: string }>(
-    "/ai-chat/generate-page-title",
-    { content },
-  );
-  return req.data.title;
-}
-
 /**
  * Agent roles API (`/ai-chat/roles`). `list` is available to any workspace
  * member (for the chat-creation picker); create/update/delete are admin-only
@@ -107,8 +76,6 @@ export async function updateAiRole(data: IAiRoleUpdate): Promise<IAiRole> {
 
 /** Soft-delete a role (admin). */
 export async function deleteAiRole(id: string): Promise<{ success: true }> {
-  const req = await api.post<{ success: true }>("/ai-chat/roles/delete", {
-    id,
-  });
+  const req = await api.post<{ success: true }>("/ai-chat/roles/delete", { id });
   return req.data;
 }

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

@@ -116,9 +116,6 @@ export interface IAiChatMessageRow {
     // turn. Distinct from `usage` (legacy cumulative totalUsage). Shown in the
     // floating window's header badge.
     contextTokens?: number;
-    // The model's max context window (denominator for the header badge); set
-    // alongside contextTokens on a completed turn; absent on older rows.
-    maxContextTokens?: number;
     // Set on an assistant row whose turn ended in a provider/stream error; the
     // raw provider error text (e.g. "402: ...") for inline display in the thread.
     error?: string;

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

@@ -0,0 +1,491 @@
+import { describe, it, expect } from "vitest";
+import { buildChatMarkdown } from "@/features/ai-chat/utils/chat-markdown.ts";
+import type { IAiChatMessageRow } from "@/features/ai-chat/types/ai-chat.types.ts";
+
+/**
+ * Tests for the client-only Markdown export builder. The output embeds a live
+ * `new Date().toISOString()` export timestamp; we never assert that value, only
+ * the deterministic structure (headings, numbering, fenced blocks, totals).
+ *
+ * A pass-through translator keeps role/tool labels predictable so the
+ * structural assertions are stable without an i18n runtime.
+ */
+const t = (key: string, values?: Record<string, unknown>): string => {
+  if (values && typeof values.name === "string") {
+    return key.replace("{{name}}", values.name);
+  }
+  return key;
+};
+
+function row(partial: Partial<IAiChatMessageRow>): IAiChatMessageRow {
+  return {
+    id: partial.id ?? "id",
+    role: partial.role ?? "user",
+    content: partial.content ?? null,
+    metadata: partial.metadata ?? null,
+    createdAt: partial.createdAt ?? "2026-06-21T00:00:00.000Z",
+  };
+}
+
+describe("buildChatMarkdown — structure", () => {
+  it("emits the title heading, chat id and message count", () => {
+    const md = buildChatMarkdown({
+      title: "My chat",
+      chatId: "chat-123",
+      rows: [],
+      t,
+    });
+    expect(md).toContain("# My chat");
+    expect(md).toContain("- Chat ID: `chat-123`");
+    expect(md).toContain("- Messages: 0");
+    expect(md).toContain("- Exported:"); // timestamp present, value not asserted
+  });
+
+  it("falls back to the translated 'Untitled chat' for empty/blank titles", () => {
+    expect(
+      buildChatMarkdown({ title: null, chatId: "c", rows: [], t }),
+    ).toContain("# Untitled chat");
+    expect(
+      buildChatMarkdown({ title: "   ", chatId: "c", rows: [], t }),
+    ).toContain("# Untitled chat");
+  });
+
+  it("numbers rows sequentially with role headings", () => {
+    const md = buildChatMarkdown({
+      title: "t",
+      chatId: "c",
+      rows: [
+        row({ role: "user", content: "hi" }),
+        row({ role: "assistant", content: "hello" }),
+        row({ role: "user", content: "again" }),
+      ],
+      t,
+    });
+    expect(md).toContain("## 1. You");
+    expect(md).toContain("## 2. AI agent");
+    expect(md).toContain("## 3. You");
+    // Heading numbering is strictly index+1, not e.g. role-relative.
+    expect(md).not.toContain("## 0.");
+  });
+
+  it("renders the per-row text content from `content` when no metadata.parts", () => {
+    const md = buildChatMarkdown({
+      title: "t",
+      chatId: "c",
+      rows: [row({ role: "user", content: "plain body" })],
+      t,
+    });
+    expect(md).toContain("plain body");
+  });
+});
+
+describe("buildChatMarkdown — text parts", () => {
+  it("skips empty / whitespace-only text parts", () => {
+    const md = buildChatMarkdown({
+      title: "t",
+      chatId: "c",
+      rows: [
+        row({
+          role: "assistant",
+          content: "ignored-content",
+          metadata: {
+            parts: [
+              { type: "text", text: "   " },
+              { type: "text", text: "" },
+              { type: "text", text: "kept line" },
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            ] as any,
+          },
+        }),
+      ],
+      t,
+    });
+    expect(md).toContain("kept line");
+    // Whitespace-only part contributed no block of its own.
+    expect(md).not.toContain("   \n\n");
+    // When metadata.parts exists, the plain `content` fallback is NOT used.
+    expect(md).not.toContain("ignored-content");
+  });
+});
+
+describe("buildChatMarkdown — tool parts", () => {
+  it("renders a tool label, name, state and fenced Input/Output blocks", () => {
+    const md = buildChatMarkdown({
+      title: "t",
+      chatId: "c",
+      rows: [
+        row({
+          role: "assistant",
+          content: "",
+          metadata: {
+            parts: [
+              {
+                type: "tool-getPage",
+                state: "output-available",
+                input: { pageId: "p1" },
+                output: { id: "p1", title: "Home" },
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              } as any,
+            ],
+          },
+        }),
+      ],
+      t,
+    });
+    // Known tool name maps to its label key; raw name in backticks; done state.
+    expect(md).toContain("**Tool: Read page** (`getPage`) — done");
+    expect(md).toContain("Input:");
+    expect(md).toContain("Output:");
+    // Fenced JSON blocks contain the stringified payloads.
+    expect(md).toContain('"pageId": "p1"');
+    expect(md).toContain('"title": "Home"');
+    expect(md).toContain("```json");
+  });
+
+  it("renders the generic label for an unknown tool and surfaces errorText", () => {
+    const md = buildChatMarkdown({
+      title: "t",
+      chatId: "c",
+      rows: [
+        row({
+          role: "assistant",
+          content: "",
+          metadata: {
+            parts: [
+              {
+                type: "tool-mysteryTool",
+                state: "output-error",
+                input: { a: 1 },
+                errorText: "boom",
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              } as any,
+            ],
+          },
+        }),
+      ],
+      t,
+    });
+    expect(md).toContain("**Tool: Ran tool mysteryTool** (`mysteryTool`) — error");
+    expect(md).toContain("**Error:** boom");
+  });
+
+  it("does not throw on a circular tool input (falls back to String)", () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const circular: any = {};
+    circular.self = circular;
+    expect(() =>
+      buildChatMarkdown({
+        title: "t",
+        chatId: "c",
+        rows: [
+          row({
+            role: "assistant",
+            content: "",
+            metadata: {
+              parts: [
+                {
+                  type: "tool-getPage",
+                  state: "input-available",
+                  input: circular,
+                  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                } as any,
+              ],
+            },
+          }),
+        ],
+        t,
+      }),
+    ).not.toThrow();
+  });
+});
+
+describe("buildChatMarkdown — fence anti-breakout", () => {
+  it("lengthens the delimiter so embedded ``` cannot break out of the block", () => {
+    // Tool input whose stringified string form contains a literal ``` run.
+    const md = buildChatMarkdown({
+      title: "t",
+      chatId: "c",
+      rows: [
+        row({
+          role: "assistant",
+          content: "",
+          metadata: {
+            parts: [
+              {
+                type: "tool-getPage",
+                state: "output-available",
+                // A bare string passes through stringify() verbatim.
+                input: "before ``` after",
+                output: "x",
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              } as any,
+            ],
+          },
+        }),
+      ],
+      t,
+    });
+    // The fence around the 3-backtick content must use at least 4 backticks so
+    // the embedded ``` run cannot terminate the block.
+    expect(md).toContain("````json\nbefore ``` after\n````");
+    // Robust anti-breakout check: the opening fence delimiter is strictly
+    // longer than the longest backtick run inside the wrapped content. (A naive
+    // `not.toContain("```json...")` is a false negative — a 4-backtick fence
+    // textually contains the 3-backtick substring.)
+    const open = md.match(/(`{3,})json\nbefore/);
+    expect(open).not.toBeNull();
+    expect(open![1].length).toBeGreaterThan(3); // > the 3-backtick run in content
+  });
+
+  it("uses a 5-backtick fence when the content has a 4-backtick run", () => {
+    const md = buildChatMarkdown({
+      title: "t",
+      chatId: "c",
+      rows: [
+        row({
+          role: "assistant",
+          content: "",
+          metadata: {
+            parts: [
+              {
+                type: "tool-getPage",
+                state: "output-available",
+                input: "a ```` b",
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              } as any,
+            ],
+          },
+        }),
+      ],
+      t,
+    });
+    expect(md).toContain("`````json\na ```` b\n`````");
+  });
+});
+
+describe("buildChatMarkdown — token totals", () => {
+  it("prints the total-tokens line only when the summed usage is > 0", () => {
+    const withTokens = buildChatMarkdown({
+      title: "t",
+      chatId: "c",
+      rows: [
+        row({
+          role: "assistant",
+          content: "x",
+          metadata: { usage: { inputTokens: 10, outputTokens: 5 } },
+        }),
+      ],
+      t,
+    });
+    expect(withTokens).toContain("- Total tokens: 15");
+    // Per-row usage footer too.
+    expect(withTokens).toContain("_Tokens — in: 10, out: 5, total: 15_");
+  });
+
+  it("omits the total-tokens line when the sum is 0 / usage absent", () => {
+    const noTokens = buildChatMarkdown({
+      title: "t",
+      chatId: "c",
+      rows: [
+        row({ role: "user", content: "hi" }),
+        row({
+          role: "assistant",
+          content: "x",
+          metadata: { usage: { inputTokens: 0, outputTokens: 0 } },
+        }),
+      ],
+      t,
+    });
+    expect(noTokens).not.toContain("- Total tokens:");
+  });
+
+  it("uses totalTokens when present rather than summing in/out", () => {
+    const md = buildChatMarkdown({
+      title: "t",
+      chatId: "c",
+      rows: [
+        row({
+          role: "assistant",
+          content: "x",
+          metadata: { usage: { inputTokens: 3, outputTokens: 4, totalTokens: 99 } },
+        }),
+      ],
+      t,
+    });
+    expect(md).toContain("- Total tokens: 99");
+  });
+
+  it("appends the reasoning figure to the row footer when reasoningTokens > 0", () => {
+    const md = buildChatMarkdown({
+      title: "t",
+      chatId: "c",
+      rows: [
+        row({
+          role: "assistant",
+          content: "x",
+          metadata: {
+            usage: { inputTokens: 10, outputTokens: 8, reasoningTokens: 3 },
+          },
+        }),
+      ],
+      t,
+    });
+    expect(md).toContain("_Tokens — in: 10, out: 8, reasoning: 3, total: 18_");
+  });
+
+  it("omits the reasoning figure when reasoningTokens is 0 / absent", () => {
+    const zero = buildChatMarkdown({
+      title: "t",
+      chatId: "c",
+      rows: [
+        row({
+          role: "assistant",
+          content: "x",
+          metadata: {
+            usage: { inputTokens: 10, outputTokens: 5, reasoningTokens: 0 },
+          },
+        }),
+      ],
+      t,
+    });
+    expect(zero).toContain("_Tokens — in: 10, out: 5, total: 15_");
+    expect(zero).not.toContain("reasoning:");
+
+    const absent = buildChatMarkdown({
+      title: "t",
+      chatId: "c",
+      rows: [
+        row({
+          role: "assistant",
+          content: "x",
+          metadata: { usage: { inputTokens: 10, outputTokens: 5 } },
+        }),
+      ],
+      t,
+    });
+    expect(absent).not.toContain("reasoning:");
+  });
+});
+
+describe("buildChatMarkdown — pending / in-progress messages", () => {
+  it("continues the heading numbering after the persisted rows", () => {
+    const md = buildChatMarkdown({
+      title: "t",
+      chatId: "c",
+      rows: [row({ role: "user", content: "persisted" })],
+      pending: [
+        {
+          role: "user",
+          parts: [{ type: "text", text: "live question" }],
+          generating: false,
+        },
+        {
+          role: "assistant",
+          parts: [{ type: "text", text: "live answer" }],
+          generating: true,
+        },
+      ],
+      t,
+    });
+    expect(md).toContain("## 1. You");
+    expect(md).toContain("## 2. You");
+    expect(md).toContain("## 3. AI agent");
+    expect(md).toContain("live question");
+    expect(md).toContain("live answer");
+  });
+
+  it("flags a generating assistant pending message as still being generated", () => {
+    const md = buildChatMarkdown({
+      title: "t",
+      chatId: "c",
+      rows: [row({ role: "user", content: "persisted" })],
+      pending: [
+        {
+          role: "assistant",
+          parts: [{ type: "text", text: "partial reply" }],
+          generating: true,
+        },
+      ],
+      t,
+    });
+    expect(md).toContain("partial reply");
+    expect(md).toContain("still being generated");
+  });
+
+  it("renders a non-generating user pending message without the note", () => {
+    const md = buildChatMarkdown({
+      title: "t",
+      chatId: "c",
+      rows: [row({ role: "user", content: "persisted" })],
+      pending: [
+        {
+          role: "user",
+          parts: [{ type: "text", text: "my live message" }],
+          generating: false,
+        },
+      ],
+      t,
+    });
+    expect(md).toContain("my live message");
+    expect(md).not.toContain("still being generated");
+  });
+
+  it("includes the pending messages in the metadata message count", () => {
+    const md = buildChatMarkdown({
+      title: "t",
+      chatId: "c",
+      rows: [
+        row({ role: "user", content: "a" }),
+        row({ role: "assistant", content: "b" }),
+      ],
+      pending: [
+        {
+          role: "user",
+          parts: [{ type: "text", text: "c" }],
+          generating: false,
+        },
+        {
+          role: "assistant",
+          parts: [{ type: "text", text: "d" }],
+          generating: true,
+        },
+      ],
+      t,
+    });
+    // 2 persisted rows + 2 pending = 4.
+    expect(md).toContain("- Messages: 4");
+  });
+
+  it("emits the heading and note for a generating assistant with empty parts", () => {
+    expect(() =>
+      buildChatMarkdown({
+        title: "t",
+        chatId: "c",
+        rows: [row({ role: "user", content: "persisted" })],
+        pending: [
+          {
+            role: "assistant",
+            parts: [],
+            generating: true,
+          },
+        ],
+        t,
+      }),
+    ).not.toThrow();
+    const md = buildChatMarkdown({
+      title: "t",
+      chatId: "c",
+      rows: [row({ role: "user", content: "persisted" })],
+      pending: [
+        {
+          role: "assistant",
+          parts: [],
+          generating: true,
+        },
+      ],
+      t,
+    });
+    expect(md).toContain("## 2. AI agent");
+    expect(md).toContain("still being generated");
+  });
+});

apps/client/src/features/ai-chat/utils/chat-markdown.ts

@@ -0,0 +1,215 @@
+/**
+ * Client-only Markdown builder for an AI agent chat. Serializes the already
+ * persisted message rows (loaded via `useAiChatMessagesQuery`) into a single
+ * Markdown string suitable for copying to the clipboard. NO network call is
+ * made and NO server/DB code is touched — this reuses the rich "request
+ * internals" (tool calls with input/output, per-message token usage,
+ * finish/error info) that the chat already holds client-side.
+ *
+ * Only role labels and tool action labels are localized via the passed-in `t`
+ * translator; the structural document words (Input/Output/Error/Tokens/...) are
+ * plain English constants because the output is a technical artifact.
+ */
+
+import type { IAiChatMessageRow } from "@/features/ai-chat/types/ai-chat.types.ts";
+import {
+  ToolUiPart,
+  getToolName,
+  toolRunState,
+  toolLabelKey,
+} from "@/features/ai-chat/utils/tool-parts.tsx";
+
+// Minimal translator signature compatible with react-i18next's `t`.
+type Translate = (key: string, values?: Record<string, unknown>) => string;
+
+interface BuildChatMarkdownArgs {
+  title: string | null;
+  chatId: string;
+  rows: IAiChatMessageRow[];
+  /** In-progress, not-yet-persisted live messages (the current streaming
+   *  turn) to append after the persisted rows. `generating: true` adds a
+   *  note that the message is still being produced. */
+  pending?: PendingMessage[];
+  t: Translate;
+}
+
+/** A single AI SDK UIMessage part (text part or other). */
+interface TextLikePart {
+  type: string;
+  text?: string;
+}
+
+/** A live, not-yet-persisted message (current streaming turn) to append. */
+interface PendingMessage {
+  role: "user" | "assistant" | string;
+  parts: TextLikePart[];
+  generating: boolean;
+}
+
+/**
+ * Stringify an arbitrary tool input/output value for a fenced block. Strings
+ * pass through as-is; everything else is pretty-printed JSON, falling back to
+ * `String(value)` if serialization throws (e.g. a circular structure).
+ */
+function stringify(value: unknown): string {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+
+/**
+ * Wrap `code` in a fenced code block whose backtick delimiter is LONGER than
+ * the longest backtick run inside the content, so embedded backticks (or even
+ * a literal ``` fence) never break out of the block. Minimum 3 backticks.
+ */
+function fence(code: string, lang = ""): string {
+  const runs: string[] = code.match(/`+/g) ?? [];
+  const longest = runs.reduce((m, s) => Math.max(m, s.length), 0);
+  const delim = "`".repeat(Math.max(3, longest + 1));
+  return `${delim}${lang}\n${code}\n${delim}`;
+}
+
+/** Per-row token count, mirroring the header sum in ai-chat-window.tsx. */
+function rowTokens(usage: {
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+  reasoningTokens?: number;
+}): number {
+  return (
+    usage.totalTokens ?? (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0)
+  );
+}
+
+/** Render one message's UIMessage parts into an array of Markdown blocks
+ *  (text blocks + tool blocks). Mirrors MessageItem's part handling. */
+function renderMessageParts(parts: TextLikePart[], t: Translate): string[] {
+  const out: string[] = [];
+
+  for (const part of parts) {
+    if (part.type === "text") {
+      const text = (part.text ?? "").trim();
+      // Skip empty/whitespace-only text parts (matches MessageItem).
+      if (text.length > 0) out.push(text);
+      continue;
+    }
+
+    const isToolPart =
+      part.type.startsWith("tool-") || part.type === "dynamic-tool";
+    if (!isToolPart) continue;
+
+    const tp = part as unknown as ToolUiPart;
+    const name = getToolName(tp);
+    const { key, values } = toolLabelKey(name);
+    const label = t(key, values);
+    const state = toolRunState(tp.state);
+
+    const toolLines: string[] = [
+      `**Tool: ${label}** (\`${name}\`) — ${state}`,
+    ];
+    if (tp.input !== undefined) {
+      toolLines.push("Input:");
+      toolLines.push(fence(stringify(tp.input), "json"));
+    }
+    if (tp.output !== undefined) {
+      toolLines.push("Output:");
+      toolLines.push(fence(stringify(tp.output), "json"));
+    }
+    if (tp.errorText) {
+      toolLines.push(`**Error:** ${tp.errorText}`);
+    }
+    out.push(toolLines.join("\n\n"));
+  }
+
+  return out;
+}
+
+/**
+ * Serialize a chat to a Markdown string. Pure (apart from `new Date()` for the
+ * export timestamp), so it is straightforward to unit-test.
+ */
+export function buildChatMarkdown(args: BuildChatMarkdownArgs): string {
+  const { title, chatId, rows, pending, t } = args;
+  const blocks: string[] = [];
+
+  const heading = (title ?? "").trim() || t("Untitled chat");
+  blocks.push(`# ${heading}`);
+
+  // Metadata bullet list. Total tokens is only shown when there is a sum.
+  const totalTokens = rows.reduce((sum, row) => {
+    const usage = row.metadata?.usage;
+    return usage ? sum + rowTokens(usage) : sum;
+  }, 0);
+  const meta = [
+    `- Chat ID: \`${chatId}\``,
+    `- Exported: ${new Date().toISOString()}`,
+    `- Messages: ${rows.length + (pending?.length ?? 0)}`,
+  ];
+  if (totalTokens > 0) meta.push(`- Total tokens: ${totalTokens}`);
+  blocks.push(meta.join("\n"));
+
+  rows.forEach((row, index) => {
+    blocks.push("---");
+
+    const roleLabel = row.role === "assistant" ? t("AI agent") : t("You");
+    blocks.push(`## ${index + 1}. ${roleLabel}`);
+
+    // Created-at kept in source as an HTML comment (out of the rendered prose).
+    blocks.push(`<!-- ${row.createdAt} -->`);
+
+    // Resolve parts: prefer the rich persisted parts, else a single text part
+    // built from the plain-text content (mirrors `rowToUiMessage`).
+    const parts: TextLikePart[] =
+      Array.isArray(row.metadata?.parts) && row.metadata.parts.length > 0
+        ? (row.metadata.parts as TextLikePart[])
+        : [{ type: "text", text: row.content ?? "" }];
+
+    blocks.push(...renderMessageParts(parts, t));
+
+    if (row.metadata?.error) {
+      blocks.push(`**⚠️ Error:** ${row.metadata.error}`);
+    }
+
+    const usage = row.metadata?.usage;
+    if (usage) {
+      const total = usage.totalTokens ?? rowTokens(usage);
+      // Reasoning (thinking) tokens are shown only when the provider reported a
+      // positive count; old rows / non-reasoning providers omit it.
+      const reasoning =
+        usage.reasoningTokens && usage.reasoningTokens > 0
+          ? `, reasoning: ${usage.reasoningTokens}`
+          : "";
+      blocks.push(
+        `_Tokens — in: ${usage.inputTokens ?? "?"}, out: ${usage.outputTokens ?? "?"}${reasoning}, total: ${total}_`,
+      );
+    }
+  });
+
+  // Append the in-progress, not-yet-persisted live messages (the current
+  // streaming turn) after the persisted rows. Heading numbering CONTINUES from
+  // the persisted rows. A `generating` assistant gets a note that the captured
+  // response is partial; pending messages carry no usage/token footer yet.
+  (pending ?? []).forEach((message, p) => {
+    blocks.push("---");
+
+    const num = rows.length + p + 1;
+    const roleLabel = message.role === "assistant" ? t("AI agent") : t("You");
+    blocks.push(`## ${num}. ${roleLabel}`);
+
+    blocks.push(...renderMessageParts(message.parts, t));
+
+    // A generating assistant may have empty/no parts yet — still emit the
+    // heading (above) and this note so the export shows the in-progress turn.
+    if (message.generating === true) {
+      blocks.push(
+        "_⏳ This message is still being generated — the export captured a partial, in-progress response._",
+      );
+    }
+  });
+
+  // Blank line between blocks so the Markdown renders cleanly.
+  return blocks.join("\n\n");
+}

apps/client/src/features/ai-chat/utils/collapse-blank-lines.test.ts

@@ -1,61 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { collapseBlankLines } from "@/features/ai-chat/utils/collapse-blank-lines.ts";
-import { renderChatMarkdown } from "@/features/ai-chat/utils/markdown.ts";
-
-describe("collapseBlankLines", () => {
-  it("collapses a run of 2+ newlines to a single newline", () => {
-    expect(collapseBlankLines("a\n\nb")).toBe("a\nb");
-    expect(collapseBlankLines("a\n\n\n\nb")).toBe("a\nb");
-  });
-
-  it("keeps single newlines untouched", () => {
-    expect(collapseBlankLines("a\nb\nc")).toBe("a\nb\nc");
-  });
-
-  it("preserves blank lines INSIDE a fenced code block", () => {
-    const src = "a\n\n\nb\n\n```\nx\n\n\ny\n```\n\nc";
-    // Prose blanks collapse; the blank lines between the ``` fences survive.
-    expect(collapseBlankLines(src)).toBe("a\nb\n```\nx\n\n\ny\n```\nc");
-  });
-
-  it("handles a tilde fence and preserves its interior blanks", () => {
-    const src = "p\n\n~~~\ncode\n\nmore\n~~~\n\nq";
-    expect(collapseBlankLines(src)).toBe("p\n~~~\ncode\n\nmore\n~~~\nq");
-  });
-
-  it("leaves an unclosed fence's remaining lines verbatim", () => {
-    const src = "intro\n\n```\nstill\n\nopen";
-    expect(collapseBlankLines(src)).toBe("intro\n```\nstill\n\nopen");
-  });
-
-  it("is a no-op for text with no blank lines", () => {
-    expect(collapseBlankLines("just one line")).toBe("just one line");
-  });
-});
-
-describe("collapseBlankLines + renderChatMarkdown (tight reasoning rendering)", () => {
-  it("renders a blank-line-separated list as a TIGHT list (no <li><p>)", () => {
-    const loose =
-      "Intro paragraph.\n\n- item one\n\n- item two\n\n- item three";
-    const html = renderChatMarkdown(collapseBlankLines(loose), {});
-    // Tight list: each <li> holds the text directly, not wrapped in a <p>.
-    expect(html).toContain("<li>item one</li>");
-    expect(html).not.toContain("<li><p>");
-    // The list still parses as a list after the paragraph (not a paragraph+<br>).
-    expect(html).toContain("<ul>");
-    expect(html).toContain("<p>Intro paragraph.</p>");
-  });
-
-  it("renders an ordered list (1. 2.) as tight after collapsing", () => {
-    const loose = "Intro.\n\n1. first\n\n2. second";
-    const html = renderChatMarkdown(collapseBlankLines(loose), {});
-    expect(html).toContain("<ol>");
-    expect(html).toContain("<li>first</li>");
-    expect(html).not.toContain("<li><p>");
-  });
-
-  it("the loose source WOULD render <li><p> without collapsing (control)", () => {
-    const loose = "- a\n\n- b";
-    expect(renderChatMarkdown(loose, {})).toContain("<li><p>");
-  });
-});

apps/client/src/features/ai-chat/utils/collapse-blank-lines.ts

@@ -1,56 +0,0 @@
-// Pure helper for compact reasoning ("Thinking") rendering. Kept free of React
-// so it can be unit-tested in isolation (see collapse-blank-lines.test.ts).
-
-/**
- * Collapse runs of 2+ newlines down to a single newline, EXCEPT inside fenced
- * code blocks (``` ... ``` or ~~~ ... ~~~), where blank lines are significant.
- *
- * Why: reasoning models emit thinking with a blank line (`\n\n`) between every
- * list item and paragraph. `marked` turns those into "loose" lists (each `<li>`
- * wrapped in a `<p>`) and separate `<p>` paragraphs, each carrying a vertical
- * margin — so the "Thinking" block renders with large, airy gaps. Removing the
- * blank-line gaps yields tight lists (no `<li><p>`) and joined paragraphs. The
- * chat markdown renderer runs with `breaks: true`, so a single `\n` still
- * becomes a `<br>` — line breaks inside the reasoning are preserved; only the
- * empty gaps between blocks disappear. Apply ONLY to reasoning text, never to a
- * normal assistant answer (where paragraph spacing is intentional).
- *
- * Fenced code is preserved verbatim: a fence opens on a line whose first
- * non-space characters are ``` or ~~~ and closes on the next line that starts
- * with the same fence character. Blank lines between fences (significant for
- * code formatting) are never collapsed.
- */
-export function collapseBlankLines(text: string): string {
-  const lines = text.split("\n");
-  const out: string[] = [];
-  let inFence = false;
-  let fenceChar = "";
-
-  for (const line of lines) {
-    const fenceMatch = line.match(/^\s*(`{3,}|~{3,})/);
-    if (fenceMatch) {
-      const ch = fenceMatch[1][0];
-      if (!inFence) {
-        inFence = true;
-        fenceChar = ch;
-      } else if (ch === fenceChar) {
-        inFence = false;
-      }
-      out.push(line);
-      continue;
-    }
-
-    // Inside a fenced block every line (including blanks) is significant.
-    if (inFence) {
-      out.push(line);
-      continue;
-    }
-
-    // Outside fences: drop blank lines so a `\n\n+` gap collapses to a single
-    // `\n` between the surrounding content lines.
-    if (line.trim() === "") continue;
-    out.push(line);
-  }
-
-  return out.join("\n");
-}

apps/client/src/features/ai-chat/utils/context-badge.test.ts

@@ -1,90 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { IAiChatMessageRow } from "@/features/ai-chat/types/ai-chat.types.ts";
-import { selectContextBadge } from "@/features/ai-chat/utils/context-badge.ts";
-
-/**
- * Pure-helper tests for the header context badge selection. Covers the two
- * non-obvious rules: numerator and denominator are each taken from the most
- * recent row carrying THAT value (they may live on different rows), and a fresh
- * row with a zero/absent value must NOT shadow an older positive one.
- */
-const row = (metadata: IAiChatMessageRow["metadata"]): IAiChatMessageRow => ({
-  id: Math.random().toString(),
-  role: "assistant",
-  content: null,
-  metadata,
-  createdAt: "2026-01-01T00:00:00.000Z",
-});
-
-describe("selectContextBadge", () => {
-  it("returns zeros for empty / nullish input", () => {
-    expect(selectContextBadge(undefined)).toEqual({
-      contextTokens: 0,
-      maxContextTokens: 0,
-    });
-    expect(selectContextBadge(null)).toEqual({
-      contextTokens: 0,
-      maxContextTokens: 0,
-    });
-    expect(selectContextBadge([])).toEqual({
-      contextTokens: 0,
-      maxContextTokens: 0,
-    });
-  });
-
-  it("reads both figures from the most recent row that carries them", () => {
-    expect(
-      selectContextBadge([
-        row({ contextTokens: 100, maxContextTokens: 200000 }),
-        row({ contextTokens: 1500, maxContextTokens: 200000 }),
-      ]),
-    ).toEqual({ contextTokens: 1500, maxContextTokens: 200000 });
-  });
-
-  it("falls back to legacy usage total for older rows without contextTokens", () => {
-    expect(
-      selectContextBadge([
-        row({ usage: { inputTokens: 30, outputTokens: 70 } }),
-      ]),
-    ).toEqual({ contextTokens: 100, maxContextTokens: 0 });
-
-    expect(
-      selectContextBadge([row({ usage: { totalTokens: 250 } })]),
-    ).toEqual({ contextTokens: 250, maxContextTokens: 0 });
-  });
-
-  it("takes numerator and denominator from different rows", () => {
-    // Freshest row (an error turn) carries contextTokens but no max; the older
-    // completed turn carries the max. Each is picked from its own latest row.
-    expect(
-      selectContextBadge([
-        row({ contextTokens: 800, maxContextTokens: 200000 }),
-        row({ contextTokens: 1200, error: "402: nope" }),
-      ]),
-    ).toEqual({ contextTokens: 1200, maxContextTokens: 200000 });
-  });
-
-  it("does not let a fresh zero/absent max shadow an older positive max", () => {
-    expect(
-      selectContextBadge([
-        row({ contextTokens: 100, maxContextTokens: 200000 }),
-        row({ contextTokens: 1200, maxContextTokens: 0 }),
-      ]),
-    ).toEqual({ contextTokens: 1200, maxContextTokens: 200000 });
-  });
-
-  it("skips rows with null metadata", () => {
-    expect(
-      selectContextBadge([
-        row({ contextTokens: 500, maxContextTokens: 200000 }),
-        row(null),
-      ]),
-    ).toEqual({ contextTokens: 500, maxContextTokens: 200000 });
-  });
-
-  it("reports current > max as-is (no clamp)", () => {
-    expect(
-      selectContextBadge([row({ contextTokens: 250000, maxContextTokens: 200000 })]),
-    ).toEqual({ contextTokens: 250000, maxContextTokens: 200000 });
-  });
-});

apps/client/src/features/ai-chat/utils/context-badge.ts

@@ -1,49 +0,0 @@
-import type { IAiChatMessageRow } from "@/features/ai-chat/types/ai-chat.types.ts";
-
-/**
- * Derive the header context badge figures from the persisted message rows.
- *
- * - `contextTokens` (numerator): how much the conversation now occupies in the
- *   model's context window. Read from the most recent row carrying a context
- *   figure — `contextTokens` (final-step input+output) on rows recorded after
- *   this shipped, else that turn's legacy `usage` total for older rows.
- * - `maxContextTokens` (denominator): the model's configured max window, stamped
- *   alongside `contextTokens` on a completed turn.
- *
- * Each value is taken from the most recent row carrying THAT value
- * independently — they may land on different rows (e.g. a fresh error row can
- * carry `contextTokens` but not `maxContextTokens`), so the scan continues for
- * whichever is still unset. `0` means "no row has it" (older rows, or no
- * admin-configured limit); the badge then omits the value.
- */
-export function selectContextBadge(
-  messageRows: readonly IAiChatMessageRow[] | undefined | null,
-): { contextTokens: number; maxContextTokens: number } {
-  let contextTokens = 0;
-  let maxContextTokens = 0;
-  if (!messageRows) return { contextTokens, maxContextTokens };
-  for (let i = messageRows.length - 1; i >= 0; i--) {
-    const meta = messageRows[i].metadata;
-    if (!meta) continue;
-    if (contextTokens === 0) {
-      if (typeof meta.contextTokens === "number" && meta.contextTokens > 0) {
-        contextTokens = meta.contextTokens;
-      } else if (meta.usage) {
-        const usage = meta.usage;
-        const fallback =
-          usage.totalTokens ??
-          (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0);
-        if (fallback > 0) contextTokens = fallback;
-      }
-    }
-    if (
-      maxContextTokens === 0 &&
-      typeof meta.maxContextTokens === "number" &&
-      meta.maxContextTokens > 0
-    ) {
-      maxContextTokens = meta.maxContextTokens;
-    }
-    if (contextTokens !== 0 && maxContextTokens !== 0) break;
-  }
-  return { contextTokens, maxContextTokens };
-}

apps/client/src/features/ai-chat/utils/count-stream-tokens.test.ts

@@ -1,5 +1,17 @@
 import { describe, expect, it } from "vitest";
-import { estimateTokens } from "@/features/ai-chat/utils/count-stream-tokens.ts";
+import type { UIMessage } from "@ai-sdk/react";
+import {
+  estimateTokens,
+  liveTurnTokens,
+} from "@/features/ai-chat/utils/count-stream-tokens.ts";
+
+const msg = (parts: unknown[], metadata?: unknown): UIMessage =>
+  ({
+    id: Math.random().toString(),
+    role: "assistant",
+    parts,
+    metadata,
+  }) as UIMessage;
 
 describe("estimateTokens", () => {
   it("returns 0 for the empty string", () => {
@@ -13,3 +25,147 @@ describe("estimateTokens", () => {
     expect(estimateTokens("12345678")).toBe(2);
   });
 });
+
+describe("liveTurnTokens — estimate path", () => {
+  it("is all zeros for an undefined message", () => {
+    expect(liveTurnTokens(undefined)).toEqual({
+      reasoning: 0,
+      output: 0,
+      authoritative: false,
+    });
+  });
+
+  it("is all zeros for a parts-less message", () => {
+    expect(liveTurnTokens({ id: "x", role: "assistant" } as UIMessage)).toEqual({
+      reasoning: 0,
+      output: 0,
+      authoritative: false,
+    });
+  });
+
+  it("estimates output from text parts", () => {
+    // 8 chars -> 2 tokens.
+    const r = liveTurnTokens(msg([{ type: "text", text: "12345678" }]));
+    expect(r).toEqual({ reasoning: 0, output: 2, authoritative: false });
+  });
+
+  it("estimates reasoning from reasoning parts (kept separate from output)", () => {
+    const r = liveTurnTokens(
+      msg([
+        { type: "reasoning", text: "12345678" },
+        { type: "text", text: "abcd" },
+      ]),
+    );
+    expect(r).toEqual({ reasoning: 2, output: 1, authoritative: false });
+  });
+
+  it("accumulates across multiple text + reasoning parts (multi-step)", () => {
+    const r = liveTurnTokens(
+      msg([
+        { type: "reasoning", text: "abcd" }, // 1
+        { type: "text", text: "abcd" }, // 1
+        { type: "tool-getPage", state: "output-available" }, // ignored
+        { type: "reasoning", text: "abcd" }, // 1
+        { type: "text", text: "abcdefgh" }, // 2
+      ]),
+    );
+    expect(r).toEqual({ reasoning: 2, output: 3, authoritative: false });
+  });
+
+  it("ignores non text/reasoning parts (tools, step-start)", () => {
+    const r = liveTurnTokens(
+      msg([
+        { type: "step-start" },
+        { type: "tool-getPage", state: "input-available" },
+      ]),
+    );
+    expect(r).toEqual({ reasoning: 0, output: 0, authoritative: false });
+  });
+});
+
+describe("liveTurnTokens — authoritative path", () => {
+  it("returns authoritative usage verbatim, splitting reasoning out of output", () => {
+    // outputTokens INCLUDES reasoning in the AI SDK shape -> answer = 100 - 30.
+    const r = liveTurnTokens(
+      msg([{ type: "text", text: "estimate would be tiny" }], {
+        usage: { inputTokens: 500, outputTokens: 100, reasoningTokens: 30 },
+      }),
+    );
+    expect(r).toEqual({ reasoning: 30, output: 70, authoritative: true });
+  });
+
+  it("treats missing reasoningTokens as 0 and keeps full output", () => {
+    const r = liveTurnTokens(
+      msg([{ type: "text", text: "x" }], {
+        usage: { inputTokens: 10, outputTokens: 42 },
+      }),
+    );
+    expect(r).toEqual({ reasoning: 0, output: 42, authoritative: true });
+  });
+
+  it("never returns a negative output when reasoning exceeds reported output", () => {
+    const r = liveTurnTokens(
+      msg([], { usage: { outputTokens: 10, reasoningTokens: 40 } }),
+    );
+    expect(r).toEqual({ reasoning: 40, output: 0, authoritative: true });
+  });
+
+  it("falls back to the estimate when metadata has no usage object", () => {
+    const r = liveTurnTokens(
+      msg([{ type: "text", text: "abcd" }], { chatId: "c1" }),
+    );
+    expect(r).toEqual({ reasoning: 0, output: 1, authoritative: false });
+  });
+});
+
+describe("liveTurnTokens — combined authoritative + estimate (#163)", () => {
+  it("ticks the in-flight step above the completed-steps authoritative base", () => {
+    // The authoritative usage is the sum over COMPLETED steps (step 1). The
+    // CURRENT step is streaming and its text is NOT in `usage` yet, but it IS in
+    // the parts -> the running estimate must push the live figure above the base
+    // so the badge keeps growing between step boundaries.
+    const longText = "x".repeat(800); // 800 chars -> 200 est output tokens
+    const r = liveTurnTokens(
+      msg([{ type: "text", text: longText }], {
+        usage: { inputTokens: 500, outputTokens: 40 }, // step-1 base: 40 output
+      }),
+    );
+    // max(authOutput=40, estOutput=200) = 200 -> the counter ticks, not frozen.
+    expect(r.output).toBe(200);
+    expect(r.authoritative).toBe(true);
+  });
+
+  it("ticks reasoning of the in-flight step above the authoritative reasoning base", () => {
+    const longReasoning = "r".repeat(400); // 400 chars -> 100 est reasoning
+    const r = liveTurnTokens(
+      msg([{ type: "reasoning", text: longReasoning }], {
+        usage: { inputTokens: 100, outputTokens: 20, reasoningTokens: 20 },
+      }),
+    );
+    // reasoning: max(20, 100) = 100 ; output: max(max(0,20-20)=0, 0) = 0.
+    expect(r.reasoning).toBe(100);
+    expect(r.output).toBe(0);
+    expect(r.authoritative).toBe(true);
+  });
+
+  it("snaps to the authoritative figure once it exceeds the rough estimate", () => {
+    // Short on-screen text (estimate tiny) but a large authoritative output:
+    // the exact figure wins at the boundary (the counter never under-reports).
+    const r = liveTurnTokens(
+      msg([{ type: "text", text: "abcd" }], {
+        usage: { inputTokens: 10, outputTokens: 5000 },
+      }),
+    );
+    expect(r.output).toBe(5000);
+  });
+
+  it("is monotonic: max never drops below the authoritative base when the estimate is smaller", () => {
+    // Mirrors the legacy 'verbatim' tests: estimate < authoritative -> unchanged.
+    const r = liveTurnTokens(
+      msg([{ type: "text", text: "tiny" }], {
+        usage: { inputTokens: 500, outputTokens: 100, reasoningTokens: 30 },
+      }),
+    );
+    expect(r).toEqual({ reasoning: 30, output: 70, authoritative: true });
+  });
+});

apps/client/src/features/ai-chat/utils/count-stream-tokens.ts

@@ -1,11 +1,18 @@
+import type { UIMessage } from "@ai-sdk/react";
+
 /**
- * Rough client-side token estimation for AI-chat UI affordances.
+ * Live token counting for a streaming AI-chat turn — split into REASONING
+ * (thinking) and OUTPUT (answer) tokens, mirroring how Claude Code shows
+ * `Thinking… · 60 tokens` next to its thinking indicator.
  *
- * No provider streams exact per-token usage mid-stream, so any in-flight figure
- * is a CLIENT ESTIMATE (chars/≈4 heuristic). Pure + unit-testable: it never runs
- * a real BPE tokenizer (that would be O(n²) on the hot path, bloat the bundle,
- * and be wrong for Gemini/Ollama anyway). Used by the in-body reasoning counter
- * ("Thinking · N tokens").
+ * No provider streams exact per-token usage mid-stream, so the live number is a
+ * CLIENT ESTIMATE (chars/≈4 heuristic) that is reconciled to AUTHORITATIVE usage
+ * once the server attaches it on a step/turn boundary (see the server's
+ * `chatStreamMetadata` + the client's read of `message.metadata.usage`). When
+ * authoritative usage is present we return it verbatim (the number "jumps to
+ * exact"); otherwise we return the running estimate. Pure + unit-testable: it
+ * never runs a real BPE tokenizer (that would be O(n²) on the hot path, bloat the
+ * bundle, and be wrong for Gemini/Ollama anyway).
  */
 
 /**
@@ -17,3 +24,90 @@ export function estimateTokens(text: string): number {
   if (!text) return 0;
   return Math.ceil(text.length / 4);
 }
+
+/** Authoritative per-step/turn usage the server attaches to message metadata. */
+export interface AuthoritativeUsage {
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+  reasoningTokens?: number;
+}
+
+/** Live token split for a turn's tail (streaming) assistant message. */
+export interface LiveTurnTokens {
+  /** Thinking/reasoning tokens (estimate, or authoritative when available). */
+  reasoning: number;
+  /** Answer/output tokens (estimate, or authoritative when available). */
+  output: number;
+  /** True when the numbers come from authoritative server usage, not estimate. */
+  authoritative: boolean;
+}
+
+/** Read the authoritative usage off a UIMessage's metadata, if the server set it. */
+function metadataUsage(message: UIMessage): AuthoritativeUsage | undefined {
+  const meta = message?.metadata as
+    | { usage?: AuthoritativeUsage }
+    | undefined;
+  const usage = meta?.usage;
+  if (!usage || typeof usage !== "object") return undefined;
+  return usage;
+}
+
+/**
+ * Token split for the given (streaming) assistant message.
+ *
+ * COMBINES the authoritative server usage with the running text estimate so the
+ * counter ticks in real time AND lands exact. The server only attaches
+ * `metadata.usage` at a step/turn boundary (`finish-step`/`finish`) and it is
+ * CUMULATIVE over COMPLETED steps — it does NOT yet include the in-flight step.
+ * So a multi-step turn that returned the authoritative figure verbatim would
+ * FREEZE between boundaries and jump in steps (issue #163).
+ *
+ * Instead we always compute the running ESTIMATE (chars/≈4 over the message's
+ * `reasoning`/`text` parts, which grows on every streamed delta) and take the
+ * per-component MAX of the authoritative base and the estimate:
+ *   - between boundaries the estimate of the in-flight step ticks the number up;
+ *   - at a boundary the authoritative figure snaps it to exact;
+ *   - because the server's usage is cumulative and we only ever take the max, the
+ *     number is MONOTONIC — it never drops.
+ *
+ * Providers that don't stream reasoning text still surface a reasoning count once
+ * the authoritative usage arrives (`max(reasoningTokens, 0)`); on the pure
+ * estimate path (no usage yet) such a turn shows `reasoning: 0` until then.
+ */
+export function liveTurnTokens(message: UIMessage | undefined): LiveTurnTokens {
+  if (!message) return { reasoning: 0, output: 0, authoritative: false };
+
+  // Running ESTIMATE over every reasoning/text part — grows on each delta. This
+  // includes the IN-FLIGHT step, which the authoritative usage does not cover yet.
+  let estReasoning = 0;
+  let estOutput = 0;
+  for (const part of message.parts ?? []) {
+    if (part.type === "reasoning") {
+      estReasoning += estimateTokens((part as { text?: string }).text ?? "");
+    } else if (part.type === "text") {
+      estOutput += estimateTokens((part as { text?: string }).text ?? "");
+    }
+  }
+
+  const usage = metadataUsage(message);
+  if (!usage) {
+    // No authoritative usage streamed yet: the estimate IS the live figure.
+    return { reasoning: estReasoning, output: estOutput, authoritative: false };
+  }
+
+  // Authoritative sum over COMPLETED steps. `outputTokens` already INCLUDES
+  // reasoning in the AI SDK usage shape, so subtract it out for the "answer"
+  // figure (never go negative if a provider reports them inconsistently).
+  const authReasoning = usage.reasoningTokens ?? 0;
+  const authOutput = Math.max(0, (usage.outputTokens ?? 0) - authReasoning);
+
+  // Per-component max: the in-flight step's estimate ticks above the completed-
+  // steps base between boundaries, and the authoritative figure wins once it
+  // exceeds the (rough) estimate at the next boundary. Monotonic by construction.
+  return {
+    reasoning: Math.max(authReasoning, estReasoning),
+    output: Math.max(authOutput, estOutput),
+    authoritative: true,
+  };
+}

apps/client/src/features/ai-chat/utils/message-signature.test.ts

@@ -1,241 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { UIMessage } from "@ai-sdk/react";
-import { messageSignature } from "@/features/ai-chat/utils/message-signature.ts";
-
-/**
- * Pure-helper tests for `messageSignature`, the cheap per-message content
- * signature that drives MessageItem's memo (a streaming row's signature must
- * change on every delta so it re-renders, while a finalized row's stays stable
- * so it is skipped). Each test exercises ONE change signal and asserts it flips
- * the signature; a content-identical clone must keep an EQUAL signature.
- *
- * The signature embeds `message.id` and `message.role`, so the `msg` factory
- * uses a FIXED id/role here (not `Math.random()`): otherwise two messages with
- * identical content would get different signatures and the negative case would
- * be impossible to express.
- */
-const msg = (
-  parts: UIMessage["parts"],
-  metadata?: unknown,
-): UIMessage =>
-  ({
-    id: "m1",
-    role: "assistant",
-    parts,
-    metadata,
-  }) as UIMessage;
-
-describe("messageSignature", () => {
-  it("changes when a text part grows", () => {
-    const before = msg([{ type: "text", text: "alpha" }]);
-    const after = msg([{ type: "text", text: "alpha beta" }]);
-    expect(messageSignature(before)).not.toBe(messageSignature(after));
-  });
-
-  it("changes when a new part is appended", () => {
-    const before = msg([{ type: "text", text: "alpha" }]);
-    const after = msg([
-      { type: "text", text: "alpha" },
-      { type: "text", text: "beta" },
-    ]);
-    expect(messageSignature(before)).not.toBe(messageSignature(after));
-  });
-
-  it("changes when a part's state flips", () => {
-    const before = msg([
-      { type: "tool-getPage", state: "input-streaming" } as never,
-    ]);
-    const after = msg([
-      { type: "tool-getPage", state: "output-available" } as never,
-    ]);
-    expect(messageSignature(before)).not.toBe(messageSignature(after));
-  });
-
-  it("changes when a tool part gains an output", () => {
-    const before = msg([
-      { type: "tool-getPage", state: "output-available" } as never,
-    ]);
-    const after = msg([
-      {
-        type: "tool-getPage",
-        state: "output-available",
-        output: { ok: true },
-      } as never,
-    ]);
-    expect(messageSignature(before)).not.toBe(messageSignature(after));
-  });
-
-  it("changes when a part gains an errorText", () => {
-    const before = msg([
-      { type: "tool-getPage", state: "output-error" } as never,
-    ]);
-    const after = msg([
-      {
-        type: "tool-getPage",
-        state: "output-error",
-        errorText: "boom",
-      } as never,
-    ]);
-    expect(messageSignature(before)).not.toBe(messageSignature(after));
-  });
-
-  it("changes when usage.reasoningTokens arrives on finish-step (text/state already frozen)", () => {
-    // The specifically-commented edge case: the authoritative turn total lands on
-    // the final finish-step AFTER the reasoning text length and state are frozen.
-    // Only the token count appears between these two snapshots, so the signature
-    // MUST still flip — otherwise the "Thinking · N tokens" header would never
-    // snap from the live estimate to the exact figure.
-    const before = msg([
-      { type: "reasoning", text: "thinking", state: "done" } as never,
-    ]);
-    const after = msg(
-      [{ type: "reasoning", text: "thinking", state: "done" } as never],
-      { usage: { reasoningTokens: 42 } },
-    );
-    expect(messageSignature(before)).not.toBe(messageSignature(after));
-  });
-
-  it("changes when metadata.error appears", () => {
-    const before = msg([{ type: "text", text: "answer" }]);
-    const after = msg([{ type: "text", text: "answer" }], { error: "boom" });
-    expect(messageSignature(before)).not.toBe(messageSignature(after));
-  });
-
-  it("changes when metadata.finishReason changes (e.g. to 'aborted')", () => {
-    const before = msg([{ type: "text", text: "answer" }], {
-      finishReason: "stop",
-    });
-    const after = msg([{ type: "text", text: "answer" }], {
-      finishReason: "aborted",
-    });
-    expect(messageSignature(before)).not.toBe(messageSignature(after));
-  });
-
-  it("is UNCHANGED for a content-identical clone (different object, same values)", () => {
-    // A finalized row that is re-created as a fresh object (different parts array
-    // by reference, same parts by value) must keep an EQUAL signature, so the
-    // memo skips re-rendering it.
-    const a = msg([
-      { type: "text", text: "alpha" },
-      { type: "tool-getPage", state: "output-available", output: { ok: true } } as never,
-    ]);
-    const b = msg([
-      { type: "text", text: "alpha" },
-      { type: "tool-getPage", state: "output-available", output: { ok: true } } as never,
-    ]);
-    expect(a).not.toBe(b);
-    expect(messageSignature(a)).toBe(messageSignature(b));
-  });
-});
-
-/**
- * Per-part-kind coupling guard for the load-bearing invariant documented at the
- * top of message-signature.ts: the signature MUST sample every VISIBLE field the
- * MessageItem render body draws, or the memo freezes a stale row. This is an
- * executable lock for the part kinds rendered TODAY — read alongside
- * `MessageItem` (message-item.tsx) and the `assistantMessageHasVisibleContent`
- * helper (message-content.ts), which "mirrors MessageItem's render decisions
- * EXACTLY". For each kind, mutating a field the render body DRAWS must flip the
- * signature. If a new visible field is rendered without being added here AND to
- * the signature, the corresponding assertion below should fail — that is the
- * guard. (This intentionally stops short of the render-descriptor refactor:
- * adding a part kind or a visible field still requires a human to extend both
- * the signature and this block.)
- */
-describe("messageSignature ↔ render coupling (per visible part kind)", () => {
-  describe("text part — render draws part.text (MarkdownPart text={part.text})", () => {
-    it("flips when the visible text changes", () => {
-      // Streaming is append-only, so the visible text only grows; the signature
-      // samples its length, so the growth is the change signal.
-      const before = msg([{ type: "text", text: "answer" }]);
-      const after = msg([{ type: "text", text: "answer extended" }]);
-      expect(messageSignature(before)).not.toBe(messageSignature(after));
-    });
-  });
-
-  describe("reasoning part — render draws text + tokens (ReasoningBlock)", () => {
-    it("flips when the visible reasoning text changes", () => {
-      const before = msg([
-        { type: "reasoning", text: "think", state: "streaming" } as never,
-      ]);
-      const after = msg([
-        { type: "reasoning", text: "think harder", state: "streaming" } as never,
-      ]);
-      expect(messageSignature(before)).not.toBe(messageSignature(after));
-    });
-
-    it("flips when the visible token count (metadata.usage.reasoningTokens) lands", () => {
-      // The header's "Thinking · N tokens" reads reasoningTokensForPart, fed by
-      // metadata.usage.reasoningTokens — a VISIBLE field that arrives on the final
-      // finish-step after text length and state are frozen.
-      const before = msg([
-        { type: "reasoning", text: "think", state: "done" } as never,
-      ]);
-      const after = msg(
-        [{ type: "reasoning", text: "think", state: "done" } as never],
-        { usage: { reasoningTokens: 99 } },
-      );
-      expect(messageSignature(before)).not.toBe(messageSignature(after));
-    });
-  });
-
-  describe("tool-* part — render draws state/errorText/citations (ToolCallCard)", () => {
-    it("flips when the run state changes (running ↔ done icon + label)", () => {
-      // toolRunState(part.state) selects the spinner/check/error icon.
-      const before = msg([
-        { type: "tool-getPage", state: "input-available" } as never,
-      ]);
-      const after = msg([
-        { type: "tool-getPage", state: "output-available" } as never,
-      ]);
-      expect(messageSignature(before)).not.toBe(messageSignature(after));
-    });
-
-    it("flips when output arrives (drives the rendered citation links)", () => {
-      // toolCitations reads part.output to render the "/p/{id}" anchors.
-      const before = msg([
-        { type: "tool-getPage", state: "output-available" } as never,
-      ]);
-      const after = msg([
-        {
-          type: "tool-getPage",
-          state: "output-available",
-          output: { id: "page-1", title: "Doc" },
-        } as never,
-      ]);
-      expect(messageSignature(before)).not.toBe(messageSignature(after));
-    });
-
-    it("flips when errorText appears (the visible red error detail line)", () => {
-      const before = msg([
-        { type: "tool-getPage", state: "output-error" } as never,
-      ]);
-      const after = msg([
-        {
-          type: "tool-getPage",
-          state: "output-error",
-          errorText: "permission denied",
-        } as never,
-      ]);
-      expect(messageSignature(before)).not.toBe(messageSignature(after));
-    });
-  });
-
-  describe("metadata banners — render draws error / aborted notices", () => {
-    it("flips when metadata.error appears (ChatErrorAlert banner)", () => {
-      const before = msg([{ type: "text", text: "answer" }]);
-      const after = msg([{ type: "text", text: "answer" }], { error: "boom" });
-      expect(messageSignature(before)).not.toBe(messageSignature(after));
-    });
-
-    it("flips when metadata.finishReason becomes 'aborted' (ChatStoppedNotice)", () => {
-      const before = msg([{ type: "text", text: "answer" }], {
-        finishReason: "stop",
-      });
-      const after = msg([{ type: "text", text: "answer" }], {
-        finishReason: "aborted",
-      });
-      expect(messageSignature(before)).not.toBe(messageSignature(after));
-    });
-  });
-});

apps/client/src/features/ai-chat/utils/message-signature.ts

@@ -1,44 +0,0 @@
-import type { UIMessage } from "@ai-sdk/react";
-
-/** Cheap content signature for one message: changes iff something VISIBLE in the
- *  row changed. Streaming is APPEND-ONLY (text parts only grow, parts are only
- *  appended, a tool/text part flips state once), so a per-part [type, text
- *  length, state, error/output presence] tuple + the persisted metadata
- *  (error/finishReason) is a sufficient change signal without comparing full
- *  strings on every delta. WARNING — load-bearing for the MessageItem memo:
- *  if a future part kind's VISIBLE content can change WITHOUT changing [type,
- *  text length, state, error/output presence] (e.g. a tool that streams
- *  `preliminary` output, or a client-side regenerate that edits a finalized
- *  row in place), extend this signature or the memo will freeze a stale row. */
-export function messageSignature(message: UIMessage): string {
-  const parts = message.parts
-    .map((p) => {
-      const any = p as {
-        type: string;
-        text?: string;
-        state?: string;
-        errorText?: string;
-        output?: unknown;
-      };
-      return [
-        any.type,
-        any.text?.length ?? 0,
-        any.state ?? "",
-        any.errorText ? 1 : 0,
-        any.output !== undefined ? 1 : 0,
-      ].join(":");
-    })
-    .join("|");
-  const meta = message.metadata as
-    | { error?: string; finishReason?: string; usage?: { reasoningTokens?: number } }
-    | undefined;
-  // `usage.reasoningTokens` is neither append-only nor part-bound: the authoritative
-  // turn total arrives on the final `finish-step` AFTER the reasoning text length and
-  // state are already frozen. Without it in the signature the row's signature would be
-  // unchanged at that point and the re-render skipped, so the "Thinking · N tokens"
-  // header (reasoningTokensForPart) would keep the live estimate instead of snapping
-  // to the exact figure.
-  return `${message.id}#${message.role}#${parts}#${meta?.error ?? ""}#${
-    meta?.finishReason ?? ""
-  }#${meta?.usage?.reasoningTokens ?? ""}`;
-}

apps/client/src/features/ai-chat/utils/queue-helpers.test.ts

@@ -2,7 +2,6 @@ import { describe, it, expect } from "vitest";
 import {
   enqueueMessage,
   dequeue,
-  promoteToHead,
   removeQueuedById,
   type QueuedMessage,
 } from "./queue-helpers";
@@ -90,52 +89,6 @@ describe("removeQueuedById", () => {
   });
 });
 
-describe("promoteToHead", () => {
-  it("moves the matching id to the front, preserving the rest's order", () => {
-    const queue: QueuedMessage[] = [
-      { id: "a", text: "first" },
-      { id: "b", text: "second" },
-      { id: "c", text: "third" },
-    ];
-    expect(promoteToHead(queue, "c")).toEqual([
-      { id: "c", text: "third" },
-      { id: "a", text: "first" },
-      { id: "b", text: "second" },
-    ]);
-  });
-
-  it("is a no-op order-wise when the id is already the head", () => {
-    const queue: QueuedMessage[] = [
-      { id: "a", text: "first" },
-      { id: "b", text: "second" },
-    ];
-    expect(promoteToHead(queue, "a")).toEqual([
-      { id: "a", text: "first" },
-      { id: "b", text: "second" },
-    ]);
-  });
-
-  it("returns an equivalent list when the id is not present", () => {
-    const queue: QueuedMessage[] = [
-      { id: "a", text: "first" },
-      { id: "b", text: "second" },
-    ];
-    expect(promoteToHead(queue, "missing")).toEqual(queue);
-  });
-
-  it("does not mutate the input queue", () => {
-    const queue: QueuedMessage[] = [
-      { id: "a", text: "first" },
-      { id: "b", text: "second" },
-    ];
-    promoteToHead(queue, "b");
-    expect(queue).toEqual([
-      { id: "a", text: "first" },
-      { id: "b", text: "second" },
-    ]);
-  });
-});
-
 describe("FIFO order", () => {
   it("preserves order across enqueue -> dequeue", () => {
     let queue: QueuedMessage[] = [];

apps/client/src/features/ai-chat/utils/queue-helpers.ts

@@ -32,16 +32,3 @@ export function removeQueuedById(
 ): QueuedMessage[] {
   return queue.filter((m) => m.id !== id);
 }
-
-/** Move the queued message with the given id to the FRONT (returns a new array).
- *  No-op (returns an equivalent array) when the id is absent. Pure — backs the
- *  "send now" action: promoting a message to the head lets the existing
- *  onFinish -> flushNext path send exactly that message on the abort we trigger. */
-export function promoteToHead(
-  queue: QueuedMessage[],
-  id: string,
-): QueuedMessage[] {
-  const target = queue.find((m) => m.id === id);
-  if (!target) return queue;
-  return [target, ...queue.filter((m) => m.id !== id)];
-}

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

@@ -10,6 +10,8 @@ export const readOnlyEditorAtom = atom<Editor | null>(null);
 
 export const yjsConnectionStatusAtom = atom<string>("");
 
+export const showAiMenuAtom = atom(false);
+
 export const showLinkMenuAtom = atom(false);
 
 // Current page's edit mode — initialized from the user's saved preference on

apps/client/src/features/editor/components/bubble-menu/bubble-menu.tsx

@@ -9,10 +9,11 @@ import {
   IconStrikethrough,
   IconUnderline,
   IconMessage,
+  IconSparkles,
 } from "@tabler/icons-react";
 import clsx from "clsx";
 import classes from "./bubble-menu.module.css";
-import { ActionIcon, rem, Tooltip } from "@mantine/core";
+import { ActionIcon, Button, rem, Tooltip } from "@mantine/core";
 import { ColorSelector } from "./color-selector";
 import { NodeSelector } from "./node-selector";
 import { TextAlignmentSelector } from "./text-alignment-selector";
@@ -25,8 +26,8 @@ import { v7 as uuid7 } from "uuid";
 import { isCellSelection, isTextSelected } from "@docmost/editor-ext";
 import { LinkSelector } from "@/features/editor/components/bubble-menu/link-selector.tsx";
 import { useTranslation } from "react-i18next";
-import { showLinkMenuAtom } from "@/features/editor/atoms/editor-atoms";
-import { userAtom } from "@/features/user/atoms/current-user-atom";
+import { showAiMenuAtom, showLinkMenuAtom } from "@/features/editor/atoms/editor-atoms";
+import { userAtom, workspaceAtom } from "@/features/user/atoms/current-user-atom";
 
 export interface BubbleMenuItem {
   name: string;
@@ -43,12 +44,16 @@ type EditorBubbleMenuProps = Omit<BubbleMenuProps, "children" | "editor"> & {
 export const EditorBubbleMenu: FC<EditorBubbleMenuProps> = (props) => {
   const { templateMode = false } = props;
   const { t } = useTranslation();
+  const [showAiMenu, setShowAiMenu] = useAtom(showAiMenuAtom);
   const [showCommentPopup, setShowCommentPopup] = useAtom(showCommentPopupAtom);
+  const workspace = useAtomValue(workspaceAtom);
+  const isGenerativeAiEnabled = workspace?.settings?.ai?.generative === true;
   const user = useAtomValue(userAtom);
   const editorToolbarEnabled =
     user?.settings?.preferences?.editorToolbar ?? false;
   const [, setDraftCommentId] = useAtom(draftCommentIdAtom);
   const showCommentPopupRef = useRef(showCommentPopup);
+  const showAiMenuRef = useRef(showAiMenu);
   const [showLinkMenu] = useAtom(showLinkMenuAtom);
   const showLinkMenuRef = useRef(showLinkMenu);
 
@@ -56,6 +61,10 @@ export const EditorBubbleMenu: FC<EditorBubbleMenuProps> = (props) => {
     showCommentPopupRef.current = showCommentPopup;
   }, [showCommentPopup]);
 
+  useEffect(() => {
+    showAiMenuRef.current = showAiMenu;
+  }, [showAiMenu]);
+
   useEffect(() => {
     showLinkMenuRef.current = showLinkMenu;
   }, [showLinkMenu]);
@@ -136,6 +145,7 @@ export const EditorBubbleMenu: FC<EditorBubbleMenuProps> = (props) => {
         empty ||
         isNodeSelection(selection) ||
         isCellSelection(selection) ||
+        showAiMenuRef.current ||
         showLinkMenuRef.current ||
         showCommentPopupRef?.current
       ) {
@@ -158,8 +168,8 @@ export const EditorBubbleMenu: FC<EditorBubbleMenuProps> = (props) => {
   const [isTextAlignmentSelectorOpen, setIsTextAlignmentOpen] = useState(false);
   const [isColorSelectorOpen, setIsColorSelectorOpen] = useState(false);
 
-  // Hide the bubble menu immediately when the link menu is shown
-  if (showLinkMenu) return;
+  // Hide the bubble menu immediately when AI menu is shown
+  if (showAiMenu || showLinkMenu) return;
 
   return (
     <BubbleMenu
@@ -167,6 +177,22 @@ export const EditorBubbleMenu: FC<EditorBubbleMenuProps> = (props) => {
       style={{ zIndex: 199, position: "relative" }}
     >
       <div className={classes.bubbleMenu}>
+        {isGenerativeAiEnabled && (
+          <>
+            <Button
+              variant="default"
+              className={clsx(classes.buttonRoot)}
+              radius="0"
+              leftSection={<IconSparkles size={16} />}
+              onClick={() => {
+                setShowAiMenu(true);
+              }}
+            >
+              {t("Ask AI")}
+            </Button>
+            <div className={classes.divider} />
+          </>
+        )}
         {!editorToolbarEnabled && (
           <>
             <NodeSelector

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

@@ -12,6 +12,8 @@ import { MediaGroup } from "./groups/media-group";
 import { QuickInsertsGroup } from "./groups/quick-inserts-group";
 import { MoreInsertsGroup } from "./groups/more-inserts-group";
 import { HistoryGroup } from "./groups/history-group";
+import { AskAiGroup } from "./groups/ask-ai-group";
+import { workspaceAtom } from "@/features/user/atoms/current-user-atom";
 import classes from "./fixed-toolbar.module.css";
 
 type FixedToolbarProps = {
@@ -26,6 +28,8 @@ export const FixedToolbar: FC<FixedToolbarProps> = ({
   const editorFromAtom = useAtomValue(pageEditorAtom);
   const editor = editorProp ?? editorFromAtom;
   const state = useToolbarState(editor);
+  const workspace = useAtomValue(workspaceAtom);
+  const isGenerativeAiEnabled = workspace?.settings?.ai?.generative === true;
 
   if (!editor || !state) return null;
 
@@ -39,6 +43,12 @@ export const FixedToolbar: FC<FixedToolbarProps> = ({
         onMouseDown={(e) => e.preventDefault()}
       >
         <div className={classes.inner}>
+          {/* {isGenerativeAiEnabled && (
+            <>
+              <AskAiGroup />
+              <div className={classes.divider} />
+            </>
+          )} */}
           <BlockTypeGroup editor={editor} />
           <div className={classes.divider} />
           <InlineMarksGroup editor={editor} state={state} />

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

@@ -0,0 +1,23 @@
+import { FC } from "react";
+import { Button } from "@mantine/core";
+import { IconSparkles } from "@tabler/icons-react";
+import { useSetAtom } from "jotai";
+import { useTranslation } from "react-i18next";
+import { showAiMenuAtom } from "@/features/editor/atoms/editor-atoms";
+
+export const AskAiGroup: FC = () => {
+  const { t } = useTranslation();
+  const setShowAiMenu = useSetAtom(showAiMenuAtom);
+
+  return (
+    <Button
+      variant="subtle"
+      color="dark"
+      size="xs"
+      leftSection={<IconSparkles size={14} />}
+      onClick={() => setShowAiMenu(true)}
+    >
+      {t("Ask AI")}
+    </Button>
+  );
+};

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

@@ -1,39 +0,0 @@
-import { FC } from "react";
-import { ActionIcon, Tooltip } from "@mantine/core";
-import { IconSparkles } from "@tabler/icons-react";
-import { useTranslation } from "react-i18next";
-import { useGeneratePageTitle } from "@/features/editor/hooks/use-generate-page-title.ts";
-
-interface Props {
-  pageId: string;
-  color?: string;
-  iconSize?: number;
-}
-
-/**
- * AI "generate title" button (#199). Reads the live editor content and applies a
- * model-suggested title immediately. Rendered in the page byline, only in edit
- * mode and when the workspace's AI chat flag is on.
- */
-export const GenerateTitleGroup: FC<Props> = ({
-  pageId,
-  color = "gray",
-  iconSize = 20,
-}) => {
-  const { t } = useTranslation();
-  const gen = useGeneratePageTitle(pageId);
-
-  return (
-    <Tooltip label={t("Generate title with AI")} withArrow openDelay={250}>
-      <ActionIcon
-        variant="subtle"
-        color={color}
-        aria-label={t("Generate title with AI")}
-        loading={gen.isPending}
-        onClick={() => gen.mutate()}
-      >
-        <IconSparkles size={iconSize} stroke={1.5} />
-      </ActionIcon>
-    </Tooltip>
-  );
-};

apps/client/src/features/editor/components/footnote/footnote-definition-view.tsx

@@ -1,45 +1,25 @@
 import { NodeViewContent, NodeViewProps, NodeViewWrapper } from "@tiptap/react";
 import { useTranslation } from "react-i18next";
-import { getFootnoteNumber, getFootnoteRefCount } from "@docmost/editor-ext";
+import { getFootnoteNumber } from "@docmost/editor-ext";
 import classes from "./footnote.module.css";
 
-/**
- * A 0-based backlink index -> its lowercase letter label (0 -> "a", 25 -> "z",
- * 26 -> "aa", ...), matching the Pandoc/Wikipedia "↩ a b c" convention.
- */
-export function backlinkLabel(index: number): string {
-  let out = "";
-  let x = index;
-  while (x >= 0) {
-    out = String.fromCharCode(97 + (x % 26)) + out;
-    x = Math.floor(x / 26) - 1;
-  }
-  return out;
-}
-
 /**
  * NodeView for a single footnote definition: a decorative number marker, the
  * editable content (NodeViewContent), and a "↩" back-link to its reference.
  * The number is derived from the document (not stored).
- *
- * After #166 a footnote can be referenced more than once (one number, one
- * definition, N forward links). When it is, the back-link becomes a row of
- * per-occurrence links — ↩ a b c … — each scrolling to its own reference (#168);
- * a single-reference footnote keeps the plain ↩.
  */
 export default function FootnoteDefinitionView(props: NodeViewProps) {
   const { node, editor } = props;
   const { t } = useTranslation();
   const id = node.attrs.id as string;
 
-  // Read the cached number/ref-count from the numbering plugin (computed once
-  // per doc change) rather than recomputing the whole map on every render.
+  // Read the cached number from the numbering plugin (computed once per doc
+  // change) rather than recomputing the whole map on every render.
   const number = getFootnoteNumber(editor.state, id) ?? "?";
-  const refCount = getFootnoteRefCount(editor.state, id);
 
-  const jumpTo = (e: React.MouseEvent, index: number) => {
+  const handleBack = (e: React.MouseEvent) => {
     e.preventDefault();
-    editor.commands.scrollToReference(id, index);
+    editor.commands.scrollToReference(id);
   };
 
   return (
@@ -62,47 +42,16 @@ export default function FootnoteDefinitionView(props: NodeViewProps) {
       >
         {number}.
       </span>
-      {refCount > 1 ? (
-        // Multiple references -> ↩ followed by one lettered link per occurrence.
-        <span
-          className={classes.backLinks}
-          contentEditable={false}
-          role="group"
-          aria-label={t("Back to references")}
-        >
-          <span className={classes.backLinkArrow} aria-hidden="true">
-            ↩
-          </span>
-          {Array.from({ length: refCount }, (_, i) => (
-            <span
-              key={i}
-              className={classes.backLink}
-              onClick={(e) => jumpTo(e, i)}
-              role="button"
-              aria-label={t("Back to reference {{label}}", {
-                label: backlinkLabel(i),
-              })}
-              title={t("Back to reference {{label}}", {
-                label: backlinkLabel(i),
-              })}
-            >
-              {backlinkLabel(i)}
-            </span>
-          ))}
-        </span>
-      ) : (
-        // Single reference -> the plain ↩ (unchanged behavior).
-        <span
-          className={classes.backLink}
-          contentEditable={false}
-          onClick={(e) => jumpTo(e, 0)}
-          role="button"
-          aria-label={t("Back to reference")}
-          title={t("Back to reference")}
-        >
-          ↩
-        </span>
-      )}
+      <span
+        className={classes.backLink}
+        contentEditable={false}
+        onClick={handleBack}
+        role="button"
+        aria-label={t("Back to reference")}
+        title={t("Back to reference")}
+      >
+        ↩
+      </span>
     </NodeViewWrapper>
   );
 }

apps/client/src/features/editor/components/footnote/footnote-views.structure.test.tsx

@@ -1,5 +1,5 @@
-import { describe, it, expect, vi, afterEach } from "vitest";
-import { render, fireEvent } from "@testing-library/react";
+import { describe, it, expect, vi } from "vitest";
+import { render } from "@testing-library/react";
 
 /**
  * Structural regression guard for #146 (PR #147).
@@ -36,14 +36,10 @@ vi.mock("react-i18next", () => ({
   useTranslation: () => ({ t: (key: string) => key }),
 }));
 
-// footnote-definition-view reads a cached number + reference count from the
-// numbering plugin; stub them so we don't need a live ProseMirror state. The
-// ref-count is a hoisted mutable so a test can drive the single-vs-multi
-// backlink branch (#168). Default 1 = single reference (the #146 cases).
-const { mockRefCount } = vi.hoisted(() => ({ mockRefCount: { value: 1 } }));
+// footnote-definition-view reads a cached number from the numbering plugin;
+// stub it so we don't need a live ProseMirror state.
 vi.mock("@docmost/editor-ext", () => ({
   getFootnoteNumber: () => 1,
-  getFootnoteRefCount: () => mockRefCount.value,
 }));
 
 // Mocks so CodeBlockView renders cheaply (no MantineProvider, no matchMedia).
@@ -63,8 +59,7 @@ vi.mock("@mantine/core", () => ({
   ),
 }));
 vi.mock("@/components/common/copy-button", () => ({
-  CopyButton: ({ children }: any) =>
-    children({ copied: false, copy: () => {} }),
+  CopyButton: ({ children }: any) => children({ copied: false, copy: () => {} }),
 }));
 vi.mock("@tabler/icons-react", () => ({
   IconCheck: () => null,
@@ -75,9 +70,7 @@ vi.mock("@/features/editor/components/code-block/mermaid-view.tsx", () => ({
 }));
 
 import FootnotesListView from "./footnotes-list-view";
-import FootnoteDefinitionView, {
-  backlinkLabel,
-} from "./footnote-definition-view";
+import FootnoteDefinitionView from "./footnote-definition-view";
 import CodeBlockView from "../code-block/code-block-view";
 
 // Minimal NodeViewProps stub: definition view only touches node.attrs.id and
@@ -148,84 +141,3 @@ describe("#146 editable NodeView contentDOM-first invariant", () => {
     },
   );
 });
-
-// #168: a footnote referenced more than once shows one lettered backlink per
-// occurrence (↩ a b c), each scrolling to its own reference; a single-reference
-// footnote keeps the plain ↩.
-describe("#168 footnote definition multi-backlinks", () => {
-  afterEach(() => {
-    // Reset the shared ref-count mock so other tests see a single reference.
-    mockRefCount.value = 1;
-  });
-
-  const makeProps = () =>
-    ({
-      node: { attrs: { id: "fn-1" }, textContent: "" },
-      editor: {
-        state: {},
-        isEditable: true,
-        commands: { scrollToReference: vi.fn() },
-      },
-      getPos: () => 0,
-      updateAttributes: () => {},
-      deleteNode: () => {},
-    }) as any;
-
-  it("renders one lettered backlink per reference (a, b, c) plus the ↩ arrow", () => {
-    mockRefCount.value = 3;
-    const { getByTestId } = render(<FootnoteDefinitionView {...makeProps()} />);
-    const wrapper = getByTestId("nvw");
-
-    const links = wrapper.querySelectorAll('[role="button"]');
-    expect(Array.from(links).map((l) => l.textContent)).toEqual([
-      "a",
-      "b",
-      "c",
-    ]);
-    // The ↩ arrow is present (as decorative chrome, not a button).
-    expect(wrapper.textContent).toContain("↩");
-  });
-
-  it("clicking the n-th backlink scrolls to the n-th occurrence (0-based)", () => {
-    mockRefCount.value = 3;
-    const props = makeProps();
-    const { getByTestId } = render(<FootnoteDefinitionView {...props} />);
-    const links = getByTestId("nvw").querySelectorAll('[role="button"]');
-
-    fireEvent.click(links[1]); // "b"
-    expect(props.editor.commands.scrollToReference).toHaveBeenCalledWith(
-      "fn-1",
-      1,
-    );
-  });
-
-  it("a single-reference footnote renders just one ↩ (no letters)", () => {
-    mockRefCount.value = 1;
-    const props = makeProps();
-    const { getByTestId } = render(<FootnoteDefinitionView {...props} />);
-    const wrapper = getByTestId("nvw");
-
-    const links = wrapper.querySelectorAll('[role="button"]');
-    expect(links.length).toBe(1);
-    expect(links[0].textContent).toBe("↩");
-
-    fireEvent.click(links[0]);
-    expect(props.editor.commands.scrollToReference).toHaveBeenCalledWith(
-      "fn-1",
-      0,
-    );
-  });
-});
-
-// #185 re-review pt 7: backlinkLabel is base-26 (a..z, then aa…). The component
-// tests only cover a,b,c (index 0-2); pin the >= 26 carry boundary.
-describe("backlinkLabel base-26 boundary (#168)", () => {
-  it("maps 0->a, 25->z, 26->aa, 27->ab, 51->az, 52->ba", () => {
-    expect(backlinkLabel(0)).toBe("a");
-    expect(backlinkLabel(25)).toBe("z");
-    expect(backlinkLabel(26)).toBe("aa");
-    expect(backlinkLabel(27)).toBe("ab");
-    expect(backlinkLabel(51)).toBe("az");
-    expect(backlinkLabel(52)).toBe("ba");
-  });
-});

apps/client/src/features/editor/components/footnote/footnote.module.css

@@ -104,19 +104,6 @@
   min-width: 0;
 }
 
-/* The inner editable paragraph inherits `.ProseMirror p { margin: 0.5em 0 }`,
-   which pushes the first text line ~0.5em below the "N." marker (aligned to
-   flex-start), making the number float above the text. Drop the outer margins
-   so the marker and the first line share the same top edge — same approach
-   used for callouts in core.css. */
-.definitionContent > :first-child {
-  margin-top: 0;
-}
-
-.definitionContent > :last-child {
-  margin-bottom: 0;
-}
-
 .backLink {
   flex: 0 0 auto;
   cursor: pointer;
@@ -128,18 +115,3 @@
 .backLink:hover {
   text-decoration: underline;
 }
-
-/* Multi-backlink row (#168): ↩ a b c — one lettered link per reference
-   occurrence. Sits on the right, after the content, like the single ↩. */
-.backLinks {
-  flex: 0 0 auto;
-  display: inline-flex;
-  align-items: baseline;
-  gap: 0.3em;
-  user-select: none;
-}
-
-.backLinkArrow {
-  color: var(--mantine-color-dimmed);
-  font-size: 0.9em;
-}

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

@@ -26,20 +26,17 @@ import { FixedToolbar } from "@/features/editor/components/fixed-toolbar/fixed-t
 import { PageEditMode } from "@/features/user/types/user.types.ts";
 import { useAsideTriggerProps } from "@/hooks/use-toggle-aside.tsx";
 import { DeletedPageBanner } from "@/features/page/trash/components/deleted-page-banner.tsx";
-import { TemporaryNoteBanner } from "@/features/page/components/temporary-note-banner.tsx";
 import clsx from "clsx";
 import {
   currentPageEditModeAtom,
   pageEditorAtom,
 } from "@/features/editor/atoms/editor-atoms.ts";
 import { DictationGroup } from "@/features/editor/components/fixed-toolbar/groups/dictation-group";
-import { GenerateTitleGroup } from "@/features/editor/components/fixed-toolbar/groups/generate-title-group";
 
 const MemoizedTitleEditor = React.memo(TitleEditor);
 const MemoizedPageEditor = React.memo(PageEditor);
 const MemoizedFixedToolbar = React.memo(FixedToolbar);
 const MemoizedDeletedPageBanner = React.memo(DeletedPageBanner);
-const MemoizedTemporaryNoteBanner = React.memo(TemporaryNoteBanner);
 
 type PageUser = {
   id: string;
@@ -77,9 +74,6 @@ export function FullEditor({
   const [user] = useAtom(userAtom);
   const workspace = useAtomValue(workspaceAtom);
   const isDictationEnabled = workspace?.settings?.ai?.dictation === true;
-  // AI title generation is gated by the general AI chat flag (the same toggle
-  // that enables the chat agent); the server enforces it too (#199).
-  const isTitleGenEnabled = workspace?.settings?.ai?.chat === true;
   const fullPageWidth = user.settings?.preferences?.fullPageWidth;
   const editorToolbarEnabled =
     user.settings?.preferences?.editorToolbar ?? false;
@@ -109,7 +103,6 @@ export function FullEditor({
         <MemoizedFixedToolbar />
       )}
       <MemoizedDeletedPageBanner slugId={slugId} />
-      <MemoizedTemporaryNoteBanner slugId={slugId} />
       <MemoizedTitleEditor
         pageId={pageId}
         slugId={slugId}
@@ -118,13 +111,11 @@ export function FullEditor({
         editable={editable}
       />
       <PageByline
-        pageId={pageId}
         creator={creator}
         contributors={contributors}
         editable={editable}
         isEditMode={isEditMode}
         isDictationEnabled={isDictationEnabled}
-        isTitleGenEnabled={isTitleGenEnabled}
       />
       <MemoizedPageEditor
         pageId={pageId}
@@ -137,23 +128,19 @@ export function FullEditor({
 }
 
 type PageBylineProps = {
-  pageId: string;
   creator?: PageUser;
   contributors?: IContributor[];
   editable?: boolean;
   isEditMode?: boolean;
   isDictationEnabled?: boolean;
-  isTitleGenEnabled?: boolean;
 };
 
 function PageByline({
-  pageId,
   creator,
   contributors,
   editable,
   isEditMode,
   isDictationEnabled,
-  isTitleGenEnabled,
 }: PageBylineProps) {
   const { t } = useTranslation();
   const detailsTriggerProps = useAsideTriggerProps("details");
@@ -161,9 +148,6 @@ function PageByline({
   const showDictation = Boolean(
     isDictationEnabled && editable && isEditMode && editor,
   );
-  const showTitleGen = Boolean(
-    isTitleGenEnabled && editable && isEditMode && editor,
-  );
 
   const otherContributors = (contributors ?? []).filter(
     (c) => c.id !== creator?.id,
@@ -254,11 +238,6 @@ function PageByline({
         {showDictation && editor && (
           <DictationGroup editor={editor} color="gray" iconSize={20} />
         )}
-        {/* Shown only in edit mode when the workspace's AI chat flag is on,
-            so AI title generation stays reachable from the byline (#199). */}
-        {showTitleGen && (
-          <GenerateTitleGroup pageId={pageId} color="gray" iconSize={20} />
-        )}
       </Group>
     </Group>
   );

apps/client/src/features/editor/hooks/use-generate-page-title.test.tsx

@@ -1,294 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { renderHook, act } from "@testing-library/react";
-import type { ReactNode } from "react";
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { Provider, createStore } from "jotai";
-import type { Editor } from "@tiptap/core";
-import {
-  pageEditorAtom,
-  titleEditorAtom,
-} from "@/features/editor/atoms/editor-atoms.ts";
-
-// --- Mocks for the hook's collaborators ---------------------------------------
-
-const generatePageTitleMock = vi.fn();
-vi.mock("@/features/ai-chat/services/ai-chat-service.ts", () => ({
-  generatePageTitle: (content: string) => generatePageTitleMock(content),
-}));
-
-const updateTitleMock = vi.fn();
-const updatePageDataMock = vi.fn();
-vi.mock("@/features/page/queries/page-query.ts", () => ({
-  useUpdateTitlePageMutation: () => ({ mutateAsync: updateTitleMock }),
-  updatePageData: (page: unknown) => updatePageDataMock(page),
-}));
-
-const emitMock = vi.fn();
-vi.mock("@/features/websocket/use-query-emit.ts", () => ({
-  useQueryEmit: () => emitMock,
-}));
-
-const localEmitMock = vi.fn();
-vi.mock("@/lib/local-emitter.ts", () => ({
-  default: { emit: (...args: unknown[]) => localEmitMock(...args) },
-}));
-
-// htmlToMarkdown just echoes the editor HTML so each test controls the markdown
-// purely via the fake page editor's getHTML().
-vi.mock("@docmost/editor-ext", () => ({
-  htmlToMarkdown: (html: string) => html,
-}));
-
-const notificationsShowMock = vi.fn();
-vi.mock("@mantine/notifications", () => ({
-  notifications: { show: (opts: unknown) => notificationsShowMock(opts) },
-}));
-
-vi.mock("react-i18next", () => ({
-  useTranslation: () => ({ t: (key: string) => key }),
-}));
-
-// Import after mocks are registered.
-import { useGeneratePageTitle } from "./use-generate-page-title.ts";
-
-// --- Test helpers -------------------------------------------------------------
-
-function makePageEditor(pageId: string, html = "<p>content</p>"): Editor {
-  return {
-    isDestroyed: false,
-    getHTML: () => html,
-    storage: { pageId },
-  } as unknown as Editor;
-}
-
-function makeTitleEditor(): Editor & {
-  commands: { setContent: ReturnType<typeof vi.fn> };
-} {
-  return {
-    isDestroyed: false,
-    isFocused: false,
-    commands: { setContent: vi.fn() },
-  } as unknown as Editor & {
-    commands: { setContent: ReturnType<typeof vi.fn> };
-  };
-}
-
-function setup(pageId: string, store = createStore()) {
-  const queryClient = new QueryClient({
-    defaultOptions: { mutations: { retry: false } },
-  });
-  const wrapper = ({ children }: { children: ReactNode }) => (
-    <QueryClientProvider client={queryClient}>
-      <Provider store={store}>{children}</Provider>
-    </QueryClientProvider>
-  );
-  const { result } = renderHook(() => useGeneratePageTitle(pageId), {
-    wrapper,
-  });
-  return { result, store };
-}
-
-const PAGE_A = {
-  id: "pageA",
-  title: "Generated Title",
-  spaceId: "space1",
-  slugId: "slugA",
-  parentPageId: null,
-  icon: null,
-} as any;
-
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-
-describe("useGeneratePageTitle", () => {
-  it("shows a notice and bails when the editor content is empty", async () => {
-    const store = createStore();
-    store.set(pageEditorAtom as never, makePageEditor("pageA", "   "));
-    store.set(titleEditorAtom as never, makeTitleEditor());
-    const { result } = setup("pageA", store);
-
-    await act(async () => {
-      await result.current.mutateAsync();
-    });
-
-    expect(notificationsShowMock).toHaveBeenCalledWith(
-      expect.objectContaining({ message: "The note is empty", color: "yellow" }),
-    );
-    expect(generatePageTitleMock).not.toHaveBeenCalled();
-    expect(updateTitleMock).not.toHaveBeenCalled();
-  });
-
-  it("leaves the title untouched when the model returns nothing usable", async () => {
-    const store = createStore();
-    store.set(pageEditorAtom as never, makePageEditor("pageA"));
-    store.set(titleEditorAtom as never, makeTitleEditor());
-    generatePageTitleMock.mockResolvedValue("   ");
-    const { result } = setup("pageA", store);
-
-    await act(async () => {
-      await result.current.mutateAsync();
-    });
-
-    expect(updateTitleMock).not.toHaveBeenCalled();
-    expect(notificationsShowMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        message: "Could not generate a title",
-        color: "yellow",
-      }),
-    );
-  });
-
-  it("happy path: applies the title, refreshes cache, writes the field, broadcasts", async () => {
-    const store = createStore();
-    const titleEditor = makeTitleEditor();
-    store.set(pageEditorAtom as never, makePageEditor("pageA"));
-    store.set(titleEditorAtom as never, titleEditor);
-    generatePageTitleMock.mockResolvedValue("Generated Title");
-    updateTitleMock.mockResolvedValue(PAGE_A);
-    const { result } = setup("pageA", store);
-
-    await act(async () => {
-      await result.current.mutateAsync();
-    });
-
-    expect(updateTitleMock).toHaveBeenCalledWith({
-      pageId: "pageA",
-      title: "Generated Title",
-    });
-    expect(updatePageDataMock).toHaveBeenCalledWith(PAGE_A);
-    expect(titleEditor.commands.setContent).toHaveBeenCalledWith(
-      "Generated Title",
-    );
-    expect(localEmitMock).toHaveBeenCalled();
-    expect(emitMock).toHaveBeenCalled();
-    expect(notificationsShowMock).toHaveBeenCalledWith(
-      expect.objectContaining({ message: "Title generated" }),
-    );
-  });
-
-  it("does NOT write the visible title field when the user navigated away during generation", async () => {
-    const store = createStore();
-    const titleEditor = makeTitleEditor(); // persistent across navigation
-    store.set(pageEditorAtom as never, makePageEditor("pageA"));
-    store.set(titleEditorAtom as never, titleEditor);
-
-    // Control when generation resolves so we can navigate mid-flight.
-    let resolveTitle!: (t: string) => void;
-    generatePageTitleMock.mockReturnValue(
-      new Promise<string>((res) => {
-        resolveTitle = res;
-      }),
-    );
-    updateTitleMock.mockResolvedValue(PAGE_A);
-    const { result } = setup("pageA", store);
-
-    let pending!: Promise<void>;
-    act(() => {
-      pending = result.current.mutateAsync();
-    });
-
-    // User navigates to page B: the live page editor now belongs to pageB.
-    act(() => {
-      store.set(pageEditorAtom as never, makePageEditor("pageB"));
-    });
-
-    await act(async () => {
-      resolveTitle("Generated Title");
-      await pending;
-    });
-
-    // DB write is still correct (keyed by the captured pageId)...
-    expect(updateTitleMock).toHaveBeenCalledWith({
-      pageId: "pageA",
-      title: "Generated Title",
-    });
-    // ...but we must NOT stamp page A's title into page B's visible field.
-    expect(titleEditor.commands.setContent).not.toHaveBeenCalled();
-    // The change is still broadcast to other clients.
-    expect(emitMock).toHaveBeenCalled();
-  });
-
-  it("does NOT write the visible title field when the title editor is focused", async () => {
-    const store = createStore();
-    const titleEditor = makeTitleEditor();
-    store.set(pageEditorAtom as never, makePageEditor("pageA"));
-    store.set(titleEditorAtom as never, titleEditor);
-
-    // Resolve generation under our control so we can mark the live title editor
-    // as focused before the post-generation write runs.
-    let resolveTitle!: (t: string) => void;
-    generatePageTitleMock.mockReturnValue(
-      new Promise<string>((res) => {
-        resolveTitle = res;
-      }),
-    );
-    updateTitleMock.mockResolvedValue(PAGE_A);
-    const { result } = setup("pageA", store);
-
-    let pending!: Promise<void>;
-    act(() => {
-      pending = result.current.mutateAsync();
-    });
-
-    // The user clicked into the title field while the model ran — overwriting it
-    // now would clobber what they are actively typing.
-    act(() => {
-      (titleEditor as { isFocused: boolean }).isFocused = true;
-    });
-
-    await act(async () => {
-      resolveTitle("Generated Title");
-      await pending;
-    });
-
-    // The DB write still persists the value...
-    expect(updateTitleMock).toHaveBeenCalledWith({
-      pageId: "pageA",
-      title: "Generated Title",
-    });
-    expect(updatePageDataMock).toHaveBeenCalledWith(PAGE_A);
-    // ...but the visible field is left alone while it is focused.
-    expect(titleEditor.commands.setContent).not.toHaveBeenCalled();
-    // The change is still broadcast to other clients.
-    expect(localEmitMock).toHaveBeenCalled();
-    expect(emitMock).toHaveBeenCalled();
-  });
-
-  it("bails before calling the model when the page editor is destroyed", async () => {
-    const store = createStore();
-    const pageEditor = makePageEditor("pageA");
-    (pageEditor as { isDestroyed: boolean }).isDestroyed = true;
-    store.set(pageEditorAtom as never, pageEditor);
-    store.set(titleEditorAtom as never, makeTitleEditor());
-    const { result } = setup("pageA", store);
-
-    await act(async () => {
-      await result.current.mutateAsync();
-    });
-
-    expect(generatePageTitleMock).not.toHaveBeenCalled();
-    expect(updateTitleMock).not.toHaveBeenCalled();
-  });
-
-  it.each([
-    [403, "AI title generation is disabled"],
-    [503, "AI is not configured"],
-    [429, "Too many requests, please try again later"],
-    [500, "Failed to generate title"],
-  ])("maps HTTP %s onError to a friendly message", async (status, message) => {
-    const store = createStore();
-    store.set(pageEditorAtom as never, makePageEditor("pageA"));
-    store.set(titleEditorAtom as never, makeTitleEditor());
-    generatePageTitleMock.mockRejectedValue({ response: { status } });
-    const { result } = setup("pageA", store);
-
-    await act(async () => {
-      await expect(result.current.mutateAsync()).rejects.toBeTruthy();
-    });
-
-    expect(notificationsShowMock).toHaveBeenCalledWith(
-      expect.objectContaining({ message, color: "red" }),
-    );
-  });
-});

apps/client/src/features/editor/hooks/use-generate-page-title.ts

@@ -1,134 +0,0 @@
-import { useRef } from "react";
-import { useMutation } from "@tanstack/react-query";
-import { useAtomValue } from "jotai";
-import { notifications } from "@mantine/notifications";
-import { useTranslation } from "react-i18next";
-import { htmlToMarkdown } from "@docmost/editor-ext";
-import {
-  pageEditorAtom,
-  titleEditorAtom,
-} from "@/features/editor/atoms/editor-atoms.ts";
-import {
-  updatePageData,
-  useUpdateTitlePageMutation,
-} from "@/features/page/queries/page-query.ts";
-import { generatePageTitle } from "@/features/ai-chat/services/ai-chat-service.ts";
-import { useQueryEmit } from "@/features/websocket/use-query-emit.ts";
-import { UpdateEvent } from "@/features/websocket/types";
-import localEmitter from "@/lib/local-emitter.ts";
-
-// Maximum length we send to the model. The server truncates again; this is a
-// cheap client-side bound so we never ship a huge body over the wire.
-const MAX_CONTENT_CHARS = 20000;
-
-/**
- * Generate a title for the given page from the LIVE editor content (#199),
- * including unsaved edits, then apply it IMMEDIATELY (per product decision). The
- * server endpoint only summarizes the supplied markdown — it never writes the
- * page; the actual title write goes through the existing /pages/update mutation
- * (which enforces edit permission), and is mirrored to the title field + other
- * clients exactly like TitleEditor.saveTitle. Returns a mutation-like API so the
- * button can show a loading state via `isPending`.
- */
-export function useGeneratePageTitle(pageId: string) {
-  const { t } = useTranslation();
-  const pageEditor = useAtomValue(pageEditorAtom);
-  const titleEditor = useAtomValue(titleEditorAtom);
-  const { mutateAsync: updateTitle } = useUpdateTitlePageMutation();
-  const emit = useQueryEmit();
-
-  // The page/title editors come from GLOBAL atoms that re-point when the user
-  // navigates to another page. The mutation below awaits the model for 1-3s, and
-  // its closure captures the editors from the render that started it. Keep a live
-  // reference so the post-generation write targets whatever page is on screen
-  // *now*, not the page the generation was started from.
-  const editorsRef = useRef({ pageEditor, titleEditor });
-  editorsRef.current = { pageEditor, titleEditor };
-
-  return useMutation<void, Error, void>({
-    mutationFn: async () => {
-      if (!pageEditor || pageEditor.isDestroyed) return;
-
-      const markdown = htmlToMarkdown(pageEditor.getHTML()).trim();
-      if (!markdown) {
-        notifications.show({ message: t("The note is empty"), color: "yellow" });
-        return;
-      }
-
-      const title = (
-        await generatePageTitle(markdown.slice(0, MAX_CONTENT_CHARS))
-      ).trim();
-      if (!title) {
-        // The model returned nothing usable — keep the existing title untouched.
-        notifications.show({
-          message: t("Could not generate a title"),
-          color: "yellow",
-        });
-        return;
-      }
-
-      const page = await updateTitle({ pageId, title }); // POST /pages/update
-      updatePageData(page); // refresh the react-query cache
-
-      // Reflect the new title in the field immediately. The button lives in the
-      // byline, so the title editor is not focused — setContent is safe and stays
-      // undoable through its History extension (Ctrl/Cmd+Z reverts the change).
-      //
-      // Guard against navigation during generation: if the user switched pages
-      // while the model ran, the (persistent) title editor now shows ANOTHER
-      // page, so writing here would drop page A's title into page B's visible
-      // field. page-editor.tsx stamps the live page editor with its pageId
-      // (`editor.storage.pageId`), mirroring TitleEditor's `activePageId !==
-      // pageId` guard — bail the visible write unless that live editor still
-      // belongs to the page this title was generated for. The DB write above is
-      // already correct (keyed by the captured `pageId`), and the broadcast below
-      // still propagates page A's change to other clients.
-      const livePageEditor = editorsRef.current.pageEditor;
-      const liveTitleEditor = editorsRef.current.titleEditor;
-      // `storage.pageId` is stamped untyped in page-editor.tsx's onCreate.
-      const livePageId = (livePageEditor?.storage as { pageId?: string })
-        ?.pageId;
-      const stillOnPage = livePageId === pageId;
-      if (
-        stillOnPage &&
-        liveTitleEditor &&
-        !liveTitleEditor.isDestroyed &&
-        !liveTitleEditor.isFocused
-      ) {
-        liveTitleEditor.commands.setContent(page.title);
-      }
-
-      // Broadcast to other clients, mirroring TitleEditor.saveTitle's event shape.
-      const event: UpdateEvent = {
-        operation: "updateOne",
-        spaceId: page.spaceId,
-        entity: ["pages"],
-        id: page.id,
-        payload: {
-          title: page.title,
-          slugId: page.slugId,
-          parentPageId: page.parentPageId,
-          icon: page.icon,
-        },
-      };
-      localEmitter.emit("message", event);
-      emit(event);
-
-      notifications.show({ message: t("Title generated") });
-    },
-    onError: (err) => {
-      // Map known HTTP statuses to friendly messages, falling back to generic.
-      const status = (err as { response?: { status?: number } })?.response
-        ?.status;
-      const message =
-        status === 403
-          ? t("AI title generation is disabled")
-          : status === 503
-            ? t("AI is not configured")
-            : status === 429
-              ? t("Too many requests, please try again later")
-              : t("Failed to generate title");
-      notifications.show({ message, color: "red" });
-    },
-  });
-}

apps/client/src/features/editor/styles/task-list.css

@@ -10,15 +10,9 @@ ul[data-type="taskList"] {
         display: flex;
 
         > label {
-            /* Box exactly one text-line tall and center the checkbox in it, so the
-               checkbox lines up with the first line of the item's text. This tracks
-               the editor line-height (--mantine-line-height-xl) instead of a magic
-               padding-top that drifts from the real line box. */
+            padding-top: 0.2rem;
             flex: 0 0 auto;
             margin-right: 0.5rem;
-            height: calc(var(--mantine-line-height-xl, 1.65) * 1em);
-            display: inline-flex;
-            align-items: center;
             user-select: none;
         }
 

apps/client/src/features/home/components/new-note-button.tsx

@@ -1,6 +1,5 @@
-import { Button, Group, Menu, Text } from "@mantine/core";
-import { IconHourglass, IconPlus } from "@tabler/icons-react";
-import { ReactNode } from "react";
+import { Button, Menu, Text } from "@mantine/core";
+import { IconPlus } from "@tabler/icons-react";
 import { useNavigate } from "react-router-dom";
 import { useTranslation } from "react-i18next";
 import { useGetSpacesQuery } from "@/features/space/queries/space-query.ts";
@@ -11,34 +10,24 @@ import { CustomAvatar } from "@/components/ui/custom-avatar.tsx";
 import { AvatarIconType } from "@/features/attachments/types/attachment.types.ts";
 import { canCreatePage } from "./can-create-page.ts";
 
-// A single create-note action, parametrized by `temporary`. Self-contained: it
-// owns its own create mutation so the regular and temporary buttons show
-// independent loading state, while the list of writable spaces is resolved once
-// by the parent and passed in. With exactly one writable space it creates
-// directly; with several it shows a target-space picker.
-function CreateNoteButton({
-  writableSpaces,
-  temporary,
-  label,
-  icon,
-}: {
-  writableSpaces: ISpace[];
-  temporary: boolean;
-  label: string;
-  icon: ReactNode;
-}) {
+// Prominent home-screen action to create a new note (page). Because the home
+// screen has no active space, the target space is resolved from the user's
+// writable spaces: created directly when there is one, picked from a dropdown
+// when there are several.
+export default function NewNoteButton() {
   const { t } = useTranslation();
   const navigate = useNavigate();
   const createPageMutation = useCreatePageMutation();
+  const { data } = useGetSpacesQuery({ limit: 100 });
+
+  const writableSpaces = (data?.items ?? []).filter(canCreatePage);
 
   const createNote = async (space: ISpace) => {
     try {
-      // `spaceId`/`temporary` are accepted by the create-page endpoint but are
-      // not part of the shared `IPageInput` type; cast to satisfy the mutation
-      // signature.
+      // `spaceId` is accepted by the create-page endpoint but is not part of
+      // the shared `IPageInput` type; cast to satisfy the mutation signature.
       const createdPage = await createPageMutation.mutateAsync({
         spaceId: space.id,
-        ...(temporary ? { temporary: true } : {}),
       } as any);
       navigate(buildPageUrl(space.slug, createdPage.slugId, createdPage.title));
     } catch {
@@ -46,20 +35,24 @@ function CreateNoteButton({
     }
   };
 
+  // No writable space → nothing to create in; render nothing.
+  if (writableSpaces.length === 0) return null;
+
   const isPending = createPageMutation.isPending;
 
   // Exactly one writable space → create directly, no picker needed.
   if (writableSpaces.length === 1) {
     return (
       <Button
+        fullWidth
         size="md"
         variant="light"
         color="gray"
-        leftSection={icon}
+        leftSection={<IconPlus size={18} />}
         loading={isPending}
         onClick={() => createNote(writableSpaces[0])}
       >
-        {label}
+        {t("New note")}
       </Button>
     );
   }
@@ -69,13 +62,14 @@ function CreateNoteButton({
     <Menu shadow="md" width="target" position="bottom-start">
       <Menu.Target>
         <Button
+          fullWidth
           size="md"
           variant="light"
           color="gray"
-          leftSection={icon}
+          leftSection={<IconPlus size={18} />}
           loading={isPending}
         >
-          {label}
+          {t("New note")}
         </Button>
       </Menu.Target>
       <Menu.Dropdown>
@@ -105,35 +99,3 @@ function CreateNoteButton({
     </Menu>
   );
 }
-
-// Prominent home-screen actions to create a new note (page). Because the home
-// screen has no active space, the target space is resolved from the user's
-// writable spaces: created directly when there is one, picked from a dropdown
-// when there are several. Renders two equal-width buttons: a regular note and a
-// temporary note (which auto-moves to Trash after the workspace lifetime).
-export default function NewNoteButton() {
-  const { t } = useTranslation();
-  const { data } = useGetSpacesQuery({ limit: 100 });
-
-  const writableSpaces = (data?.items ?? []).filter(canCreatePage);
-
-  // No writable space → nothing to create in; render nothing.
-  if (writableSpaces.length === 0) return null;
-
-  return (
-    <Group grow gap="sm">
-      <CreateNoteButton
-        writableSpaces={writableSpaces}
-        temporary={false}
-        label={t("New note")}
-        icon={<IconPlus size={18} />}
-      />
-      <CreateNoteButton
-        writableSpaces={writableSpaces}
-        temporary={true}
-        label={t("New temporary note")}
-        icon={<IconHourglass size={18} />}
-      />
-    </Group>
-  );
-}

apps/client/src/features/page-embed/queries/page-embed-query.ts

@@ -1,40 +1,7 @@
 import { useMutation } from "@tanstack/react-query";
 import { notifications } from "@mantine/notifications";
-import {
-  toggleTemplate,
-  toggleTemporary,
-} from "@/features/page-embed/services/page-embed-api";
-import type {
-  ToggleTemplateResponse,
-  ToggleTemporaryResponse,
-} from "@/features/page-embed/types/page-embed.types";
-import { queryClient } from "@/main.tsx";
-
-/**
- * After toggling a note's temporary state, mirror the new deadline into the
- * shared page cache (keyed by both slugId and id) and refresh the sidebar so the
- * menu label, the in-page banner, and the tree icon all reflect the change.
- * Centralised here so the header menu and the banner can't drift apart on the
- * cache-key plumbing.
- */
-export function syncTemporaryExpiresInCache(
-  page: { id: string; slugId: string },
-  temporaryExpiresAt: string | null,
-) {
-  for (const key of [page.slugId, page.id]) {
-    const cached = queryClient.getQueryData<any>(["pages", key]);
-    if (cached) {
-      queryClient.setQueryData(["pages", key], {
-        ...cached,
-        temporaryExpiresAt,
-      });
-    }
-  }
-  queryClient.invalidateQueries({
-    predicate: (item) =>
-      ["sidebar-pages"].includes(item.queryKey[0] as string),
-  });
-}
+import { toggleTemplate } from "@/features/page-embed/services/page-embed-api";
+import type { ToggleTemplateResponse } from "@/features/page-embed/types/page-embed.types";
 
 export function useToggleTemplateMutation() {
   return useMutation<
@@ -51,20 +18,3 @@ export function useToggleTemplateMutation() {
     },
   });
 }
-
-export function useToggleTemporaryMutation() {
-  return useMutation<
-    ToggleTemporaryResponse,
-    Error,
-    { pageId: string; temporary?: boolean }
-  >({
-    mutationFn: (data) => toggleTemporary(data),
-    onError: (err: any) => {
-      notifications.show({
-        message:
-          err?.response?.data?.message || "Failed to update temporary note",
-        color: "red",
-      });
-    },
-  });
-}

apps/client/src/features/page-embed/services/page-embed-api.ts

@@ -2,7 +2,6 @@ import api from "@/lib/api-client";
 import type {
   PageTemplateLookup,
   ToggleTemplateResponse,
-  ToggleTemporaryResponse,
 } from "../types/page-embed.types";
 
 export async function lookupTemplate(params: {
@@ -19,11 +18,3 @@ export async function toggleTemplate(params: {
   const r = await api.post("/pages/toggle-template", params);
   return r.data;
 }
-
-export async function toggleTemporary(params: {
-  pageId: string;
-  temporary?: boolean;
-}): Promise<ToggleTemporaryResponse> {
-  const r = await api.post("/pages/toggle-temporary", params);
-  return r.data;
-}

apps/client/src/features/page-embed/types/page-embed.types.ts

@@ -14,9 +14,3 @@ export type ToggleTemplateResponse = {
   pageId: string;
   isTemplate: boolean;
 };
-
-export type ToggleTemporaryResponse = {
-  pageId: string;
-  // null => the note was made permanent; ISO string => armed deadline.
-  temporaryExpiresAt: string | null;
-};

apps/client/src/features/page/components/header/page-header-menu.tsx

@@ -2,7 +2,6 @@ import { ActionIcon, Button, Group, Menu, Text, ThemeIcon, Tooltip } from "@mant
 import {
   IconArrowRight,
   IconArrowsHorizontal,
-  IconClockHour4,
   IconDots,
   IconEye,
   IconEyeOff,
@@ -25,10 +24,6 @@ import { useDisclosure, useHotkeys } from "@mantine/hooks";
 import { useClipboard } from "@/hooks/use-clipboard";
 import { useParams } from "react-router-dom";
 import { usePageQuery } from "@/features/page/queries/page-query.ts";
-import {
-  useToggleTemporaryMutation,
-  syncTemporaryExpiresInCache,
-} from "@/features/page-embed/queries/page-embed-query.ts";
 import { buildPageUrl } from "@/features/page/page.utils.ts";
 import { notifications } from "@mantine/notifications";
 import { getAppUrl } from "@/lib/config.ts";
@@ -165,29 +160,6 @@ function PageActionMenu({ readOnly }: PageActionMenuProps) {
   const { data: watchStatus } = useWatchStatusQuery(page?.id);
   const watchPage = useWatchPageMutation();
   const unwatchPage = useUnwatchPageMutation();
-  const toggleTemporary = useToggleTemporaryMutation();
-  const isTemporary = !!page?.temporaryExpiresAt;
-
-  const handleToggleTemporary = async () => {
-    if (!page?.id) return;
-    const next = !isTemporary;
-    try {
-      const res = await toggleTemporary.mutateAsync({
-        pageId: page.id,
-        temporary: next,
-      });
-      // Reflect the new deadline in the page cache so the menu label flips and
-      // any banner updates. The sidebar icon refreshes via its own query.
-      syncTemporaryExpiresInCache(page, res.temporaryExpiresAt);
-      notifications.show({
-        message: next
-          ? t("Note will move to trash unless made permanent")
-          : t("Note is now permanent"),
-      });
-    } catch {
-      // mutation surfaces the error via notifications
-    }
-  };
 
   const handleCopyLink = () => {
     const pageUrl =
@@ -337,12 +309,6 @@ function PageActionMenu({ readOnly }: PageActionMenuProps) {
           {!readOnly && (
             <>
               <Menu.Divider />
-              <Menu.Item
-                leftSection={<IconClockHour4 size={16} />}
-                onClick={handleToggleTemporary}
-              >
-                {isTemporary ? t("Make permanent") : t("Make temporary")}
-              </Menu.Item>
               <Menu.Item
                 color={"red"}
                 leftSection={<IconTrash size={16} />}

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

@@ -1,87 +0,0 @@
-import { Button, Group, Paper, Text } from "@mantine/core";
-import { IconClockHour4 } from "@tabler/icons-react";
-import { Trans, useTranslation } from "react-i18next";
-import { useTimeAgo } from "@/hooks/use-time-ago.tsx";
-import { usePageQuery } from "@/features/page/queries/page-query.ts";
-import {
-  useToggleTemporaryMutation,
-  syncTemporaryExpiresInCache,
-} from "@/features/page-embed/queries/page-embed-query.ts";
-import { useGetSpaceBySlugQuery } from "@/features/space/queries/space-query.ts";
-import { useSpaceAbility } from "@/features/space/permissions/use-space-ability.ts";
-import {
-  SpaceCaslAction,
-  SpaceCaslSubject,
-} from "@/features/space/permissions/permissions.type.ts";
-
-type TemporaryNoteBannerProps = {
-  slugId: string;
-};
-
-/**
- * Banner shown on an open temporary note ("structure or die"). Mirrors
- * DeletedPageBanner: it reads the page from the shared query cache and offers
- * the explicit rescue action — "Make permanent". Children ride along to trash
- * with the note, which is noted in the copy.
- */
-export function TemporaryNoteBanner({ slugId }: TemporaryNoteBannerProps) {
-  const { t } = useTranslation();
-  const { data: page } = usePageQuery({ pageId: slugId });
-  const { data: space } = useGetSpaceBySlugQuery(page?.space?.slug);
-  const spaceAbility = useSpaceAbility(space?.membership?.permissions);
-  const expiresTimeAgo = useTimeAgo(page?.temporaryExpiresAt);
-  const toggleTemporary = useToggleTemporaryMutation();
-
-  // Don't show on a note that is already in trash; the deleted-page banner
-  // owns that state.
-  if (!page?.temporaryExpiresAt || page?.deletedAt) return null;
-
-  const canEdit = spaceAbility.can(SpaceCaslAction.Edit, SpaceCaslSubject.Page);
-
-  const handleMakePermanent = async () => {
-    try {
-      const res = await toggleTemporary.mutateAsync({
-        pageId: page.id,
-        temporary: false,
-      });
-      syncTemporaryExpiresInCache(page, res.temporaryExpiresAt);
-    } catch {
-      // mutation surfaces the error via notifications
-    }
-  };
-
-  return (
-    <Paper radius="sm" mb="md" px="md" py="xs" bg="orange.0">
-      <Group justify="space-between" wrap="wrap" gap="sm">
-        <Group gap="xs" wrap="nowrap" style={{ flex: 1, minWidth: 0 }}>
-          <IconClockHour4
-            size={18}
-            stroke={1.5}
-            style={{
-              flexShrink: 0,
-              color: "var(--mantine-color-orange-7)",
-            }}
-          />
-          <Text size="sm">
-            <Trans
-              i18nKey="This temporary note moves to trash {{time}} (with its sub-pages) unless made permanent."
-              values={{ time: expiresTimeAgo }}
-            />
-          </Text>
-        </Group>
-        {canEdit && (
-          <Button
-            size="xs"
-            variant="light"
-            color="orange"
-            leftSection={<IconClockHour4 size={16} />}
-            onClick={handleMakePermanent}
-            loading={toggleTemporary.isPending}
-          >
-            {t("Make permanent")}
-          </Button>
-        )}
-      </Group>
-    </Paper>
-  );
-}

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

@@ -274,10 +274,7 @@ export function useRestorePageMutation() {
       queryClient.setQueryData<IPage>(["pages", restoredPage.slugId], merge);
     },
     onError: (error) => {
-      notifications.show({
-        message: t("Failed to restore page"),
-        color: "red",
-      });
+      notifications.show({ message: t("Failed to restore page"), color: "red" });
     },
   });
 }
@@ -288,10 +285,10 @@ export function useGetSidebarPagesQuery(
   return useInfiniteQuery({
     queryKey: ["sidebar-pages", data],
     enabled: !!data?.pageId || !!data?.spaceId,
-    queryFn: ({ pageParam }) =>
-      getSidebarPages({ ...data, cursor: pageParam, limit: 100 }),
+    queryFn: ({ pageParam }) => getSidebarPages({ ...data, cursor: pageParam, limit: 100 }),
     initialPageParam: undefined,
-    getNextPageParam: (lastPage) => lastPage.meta?.nextCursor ?? undefined,
+    getNextPageParam: (lastPage) =>
+      lastPage.meta?.nextCursor ?? undefined,
   });
 }
 
@@ -299,14 +296,11 @@ export function useGetRootSidebarPagesQuery(data: SidebarPagesParams) {
   return useInfiniteQuery({
     queryKey: ["root-sidebar-pages", data.spaceId],
     queryFn: async ({ pageParam }) => {
-      return getSidebarPages({
-        spaceId: data.spaceId,
-        cursor: pageParam,
-        limit: 100,
-      });
+      return getSidebarPages({ spaceId: data.spaceId, cursor: pageParam, limit: 100 });
     },
     initialPageParam: undefined,
-    getNextPageParam: (lastPage) => lastPage.meta?.nextCursor ?? undefined,
+    getNextPageParam: (lastPage) =>
+      lastPage.meta?.nextCursor ?? undefined,
   });
 }
 
@@ -329,17 +323,12 @@ export function usePageBreadcrumbsQuery(
   });
 }
 
-export async function fetchAllAncestorChildren(
-  params: SidebarPagesParams,
-  // `fresh: true` forces a server refetch (staleTime 0) — used by the reconnect
-  // refresh (#159 #8), which must NOT receive the 30-min-cached children.
-  opts?: { fresh?: boolean },
-) {
+export async function fetchAllAncestorChildren(params: SidebarPagesParams) {
   // not using a hook here, so we can call it inside a useEffect hook
   const response = await queryClient.fetchQuery({
     queryKey: ["sidebar-pages", params],
     queryFn: () => getAllSidebarPages(params),
-    staleTime: opts?.fresh ? 0 : 30 * 60 * 1000,
+    staleTime: 30 * 60 * 1000,
   });
 
   const allItems = response.pages.flatMap((page) => page.items);
@@ -358,15 +347,11 @@ export function useRecentChangesQuery(spaceId?: string) {
   });
 }
 
-export function useCreatedByQuery(params?: {
-  userId?: string;
-  spaceId?: string;
-}) {
+export function useCreatedByQuery(params?: { userId?: string; spaceId?: string }) {
   const { userId, spaceId } = params ?? {};
   return useInfiniteQuery({
     queryKey: ["pages-created-by-user", { userId, spaceId }],
-    queryFn: ({ pageParam }) =>
-      getCreatedByPages({ userId, spaceId, cursor: pageParam, limit: 15 }),
+    queryFn: ({ pageParam }) => getCreatedByPages({ userId, spaceId, cursor: pageParam, limit: 15 }),
     initialPageParam: undefined as string | undefined,
     getNextPageParam: (lastPage) =>
       lastPage.meta.hasNextPage ? lastPage.meta.nextCursor : undefined,

apps/client/src/features/page/tree/components/space-tree-node-menu.tsx

@@ -6,7 +6,6 @@ import { useDisclosure } from "@mantine/hooks";
 import { notifications } from "@mantine/notifications";
 import {
   IconArrowRight,
-  IconClockHour4,
   IconCopy,
   IconDotsVertical,
   IconFileExport,
@@ -31,10 +30,7 @@ import {
   useRemoveFavoriteMutation,
 } from "@/features/favorite/queries/favorite-query";
 
-import {
-  useToggleTemplateMutation,
-  useToggleTemporaryMutation,
-} from "@/features/page-embed/queries/page-embed-query";
+import { useToggleTemplateMutation } from "@/features/page-embed/queries/page-embed-query";
 import { treeDataAtom } from "@/features/page/tree/atoms/tree-data-atom.ts";
 import { treeModel } from "@/features/page/tree/model/tree-model";
 import { useTreeMutation } from "@/features/page/tree/hooks/use-tree-mutation.ts";
@@ -69,8 +65,6 @@ export function NodeMenu({ node, canEdit }: NodeMenuProps) {
   const isFavorited = favoriteIds.has(node.id);
   const toggleTemplate = useToggleTemplateMutation();
   const isTemplate = !!node.isTemplate;
-  const toggleTemporary = useToggleTemporaryMutation();
-  const isTemporary = !!node.temporaryExpiresAt;
 
   const handleToggleTemplate = async () => {
     const next = !isTemplate;
@@ -90,29 +84,6 @@ export function NodeMenu({ node, canEdit }: NodeMenuProps) {
     }
   };
 
-  const handleToggleTemporary = async () => {
-    const next = !isTemporary;
-    try {
-      const res = await toggleTemporary.mutateAsync({
-        pageId: node.id,
-        temporary: next,
-      });
-      // Reflect the new deadline locally so the icon/menu update immediately.
-      setData((prev) =>
-        treeModel.update(prev, node.id, {
-          temporaryExpiresAt: res.temporaryExpiresAt,
-        } as any),
-      );
-      notifications.show({
-        message: next
-          ? t("Note will move to trash unless made permanent")
-          : t("Note is now permanent"),
-      });
-    } catch {
-      // mutation surfaces the error via notifications
-    }
-  };
-
   const handleCopyLink = () => {
     const pageUrl =
       getAppUrl() + buildPageUrl(spaceSlug, node.slugId, node.name);
@@ -277,17 +248,6 @@ export function NodeMenu({ node, canEdit }: NodeMenuProps) {
                 {isTemplate ? t("Unset as template") : t("Make template")}
               </Menu.Item>
 
-              <Menu.Item
-                leftSection={<IconClockHour4 size={16} />}
-                onClick={(e) => {
-                  e.preventDefault();
-                  e.stopPropagation();
-                  handleToggleTemporary();
-                }}
-              >
-                {isTemporary ? t("Make permanent") : t("Make temporary")}
-              </Menu.Item>
-
               <Menu.Divider />
               <Menu.Item
                 c="red"

apps/client/src/features/page/tree/components/space-tree-row.tsx

@@ -6,7 +6,6 @@ import { ActionIcon, rem, Tooltip } from "@mantine/core";
 import {
   IconChevronDown,
   IconChevronRight,
-  IconClockHour4,
   IconFileDescription,
   IconPlus,
   IconPointFilled,
@@ -192,28 +191,6 @@ export function SpaceTreeRow({
         </Tooltip>
       )}
 
-      {node.temporaryExpiresAt && (
-        <Tooltip
-          // Children ride along to trash with the note (recursive removePage).
-          label={t("Temporary note — moves to trash unless made permanent")}
-          withArrow
-        >
-          <IconClockHour4
-            size={14}
-            stroke={1.5}
-            // Same visual-only indicator pattern as the template icon, but
-            // orange to flag the impending death timer.
-            style={{
-              flexShrink: 0,
-              marginLeft: rem(4),
-              color: "var(--mantine-color-orange-6)",
-            }}
-            aria-label={t("Temporary note")}
-            role="img"
-          />
-        </Tooltip>
-      )}
-
       <div className={classes.actions}>
         <NodeMenu node={node} canEdit={canEdit} />
 

apps/client/src/features/page/tree/components/space-tree.tsx

@@ -29,11 +29,9 @@ import {
   collectBranchIds,
   openBranches,
   closeIds,
-  loadedOpenBranchIds,
 } from "@/features/page/tree/utils/utils.ts";
 import { SpaceTreeNode } from "@/features/page/tree/types.ts";
 import { treeModel } from "@/features/page/tree/model/tree-model";
-import { socketAtom } from "@/features/websocket/atoms/socket-atom.ts";
 import {
   getPageBreadcrumbs,
   getSpaceTree,
@@ -41,7 +39,11 @@ import {
 import { IPage } from "@/features/page/types/page.types.ts";
 import { extractPageSlugId } from "@/lib";
 import { isCompactPageTreeEnabled } from "@/lib/config.ts";
-import { DocTree, ROW_HEIGHT_COMPACT, ROW_HEIGHT_STANDARD } from "./doc-tree";
+import {
+  DocTree,
+  ROW_HEIGHT_COMPACT,
+  ROW_HEIGHT_STANDARD,
+} from "./doc-tree";
 import { SpaceTreeRow } from "./space-tree-row";
 
 interface SpaceTreeProps {
@@ -191,54 +193,6 @@ const SpaceTree = forwardRef<SpaceTreeApi, SpaceTreeProps>(function SpaceTree(
     [openTreeNodes],
   );
 
-  // Latest tree + open-state for the reconnect handler (its closure would
-  // otherwise read stale snapshots).
-  const [socket] = useAtom(socketAtom);
-  const dataRef = useRef(data);
-  dataRef.current = data;
-  const openIdsRef = useRef(openIds);
-  openIdsRef.current = openIds;
-
-  // Reconnect refresh (#159 #8): on a socket reconnect, re-fetch and reconcile
-  // the children of every currently-open, already-loaded branch of THIS space,
-  // so a move/rename/delete that happened INSIDE a loaded branch while events
-  // were missed (laptop sleep / wifi gap) is reflected instead of left stale.
-  // The ROOT level is reconciled separately by the root-query refetch +
-  // mergeRootTrees; an UNLOADED branch is skipped (lazy-load fetches it fresh on
-  // expand). No first-connect guard is needed: space-tree usually mounts AFTER
-  // the initial connect, so every `connect` it sees is a reconnect; the rare
-  // initial-connect case has an empty tree, so the refresh is a harmless no-op.
-  useEffect(() => {
-    if (!socket) return;
-    const onConnect = async () => {
-      const effectSpaceId = spaceIdRef.current;
-      const branchIds = loadedOpenBranchIds(
-        dataRef.current.filter((n) => n?.spaceId === effectSpaceId),
-        openIdsRef.current,
-      );
-      if (branchIds.length === 0) return;
-      for (const id of branchIds) {
-        try {
-          // `fresh: true` bypasses the 30-min sidebar-pages cache so the
-          // reconcile sees the server's CURRENT children (handler-order
-          // independent — no reliance on the global reconnect invalidation).
-          const fresh = await fetchAllAncestorChildren(
-            { pageId: id, spaceId: effectSpaceId },
-            { fresh: true },
-          );
-          if (spaceIdRef.current !== effectSpaceId) return; // space switched
-          setData((prev) => treeModel.reconcileChildren(prev, id, fresh));
-        } catch (err) {
-          console.error("[tree] reconnect branch refresh failed", err);
-        }
-      }
-    };
-    socket.on("connect", onConnect);
-    return () => {
-      socket.off("connect", onConnect);
-    };
-  }, [socket, setData]);
-
   const handleToggle = useCallback(
     async (id: string, isOpen: boolean) => {
       setOpenTreeNodes((prev) => ({ ...prev, [id]: isOpen }));
@@ -291,7 +245,8 @@ const SpaceTree = forwardRef<SpaceTreeApi, SpaceTreeProps>(function SpaceTree(
       notifications.show({
         color: "red",
         message: t("Couldn't expand the tree: {{reason}}", {
-          reason: err?.response?.data?.message ?? err?.message ?? String(err),
+          reason:
+            err?.response?.data?.message ?? err?.message ?? String(err),
         }),
       });
     } finally {
@@ -307,11 +262,11 @@ const SpaceTree = forwardRef<SpaceTreeApi, SpaceTreeProps>(function SpaceTree(
     setOpenTreeNodes((prev) => closeIds(prev, ids));
   }, [filteredData, setOpenTreeNodes]);
 
-  useImperativeHandle(ref, () => ({ expandAll, collapseAll, isExpanding }), [
-    expandAll,
-    collapseAll,
-    isExpanding,
-  ]);
+  useImperativeHandle(
+    ref,
+    () => ({ expandAll, collapseAll, isExpanding }),
+    [expandAll, collapseAll, isExpanding],
+  );
 
   // Stable callbacks for DocTree. Without these, every parent render recreates
   // the props and tears down every row's draggable/dropTarget subscription,

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

@@ -22,10 +22,7 @@ import { getSpaceUrl } from "@/lib/config.ts";
 
 export type UseTreeMutation = {
   handleMove: (sourceId: string, op: DropOp) => Promise<void>;
-  handleCreate: (
-    parentId: string | null,
-    opts?: { temporary?: boolean },
-  ) => Promise<void>;
+  handleCreate: (parentId: string | null) => Promise<void>;
   handleRename: (id: string, name: string) => Promise<void>;
   handleDelete: (id: string) => Promise<void>;
 };
@@ -122,15 +119,9 @@ export function useTreeMutation(spaceId: string): UseTreeMutation {
   );
 
   const handleCreate = useCallback(
-    async (parentId: string | null, opts?: { temporary?: boolean }) => {
-      const payload: {
-        spaceId: string;
-        parentPageId?: string;
-        temporary?: boolean;
-      } = { spaceId };
+    async (parentId: string | null) => {
+      const payload: { spaceId: string; parentPageId?: string } = { spaceId };
       if (parentId) payload.parentPageId = parentId;
-      // Ask the server to arm the death timer for a "temporary note".
-      if (opts?.temporary) payload.temporary = true;
 
       let createdPage: IPage;
       try {
@@ -147,8 +138,6 @@ export function useTreeMutation(spaceId: string): UseTreeMutation {
         spaceId: createdPage.spaceId,
         parentPageId: createdPage.parentPageId,
         hasChildren: false,
-        // Show the temporary-note icon immediately on optimistic insert.
-        temporaryExpiresAt: createdPage.temporaryExpiresAt,
         children: [],
       };
 

apps/client/src/features/page/tree/model/tree-model.ts

@@ -1,4 +1,4 @@
-import type { TreeNode, SiblingsInfo } from "./tree-model.types";
+import type { TreeNode, SiblingsInfo } from './tree-model.types';
 
 function findInternal<T extends object>(
   nodes: TreeNode<T>[],
@@ -19,10 +19,7 @@ export const treeModel = {
     return findInternal(tree, id)?.node ?? null;
   },
 
-  path<T extends object>(
-    tree: TreeNode<T>[],
-    id: string,
-  ): TreeNode<T>[] | null {
+  path<T extends object>(tree: TreeNode<T>[], id: string): TreeNode<T>[] | null {
     const found = findInternal(tree, id);
     if (!found) return null;
     return [...found.parents, found.node];
@@ -126,23 +123,6 @@ export const treeModel = {
       return treeModel.insert(tree, null, node, index(tree));
     }
     const parent = treeModel.find(tree, parentId);
-    // The parent is in the tree but its children have NOT been lazy-loaded yet
-    // (`children === undefined`, distinct from a loaded-but-empty `[]`). Inserting
-    // here would MATERIALIZE a misleading partial child list (`[node]`) that
-    // defeats the lazy-load gate — which fetches only when children are
-    // absent/empty — so the parent's OTHER real children would never load and the
-    // moved/added node would be the only one shown (a silent data loss, #159 #1).
-    // Instead, leave the children unloaded and just flag `hasChildren` so the
-    // chevron appears; expanding fetches the FULL set (including this node).
-    if (parent && parent.children === undefined) {
-      return treeModel.update(
-        tree,
-        parentId,
-        // hasChildren is not part of the generic T constraint; tree nodes carry
-        // it. Cast narrowly so this stays a single, well-understood exception.
-        { hasChildren: true } as unknown as Omit<Partial<T>, "id" | "children">,
-      );
-    }
     const kids = (parent?.children as TreeNode<T>[] | undefined) ?? [];
     return treeModel.insert(tree, parentId, node, index(kids));
   },
@@ -223,48 +203,6 @@ export const treeModel = {
     return touched ? out : tree;
   },
 
-  // Replace a parent's DIRECT children with the authoritative `fresh` set while
-  // PRESERVING each surviving child's already-loaded grandchildren (deeper
-  // expansion). Unlike `appendChildren` (add-only), this DROPS children that are
-  // no longer present and reorders to `fresh` — so a move/delete/rename that
-  // happened inside a loaded branch while events were missed (a socket reconnect
-  // gap) is reflected, not left stale (#159 #8). Only used to reconcile an
-  // already-loaded branch against a fresh fetch; a parent with no loaded children
-  // (`children === undefined`) is left untouched (lazy-load handles it).
-  reconcileChildren<T extends object>(
-    tree: TreeNode<T>[],
-    parentId: string,
-    fresh: TreeNode<T>[],
-  ): TreeNode<T>[] {
-    let touched = false;
-    const walk = (nodes: TreeNode<T>[]): TreeNode<T>[] =>
-      nodes.map((n) => {
-        if (n.id === parentId) {
-          // Only reconcile a branch whose children were actually loaded; an
-          // unloaded parent stays unloaded (lazy-load fetches it fresh later).
-          if (n.children === undefined) return n;
-          const prevById = new Map(n.children.map((c) => [c.id, c]));
-          const merged = fresh.map((f) => {
-            const prev = prevById.get(f.id);
-            // Preserve the surviving child's previously loaded grandchildren so
-            // deeper expansion is not collapsed by the reconcile.
-            return prev?.children !== undefined
-              ? { ...f, children: prev.children }
-              : f;
-          });
-          touched = true;
-          return { ...n, children: merged };
-        }
-        if (n.children) {
-          const next = walk(n.children);
-          if (next !== n.children) return { ...n, children: next };
-        }
-        return n;
-      });
-    const out = walk(tree);
-    return touched ? out : tree;
-  },
-
   place<T extends object>(
     tree: TreeNode<T>[],
     sourceId: string,
@@ -294,20 +232,6 @@ export const treeModel = {
     const source = treeModel.find(tree, sourceId);
     if (!source) return tree;
     if (to.parentId !== null && !treeModel.find(tree, to.parentId)) return tree;
-    // Cycle guard, mirroring `move`'s `isDescendant` check (#206 ui-state-races-1).
-    // If the destination parent is INSIDE the moved node's own subtree (reachable
-    // when server-authoritative move events arrive out of order — e.g. X moved
-    // under Y, then Y under X, but on this receiver Y is still inside X), then
-    // `remove(sourceId)` would drop the future parent along with the whole subtree
-    // and `insertByPosition` could not find it again — the node and ALL its
-    // descendants would silently vanish. Refuse the move and return the same
-    // reference so callers can detect the no-op and reconcile (refetch) instead.
-    if (
-      to.parentId !== null &&
-      treeModel.isDescendant(tree, sourceId, to.parentId)
-    ) {
-      return tree;
-    }
     const removed = treeModel.remove(tree, sourceId);
     // Reuse the same position-ordered insertion as `insertByPosition` by
     // stamping the authoritative position onto the moved node first.
@@ -318,10 +242,9 @@ export const treeModel = {
   move<T extends object>(
     tree: TreeNode<T>[],
     sourceId: string,
-    op: import("./tree-model.types").DropOp,
-  ): { tree: TreeNode<T>[]; result: import("./tree-model.types").DropResult } {
-    if (sourceId === op.targetId)
-      return { tree, result: { parentId: null, index: 0 } };
+    op: import('./tree-model.types').DropOp,
+  ): { tree: TreeNode<T>[]; result: import('./tree-model.types').DropResult } {
+    if (sourceId === op.targetId) return { tree, result: { parentId: null, index: 0 } };
     if (!treeModel.find(tree, sourceId) || !treeModel.find(tree, op.targetId)) {
       return { tree, result: { parentId: null, index: 0 } };
     }
@@ -332,7 +255,7 @@ export const treeModel = {
     let parentId: string | null;
     let index: number;
 
-    if (op.kind === "make-child") {
+    if (op.kind === 'make-child') {
       parentId = op.targetId;
       const target = treeModel.find(tree, op.targetId)!;
       index = target.children?.length ?? 0;
@@ -341,8 +264,9 @@ export const treeModel = {
       parentId = info.parentId;
       const sourceInfo = treeModel.siblingsOf(tree, sourceId)!;
       const sameParent = sourceInfo.parentId === parentId;
-      const adjust = sameParent && sourceInfo.index < info.index ? -1 : 0;
-      index = info.index + adjust + (op.kind === "reorder-after" ? 1 : 0);
+      const adjust =
+        sameParent && sourceInfo.index < info.index ? -1 : 0;
+      index = info.index + adjust + (op.kind === 'reorder-after' ? 1 : 0);
     }
 
     const next = treeModel.place(tree, sourceId, { parentId, index });

apps/client/src/features/page/tree/types.ts

@@ -9,7 +9,5 @@ export type SpaceTreeNode = {
   hasChildren: boolean;
   canEdit?: boolean;
   isTemplate?: boolean;
-  // Death-timer deadline. null/absent => permanent; ISO string => temporary note.
-  temporaryExpiresAt?: string | null;
   children: SpaceTreeNode[];
 };

apps/client/src/features/page/tree/utils/utils.test.ts

@@ -6,8 +6,6 @@ import {
   collectBranchIds,
   openBranches,
   closeIds,
-  mergeRootTrees,
-  loadedOpenBranchIds,
 } from "./utils";
 import type { IPage } from "@/features/page/types/page.types.ts";
 import type { SpaceTreeNode } from "@/features/page/tree/types.ts";
@@ -46,7 +44,10 @@ function flatNode(
 }
 
 // Nested SpaceTreeNode factory for collectAllIds / collectBranchIds.
-function treeNode(id: string, children: SpaceTreeNode[] = []): SpaceTreeNode {
+function treeNode(
+  id: string,
+  children: SpaceTreeNode[] = [],
+): SpaceTreeNode {
   return {
     id,
     slugId: `slug-${id}`,
@@ -93,7 +94,11 @@ describe("collectBranchIds", () => {
       ]),
       treeNode("root2", [treeNode("leaf3")]),
     ];
-    expect(collectBranchIds(tree).sort()).toEqual(["branch1", "root", "root2"]);
+    expect(collectBranchIds(tree).sort()).toEqual([
+      "branch1",
+      "root",
+      "root2",
+    ]);
   });
 
   it("returns [] for a leaf-only tree", () => {
@@ -268,95 +273,3 @@ describe("closeIds", () => {
     expect(twice).toEqual({ keep: true, a: false, b: false });
   });
 });
-
-describe("mergeRootTrees (#159 #2 reconnect reconcile)", () => {
-  // Root node with a position and optional already-loaded children.
-  function root(
-    id: string,
-    position: string,
-    children?: SpaceTreeNode[],
-  ): SpaceTreeNode {
-    return {
-      id,
-      slugId: `slug-${id}`,
-      name: id.toUpperCase(),
-      icon: undefined,
-      position,
-      spaceId: "space-1",
-      parentPageId: null as unknown as string,
-      hasChildren: !!children?.length,
-      children: children as SpaceTreeNode[],
-    };
-  }
-
-  it("DROPS a stale root that is absent from the incoming (authoritative) set", () => {
-    // 'ghost' was a root before the gap; the server's current roots no longer
-    // include it (deleted / moved under another page). It must not linger.
-    const prev = [root("a", "a0"), root("ghost", "a2"), root("b", "a4")];
-    const incoming = [root("a", "a0"), root("b", "a4")];
-    const merged = mergeRootTrees(prev, incoming);
-    expect(merged.map((n) => n.id)).toEqual(["a", "b"]);
-    expect(merged.find((n) => n.id === "ghost")).toBeUndefined();
-  });
-
-  it("PRESERVES a surviving root's lazy-loaded children (subtree not lost on refetch)", () => {
-    const loadedChild = root("a1", "a0");
-    const prev = [root("a", "a0", [loadedChild])];
-    // The root query returns only top-level roots (no children).
-    const incoming = [root("a", "a0")];
-    const merged = mergeRootTrees(prev, incoming);
-    expect(merged[0].children?.map((c) => c.id)).toEqual(["a1"]);
-  });
-
-  it("ADDS a new incoming root", () => {
-    const prev = [root("a", "a0")];
-    const incoming = [root("a", "a0"), root("new", "a2")];
-    const merged = mergeRootTrees(prev, incoming);
-    expect(merged.map((n) => n.id)).toEqual(["a", "new"]);
-  });
-
-  it("REFRESHES a surviving root's own fields from the incoming copy (e.g. rename)", () => {
-    const prev = [{ ...root("a", "a0"), name: "OLD" }];
-    const incoming = [{ ...root("a", "a0"), name: "NEW" }];
-    const merged = mergeRootTrees(prev, incoming);
-    expect(merged[0].name).toBe("NEW");
-  });
-});
-
-describe("loadedOpenBranchIds (#159 #8 reconnect refresh targets)", () => {
-  function n(id: string, children?: SpaceTreeNode[]): SpaceTreeNode {
-    return {
-      id,
-      slugId: `slug-${id}`,
-      name: id.toUpperCase(),
-      icon: undefined,
-      position: "a0",
-      spaceId: "space-1",
-      parentPageId: null as unknown as string,
-      hasChildren: !!children,
-      children: children as SpaceTreeNode[],
-    };
-  }
-
-  it("returns OPEN branches whose children are loaded (array)", () => {
-    const tree = [n("a", [n("a1")]), n("b", [n("b1")])];
-    const ids = loadedOpenBranchIds(tree, new Set(["a"]));
-    expect(ids).toEqual(["a"]); // b is closed; a is open+loaded
-  });
-
-  it("skips an open branch whose children are NOT loaded (undefined)", () => {
-    const tree = [n("a")]; // children undefined
-    expect(loadedOpenBranchIds(tree, new Set(["a"]))).toEqual([]);
-  });
-
-  it("includes a loaded-but-empty open branch (a child may have been added during the gap)", () => {
-    const tree = [n("a", [])];
-    expect(loadedOpenBranchIds(tree, new Set(["a"]))).toEqual(["a"]);
-  });
-
-  it("walks nested open+loaded branches (deep chain refreshes every level)", () => {
-    const tree = [n("a", [n("a1", [n("a1a")])])];
-    const ids = loadedOpenBranchIds(tree, new Set(["a", "a1"]));
-    expect(ids.sort()).toEqual(["a", "a1"]);
-  });
-});

apps/client/src/features/page/tree/utils/utils.ts

@@ -26,7 +26,6 @@ export function buildTree(pages: IPage[]): SpaceTreeNode[] {
       parentPageId: page.parentPageId,
       canEdit: page.canEdit ?? page.permissions?.canEdit,
       isTemplate: page.isTemplate,
-      temporaryExpiresAt: page.temporaryExpiresAt,
       children: [],
     };
   });
@@ -215,59 +214,21 @@ export function appendNodeChildren(
 }
 
 /**
- * Reconcile the loaded root nodes to the authoritative INCOMING set (the
- * server's complete current roots for the space), preserving any lazy-loaded
- * children/subtree of a root that still exists.
- *
- * This runs only once all root pages are fetched, so `incomingRoots` is the full
- * server root set and is authoritative for WHICH roots exist:
- *  - a root in BOTH: kept, with its own fields refreshed from `incoming` (so a
- *    rename/move during a gap shows) while PRESERVING its previously lazy-loaded
- *    `children` (expanded subtrees + open-state survive a refetch);
- *  - a root only in `incoming`: a new root, added as-is;
- *  - a root only in `prev`: it was DELETED or moved under another page while we
- *    were not receiving events (e.g. a socket reconnect after a sleep/wifi gap).
- *    It is DROPPED instead of lingering as a 404 "ghost" root (#159 #2). The old
- *    append-only merge kept it forever.
+ * Merge root nodes; keep existing ones intact, append new ones,
  */
 export function mergeRootTrees(
   prevRoots: SpaceTreeNode[],
   incomingRoots: SpaceTreeNode[],
 ): SpaceTreeNode[] {
-  const prevById = new Map(prevRoots.map((r) => [r.id, r]));
+  const seen = new Set(prevRoots.map((r) => r.id));
 
-  const reconciled = incomingRoots.map((incoming) => {
-    const prev = prevById.get(incoming.id);
-    // Preserve the previously loaded children/subtree (the root query returns
-    // only top-level roots, so `incoming` carries no children); refresh the
-    // node's own fields from the authoritative incoming copy.
-    return prev ? { ...incoming, children: prev.children } : incoming;
+  // add new roots that were not present before
+  const merged = [...prevRoots];
+  incomingRoots.forEach((node) => {
+    if (!seen.has(node.id)) merged.push(node);
   });
 
-  return sortPositionKeys(reconciled);
-}
-
-/**
- * Ids of branches a socket-reconnect refresh should re-fetch and reconcile
- * (#159 #8): a node that is currently OPEN and whose children are LOADED
- * (`children` is an array — possibly empty). An unloaded branch (`children ===
- * undefined`) is skipped because lazy-load fetches it fresh on the next expand,
- * so there is nothing stale to reconcile. Walks the whole tree (a deep open
- * chain refreshes every loaded level).
- */
-export function loadedOpenBranchIds(
-  tree: SpaceTreeNode[],
-  openIds: ReadonlySet<string>,
-): string[] {
-  const ids: string[] = [];
-  const walk = (nodes: SpaceTreeNode[]) => {
-    for (const n of nodes) {
-      if (openIds.has(n.id) && Array.isArray(n.children)) ids.push(n.id);
-      if (n.children) walk(n.children);
-    }
-  };
-  walk(tree);
-  return ids;
+  return sortPositionKeys(merged);
 }
 
 // Collect every node id in the tree (roots, branches, leaves). Used by

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

@@ -13,10 +13,6 @@ export interface IPage {
   workspaceId: string;
   isLocked: boolean;
   isTemplate?: boolean;
-  // Death-timer deadline. null/absent => permanent; ISO string => temporary note.
-  temporaryExpiresAt?: string | null;
-  // Create-only input flag: ask the server to arm the timer on a new page.
-  temporary?: boolean;
   lastUpdatedById: string;
   createdAt: Date;
   updatedAt: Date;

apps/client/src/features/share/components/share-alias-section.tsx

@@ -1,266 +0,0 @@
-import {
-  ActionIcon,
-  Box,
-  Button,
-  Group,
-  Modal,
-  Text,
-  TextInput,
-} from "@mantine/core";
-import { IconExternalLink } from "@tabler/icons-react";
-import { useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
-import { useTranslation } from "react-i18next";
-import CopyTextButton from "@/components/common/copy.tsx";
-import { getAppUrl } from "@/lib/config.ts";
-import {
-  useRemoveShareAliasMutation,
-  useSetShareAliasMutation,
-  useShareAliasForPageQuery,
-} from "@/features/share/queries/share-query.ts";
-import { checkShareAliasAvailability } from "@/features/share/services/share-service.ts";
-import {
-  isValidShareAlias,
-  normalizeShareAlias,
-} from "@/features/share/share-alias.util.ts";
-
-interface ShareAliasSectionProps {
-  pageId: string;
-  readOnly: boolean;
-}
-
-// The prefix label shown next to the slug input, e.g. "docs.example.com/l/".
-function aliasPrefixLabel(): string {
-  const url = getAppUrl();
-  const host = url.replace(/^https?:\/\//, "").replace(/\/+$/, "");
-  return `${host}/l/`;
-}
-
-export default function ShareAliasSection({
-  pageId,
-  readOnly,
-}: ShareAliasSectionProps) {
-  const { t } = useTranslation();
-  const { data: currentAlias } = useShareAliasForPageQuery(pageId);
-  const setAliasMutation = useSetShareAliasMutation();
-  const removeAliasMutation = useRemoveShareAliasMutation();
-
-  const [value, setValue] = useState("");
-  const [availability, setAvailability] = useState<{
-    valid: boolean;
-    available: boolean;
-    currentPageId: string | null;
-  } | null>(null);
-  const [reassign, setReassign] = useState<{
-    alias: string;
-    currentPageTitle: string | null;
-  } | null>(null);
-
-  // Seed the input from the page's current alias (if any).
-  useEffect(() => {
-    setValue(currentAlias?.alias ?? "");
-  }, [currentAlias?.alias, pageId]);
-
-  const normalized = useMemo(() => normalizeShareAlias(value), [value]);
-  const isValid = isValidShareAlias(normalized);
-  const unchanged = currentAlias?.alias === normalized;
-
-  // Debounced availability probe (skips when invalid or unchanged).
-  const debounceRef = useRef<ReturnType<typeof setTimeout>>();
-  useEffect(() => {
-    setAvailability(null);
-    if (!isValid || unchanged) return;
-    debounceRef.current && clearTimeout(debounceRef.current);
-    debounceRef.current = setTimeout(async () => {
-      try {
-        const res = await checkShareAliasAvailability(normalized);
-        setAvailability({
-          valid: res.valid,
-          available: res.available,
-          currentPageId: res.currentPageId,
-        });
-      } catch {
-        setAvailability(null);
-      }
-    }, 400);
-    return () => {
-      debounceRef.current && clearTimeout(debounceRef.current);
-    };
-  }, [normalized, isValid, unchanged]);
-
-  const prettyLink = currentAlias?.alias
-    ? `${getAppUrl()}/l/${currentAlias.alias}`
-    : null;
-
-  const handleSave = async (confirmReassign = false) => {
-    try {
-      await setAliasMutation.mutateAsync({
-        pageId,
-        alias: normalized,
-        confirmReassign,
-      });
-      setReassign(null);
-    } catch (error: any) {
-      // The address already points at another page: prompt to move it here.
-      if (error?.status === 409 || error?.response?.status === 409) {
-        const data = error?.response?.data;
-        if (data?.code === "ALIAS_REASSIGN_REQUIRED") {
-          setReassign({
-            alias: normalized,
-            currentPageTitle: data?.currentPageTitle ?? null,
-          });
-        }
-      }
-    }
-  };
-
-  const handleRemove = async () => {
-    if (!currentAlias?.id) return;
-    await removeAliasMutation.mutateAsync(currentAlias.id);
-    setValue("");
-  };
-
-  const showInvalid = normalized.length > 0 && !isValid;
-  const showTaken =
-    isValid && !unchanged && availability && !availability.available;
-
-  // The slug prefix (e.g. "docs.example.com/l/") is static for the session.
-  const prefixLabel = aliasPrefixLabel();
-  const prefixRef = useRef<HTMLDivElement>(null);
-  const [prefixWidth, setPrefixWidth] = useState(0);
-
-  // Measure the real rendered width of the prefix so the slug input sits flush
-  // next to it, instead of after an over-estimated character-counted gap.
-  useLayoutEffect(() => {
-    if (prefixRef.current) {
-      setPrefixWidth(Math.ceil(prefixRef.current.scrollWidth) + 1);
-    }
-  }, [prefixLabel]);
-
-  return (
-    <>
-      <Text size="sm" fw={500} mt="md">
-        {t("Custom address")}
-      </Text>
-      <Text size="xs" c="dimmed" mb={6}>
-        {t("A short, memorable link you can point at any shared page.")}
-      </Text>
-
-      {prettyLink && (
-        <Group my="xs" gap={4} wrap="nowrap">
-          <TextInput
-            variant="filled"
-            value={prettyLink}
-            readOnly
-            rightSection={<CopyTextButton text={prettyLink} />}
-            style={{ width: "100%" }}
-          />
-          <ActionIcon
-            component="a"
-            variant="default"
-            target="_blank"
-            href={prettyLink}
-            size="sm"
-          >
-            <IconExternalLink size={16} />
-          </ActionIcon>
-        </Group>
-      )}
-
-      <TextInput
-        value={value}
-        onChange={(e) => setValue(e.currentTarget.value)}
-        // Show the canonical form once the user pauses so what they type maps
-        // visibly to what gets stored.
-        onBlur={() => setValue(normalized)}
-        leftSection={
-          <Box
-            ref={prefixRef}
-            style={{
-              display: "flex",
-              alignItems: "center",
-              width: "100%",
-              height: "100%",
-              paddingInline: "var(--mantine-spacing-xs)",
-              whiteSpace: "nowrap",
-              fontSize: "var(--mantine-font-size-xs)",
-              color: "var(--mantine-color-dimmed)",
-              backgroundColor: "var(--mantine-color-default-hover)",
-              borderTopLeftRadius: "var(--input-radius)",
-              borderBottomLeftRadius: "var(--input-radius)",
-            }}
-          >
-            {prefixLabel}
-          </Box>
-        }
-        leftSectionWidth={prefixWidth || undefined}
-        placeholder={t("my-page")}
-        disabled={readOnly}
-        error={
-          showInvalid
-            ? t("Use 2-60 lowercase letters, digits and hyphens")
-            : showTaken
-              ? t("This address is already in use")
-              : undefined
-        }
-      />
-
-      <Group mt="sm" gap="xs">
-        <Button
-          size="compact-sm"
-          onClick={() => handleSave(false)}
-          loading={setAliasMutation.isPending}
-          disabled={readOnly || !isValid || unchanged}
-        >
-          {t("Save")}
-        </Button>
-        {currentAlias?.id && (
-          <Button
-            size="compact-sm"
-            variant="default"
-            color="red"
-            onClick={handleRemove}
-            loading={removeAliasMutation.isPending}
-            disabled={readOnly}
-          >
-            {t("Remove")}
-          </Button>
-        )}
-      </Group>
-
-      <Modal
-        opened={!!reassign}
-        onClose={() => setReassign(null)}
-        title={t("Move custom address?")}
-        centered
-        size="sm"
-      >
-        <Text size="sm">
-          {reassign?.currentPageTitle
-            ? t(
-                'The address "{{alias}}" currently points to "{{title}}". Move it to this page?',
-                {
-                  alias: reassign?.alias,
-                  title: reassign?.currentPageTitle,
-                },
-              )
-            : t(
-                'The address "{{alias}}" is already in use. Move it to this page?',
-                { alias: reassign?.alias },
-              )}
-        </Text>
-        <Group justify="flex-end" mt="md">
-          <Button variant="default" onClick={() => setReassign(null)}>
-            {t("Cancel")}
-          </Button>
-          <Button
-            color="red"
-            onClick={() => handleSave(true)}
-            loading={setAliasMutation.isPending}
-          >
-            {t("Move here")}
-          </Button>
-        </Group>
-      </Modal>
-    </>
-  );
-}

apps/client/src/features/share/components/share-modal.tsx

@@ -25,7 +25,6 @@ import CopyTextButton from "@/components/common/copy.tsx";
 import { getAppUrl } from "@/lib/config.ts";
 import { buildPageUrl } from "@/features/page/page.utils.ts";
 import classes from "@/features/share/components/share.module.css";
-import ShareAliasSection from "@/features/share/components/share-alias-section.tsx";
 import { useAtom } from "jotai";
 import { workspaceAtom } from "@/features/user/atoms/current-user-atom.ts";
 import { useSpaceQuery } from "@/features/space/queries/space-query.ts";
@@ -254,9 +253,6 @@ export default function ShareModal({ readOnly }: ShareModalProps) {
                     disabled={readOnly}
                   />
                 </Group>
-                {pageId && (
-                  <ShareAliasSection pageId={pageId} readOnly={readOnly} />
-                )}
               </>
             )}
           </>

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

@@ -10,8 +10,6 @@ import { useTranslation } from "react-i18next";
 import {
   ICreateShare,
   IShare,
-  IShareAlias,
-  ISetShareAlias,
   ISharedItem,
   ISharedPage,
   ISharedPageTree,
@@ -22,14 +20,11 @@ import {
 import {
   createShare,
   deleteShare,
-  getShareAliasForPage,
   getSharedPageTree,
   getShareForPage,
   getShareInfo,
   getSharePageInfo,
   getShares,
-  removeShareAlias,
-  setShareAlias,
   updateShare,
 } from "@/features/share/services/share-service.ts";
 import { IPagination, QueryParams } from "@/lib/types.ts";
@@ -175,72 +170,6 @@ export function useDeleteShareMutation() {
   });
 }
 
-export function useShareAliasForPageQuery(
-  pageId: string,
-): UseQueryResult<IShareAlias | null, Error> {
-  return useQuery({
-    // The endpoint resolves to null when the page has no alias; normalize the
-    // absence so React Query never sees `undefined`.
-    queryKey: ["share-alias-for-page", pageId],
-    queryFn: async () => (await getShareAliasForPage(pageId)) ?? null,
-    enabled: !!pageId,
-    staleTime: 60 * 1000,
-    retry: false,
-  });
-}
-
-export function useSetShareAliasMutation() {
-  const { t } = useTranslation();
-  const queryClient = useQueryClient();
-
-  return useMutation<IShareAlias, Error, ISetShareAlias>({
-    mutationFn: (data) => setShareAlias(data),
-    onSuccess: () => {
-      queryClient.invalidateQueries({
-        predicate: (item) =>
-          ["share-alias-for-page", "share-list"].includes(
-            item.queryKey[0] as string,
-          ),
-      });
-    },
-    onError: (error) => {
-      // A 409 reassign-required is handled inline by the modal (it shows the
-      // "move address here?" confirmation), so don't surface a generic toast.
-      if (error?.["status"] === 409) return;
-      notifications.show({
-        message:
-          error?.["response"]?.data?.message || t("Failed to set custom address"),
-        color: "red",
-      });
-    },
-  });
-}
-
-export function useRemoveShareAliasMutation() {
-  const { t } = useTranslation();
-  const queryClient = useQueryClient();
-
-  return useMutation<void, Error, string>({
-    mutationFn: (aliasId) => removeShareAlias(aliasId),
-    onSuccess: () => {
-      queryClient.invalidateQueries({
-        predicate: (item) =>
-          ["share-alias-for-page", "share-list"].includes(
-            item.queryKey[0] as string,
-          ),
-      });
-    },
-    onError: (error) => {
-      notifications.show({
-        message:
-          error?.["response"]?.data?.message ||
-          t("Failed to remove custom address"),
-        color: "red",
-      });
-    },
-  });
-}
-
 export function useGetSharedPageTreeQuery(
   shareId: string,
 ): UseQueryResult<ISharedPageTree, Error> {

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

@@ -4,9 +4,6 @@ import { IPage } from "@/features/page/types/page.types";
 import {
   ICreateShare,
   IShare,
-  IShareAlias,
-  IShareAliasAvailability,
-  ISetShareAlias,
   ISharedItem,
   ISharedPage,
   ISharedPageTree,
@@ -60,33 +57,3 @@ export async function getSharedPageTree(
   const req = await api.post<ISharedPageTree>("/shares/tree", { shareId });
   return req.data;
 }
-
-export async function getShareAliasForPage(
-  pageId: string,
-): Promise<IShareAlias | null> {
-  const req = await api.post<IShareAlias | null>("/share-aliases/for-page", {
-    pageId,
-  });
-  return req.data;
-}
-
-export async function setShareAlias(
-  data: ISetShareAlias,
-): Promise<IShareAlias> {
-  const req = await api.post<IShareAlias>("/share-aliases/set", data);
-  return req.data;
-}
-
-export async function removeShareAlias(aliasId: string): Promise<void> {
-  await api.post("/share-aliases/remove", { aliasId });
-}
-
-export async function checkShareAliasAvailability(
-  alias: string,
-): Promise<IShareAliasAvailability> {
-  const req = await api.post<IShareAliasAvailability>(
-    "/share-aliases/availability",
-    { alias },
-  );
-  return req.data;
-}

apps/client/src/features/share/share-alias.util.test.ts

@@ -1,32 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  isValidShareAlias,
-  normalizeShareAlias,
-} from "@/features/share/share-alias.util.ts";
-
-// Mirrors the server-side util so the modal's live feedback matches what the
-// server will accept/store.
-describe("normalizeShareAlias", () => {
-  it("lowercases, trims and maps separators to single hyphens", () => {
-    expect(normalizeShareAlias("  My  Cool_Page ")).toBe("my-cool-page");
-  });
-
-  it("collapses repeated hyphens and trims edges", () => {
-    expect(normalizeShareAlias("--a---b--")).toBe("a-b");
-  });
-});
-
-describe("isValidShareAlias", () => {
-  it("accepts ascii hyphen-separated slugs of length 2..60", () => {
-    expect(isValidShareAlias("hello-world")).toBe(true);
-    expect(isValidShareAlias("a".repeat(60))).toBe(true);
-  });
-
-  it("rejects too short, edge/double hyphens, uppercase and non-ascii", () => {
-    expect(isValidShareAlias("a")).toBe(false);
-    expect(isValidShareAlias("-a")).toBe(false);
-    expect(isValidShareAlias("a--b")).toBe(false);
-    expect(isValidShareAlias("Hello")).toBe(false);
-    expect(isValidShareAlias("привет")).toBe(false);
-  });
-});

apps/client/src/features/share/share-alias.util.ts

@@ -1,26 +0,0 @@
-/**
- * Client copy of the vanity share-alias helpers. Kept in sync with the server
- * (`apps/server/src/core/share/share-alias.util.ts`) so live input feedback
- * matches what the server will store/accept. ASCII-only, lowercase, hyphen
- * separated, length 2..60.
- */
-
-// Normalize a user-provided vanity alias into canonical ASCII storage form.
-export function normalizeShareAlias(raw: string): string {
-  return (raw ?? "")
-    .trim()
-    .toLowerCase()
-    .replace(/[\s_]+/g, "-")
-    .replace(/-{2,}/g, "-")
-    .replace(/^-+|-+$/g, "");
-}
-
-const ALIAS_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-export function isValidShareAlias(alias: string): boolean {
-  return (
-    typeof alias === "string" &&
-    alias.length >= 2 &&
-    alias.length <= 60 &&
-    ALIAS_RE.test(alias)
-  );
-}

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

@@ -75,30 +75,6 @@ export interface IShareInfoInput {
   pageId: string;
 }
 
-// Vanity /l/:alias pointer.
-export interface IShareAlias {
-  id: string;
-  workspaceId: string;
-  alias: string;
-  pageId: string | null;
-  creatorId: string | null;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface ISetShareAlias {
-  pageId: string;
-  alias: string;
-  confirmReassign?: boolean;
-}
-
-export interface IShareAliasAvailability {
-  alias: string;
-  valid: boolean;
-  available: boolean;
-  currentPageId: string | null;
-}
-
 export interface ISharedPageTree {
   share: IShare;
   pageTree: Partial<IPage[]>;

apps/client/src/features/space/components/sidebar/space-sidebar.tsx

@@ -13,7 +13,6 @@ import {
   IconEye,
   IconEyeOff,
   IconFileExport,
-  IconHourglass,
   IconPlus,
   IconSettings,
   IconStar,
@@ -72,10 +71,6 @@ export function SpaceSidebar() {
     handleCreate(null);
   }
 
-  function handleCreateTemporaryPage() {
-    handleCreate(null, { temporary: true });
-  }
-
   return (
     <>
       <div className={classes.navbar}>
@@ -116,39 +111,16 @@ export function SpaceSidebar() {
                 SpaceCaslAction.Manage,
                 SpaceCaslSubject.Page,
               ) && (
-                <>
-                  <Tooltip
-                    label={t("Create page")}
-                    withArrow
-                    position="right"
+                <Tooltip label={t("Create page")} withArrow position="right">
+                  <ActionIcon
+                    variant="default"
+                    size={18}
+                    onClick={handleCreatePage}
+                    aria-label={t("Create page")}
                   >
-                    <ActionIcon
-                      variant="default"
-                      size={18}
-                      onClick={handleCreatePage}
-                      aria-label={t("Create page")}
-                    >
-                      <IconPlus />
-                    </ActionIcon>
-                  </Tooltip>
-
-                  {/* Standalone second button: a "temporary note" auto-moves to
-                      trash after the workspace lifetime unless made permanent. */}
-                  <Tooltip
-                    label={t("New temporary note")}
-                    withArrow
-                    position="right"
-                  >
-                    <ActionIcon
-                      variant="default"
-                      size={18}
-                      onClick={handleCreateTemporaryPage}
-                      aria-label={t("New temporary note")}
-                    >
-                      <IconHourglass />
-                    </ActionIcon>
-                  </Tooltip>
-                </>
+                    <IconPlus />
+                  </ActionIcon>
+                </Tooltip>
               )}
             </Group>
           </Group>

apps/client/src/features/space/components/space-create-note-buttons.tsx

@@ -1,74 +0,0 @@
-import { useState } from "react";
-import { Button, Group } from "@mantine/core";
-import { IconHourglass, IconPlus } from "@tabler/icons-react";
-import { useParams } from "react-router-dom";
-import { useTranslation } from "react-i18next";
-import { useGetSpaceBySlugQuery } from "@/features/space/queries/space-query.ts";
-import { useTreeMutation } from "@/features/page/tree/hooks/use-tree-mutation.ts";
-import { useSpaceAbility } from "@/features/space/permissions/use-space-ability.ts";
-import {
-  SpaceCaslAction,
-  SpaceCaslSubject,
-} from "@/features/space/permissions/permissions.type.ts";
-
-// Space-overview quick actions: create a regular note or a temporary note
-// (which auto-moves to Trash after the workspace lifetime) directly in the
-// current space and open it. Mirrors the sidebar's create buttons but lives on
-// the space overview screen, reusing `useTreeMutation.handleCreate` so the new
-// page is optimistically inserted into the sidebar tree and navigated to.
-export default function SpaceCreateNoteButtons() {
-  const { t } = useTranslation();
-  const { spaceSlug } = useParams();
-  const { data: space } = useGetSpaceBySlugQuery(spaceSlug);
-  const spaceAbility = useSpaceAbility(space?.membership?.permissions);
-  // `handleCreate` is read unconditionally to keep hook order stable; it is
-  // only invoked after the permission guard below confirms a loaded space.
-  const { handleCreate } = useTreeMutation(space?.id ?? "");
-  // Which create action is in flight: drives the per-button spinner and the
-  // shared disabled state so a slow create round-trip cannot be double-fired.
-  const [pending, setPending] = useState<"regular" | "temporary" | null>(null);
-
-  // Render nothing until the space loads, or when the user cannot manage pages.
-  if (!space) return null;
-  if (spaceAbility.cannot(SpaceCaslAction.Manage, SpaceCaslSubject.Page)) {
-    return null;
-  }
-
-  const createNote = (temporary: boolean) => {
-    if (pending) return;
-    setPending(temporary ? "temporary" : "regular");
-    // handleCreate creates the page then navigates away (unmounting this
-    // component); the create mutation already shows a red notification on
-    // failure, so swallow the rejection and just clear the pending flag.
-    handleCreate(null, temporary ? { temporary: true } : undefined)
-      .catch(() => {})
-      .finally(() => setPending(null));
-  };
-
-  return (
-    <Group grow gap="sm">
-      <Button
-        size="md"
-        variant="light"
-        color="gray"
-        leftSection={<IconPlus size={18} />}
-        loading={pending === "regular"}
-        disabled={pending !== null}
-        onClick={() => createNote(false)}
-      >
-        {t("New note")}
-      </Button>
-      <Button
-        size="md"
-        variant="light"
-        color="gray"
-        leftSection={<IconHourglass size={18} />}
-        loading={pending === "temporary"}
-        disabled={pending !== null}
-        onClick={() => createNote(true)}
-      >
-        {t("New temporary note")}
-      </Button>
-    </Group>
-  );
-}

apps/client/src/features/websocket/tree-socket-reducers.test.ts

@@ -81,38 +81,6 @@ describe("applyMoveTreeNode", () => {
     ]);
   });
 
-  it("does NOT create a partial child list when the destination is loaded-but-collapsed (children unloaded) — keeps it lazy-loadable (#159)", () => {
-    // `dstCollapsed` is in the tree but its children were never lazy-loaded
-    // (children === undefined). The OLD behavior inserted `src` as the ONLY
-    // child ([src]), which defeated the lazy-load gate and HID the parent's
-    // other real children. Now the move leaves children unloaded (so expanding
-    // fetches the FULL set, including src) and just flags hasChildren.
-    const tree: SpaceTreeNode[] = [
-      node("dstCollapsed", {
-        position: "a0",
-        hasChildren: false,
-        children: undefined as unknown as SpaceTreeNode[],
-      }),
-      node("src", { position: "a9" }),
-    ];
-    const next = applyMoveTreeNode(tree, {
-      id: "src",
-      parentId: "dstCollapsed",
-      oldParentId: null,
-      index: 0,
-      position: "a4",
-      pageData: {},
-    });
-    const dst = treeModel.find(next, "dstCollapsed");
-    // Children stay unloaded -> the lazy-load gate fetches the FULL set (incl.
-    // src) on expand, rather than showing a misleading partial [src] list.
-    expect(dst?.children).toBeUndefined();
-    expect(dst?.hasChildren).toBe(true);
-    // src moved away from its old root slot (it lives under dstCollapsed
-    // server-side and reappears when the parent is expanded/loaded).
-    expect(next.map((n) => n.id)).not.toContain("src");
-  });
-
   it("flips the OLD parent's hasChildren to false when it is left childless", () => {
     // src is the only child of `old`; moving it to `dst` empties `old`.
     const tree: SpaceTreeNode[] = [
@@ -183,34 +151,6 @@ describe("applyMoveTreeNode", () => {
     expect(moved?.hasChildren).toBe(true);
     expect(moved?.position).toBe("a4");
   });
-
-  it("does NOT drop a subtree on a cyclic/out-of-order move (parent inside source) (#206 ui-state-races-1)", () => {
-    // Locally `b` is still nested inside `a` (an earlier "a under b" echo hasn't
-    // applied yet). An out-of-order "move a under b" event now arrives — b is a
-    // descendant of a, so re-parenting would make placeByPosition remove a (and
-    // its whole subtree, incl. b) and fail to re-insert. Before the fix BOTH a
-    // and b silently vanished; now the reducer leaves the tree untouched.
-    const tree: SpaceTreeNode[] = [
-      node("a", {
-        position: "a0",
-        hasChildren: true,
-        children: [node("b", { position: "a1", parentPageId: "a" })],
-      }),
-    ];
-    const next = applyMoveTreeNode(tree, {
-      id: "a",
-      parentId: "b",
-      oldParentId: null,
-      index: 0,
-      position: "a4",
-      pageData: {},
-    });
-    // No silent data loss: both nodes survive.
-    expect(treeModel.find(next, "a")).not.toBeNull();
-    expect(treeModel.find(next, "b")).not.toBeNull();
-    // The cyclic move is refused as a no-op (same reference) pending reconcile.
-    expect(next).toBe(tree);
-  });
 });
 
 describe("applyDeleteTreeNode", () => {
@@ -224,9 +164,7 @@ describe("applyDeleteTreeNode", () => {
             position: "a1",
             parentPageId: "p",
             hasChildren: true,
-            children: [
-              node("grandchild", { position: "a1", parentPageId: "child" }),
-            ],
+            children: [node("grandchild", { position: "a1", parentPageId: "child" })],
           }),
         ],
       }),

apps/client/src/features/websocket/tree-socket-reducers.ts

@@ -76,19 +76,6 @@ export function applyMoveTreeNode(
   const oldParentId = (sourceBefore as SpaceTreeNode).parentPageId ?? null;
   const newParentId = payload.parentId as string | null;
 
-  // Cyclic / out-of-order move guard (#206 ui-state-races-1): if the
-  // authoritative new parent is currently INSIDE the moved node's own subtree on
-  // this client (e.g. server moved X under Y then Y under X and the events
-  // arrived such that Y is still nested in X here), re-parenting is impossible to
-  // represent locally. `placeByPosition` returns `prev` for this, but the
-  // `placed === prev` fallback below would then `remove` the source — dropping
-  // the node AND every descendant (incl. the would-be parent) silently. Leave the
-  // tree untouched instead; a later corrective event or a reconnect refetch
-  // reconciles it. Never delete a subtree we cannot safely re-place.
-  if (newParentId && treeModel.isDescendant(prev, payload.id, newParentId)) {
-    return prev;
-  }
-
   // Place the node by its fractional `position` among the new siblings — NOT by
   // the sender's absolute `index` (the sender computed that against its own
   // loaded set, which differs from this receiver's). Using the position keeps

apps/client/src/features/workspace/components/settings/components/ai-mcp-server-form.tsx

@@ -11,7 +11,6 @@ import {
   Switch,
   TagsInput,
   Text,
-  Textarea,
   TextInput,
 } from "@mantine/core";
 import { useForm } from "@mantine/form";
@@ -36,8 +35,6 @@ const formSchema = z.object({
   // Write-only secret buffer. Empty string means "do not change" (unless cleared).
   authHeader: z.string(),
   toolAllowlist: z.array(z.string()),
-  // Admin-authored prompt guidance (#180). Capped to mirror the DTO MaxLength.
-  instructions: z.string().max(4000),
   enabled: z.boolean(),
 });
 
@@ -59,14 +56,7 @@ function buildInitialValues(server?: IAiMcpServer): FormValues {
     transport: server?.transport ?? "http",
     url: server?.url ?? "",
     authHeader: "",
-    // Defensive: TagsInput calls `.map`, so a non-array here (e.g. an API that
-    // returns the jsonb column as a JSON string) would crash the whole page. The
-    // server normalizes this now, but guard anyway so a bad shape can never take
-    // the settings UI down.
-    toolAllowlist: Array.isArray(server?.toolAllowlist)
-      ? server.toolAllowlist
-      : [],
-    instructions: server?.instructions ?? "",
+    toolAllowlist: server?.toolAllowlist ?? [],
     enabled: server?.enabled ?? true,
   };
 }
@@ -128,8 +118,6 @@ export default function AiMcpServerForm({
         transport: values.transport,
         url: values.url,
         toolAllowlist: values.toolAllowlist,
-        // Always sent: a blank value clears the stored guidance (server -> null).
-        instructions: values.instructions,
         enabled: values.enabled,
       };
       // Only attach headers when set or explicitly cleared (omit => unchanged).
@@ -141,8 +129,6 @@ export default function AiMcpServerForm({
         transport: values.transport,
         url: values.url,
         toolAllowlist: values.toolAllowlist,
-        // Blank => server stores null (no guidance).
-        instructions: values.instructions,
         enabled: values.enabled,
       };
       // On create, only a typed value matters (no prior stored headers).
@@ -166,7 +152,10 @@ export default function AiMcpServerForm({
 
   return (
     <Stack>
-      <TextInput label={t("Server name")} {...form.getInputProps("name")} />
+      <TextInput
+        label={t("Server name")}
+        {...form.getInputProps("name")}
+      />
 
       <Select
         label={t("Transport")}
@@ -182,7 +171,7 @@ export default function AiMcpServerForm({
         // Clarify that the value is sent verbatim as the Authorization header,
         // so the user supplies the full scheme (no implicit Bearer prefix).
         description={t(
-          'Sent verbatim as the value of the Authorization header (e.g. "Bearer <token>" or "Basic <base64>").',
+          "Sent verbatim as the value of the Authorization header (e.g. \"Bearer <token>\" or \"Basic <base64>\").",
         )}
         // Placeholder hints whether headers are stored; the value is never shown.
         placeholder={hasHeaders ? t("•••• set") : ""}
@@ -213,20 +202,6 @@ export default function AiMcpServerForm({
         {...form.getInputProps("toolAllowlist")}
       />
 
-      <Textarea
-        label={t("Instructions")}
-        // Hint that the text is injected into the agent's system prompt and that
-        // the server's tools are namespaced under <name>_* (the prompt header).
-        description={t(
-          "Optional guidance for the agent on how and when to use this server's tools. Injected into the system prompt. The server's tools are namespaced as \"<server name>_*\".",
-        )}
-        autosize
-        minRows={2}
-        maxRows={8}
-        maxLength={4000}
-        {...form.getInputProps("instructions")}
-      />
-
       <Switch
         label={t("Enabled")}
         checked={form.values.enabled}

apps/client/src/features/workspace/components/settings/components/ai-mcp-server-test-view.test.ts

@@ -1,87 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { mcpTestButtonView } from "./ai-mcp-server-test-view";
-
-/**
- * Pure-helper tests for the inline "Test" button presentation. Covers the four
- * states (idle / loading is handled by the component's `isPending`, so here:
- * idle / ok-with-tools / ok-without-tools / failed) and the tooltip text
- * branches that are easiest to break silently.
- */
-// Identity-ish translator that echoes the key and interpolates {{n}} so the
-// label/tooltip branches are observable without the real i18n bundle.
-const t = (key: string, options?: Record<string, unknown>): string =>
-  options && "n" in options
-    ? key.replace("{{n}}", String((options as { n: unknown }).n))
-    : key;
-
-describe("mcpTestButtonView", () => {
-  it("idle when there is no result", () => {
-    expect(mcpTestButtonView(undefined, t)).toEqual({
-      state: "idle",
-      color: undefined,
-      variant: "default",
-      label: "Test",
-      tooltip: "",
-    });
-  });
-
-  it("ok with tools lists them in the tooltip", () => {
-    expect(mcpTestButtonView({ ok: true, tools: ["a", "b"] }, t)).toEqual({
-      state: "ok",
-      color: "green",
-      variant: "light",
-      label: "OK · 2",
-      tooltip: "a, b",
-    });
-  });
-
-  it('ok with zero tools shows "No tools available"', () => {
-    expect(mcpTestButtonView({ ok: true, tools: [] }, t)).toEqual({
-      state: "ok",
-      color: "green",
-      variant: "light",
-      label: "OK · 0",
-      tooltip: "No tools available",
-    });
-  });
-
-  it("failed surfaces the error text in the tooltip", () => {
-    expect(
-      mcpTestButtonView({ ok: false, error: "402: nope" }, t),
-    ).toEqual({
-      state: "failed",
-      color: "red",
-      variant: "light",
-      label: "Failed",
-      tooltip: "402: nope",
-    });
-  });
-
-  it("failed when the request itself rejects (no result payload)", () => {
-    // 401/403/500/network: there is no { ok } body, only a thrown error. The
-    // row must still show a red "Failed" rather than reverting to idle "Test".
-    expect(
-      mcpTestButtonView(undefined, t, {
-        response: { data: { message: "Unauthorized" } },
-      }),
-    ).toEqual({
-      state: "failed",
-      color: "red",
-      variant: "light",
-      label: "Failed",
-      tooltip: "Unauthorized",
-    });
-  });
-
-  it("reject without a server message falls back to the generic label", () => {
-    // A bare network error (no response body) still surfaces as failed, using
-    // the i18n fallback for the tooltip.
-    expect(mcpTestButtonView(undefined, t, new Error("network down"))).toEqual({
-      state: "failed",
-      color: "red",
-      variant: "light",
-      label: "Failed",
-      tooltip: "Failed to update data",
-    });
-  });
-});

apps/client/src/features/workspace/components/settings/components/ai-mcp-server-test-view.ts

@@ -1,90 +0,0 @@
-import type { IAiMcpServerTestResult } from "@/features/workspace/services/ai-mcp-server-service.ts";
-
-/** Minimal translator shape (i18next `t`): key + optional interpolation. */
-type Translate = (key: string, options?: Record<string, unknown>) => string;
-
-/** Subset of an axios-style rejection we read for the reject tooltip. */
-type McpTestRequestError = {
-  response?: { data?: { message?: string } };
-};
-
-/**
- * Best-effort extraction of a server-sent message from a rejected test request
- * (axios stores it at `error.response.data.message`). Returns undefined for a
- * bare/network error so the caller can fall back to a generic label.
- */
-function readRequestErrorMessage(error: unknown): string | undefined {
-  if (error && typeof error === "object" && "response" in error) {
-    return (error as McpTestRequestError).response?.data?.message;
-  }
-  return undefined;
-}
-
-/**
- * Presentation for the inline "Test" button, derived from the current test
- * result tristate (no result yet / ok / failed). Color is never the only signal
- * — the label and icon change too (a11y / colorblind-friendly). Kept as a single
- * pure derivation (rather than two parallel if/else chains) so the button and
- * tooltip can never drift apart, and so the text branches are unit-testable
- * without rendering the row.
- */
-export interface McpTestButtonView {
-  /** Tristate; the component maps this to the leftSection icon. */
-  state: "idle" | "ok" | "failed";
-  /** Mantine Button color; undefined = theme default (idle). */
-  color?: string;
-  /** Mantine Button variant. */
-  variant: string;
-  /** Translated button label. */
-  label: string;
-  /** Translated tooltip text; "" while there is no result (tooltip disabled). */
-  tooltip: string;
-}
-
-export function mcpTestButtonView(
-  result: IAiMcpServerTestResult | undefined,
-  t: Translate,
-  error?: unknown,
-): McpTestButtonView {
-  if (result?.ok) {
-    return {
-      state: "ok",
-      color: "green",
-      variant: "light",
-      label: t("OK · {{n}}", { n: result.tools.length }),
-      tooltip:
-        result.tools.length > 0
-          ? result.tools.join(", ")
-          : t("No tools available"),
-    };
-  }
-  if (result && result.ok === false) {
-    return {
-      state: "failed",
-      color: "red",
-      variant: "light",
-      label: t("Failed"),
-      tooltip: result.error,
-    };
-  }
-  if (error) {
-    // The test request itself rejected (401/403/500/network) — there is no
-    // `{ ok }` payload, so without this branch the row would silently revert to
-    // the idle "Test" instead of reporting the failure. Tooltip prefers the
-    // server-sent message, else the generic i18n fallback.
-    return {
-      state: "failed",
-      color: "red",
-      variant: "light",
-      label: t("Failed"),
-      tooltip: readRequestErrorMessage(error) ?? t("Failed to update data"),
-    };
-  }
-  return {
-    state: "idle",
-    color: undefined,
-    variant: "default",
-    label: t("Test"),
-    tooltip: "",
-  };
-}

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

@@ -1,4 +1,4 @@
-import { useEffect, useState } from "react";
+import { useState } from "react";
 import {
   ActionIcon,
   Badge,
@@ -10,28 +10,18 @@ import {
   Stack,
   Switch,
   Text,
-  Tooltip,
 } from "@mantine/core";
 import { useDisclosure } from "@mantine/hooks";
 import { modals } from "@mantine/modals";
-import {
-  IconCheck,
-  IconPencil,
-  IconPlugConnected,
-  IconPlus,
-  IconTrash,
-  IconX,
-} from "@tabler/icons-react";
+import { IconPencil, IconPlus, IconTrash } from "@tabler/icons-react";
 import { useTranslation } from "react-i18next";
 import useUserRole from "@/hooks/use-user-role.tsx";
 import {
   useAiMcpServersQuery,
   useDeleteAiMcpServerMutation,
-  useTestAiMcpServerMutation,
   useUpdateAiMcpServerMutation,
 } from "@/features/workspace/queries/ai-mcp-server-query.ts";
 import { IAiMcpServer } from "@/features/workspace/services/ai-mcp-server-service.ts";
-import { mcpTestButtonView } from "@/features/workspace/components/settings/components/ai-mcp-server-test-view.ts";
 import AiMcpServerForm from "./ai-mcp-server-form.tsx";
 
 /**
@@ -122,15 +112,55 @@ export default function AiMcpServers() {
 
       <Stack gap="xs" mt="sm">
         {servers?.map((server) => (
-          <AiMcpServerRow
-            key={server.id}
-            server={server}
-            onEdit={openEdit}
-            onDelete={confirmDelete}
-            onToggleEnabled={(enabled) =>
-              updateMutation.mutate({ id: server.id, enabled })
-            }
-          />
+          <Group key={server.id} justify="space-between" wrap="nowrap">
+            <Stack gap={2} style={{ minWidth: 0 }}>
+              <Group gap="xs">
+                <Text fw={500} truncate>
+                  {server.name}
+                </Text>
+                <Badge size="xs" variant="light">
+                  {server.transport.toUpperCase()}
+                </Badge>
+              </Group>
+              <Text
+                size="xs"
+                c="dimmed"
+                truncate
+                style={{ fontFamily: "ui-monospace, Menlo, monospace" }}
+              >
+                {server.url}
+              </Text>
+            </Stack>
+
+            <Group gap="xs" wrap="nowrap">
+              <Switch
+                size="sm"
+                checked={server.enabled}
+                aria-label={t("Enabled")}
+                onChange={(event) =>
+                  updateMutation.mutate({
+                    id: server.id,
+                    enabled: event.currentTarget.checked,
+                  })
+                }
+              />
+              <ActionIcon
+                variant="subtle"
+                aria-label={t("Edit")}
+                onClick={() => openEdit(server)}
+              >
+                <IconPencil size={16} />
+              </ActionIcon>
+              <ActionIcon
+                variant="subtle"
+                color="red"
+                aria-label={t("Delete")}
+                onClick={() => confirmDelete(server)}
+              >
+                <IconTrash size={16} />
+              </ActionIcon>
+            </Group>
+          </Group>
         ))}
       </Stack>
 
@@ -150,127 +180,3 @@ export default function AiMcpServers() {
     </Paper>
   );
 }
-
-interface AiMcpServerRowProps {
-  server: IAiMcpServer;
-  onEdit: (server: IAiMcpServer) => void;
-  onDelete: (server: IAiMcpServer) => void;
-  onToggleEnabled: (enabled: boolean) => void;
-}
-
-/**
- * A single external MCP server row: name/badge/url on the left and the
- * Test / Switch / Edit / Delete controls on the right. Each row owns its own
- * `useTestAiMcpServerMutation()` so the inline Test result and loading state are
- * independent per row (a shared mutation would make `isPending` global and make
- * every row flicker).
- */
-function AiMcpServerRow({
-  server,
-  onEdit,
-  onDelete,
-  onToggleEnabled,
-}: AiMcpServerRowProps) {
-  const { t } = useTranslation();
-  const testMutation = useTestAiMcpServerMutation();
-  const result = testMutation.data;
-
-  // The row is keyed by `server.id`, so editing the connection-relevant fields
-  // (url/transport/headers) does NOT remount it — an old success/failure result
-  // would otherwise stick. Clear the result when those fields change.
-  useEffect(() => {
-    testMutation.reset();
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [server.url, server.transport, server.hasHeaders]);
-
-  // Single derivation of the button/tooltip presentation from the test tristate
-  // (idle / ok / failed), so the two can never drift apart. Tooltip is "" while
-  // there is no result; the icon is mapped from `view.state` below. When the
-  // request itself rejects (401/403/500/network) there is no `data` payload, so
-  // we feed the mutation error in too — otherwise the row would silently revert
-  // to "Test" instead of showing a red "Failed".
-  const view = mcpTestButtonView(
-    result,
-    t,
-    testMutation.isError ? testMutation.error : undefined,
-  );
-  const tooltipLabel = view.tooltip;
-  const buttonColor = view.color;
-  const buttonVariant = view.variant;
-  const buttonLabel = view.label;
-  const buttonIcon =
-    view.state === "ok" ? (
-      <IconCheck size={16} />
-    ) : view.state === "failed" ? (
-      <IconX size={16} />
-    ) : (
-      <IconPlugConnected size={16} />
-    );
-
-  return (
-    <Group justify="space-between" wrap="nowrap">
-      <Stack gap={2} style={{ minWidth: 0 }}>
-        <Group gap="xs">
-          <Text fw={500} truncate>
-            {server.name}
-          </Text>
-          <Badge size="xs" variant="light">
-            {server.transport.toUpperCase()}
-          </Badge>
-        </Group>
-        <Text
-          size="xs"
-          c="dimmed"
-          truncate
-          style={{ fontFamily: "ui-monospace, Menlo, monospace" }}
-        >
-          {server.url}
-        </Text>
-      </Stack>
-
-      <Group gap="xs" wrap="nowrap">
-        {/* Always clickable: testing a disabled server before enabling it is useful. */}
-        <Tooltip
-          label={tooltipLabel}
-          disabled={view.state === "idle"}
-          multiline
-          maw={320}
-          withinPortal
-        >
-          <Button
-            size="xs"
-            miw={88}
-            color={buttonColor}
-            variant={buttonVariant}
-            leftSection={testMutation.isPending ? undefined : buttonIcon}
-            loading={testMutation.isPending}
-            onClick={() => testMutation.mutate(server.id)}
-          >
-            {buttonLabel}
-          </Button>
-        </Tooltip>
-        <Switch
-          size="sm"
-          checked={server.enabled}
-          aria-label={t("Enabled")}
-          onChange={(event) => onToggleEnabled(event.currentTarget.checked)}
-        />
-        <ActionIcon
-          variant="subtle"
-          aria-label={t("Edit")}
-          onClick={() => onEdit(server)}
-        >
-          <IconPencil size={16} />
-        </ActionIcon>
-        <ActionIcon
-          variant="subtle"
-          color="red"
-          aria-label={t("Delete")}
-          onClick={() => onDelete(server)}
-        >
-          <IconTrash size={16} />
-        </ActionIcon>
-      </Group>
-    </Group>
-  );
-}

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

@@ -7,7 +7,6 @@ import {
   Button,
   Group,
   Modal,
-  NumberInput,
   Paper,
   PasswordInput,
   Select,
@@ -39,7 +38,6 @@ import {
   AiTestCapability,
   IAiSettingsUpdate,
   SttApiStyle,
-  ChatApiStyle,
 } from "@/features/workspace/services/ai-settings-service.ts";
 import { useAiRolesQuery } from "@/features/ai-chat/queries/ai-chat-query.ts";
 import { IAiRole } from "@/features/ai-chat/types/ai-chat.types.ts";
@@ -84,11 +82,6 @@ const STT_LANGUAGE_OPTIONS: { value: string; label: string }[] = [
 // (empty means "leave unchanged" unless explicitly cleared).
 const formSchema = z.object({
   chatModel: z.string(),
-  // Max context window in tokens shown in the chat header badge. A number, or ""
-  // when the NumberInput is empty (no limit).
-  chatContextWindow: z.union([z.number(), z.literal("")]),
-  // Chat provider implementation (reasoning surfacing). Default openai-compatible.
-  chatApiStyle: z.enum(["openai-compatible", "openai"]),
   // Cheap model id for the anonymous public-share assistant; empty = use chatModel.
   publicShareChatModel: z.string(),
   // Agent-role id whose persona the public-share assistant adopts; empty =
@@ -315,8 +308,6 @@ export default function AiProviderSettings() {
     validate: zod4Resolver(formSchema),
     initialValues: {
       chatModel: "",
-      chatContextWindow: "",
-      chatApiStyle: "openai-compatible" as ChatApiStyle,
       publicShareChatModel: "",
       publicShareAssistantRoleId: "",
       embeddingModel: "",
@@ -339,8 +330,6 @@ export default function AiProviderSettings() {
     if (!settings) return;
     form.setValues({
       chatModel: settings.chatModel ?? "",
-      chatContextWindow: settings.chatContextWindow ?? "",
-      chatApiStyle: settings.chatApiStyle ?? "openai-compatible",
       publicShareChatModel: settings.publicShareChatModel ?? "",
       publicShareAssistantRoleId: settings.publicShareAssistantRoleId ?? "",
       embeddingModel: settings.embeddingModel ?? "",
@@ -370,13 +359,6 @@ export default function AiProviderSettings() {
       // Everything is OpenAI-compatible.
       driver: "openai",
       chatModel: values.chatModel,
-      // Max context window for the chat header badge; empty NumberInput ("") →
-      // 0, which clears the limit server-side (no denominator shown).
-      chatContextWindow:
-        typeof values.chatContextWindow === "number"
-          ? values.chatContextWindow
-          : 0,
-      chatApiStyle: values.chatApiStyle,
       // Cheap model id for the anonymous public-share assistant; empty falls
       // back to chatModel server-side.
       publicShareChatModel: values.publicShareChatModel,
@@ -779,36 +761,6 @@ export default function AiProviderSettings() {
           {t("Resolves to {{url}}", { url: chatResolved })}
         </Text>
 
-        <NumberInput
-          mt="sm"
-          label={t("Context window (tokens)")}
-          description={t(
-            "Shown as used / total in the chat header. Leave empty to hide the limit.",
-          )}
-          min={0}
-          allowDecimal={false}
-          disabled={isLoading}
-          {...form.getInputProps("chatContextWindow")}
-        />
-
-        <Select
-          mt="sm"
-          label={t("Protocol")}
-          description={t(
-            "How chat requests are sent and how reasoning is surfaced",
-          )}
-          data={[
-            {
-              value: "openai-compatible",
-              label: t("OpenAI-compatible (surfaces reasoning)"),
-            },
-            { value: "openai", label: t("OpenAI (official)") },
-          ]}
-          allowDeselect={false}
-          disabled={isLoading}
-          {...form.getInputProps("chatApiStyle")}
-        />
-
         {/* Anonymous public-share assistant: a single master toggle + an
             optional cheaper model id. Reuses this card's driver/URL/key. */}
         <Group justify="space-between" align="center" wrap="nowrap" mt="md">

apps/client/src/features/workspace/components/settings/components/temporary-note-settings.tsx

@@ -1,86 +0,0 @@
-import { useState } from "react";
-import { useAtom } from "jotai";
-import {
-  Button,
-  Group,
-  NumberInput,
-  Paper,
-  Stack,
-  Text,
-} from "@mantine/core";
-import { notifications } from "@mantine/notifications";
-import { useTranslation } from "react-i18next";
-import useUserRole from "@/hooks/use-user-role.tsx";
-import { workspaceAtom } from "@/features/user/atoms/current-user-atom.ts";
-import { updateWorkspace } from "@/features/workspace/services/workspace-service.ts";
-import { IWorkspace } from "@/features/workspace/types/workspace.types.ts";
-
-// Mirrors DEFAULT_TEMPORARY_NOTE_HOURS on the server. Shown when the workspace
-// has no explicit value configured yet.
-const DEFAULT_TEMPORARY_NOTE_HOURS = 24;
-
-/**
- * Workspace-level editor for the temporary-note lifetime, in HOURS. The deadline
- * is frozen per-note at creation, so changing this only affects notes created
- * afterwards. `temporaryNoteHours` is a top-level workspace column (like
- * trashRetentionDays), not a nested setting.
- */
-export default function TemporaryNoteSettings() {
-  const { t } = useTranslation();
-  const [workspace, setWorkspace] = useAtom(workspaceAtom);
-  const { isAdmin } = useUserRole();
-  const [isLoading, setIsLoading] = useState(false);
-  const [value, setValue] = useState<number>(
-    workspace?.temporaryNoteHours ?? DEFAULT_TEMPORARY_NOTE_HOURS,
-  );
-
-  async function handleSave() {
-    if (!value || value < 1) return;
-    setIsLoading(true);
-    try {
-      const updated = await updateWorkspace({
-        temporaryNoteHours: value,
-      } as Partial<IWorkspace>);
-      setWorkspace({ ...updated, temporaryNoteHours: value });
-      notifications.show({ message: t("Updated successfully") });
-    } catch (err) {
-      notifications.show({
-        message:
-          (err as any)?.response?.data?.message ?? t("Failed to update data"),
-        color: "red",
-      });
-    } finally {
-      setIsLoading(false);
-    }
-  }
-
-  return (
-    <Stack mt="sm">
-      <Text fw={700} size="lg">
-        {t("Temporary notes")}
-      </Text>
-
-      <Paper withBorder radius="md" p="lg">
-        <Text size="xs" c="dimmed" mb="xs">
-          {t(
-            "A temporary note is automatically moved to trash after this many hours unless it is made permanent. The deadline is fixed when the note is created.",
-          )}
-        </Text>
-        <NumberInput
-          label={t("Temporary note lifetime (hours)")}
-          min={1}
-          allowDecimal={false}
-          value={value}
-          onChange={(v) => setValue(typeof v === "number" ? v : Number(v))}
-          disabled={!isAdmin || isLoading}
-          w={220}
-        />
-        <Group justify="flex-end" mt="md">
-          <Button onClick={handleSave} loading={isLoading} disabled={!isAdmin}>
-            {t("Save")}
-          </Button>
-        </Group>
-      </Paper>
-    </Stack>
-  );
-}

apps/client/src/features/workspace/services/ai-mcp-server-service.ts

@@ -14,9 +14,6 @@ export interface IAiMcpServer {
   enabled: boolean;
   toolAllowlist: string[] | null;
   hasHeaders: boolean;
-  // Admin-authored guidance injected into the agent system prompt (#180).
-  // NON-secret, so it IS returned. Null when no guidance is configured.
-  instructions: string | null;
 }
 
 // Create payload. `headers` is write-only: omit => no auth headers.
@@ -28,8 +25,6 @@ export interface IAiMcpServerCreate {
   // never returned.
   headers?: Record<string, string>;
   toolAllowlist?: string[];
-  // Admin-authored prompt guidance (#180). Blank => stored as null.
-  instructions?: string;
   enabled?: boolean;
 }
 
@@ -44,8 +39,6 @@ export interface IAiMcpServerUpdate {
   url?: string;
   headers?: Record<string, string>;
   toolAllowlist?: string[];
-  // Admin-authored prompt guidance (#180). Absent => unchanged; blank => cleared.
-  instructions?: string;
   enabled?: boolean;
 }
 

apps/client/src/features/workspace/services/ai-settings-service.ts

@@ -9,12 +9,6 @@ export type AiDriver = "openai" | "gemini" | "ollama";
 //   - 'json'      -> JSON body with base64-encoded audio (OpenRouter)
 export type SttApiStyle = "multipart" | "json";
 
-// Chat provider implementation for the `openai` driver (chosen explicitly):
-//   - 'openai-compatible' -> maps streamed reasoning_content to reasoning parts
-//     (z.ai/GLM, DeepSeek, OpenRouter, ...). Default.
-//   - 'openai'            -> official provider; real-OpenAI reasoning-model shaping.
-export type ChatApiStyle = "openai-compatible" | "openai";
-
 // Masked AI provider settings returned by the server.
 // No API key is ever returned; only `hasApiKey` / `hasEmbeddingApiKey` indicate
 // whether one is stored. `embeddingBaseUrl` is the RAW stored value (empty means
@@ -22,9 +16,6 @@ export type ChatApiStyle = "openai-compatible" | "openai";
 export interface IAiSettings {
   driver?: AiDriver;
   chatModel?: string;
-  // Max context window in tokens shown in the chat header badge; 0/unset = no limit.
-  chatContextWindow?: number;
-  chatApiStyle?: ChatApiStyle;
   // Cheap model id for the anonymous public-share assistant; empty = chatModel.
   publicShareChatModel?: string;
   // Agent-role id whose persona the public-share assistant adopts; empty =
@@ -58,9 +49,6 @@ export interface IAiSettings {
 export interface IAiSettingsUpdate {
   driver?: AiDriver;
   chatModel?: string;
-  // Max context window in tokens for the chat header badge; 0 = clear the limit.
-  chatContextWindow?: number;
-  chatApiStyle?: ChatApiStyle;
   publicShareChatModel?: string;
   // Agent-role id whose persona the public-share assistant adopts; empty =
   // built-in locked persona.

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

@@ -20,6 +20,7 @@ export interface IWorkspace {
   plan?: string;
   enforceMfa?: boolean;
   aiSearch?: boolean;
+  generativeAi?: boolean;
   disablePublicSharing?: boolean;
   mcpEnabled?: boolean;
   aiChat?: boolean;
@@ -27,8 +28,6 @@ export interface IWorkspace {
   aiDictationStreaming?: boolean;
   aiPublicShareAssistant?: boolean;
   trashRetentionDays?: number;
-  // Default lifetime (HOURS) for new temporary notes; frozen per-note at creation.
-  temporaryNoteHours?: number;
   restrictApiToAdmins?: boolean;
   allowMemberTemplates?: boolean;
   isScimEnabled?: boolean;
@@ -60,6 +59,7 @@ export interface IWorkspaceApiSettings {
 
 export interface IWorkspaceAiSettings {
   search?: boolean;
+  generative?: boolean;
   mcp?: boolean;
   chat?: boolean;
   dictation?: boolean;

apps/client/src/pages/settings/workspace/workspace-settings.tsx

@@ -3,7 +3,6 @@ import WorkspaceNameForm from "@/features/workspace/components/settings/componen
 import WorkspaceIcon from "@/features/workspace/components/settings/components/workspace-icon.tsx";
 import HtmlEmbedSettings from "@/features/workspace/components/settings/components/html-embed-settings.tsx";
 import TrackerSettings from "@/features/workspace/components/settings/components/tracker-settings.tsx";
-import TemporaryNoteSettings from "@/features/workspace/components/settings/components/temporary-note-settings.tsx";
 import { useTranslation } from "react-i18next";
 import { getAppName } from "@/lib/config.ts";
 import { Helmet } from "react-helmet-async";
@@ -20,7 +19,6 @@ export default function WorkspaceSettings() {
       <WorkspaceNameForm />
       <HtmlEmbedSettings />
       <TrackerSettings />
-      <TemporaryNoteSettings />
     </>
   );
 }