fix(cli): don't crash session hydration on a tool_call missing its function

Resuming a session (reasonix code) whose persisted assistant message holds a
tool_call without a function — e.g. a streaming delta saved before its function
landed — threw "Cannot read properties of undefined (reading 'arguments')" in
hydrateCardsFromMessages, taking down the whole UI at startup. Skip the partial
tool_call; the orphaned tool-output message already no-ops when its card is
absent.

.env.example

@@ -1,4 +1,10 @@
 DEEPSEEK_API_KEY=sk-your-key-here
 DEEPSEEK_BASE_URL=https://api.deepseek.com
+# DEEPSEEK_API_BASE_URL is accepted as an alias of DEEPSEEK_BASE_URL.
 REASONIX_LOG_LEVEL=INFO
 REASONIX_TRANSCRIPT_DIR=./transcripts
+
+# Optional Telegram remote channel
+# TELEGRAM_BOT_TOKEN=123456:botfather-token
+# TELEGRAM_OWNER_USER_ID=123456789
+# TELEGRAM_ALLOWLIST=123456789,987654321

.github/FUNDING.yml

@@ -1 +1,3 @@
 github: esengine
+custom:
+  - https://paypal.me/yuhuahui

.github/workflows/ci.yml

@@ -33,6 +33,9 @@ jobs:
       - name: Typecheck
         run: npm run typecheck
 
+      - name: Build (tsup + dashboard)
+        run: npm run build
+
       - name: Test (vitest + coverage)
         run: npm run test:coverage
 
@@ -40,9 +43,6 @@ jobs:
         if: always()
         run: node scripts/coverage-summary.mjs
 
-      - name: Build (tsup)
-        run: npm run build
-
       # Smoke-test the bench harnesses themselves. --dry skips all LLM
       # calls, so this catches wiring regressions (task factories, CLI
       # parsing, file IO, checker determinism) without needing a
@@ -51,25 +51,14 @@ jobs:
       - name: τ-bench harness dry-run
         run: npx tsx benchmarks/tau-bench/runner.ts --dry --out "${{ runner.temp }}/tau-dry.json"
 
-  rust:
-    name: rust (ubuntu-latest)
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup Rust (stable)
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          components: rustfmt, clippy
-
-      - name: Cargo cache
-        uses: Swatinem/rust-cache@v2
-
-      - name: rustfmt
-        run: cargo fmt --all -- --check
-
-      - name: clippy
-        run: cargo clippy --all-targets -- -D warnings
-
-      - name: cargo test
-        run: cargo test --manifest-path Cargo.toml
+      - name: Notify Discord on main failure
+        if: failure() && github.event_name == 'push' && github.ref == 'refs/heads/main'
+        shell: bash
+        env:
+          WEBHOOK_URL: ${{ secrets.DISCORD_CI_WEBHOOK }}
+        run: |
+          test -n "$WEBHOOK_URL" || { echo "DISCORD_CI_WEBHOOK unset, skipping"; exit 0; }
+          RUN_URL="${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}"
+          curl -sS -X POST -H "Content-Type: application/json" \
+            -d "{\"content\":\"❌ CI failed on \`${{ github.ref_name }}\` (${{ matrix.os }}) — ${{ github.actor }}\n${RUN_URL}\"}" \
+            "$WEBHOOK_URL"

.github/workflows/publish-dsnix.yml

@@ -0,0 +1,63 @@
+name: Publish dsnix
+
+# Tag namespace: `dsnix-v<semver>` triggers npm publish for the
+# dsnix shim package only. Plain `v<semver>` tags publish the main
+# `reasonix` CLI (see publish-npm.yml); the two are decoupled so the
+# alias can be released independently when the shim itself changes.
+on:
+  push:
+    tags: ["dsnix-v*"]
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Tag to publish (e.g. dsnix-v0.48.0). Required when running manually."
+        required: true
+        type: string
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    name: publish dsnix to npm
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.inputs.tag || github.ref }}
+
+      - name: Setup Node 22
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+          cache: npm
+          registry-url: https://registry.npmjs.org/
+
+      - name: Verify tag matches packages/dsnix/package.json version
+        shell: bash
+        run: |
+          tag="${{ github.event.inputs.tag || github.ref_name }}"
+          tag_version="${tag#dsnix-v}"
+          pkg_version=$(node -p "require('./packages/dsnix/package.json').version")
+          if [ "$tag_version" != "$pkg_version" ]; then
+            echo "::error::tag $tag (version $tag_version) does not match packages/dsnix/package.json version $pkg_version"
+            exit 1
+          fi
+          echo "tag $tag matches packages/dsnix/package.json $pkg_version"
+
+      - name: Verify reasonix@<version> is already published on npm
+        shell: bash
+        run: |
+          dep_version=$(node -p "require('./packages/dsnix/package.json').dependencies.reasonix")
+          if ! npm view "reasonix@${dep_version}" version >/dev/null 2>&1; then
+            echo "::error::dsnix depends on reasonix@${dep_version} but that version is not published yet"
+            exit 1
+          fi
+          echo "reasonix@${dep_version} is published — safe to publish dsnix"
+
+      - name: Publish dsnix to npm
+        run: npm publish --access public
+        working-directory: packages/dsnix
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/publish-npm.yml

@@ -0,0 +1,66 @@
+name: Publish npm
+
+# Tag namespace: plain `v<semver>` triggers npm publish for the
+# reasonix CLI package. Desktop Tauri releases use `desktop-v*`
+# (see release.yml) — pushing one of those never reaches this
+# workflow, so the two release tracks are fully decoupled.
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Tag to publish (e.g. v0.47.0). Required when running manually."
+        required: true
+        type: string
+
+permissions:
+  contents: read
+  # `id-token: write` is the npm provenance handshake — harmless if we
+  # don't enable provenance, required if we ever do.
+  id-token: write
+
+jobs:
+  publish:
+    name: publish to npm
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          # workflow_dispatch lets a maintainer publish an older tag
+          # without re-pushing it; tag pushes already point HEAD at the
+          # right ref so the fallback is a no-op.
+          ref: ${{ github.event.inputs.tag || github.ref }}
+
+      - name: Setup Node 22
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+          cache: npm
+          registry-url: https://registry.npmjs.org/
+
+      # Fail-fast if someone tags without bumping package.json. npm itself
+      # would reject the duplicate publish, but the error there is
+      # opaque ("403 You cannot publish over the previously published
+      # versions") and CI is the place to catch it cleanly.
+      - name: Verify tag matches package.json version
+        shell: bash
+        run: |
+          tag="${{ github.event.inputs.tag || github.ref_name }}"
+          tag_version="${tag#v}"
+          pkg_version=$(node -p "require('./package.json').version")
+          if [ "$tag_version" != "$pkg_version" ]; then
+            echo "::error::tag $tag (version $tag_version) does not match package.json version $pkg_version"
+            exit 1
+          fi
+          echo "tag $tag matches package.json $pkg_version"
+
+      - name: Install dependencies
+        run: npm ci
+
+      # `npm publish` runs the prepublishOnly hook (lint + typecheck +
+      # test + build) automatically, so no separate verify step here.
+      - name: Publish to npm
+        run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/release-mirror.yml

@@ -41,6 +41,35 @@ jobs:
             -R "${{ github.repository }}" \
             -D assets
 
+      # Rewrite bundle URLs inside latest.json (Tauri updater manifest)
+      # so the desktop pulls bundles from R2, not GitHub. Without this the
+      # updater fetches the small JSON from R2 but still downloads the
+      # heavy installer from github.com — defeating the mirror.
+      # No-op when latest.json is absent (CLI-only releases).
+      - name: Rewrite latest.json URLs → R2
+        if: env.HAS_R2 == 'true'
+        env:
+          R2_PUBLIC_BASE: https://pub-147fb53b9c1e4bbf891a257968619ea7.r2.dev
+          TAG: ${{ steps.tag.outputs.name }}
+        run: |
+          file=assets/latest.json
+          if [ ! -f "$file" ]; then
+            echo "no latest.json in release — skipping rewrite"
+            exit 0
+          fi
+          # GitHub URLs look like:
+          #   https://github.com/<owner>/<repo>/releases/download/<TAG>/<file>
+          # Rewrite to:
+          #   <R2_PUBLIC_BASE>/<TAG>/<file>
+          jq --arg base "$R2_PUBLIC_BASE" --arg tag "$TAG" '
+            .platforms |= with_entries(
+              .value.url |= sub("https://github.com/[^/]+/[^/]+/releases/download/[^/]+/"; "\($base)/\($tag)/")
+            )
+          ' "$file" > "$file.new"
+          mv "$file.new" "$file"
+          echo "rewrote latest.json:"
+          cat "$file"
+
       - name: Configure AWS CLI for R2
         if: env.HAS_R2 == 'true'
         run: |

.github/workflows/release-render.yml

@@ -1,161 +0,0 @@
-name: Release render binaries
-
-on:
-  push:
-    tags: ["v*"]
-  workflow_dispatch:
-    inputs:
-      tag:
-        description: "Tag to publish (e.g. v0.44.0). Required when running manually."
-        required: true
-        type: string
-
-permissions:
-  contents: read
-  id-token: write
-
-jobs:
-  build:
-    name: build (${{ matrix.target.label }})
-    strategy:
-      fail-fast: false
-      matrix:
-        target:
-          - { label: "win32-x64",    rust: "x86_64-pc-windows-msvc",      os: "windows-latest", bin: "reasonix-render.exe" }
-          - { label: "linux-x64",    rust: "x86_64-unknown-linux-gnu",    os: "ubuntu-22.04",   bin: "reasonix-render" }
-          - { label: "linux-arm64",  rust: "aarch64-unknown-linux-gnu",   os: "ubuntu-22.04",   bin: "reasonix-render", cross: true }
-          # darwin-x64 cross-built from Apple Silicon — GH's macos-13 Intel pool was retired
-          # in 2025 and queues run to hours. rustc on macos-14 supports x86_64-apple-darwin
-          # natively via the `targets:` install; no codesign or runtime needed at build time.
-          - { label: "darwin-x64",   rust: "x86_64-apple-darwin",         os: "macos-14",       bin: "reasonix-render" }
-          - { label: "darwin-arm64", rust: "aarch64-apple-darwin",        os: "macos-14",       bin: "reasonix-render" }
-    runs-on: ${{ matrix.target.os }}
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup Rust (${{ matrix.target.rust }})
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: ${{ matrix.target.rust }}
-
-      - name: Install cross-compile linker (linux-arm64 only)
-        if: matrix.target.label == 'linux-arm64'
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y gcc-aarch64-linux-gnu
-
-      - name: Rust cache
-        uses: Swatinem/rust-cache@v2
-        with:
-          key: render-${{ matrix.target.label }}
-
-      - name: Build reasonix-render
-        env:
-          CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER: aarch64-linux-gnu-gcc
-        run: cargo build --release --target ${{ matrix.target.rust }} --bin reasonix-render
-
-      - name: Stage subpackage binary
-        shell: bash
-        run: |
-          mkdir -p subpackages/render-${{ matrix.target.label }}/bin
-          cp target/${{ matrix.target.rust }}/release/${{ matrix.target.bin }} subpackages/render-${{ matrix.target.label }}/bin/${{ matrix.target.bin }}
-
-      - name: Upload subpackage artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: subpackage-${{ matrix.target.label }}
-          path: subpackages/render-${{ matrix.target.label }}/
-          if-no-files-found: error
-          retention-days: 7
-
-  publish:
-    name: publish
-    needs: build
-    runs-on: ubuntu-22.04
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Resolve tag
-        id: tag
-        shell: bash
-        run: |
-          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            raw="${{ inputs.tag }}"
-          else
-            raw="${GITHUB_REF_NAME}"
-          fi
-          # Strip leading v so npm sees a clean SemVer.
-          version="${raw#v}"
-          echo "version=${version}" >> "$GITHUB_OUTPUT"
-          # Prereleases (0.44.0-rc.1, 0.44.0-beta.2, ...) ship under
-          # dist-tag 'next' so `npx reasonix@latest` keeps pointing at
-          # the most recent stable. Stable versions get 'latest' (npm's
-          # default — leave the flag empty).
-          if [[ "$version" == *-* ]]; then
-            echo "dist_tag=next" >> "$GITHUB_OUTPUT"
-          else
-            echo "dist_tag=latest" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: Setup Node 22
-        uses: actions/setup-node@v4
-        with:
-          node-version: "22"
-          registry-url: "https://registry.npmjs.org"
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Sync subpackage + optionalDependencies versions to tag
-        run: node scripts/sync-render-versions.mjs ${{ steps.tag.outputs.version }}
-
-      - name: Verify versions are in sync
-        run: node scripts/sync-render-versions.mjs --check
-
-      - name: Download all subpackage artifacts
-        uses: actions/download-artifact@v4
-        with:
-          path: artifacts/
-
-      - name: Stage subpackage binaries back into tree
-        shell: bash
-        run: |
-          for d in artifacts/subpackage-*; do
-            label="${d#artifacts/subpackage-}"
-            mkdir -p subpackages/render-${label}/bin
-            cp -r "$d"/bin/* subpackages/render-${label}/bin/
-          done
-          # actions/download-artifact@v4 strips Unix file modes — restore +x
-          # on the non-Windows binaries so users hitting them via spawn() (not
-          # via npm's bin symlink) don't EACCES. The bin field in each
-          # subpackage's package.json is a second layer for the normal
-          # install path.
-          for bin in subpackages/render-{linux,darwin}-*/bin/reasonix-render; do
-            [ -f "$bin" ] && chmod +x "$bin"
-          done
-          ls -la subpackages/*/bin/
-
-      - name: Build main package dist/
-        run: npm run build
-
-      - name: Publish subpackages
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-        shell: bash
-        run: |
-          set -e
-          for d in subpackages/render-*; do
-            echo "↑ publishing $d under dist-tag ${{ steps.tag.outputs.dist_tag }}"
-            (cd "$d" && npm publish --access public --provenance --tag ${{ steps.tag.outputs.dist_tag }} --ignore-scripts)
-          done
-
-      - name: Publish main reasonix package
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-        # --ignore-scripts: the explicit `npm run build` step above already
-        # produces dist/, and CI's build job already ran the full test +
-        # typecheck + lint matrix on every push. Re-running prepublishOnly's
-        # entire pipeline here just doubles latency and re-exposes us to
-        # flaky tests (ink stdout rendering, etc.) that have nothing to do
-        # with publishability.
-        run: npm publish --access public --provenance --tag ${{ steps.tag.outputs.dist_tag }} --ignore-scripts

.github/workflows/release.yml

@@ -1,12 +1,16 @@
-name: Release
+name: Release desktop
 
+# Tag namespace: `desktop-v<semver>` triggers desktop Tauri bundles.
+# Plain `v<semver>` tags are reserved for the npm CLI release (see
+# publish-npm.yml) — they intentionally do NOT trigger this workflow.
+# Bump the desktop with: `git tag desktop-vX.Y.Z && git push origin desktop-vX.Y.Z`.
 on:
   push:
-    tags: ["v*"]
+    tags: ["desktop-v*"]
   workflow_dispatch:
     inputs:
       tag:
-        description: "Tag to publish (e.g. v0.40.0). Required when running manually."
+        description: "Tag to publish (e.g. desktop-v0.47.0). Required when running manually."
         required: true
         type: string
 
@@ -20,13 +24,11 @@ jobs:
       fail-fast: false
       matrix:
         target:
-          # `rust` is the comma-separated list installed by dtolnay/rust-toolchain;
-          # `tauri` is what we pass to `cargo tauri build --target`. They differ
-          # only for the universal Mac shard, which produces one fat binary from
-          # two real Rust targets via lipo. Intel-only macos-13 runner is dropped
-          # — GH retired most of that pool, queue waits ran to hours.
+          # macOS now ships two single-arch shards so Apple Silicon and Intel
+          # users get separate DMGs. `rust` and `tauri` stay aligned per shard.
           - { os: ubuntu-22.04, label: "linux-x64", rust: "x86_64-unknown-linux-gnu", tauri: "x86_64-unknown-linux-gnu" }
-          - { os: macos-14, label: "macos-universal", rust: "aarch64-apple-darwin,x86_64-apple-darwin", tauri: "universal-apple-darwin" }
+          - { os: macos-15-intel, label: "macos-x64", rust: "x86_64-apple-darwin", tauri: "x86_64-apple-darwin" }
+          - { os: macos-14, label: "macos-arm64", rust: "aarch64-apple-darwin", tauri: "aarch64-apple-darwin" }
           - { os: windows-latest, label: "windows-x64", rust: "x86_64-pc-windows-msvc", tauri: "x86_64-pc-windows-msvc" }
     runs-on: ${{ matrix.target.os }}
     # secrets.* isn't accessible from step-level if:, so expose presence as a
@@ -92,6 +94,28 @@ jobs:
         working-directory: desktop
         run: npm run bundle:node
 
+      - name: Verify bundled Node matches host arch (macOS)
+        if: startsWith(matrix.target.os, 'macos-')
+        working-directory: desktop
+        run: |
+          expected_arch=$(uname -m)
+          archs=$(lipo -archs src-tauri/binaries/node)
+          echo "node archs: $archs"
+          echo "expected arch: $expected_arch"
+          if [ "$archs" != "$expected_arch" ]; then
+            echo "Expected $expected_arch Node, got: $archs" >&2
+            exit 1
+          fi
+          codesign -d --entitlements :- src-tauri/binaries/node 2>&1 | grep -q "com.apple.security.inherit"
+
+      - name: Build & verify desktop frontend
+        working-directory: desktop
+        shell: bash
+        run: |
+          npm run build
+          test -f dist/index.html
+          ls dist/assets/*.js >/dev/null
+
       # tauri-action signs OS bundles whenever the corresponding env vars are
       # defined — including when they're defined to the empty string, which is
       # what `secrets.UNSET` evaluates to. Gate each signing block on its
@@ -151,3 +175,13 @@ jobs:
           releaseDraft: true
           prerelease: false
           args: --target ${{ matrix.target.tauri }}
+
+      - name: Verify app Node inherits TCC grants (macOS)
+        if: startsWith(matrix.target.os, 'macos-')
+        working-directory: desktop
+        shell: bash
+        run: |
+          node_bin=$(find src-tauri/target -path '*/release/bundle/macos/*.app/Contents/Resources/node' -type f | head -n 1)
+          test -n "$node_bin"
+          codesign -vvv --strict "$node_bin"
+          codesign -d --entitlements :- "$node_bin" 2>&1 | grep -q "com.apple.security.inherit"

.gitignore

@@ -25,12 +25,15 @@ sessions/
 .turbo/
 # Local-only Claude Code settings — personal overrides, never committed.
 .claude/settings.local.json
+# Local agent notes — personal workflow reminders, never committed.
+agent.md
 # Per-user Reasonix state under .reasonix/ — committable team-level
 # files (settings.json, skills/) stay tracked, but the user-private
 # bits (semantic index, sessions, opt-out markers) never should.
 .reasonix/semantic/
 .reasonix/sessions/
 .reasonix/semantic-skip
+.reasonix/truncated-results/
 # Scratch entry regenerated each time scripts/bundle-codemirror.mjs runs.
 scripts/.cm-entry.mjs
 # Personal bun lockfile — project uses npm officially.
@@ -45,9 +48,8 @@ desktop/src-tauri/target/
 desktop/src-tauri/gen/
 desktop/src-tauri/binaries/
 
-# Cargo build artifacts for the workspace at the repo root.
-/target/
-
 # Design mock-up reference (local, not part of repo)
 .design-ref/
 *.cpuprofile
+
+.probe-snapshots/

CHANGELOG.md

@@ -3,6 +3,724 @@
 All notable changes to Reasonix. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/);
 this project uses [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.52.0] — 2026-05-26
+
+**Ink renderer in-tree as `@esengine/ink`.** The vendored Ink fork now
+lives as a workspace package (#1847), unblocking TUI-specific
+renderer tweaks (focus, IME, Static append) without forking upstream.
+TUI polish lands on top: guard ASCII IME enter commits so JP/CN IME
+atomic commits don't double-submit (#1874), preserve undo state across
+session context switches (#1810), incremental repaint coverage
+(#1873).
+
+**Desktop — clipboard image paste.** Paste screenshots / copied images
+directly into the composer (#1889); paste path hardened against
+oversized + non-image clipboard payloads (#1897). Sessions exported by
+other local AI apps can be imported into Reasonix (#1894).
+
+**Desktop — JumpBar polish + drag perf.** JumpBar now highlights the
+active message bar and follows the latest one as the thread grows
+(#1813); dot styling pulled into a shared helper (#1892). Sidebar drag
+writes CSS vars directly to the DOM with `content-visibility` on
+messages (#1812) and unit-suffixes the vars to dodge a Chromium
+recompute storm (#1875).
+
+**Desktop — smaller fixes.**
+- Search-engine API key UI + slash command interception (#1867)
+- Mention `@` popup stays stable while filtering (#1850); split
+  kind/length effects in the popup (#1859)
+- Update banner floats above the thread instead of pushing layout
+  (#1865)
+- `memoryDetail` / `onReadMemory` wired through test fixtures so the
+  desktop memory browser is exercisable in unit tests
+
+**Config — base URL + proxy.** `DEEPSEEK_API_BASE_URL` accepted as an
+env alias to the existing base-url override (#1876, #1887), and
+`proxy.url` is now a first-class field in `config.json` (#1881). MCP
+`initialize` no longer leaks LSP-only fields that some servers reject
+(#1861).
+
+**Providers.** Ollama usage parsing tolerates the field-name variants
+recent Ollama versions emit (#1886).
+
+**i18n.**
+- Russian (`ru`) language pack added (#1879)
+- German corrections — capitalization, terminology, coverage (#1878)
+- `/qq` command hints + argsHint localized; English fallback for
+  zh-CN (#1857, #1862)
+
+**Dashboard / UI.**
+- Sync TUI and Web modal state so confirm gate doesn't desync between
+  surfaces (#1831, #1866)
+- Highlight active plan edit mode (#1863)
+- `useEditHistory` no longer re-exports undo-context through itself
+  (#1854)
+
+## [0.51.0] — 2026-05-25
+
+**First paint — session restore 4.5s → 430ms.** Progressive `<Static>`
+mount streams scrollback in chunks instead of mounting the full history
+synchronously (#1761). Combined with index-backed `mutateCard` + O(n)
+`plan.drop` + cursor elide (#1769) and the bump to `[email protected]` (which
+ships the flicker fix we'd been carrying as a patch — patch-package
+machinery is gone, #1809), large session restores no longer block the
+event loop on startup.
+
+**Perf — tokenizer + markdown + search.** BPE tokenizer caches its
+table + bounds per-content counts with a fast-path truncate (#1741),
+so long sessions don't re-tokenize the world on every turn. CodeBlock
+syntax highlight is memoized (#1743). Literal-pattern search bypasses
+the regex worker entirely (#1748). Windows terminal repaint cadence is
+throttled (#1750) and a BEL → ST swap on Windows stdout stops `cmd.exe`
+from beeping on every render frame (#1795).
+
+**Cross-platform robustness.**
+- `EXDEV` fallback for atomic config writes on OneDrive / NTFS reparse
+  points (#1778) — config saves no longer fail on Windows + cloud-sync
+- Apple Terminal mouse-reset crash guarded (#1764); legacy X10 mouse
+  reports without ESC are dropped (#1723); `ESC`-less CSI recovery is
+  refused when followed by typed text (#1771)
+- CLI startup gates on unsupported Node versions with a clear error
+  instead of crashing in the middle of bootstrap (#1757)
+- Desktop bundled Node inherits parent TCC grants on macOS (#1749) so
+  file / microphone permission prompts attach to the app, not the helper
+- Crash-safe atomic rename for edit-block writes (#1721); completed
+  plans archive instead of persisting across sessions (#1700)
+- `.devenv` and `.direnv` are skipped by glob / search / directory_tree (#1706)
+
+**Memory — CLAUDE.md import for Claude Code migration.** Loading
+`CLAUDE.md` and `~/.claude/CLAUDE.md` alongside the existing
+`REASONIX.md` (#1694) lets Claude Code users carry their project /
+user memory directly into Reasonix without rewriting it.
+
+**i18n — German.** Full German (`de`) locale added (#1773) with a
+follow-up correction pass (#1797).
+
+**Desktop polish.**
+- JumpBar message navigation dock (#1725, #1729)
+- File-change summary card after each assistant turn (#1691)
+- Self-heal stale model id; expose plan as 4th editMode (#1699)
+- Restore aborted prompt drafts on relaunch (#1693)
+- Recalc thread width on resize (#1789); right panel scrollbar
+  draggable (#1765); contain long MCP spec strings (#1736)
+- Sync slash setting commands across surfaces (#1724)
+- Surface desktop startup failures instead of silent exit (#1759)
+
+**TUI polish.**
+- Plan-mode `[PLAN]` / `[计划]` badge in input bar (#1742)
+- Forward-delete for `Delete` key (#1735)
+- IME candidate window cursor alignment (#1754)
+- Coalesce prompt cursor sync to reduce flicker (#1768)
+- Demote stuck `running` plan step on turn end (#1784)
+- Hide `max` effort on non-DeepSeek endpoints (#1798)
+- Drop stale "press Cmd-C to copy" startup hint (#1692)
+
+**Dashboard / web mode.**
+- Bootstrap mcp / skills / memory panels in web mode (#1775)
+- Expose new memory browser to web (#1779)
+- Replay active modal on SSE connect so confirm gate isn't stuck (#1770)
+- Restore scroll and memory visibility (#1766)
+- Docs responsive spacing polish (#1785)
+
+**Smaller fixes.**
+- Preserve full tool results when truncated (#1615)
+- Trim long-session retained payloads to bound memory growth (#1799)
+- Drain steer queue on `/new` + `/cwd` so prior intent doesn't leak (#1774)
+- Suppress DeepSeek-specific 5xx hints when host isn't DeepSeek (#1716)
+- `normalizeSemanticEmbeddingUserConfig` preserves `timeoutMs` (#1788)
+- `REASONIX_ACP_SYSTEM_APPEND` env var for system-prompt injection (#1737)
+- Configurable cost-display currency with click-to-toggle (#1710)
+
+**Refactors / internals.**
+- Extract `LruCache` + `TtlLruCache` + `lazy()` helpers from ad-hoc
+  duplicates (#1746)
+- Split stream aggregator + chunked dispatch out of `step()` (#1739)
+- Per-component render trace gated by `REASONIX_TRACE_RENDERS` (#1747);
+  `readStats` API on render trace + real-numbers large-session probe (#1751)
+
+## [0.50.1] — 2026-05-24
+
+**Install fix — `postinstall` no longer crashes on `npx`.** The
+`postinstall` hook added in 0.50.0 (#1584) ran `npm ci` inside
+`dashboard/` and `desktop/` to set up the dev workspace, but those
+directories aren't shipped in the published tarball. Result: `npx
+reasonix@0.50.0 code` failed during install with a `dashboard/package.json
+not found` error and the CLI never started. `postinstall` now delegates
+to `scripts/postinstall.mjs`, which exits 0 when `dashboard/package.json`
+is missing (i.e. anywhere except a git checkout). 0.50.0 is deprecated
+on npm.
+
+## [0.50.0] — 2026-05-24
+
+**Desktop dashboard — unified on the CLI-hosted React surface.** The
+old Tauri+Preact dashboard inside the desktop bundle is gone (#1418).
+Desktop now embeds the same CLI-hosted dashboard the browser surface
+already uses, so there's one React app rendering chat across all
+three surfaces (CLI, browser, desktop) instead of two divergent
+implementations drifting apart. Cuts the duplicate rendering paths
+that caused tool cards, code blocks, and compacted history to look
+subtly different depending on where you opened the same session.
+
+**Presets — flash/pro are the only knobs now.** The preset abstraction
+is removed (#1657, #1630): config now exposes `model` + `effort`
+directly instead of indirecting through `preset: auto | flash | pro`.
+The `/pro` switch is dropped too — flash and pro remain as direct
+model selections. Per-skill flash/pro override lands with a Settings
+UI (#1632) so subagents can opt into a heavier model without
+reconfiguring the parent.
+
+**Cumulative usage stats — persisted + auto-restored.** Session token
+totals and accumulated cost now write to the session meta on each
+turn and reload on startup (#1667, #1680 follow-up). Cost telemetry
+survives a CLI restart or desktop relaunch instead of resetting to
+zero, and the context-size readout shows the current window, not the
+all-time cumulative cache count (#1643). `SessionStats` caps at 200
+turns with cost carryover so long-lived sessions don't unbound (#1628).
+
+**Plans — `editMode="plan"` enforced at the dispatch gate.** Plan
+mode now blocks write tools at the `ToolRegistry` dispatch layer
+(#1681), not as a per-tool soft check. Plan steps also advance
+correctly when intermediate actions are skipped (#1629), so the
+"current step" indicator no longer stalls on a step the model already
+completed.
+
+**Context — fold once at turn start.** The pre-flight fold pass is
+gone — context folding now happens once at the start of each turn
+instead of being threaded through mid-turn checks (#1642, #1646). The
+obsolete byte-ceiling check is dropped too. Compacted history renders
+as a single collapsible card on all three surfaces (#1649), so the
+fold is visible without dominating the scrollback.
+
+**Desktop polish.**
+- Draggable sidebar resize + responsive conversation panel width (#1688)
+- Responsive sidebar collapse on narrow windows (#1585)
+- Copy/edit overlay, message-history navigation, IME guard, card collapse (#1645)
+- `Esc` closes the open modal instead of aborting the model turn (#1685)
+- QQ turn routing isolated by tab so cross-tab messages don't bleed (#1672)
+- Discard explicitly aborted turns instead of replaying them on resume (#1687)
+- Render `edit_file` / `multi_edit` results as DiffCard, matching CLI (#1662)
+- Code-block syntax highlighting follows light/dark theme (#1655)
+- System events surface as a show/hide toggle (#1654, #1650)
+- File paths + completion feedback surface in tool results (#1644)
+- Block right-click context menu in release builds (#1641)
+- Preserve code operators when rendering inline code (#1640)
+- Compact composer default preserved across relaunches (#1594)
+- Stale events no longer corrupt UI after a session switch (#1582)
+- macOS bundled Node inherits parent TCC grants so file/microphone
+  permission prompts attach to the desktop app, not the helper (#1614)
+- New `dashboard.enabled` config to suppress auto-start when the
+  dashboard isn't wanted (#1612)
+- Localize edit approval/discard messages + event errors with zh-CN (#1617)
+
+**Dashboard polish.**
+- Persistent active-session URL — shareable + refresh-safe (#1586,
+  #1589, #1599)
+- Code-block syntax highlighting follows light/dark theme (#1664)
+- IME confirm-enter no longer submits mid-composition (#1689)
+- Code-fence language detection fix mirrored from desktop (#1677, #1661)
+- Heavy vendor libs split into separate chunks for faster cold load (#1587)
+- Tool cards no longer stuck spinning when the turn ends without an
+  explicit completion event (#1676)
+- Markdown tables get a horizontal scrollbar instead of overflowing
+  the chat column (#1562)
+- Search-engine switcher restored in dashboard + desktop settings (#1618)
+- Composer queue-count label was reading the wrong variable name (#1674)
+- Long file paths stop stretching the chat bubble width (#1590)
+- Don't synthesize `$turn_complete` from per-iter `assistant_final` —
+  let the real completion event fire (#1673)
+
+**TUI.**
+- New `Alt+S` hotkey stashes the current input buffer and recalls it
+  later, like a one-slot clipboard for the composer
+- Static history is isolated from input re-renders, so typing during
+  a model turn doesn't repaint the whole scrollback (#1635)
+- Legacy mouse reports (X10) are dropped so terminals that emit them
+  by default no longer flood the input stream (#1637, #1648)
+- `multi_edit` is gated in review mode to match the single-edit
+  approval flow (#1647)
+- Shell command failure output is surfaced to the user instead of
+  silently truncated (#1608)
+
+**Diff rendering — CJK column-border alignment.** `SplitDiff` no
+longer misaligns the column border when CJK characters appear in
+either side of the diff (#1686). The width math now accounts for
+double-width graphemes when laying out the gutter.
+
+**Subagents — per-skill model override.** Each named skill
+(`/explore`, `/research`, `/review`, `/security-review`) can now
+override flash/pro independently (#1632), with a Settings UI to
+manage the overrides. Defaults flow from the parent session.
+
+**MCP.**
+- Workspace roots are passed to MCP servers on connect (#1625), so
+  servers that scope by root see the right project
+- `codeCommand` honors the full `normalizeMcpConfig` pipeline including
+  inline `mcpServers` blocks (#1603, follow-up to #1568)
+
+**Config.**
+- `(baseUrl, apiKey)` is resolved as a tuple instead of two
+  independent fields (#1658), so a partial override on one no longer
+  silently falls through to the env value of the other
+- Stale model IDs self-heal on load; v3 IDs are dropped from the
+  picker fallback list (#1663)
+- Theme rename follow-up from #1666 closes out the prompt-input + user
+  card token migration (#1678, #1666, #1623)
+
+**Memory.** `JobRegistry` self-cleans entries for completed jobs
+(#1620), so long sessions don't accumulate dead job records that
+never release their references.
+
+**Other.**
+- `chore(loop)` drop redundant abort warning, keep only the synthetic
+  final event (#1659)
+- `chore(theme)` finish theme rename follow-up after #1666 (#1678)
+- `chore(ui)` drop redundant `overflow-wrap` from inherited
+  descendants (#1675)
+- `fix(presets)` drop stale "5/31 discount" framing in pro cost copy
+  (#1583)
+- `chore(install)` include desktop deps in root postinstall (#1584)
+- `test(lifecycle)` cover deterministic policy corpus + npm package
+  aliases (#1574, #1621)
+
+## [0.49.0] — 2026-05-22
+
+**TUI — Static-history renderer.** The history pane is now rendered
+exclusively through Ink's `<Static>` (#1529, stages 1–4). The previous
+virtual-viewport machinery — viewport-budget row allocator, byte-virtual
+frame layer, manual scroll math — is gone. Net: less code on the hot
+path, no more "frame drift" on very long sessions, and the rewrite stays
+Ink-native instead of fighting it. Behind `REASONIX_STATIC_HISTORY` at
+stage 1, default-on by stage 2, scaffolding removed by stage 4.
+
+**Chat — queued mid-turn steers.** Typing while the model is mid-turn
+no longer fights the live render or drops the keystroke. New input
+queues, surfaces a small "queued" hint, and feeds into the next user
+turn cleanly (#1501). Pairs with the static-history switch so the
+queued line stays visible across re-renders.
+
+**Web search — Bing default, dashboard engine switcher.** Default web
+backend switches from Mojeek to Bing (#1558); the dashboard gains a
+visible engine switcher so you can flip between configured backends
+without editing config. Mojeek is dropped from the bundled set entirely
+in this release.
+
+**Plans — lifecycle evidence summaries.** Plan acceptance now surfaces
+the evidence captured at each lifecycle step (#1500), so the "why this
+plan is ready to accept" question has a structured answer instead of
+implicit trust. Builds on the strict-lifecycle observability that
+landed in 0.48.1.
+
+**Desktop — approval + completion notifications.** Native OS
+notifications for approval prompts and turn-complete events (#1519),
+so a long-running turn can land in the background and still surface.
+Uses `tauri-plugin-notification`.
+
+**i18n — CLI command output.** `/mcp`, `/sessions`, `/prune`, `/theme`
+output is now translated (#1524), closing the remaining English-only
+gap in CLI command surfaces. Approval-prompt confirm titles and action
+labels also get zh-CN (#1560/#1561).
+
+**Security.**
+- `web_fetch` now blocks SSRF — private/loopback/link-local targets are
+  rejected at the boundary (#1544)
+- Edit snapshots can no longer read outside the workspace (#1454)
+- Shell redirects (`>`, `>>`, `<`) are constrained to the sandbox
+  boundary (#1457)
+- New Task integrity guardrail catches objective simplification — i.e.
+  the model trying to redefine a hard requirement away (#1516)
+
+**Tools.** `run_command` description now actively discourages
+shell-based file edits in favor of the structured `edit` tool (#1514).
+A per-turn dispatch-rate limit lands for tool calls (#1356), keeping
+runaway loops from burning a quota slice in one turn.
+
+**TUI polish.**
+- `Ctrl+Enter` now inserts a newline (#1513) — matching how every
+  modern composer treats the modifier
+- `mouseWheelRows` config knob tunes scroll velocity per terminal
+  (#1511) so trackpad vs. wheel mouse don't fight the default
+- `@mention` file search is restricted to the current directory prefix
+  (#1548) so the picker doesn't dump the whole repo
+- Paste-sentinel label no longer claims `^O` expands the paste — the
+  shortcut never existed (#1517)
+
+**Context.** Pinned-constraint blocks are now preserved across context
+folds (#1515) and the fold tail captures all of them, not just the last
+(#1552). Memory constraints survive the fold instead of silently
+dropping out under pressure.
+
+**Client.**
+- DeepSeek 429s are translated into an actionable "concurrency limit
+  hit" hint instead of a raw HTTP error (#1526)
+- `timeoutMs` is now wired to `fetch` when the caller passes an
+  `AbortSignal` (#1535) — previously the timeout was silently ignored
+- `--no-proxy` / `REASONIX_NO_PROXY` opt-out is honored for the
+  DeepSeek direct-route default (#1507)
+
+**Files.** Read/edit/restore now preserve the source file's encoding
+(GB18030, UTF-8 BOM, etc.) instead of normalizing to UTF-8 on write
+(#1518). Important for CJK Windows projects.
+
+**Web/Dashboard.**
+- Path-access approval modal is bridged to the dashboard (#1538) so
+  the browser surface can resolve the same prompts as CLI/Desktop
+- `@mention` file picker popover lands in the dashboard ChatPane
+  (#1546), gated on attached mode (#1549)
+
+**Config.** Atomic config writes restore the preset-write diagnostic
+trace (#1555), so when a preset write goes wrong you can actually see
+why.
+
+**Refactor.** `lifecycle` extracts a standalone risk policy module
+(#1557), shrinking the orchestrator and unblocking risk policy reuse
+from non-lifecycle callers.
+
+**Edit safety.** `read-before-edit` is now enforced at the dispatch
+gate, not as a per-tool check (#1563) — `edit` / `multi_edit` refuse
+to fire on a file the model hasn't read this session, closing the
+race where a SEARCH block could match stale bytes after an external
+write.
+
+**Cache.** Fold-summary requests now reuse the live agent's system
+prompt + tool list as their prefix, so the cached bytes the main
+agent just paid for carry over to the summary call (#1565). Measured
+on a 48.7K-token fold: 0% → 99.6% cache hit, ~89% input cost
+reduction per fold.
+
+**Other:**
+- `fix(desktop)` drop `workspace:*` protocol for core-utils — desktop
+  isn't a workspace member
+- `fix(desktop)` tsc errors blocking desktop bundle build
+
+## [0.48.1] — 2026-05-21
+
+**`dsnix` — short alias.** A new `dsnix` shim package lands alongside
+`reasonix` (#1440), so `npx dsnix` is now equivalent to `npx reasonix`
+for users who'd rather type five characters than eight. The shim is
+just a forwarding binary — same CLI, same release cadence — and ships
+on npm with the same version pinning (#1442). The root README documents
+the alias.
+
+**Lifecycle — observability + corpus tests.** Strict lifecycle now
+surfaces step-level evidence and rail decisions through a structured
+observability channel (#1426), so what the loop is doing at each step
+is legible instead of inferred. Two corpus tests lock the behavior in:
+multi-file refactor flow (#1427) and config-migration replay (#1473).
+
+**Approval prompt unification.** Phase 3 of the pause-request work
+(#1322) lands a single `PauseRequest` → UI data model shared by ACP,
+CLI, and Desktop (#1443) — the three surfaces now render the same
+prompt from the same payload instead of each translating in their own
+way. Net: pause prompts stay in sync across surfaces when fields are
+added.
+
+**i18n.** Builtin skill descriptions are now translated (#1468), and
+MCP error toasts + status labels carry zh-CN (#1481). The remaining
+hardcoded English surface in skill picker and MCP error toasts is gone.
+
+**Composer redesign + Ctrl+P shortcut modal.** The input area is
+rebuilt with a denser layout, a clearer affordance for multi-line
+input, and a Ctrl+P shortcut-help modal that lists every key binding
+in one place (#1483). The desktop composer also autosizes for
+multi-line input properly (#1439).
+
+**Java tool — cheaper.** The Java source/decompile tool description
+and output are pruned (#1485), shaving cached prefix tokens. Pairs with
+the #1390 buffer raise from 0.48.0.
+
+**Security.** `metaso` web-search no longer ships with a baked API
+key — it now requires the user-configured key like every other backend
+(#1488). Project-level hooks are trusted without an extra prompt
+provided they live inside the working directory.
+
+**YOLO mode polish.** `run_command` and `run_background` approval
+gates now auto-resolve in YOLO mode (#1489) so power users don't get a
+modal for every shell call after explicitly opting in.
+
+**Perf — folding thresholds.** Normal fold threshold raised 50% → 75%,
+aggressive 70% → 78% (#1461) — the loop now spends less time folding
+context that didn't need to be folded.
+
+**Preflight.** The cap that previously only counted tokens now also
+gates on raw JSON body bytes (#1451), catching oversized payloads that
+weren't reflected in the token count.
+
+**Desktop.** Error cards are dismissable and recoverable variants
+toned down (#1487); orphaned pause-gate modals are cleared on
+`$turn_complete` so a stale gate can't block the next turn (#1484);
+session titles are renameable from the sidebar (#1478); `/btw` now
+echoes input, surfaces busy state, and routes through the side-question
+prompt instead of silently dropping the keystroke (#1472).
+
+**TUI.** SGR mouse mode stays on for Windows Terminal (#1486) —
+alternate-scroll silently breaks the wheel there. The default for
+non-WT terminals switches to alternate-scroll (`?1007h`) (#1477) to
+avoid the click-eats-selection problem on conhost-class hosts.
+
+**Other:**
+- `fix(cost)` show session-aggregate cache hit so `/cost` matches the
+  status-bar number (#1482)
+- `fix(plan)` Accept executes immediately when the plan has no open
+  questions instead of waiting on a non-existent answer (#1480)
+- `fix` resolve root-relative edit-block paths (#1452)
+- `fix(tests)` bump chat-mcp-startup timeout to 30s for Windows test
+  matrix (#1471)
+
+## [0.48.0] — 2026-05-20
+
+**Proxy-aware networking.** `NO_PROXY` is now honored end-to-end and
+the DeepSeek host is baked into the default bypass whitelist so a
+machine-wide `HTTPS_PROXY` no longer routes API traffic through an
+unwanted proxy (#1373). A `--no-proxy` CLI flag, `REASONIX_NO_PROXY`
+env, and `cfg.proxy` field give per-invocation control (#1374), and
+`/doctor` surfaces the resolved `NO_PROXY` value plus the routing
+decision Reasonix made for each host (#1375). If proxy behavior ever
+looks wrong, `/doctor` will tell you why in one screen.
+
+**Code intelligence boost.** Two new tree-sitter–powered tools land:
+`get_symbols` and `find_in_code` cover TS/JS/Python/Go/Rust/Java
+(#1387), giving Reasonix structural code navigation instead of plain
+grep. Java gets a dedicated `java_source` tool that reads `.java`
+sources and decompiles `.class` / inner jar entries via `javap`
+(#1344), with output stripped of noise and the read buffer raised so
+large classes fit in one round (#1390). Web search adds Perplexity
+and Exa backends alongside the existing Mojeek / Tavily set (#1350).
+
+**Lifecycle round two.** Checkpoints now gate mutating tools during
+restore so an in-flight edit can't race a rollback (#1389), state is
+preserved across plan revisions (#1388), and step evidence is
+summarized at the plan card so progress is legible without expanding
+each step (#1391). `/plan` is excluded from the strict-rails cache
+constraint that would otherwise force a re-prefix on every revision
+(#1407, #1386), and a strict end-to-end harness covers the whole
+lifecycle path (#1424).
+
+**Subagent UX.** Long-running `explore` / `research` / `review` are
+now top-level slash commands with live byte-progress in the status
+row instead of a frozen spinner (#1422). The agent loop is hardened:
+`_turnAbort` resets in `finally` so a consumer break can't lock the
+session (#1421), ambiguous search-replace edit blocks are rejected
+instead of silently miss-applying (#1414), repeated gate rejections
+no longer ping-pong (#1392), and FS tools walk `.reasonix/` so user
+skills are reachable from any subdir (#1371).
+
+**Desktop.** QQ sessions are now usable from the desktop app — the
+QQ Adapter routes events through the same RPC bridge as CLI tabs
+(#1334). Custom font support + file-link rendering improvements ship
+(#1376). Reliability fixes: `rpc_spawn` is idempotent and a
+`desktop_resync` rehydrate path recovers cleanly after a renderer
+reload (#1428); F5 / Ctrl+R are swallowed in packaged builds so a
+stray refresh can't wipe the chat (#1430); React error #31 with
+non-string MCP config items is fixed (#1394); the context-token
+meter syncs after `/compact` (#1399); the cost meter and session
+cost card apply USD→CNY conversion (#1369); `augmentProcessPath()`
+lost in the #1334 rebase is restored (#1361); desktop stdout partial
+writes are handled (#1405); `/btw` on empty payload now surfaces a
+usage hint instead of dropping the keystroke (#1383).
+
+**TUI / UI.** `/about` is a new slash command showing version,
+website, GitHub, and license (#1434). Remaining hardcoded strings in
+edit history and MCP browse are now i18n'd (#1433). Reasoning,
+streaming, and diff content beyond the recent window are elided so
+long sessions don't tank scroll perf (#1432). Wheel scroll is less
+sensitive and per-card stdout resize listeners collapse to one (#1423);
+terminal mouse tracking now has a CLI opt-out for users on
+mouse-hostile terminals (#1345).
+
+**Settings / config.** `config.json` with a UTF-8 BOM is tolerated
+instead of crashing the loader (#1431); preset-trace diagnostic
+retired (#1431). The dashboard can now clear `baseUrl` to fall back
+to the bundled default (#1425). `string[]` config fields are
+sanitized at the `readConfig` boundary so a malformed entry can't
+propagate into the running session (#1396).
+
+**Other:**
+- `fix(test)` switch vitest to forks pool to stop heap OOM on
+  many-core hosts (#1408)
+- `chore(shell)` trim `run_command` param description (saves 119
+  tokens of cached prefix) (#1403)
+- `chore(scripts)` measure per-tool token cost end-to-end (#1402)
+- `test(tools)` close dispatch-level E2E gaps for shell jobs, web,
+  and scaffold (#1400)
+- `test(shell-tools)` raise `run_background` dispatch test timeout
+  to 15s (#1406)
+- `test(web)` cover Perplexity + Exa backends (#1366)
+- `docs(qq)` add desktop quick start and trim README surface (#1401)
+
+## [0.47.2] — 2026-05-19
+
+**Hotfix — `npx reasonix@latest` install.** `0.47.1` shipped with
+`@reasonix/core-utils` listed under runtime `dependencies` as
+`workspace:*`. Because the workspace package is `private: true`,
+`npm publish` did not rewrite the protocol, so consumers hit
+`EUNSUPPORTEDPROTOCOL: Unsupported URL Type "workspace:"` during
+install. The bundled `dist/` already inlines core-utils at build
+time, so the dependency belongs under `devDependencies`. Moved.
+`0.47.1` is deprecated on npm; please install `0.47.2`.
+
+## [0.47.1] — 2026-05-19
+
+**Desktop shakeout.** Follow-ups to the 0.47.0 desktop launch:
+inherit login-shell `PATH` so `nvm`/`asdf`/`fnm`-installed Node is
+visible to `run_command` (#1331); stop claiming "Connected" on the QQ
+settings page since the desktop is config-editor-only, not a live
+bridge (#1326); re-enable devtools + right-click context menu in
+release builds; route the in-app update check through the updater
+plugin so CSP doesn't block it (#1298); prevent the browser-level
+Select-All when the composer isn't focused (#1314); add unified
+`button:disabled` style; ship selectable theme styles (#1291); a few
+follow-up bug fixes from the release.
+
+**Prompt budget — round one.** `codeSystemPrompt` compressed -51%
+(~3.1k tokens/request, #1323) and tool spec descriptions -28% (~2.7k
+tokens/request, #1321), with a byte-budget regression test locked in
+(#1320). The cache-prefix shrinks accordingly — cheaper first turn,
+same behavior.
+
+**TUI / shell-exec.** Per-call shell-exec approval flow now surfaces
+on the first run instead of failing silently (#1278); spinner +
+stream tick rate dropped on legacy Windows conhost; light-theme
+picker rows highlight on selection (#1330); `//` line-comment input
+no longer parses as a slash command (#1288).
+
+**Other:**
+- `feat(core-utils)` new `@reasonix/core-utils` workspace package —
+  Phase 1 internal split, no public-API change (#1328)
+- `feat(lifecycle)` opt-in engineering lifecycle (#1306)
+- `feat(tools)` ordered interceptor chain (#1301)
+- `feat(plan)` persist step evidence metadata (#1302)
+- `feat(read_file)` lower outline threshold 512 KiB → 64 KiB (#1324)
+- `fix(multi_edit)` roll back files that may have been modified on
+  write failure (#1325)
+- `fix(permissions)` strip literal `*` from always-allow prefix in
+  Desktop/ACP (#1312)
+- `fix(client)` skip `extra_body` for Azure endpoints (#1316)
+- `fix(search)` honor `tavily` engine + read engine at call time
+- `fix(cli)` resolve heap reexec entrypoint (#1303)
+- `fix(docs)` point download mirrors at `desktop-v*` tag namespace
+
+## [0.47.0] — 2026-05-18
+
+**Desktop matures.** The Tauri app picks up the polish it was missing —
+About modal with one-click update check, KaTeX math rendering in chat,
+window/tab/session/scroll restore across relaunch, /compact /retry /btw
+/feedback slash commands, per-message copy + file-export actions, QQ
+settings entry, platform-aware keyboard shortcut hints. The auto-updater
+now reads `latest.json` from the R2 mirror so an npm-only `v*` release
+can no longer brick the in-app update banner; the banner also surfaces
+download progress while the bundle pulls. Universal Node is bundled on
+macOS so Intel Macs stop blank-screening at launch.
+
+**TUI — composer round two.** Composer keys and visuals re-align with
+Claude Code: rounded border, status row at the bottom, input-box
+background fill, left stripe on user card. `ctrl+r` toggles verbose
+(reasoning + raw tool I/O); `esc-esc` opens a rewind picker over the
+last 5s; `u` undo is now gated to the same 5s window so stale taps
+can't revert. SGR mouse wheel is on by default again, IME cursor stays
+glued to `▌`, WelcomeBanner centers vertically on empty chats.
+
+**Search hardening.** Regex now runs in a worker thread so a ReDoS
+pattern can be terminated cleanly; worker deadline 5s → 60s and walk
+deadline 15s → 120s for legitimately large repos. Tavily added as a
+`web_search` backend — escape hatch when Mojeek 403s. `search_content`
+gets a walk-level deadline and ESC preempts queued tool calls.
+
+**Claude-ecosystem compat.** Reasonix now reads `.mcp.json` and
+`.claude/skills/` from the repo so existing Claude Code setups work
+without a second copy; common skill fields (`type`/`context`/`agent`)
+are aliased.
+
+**Other:**
+- `feat(embedding)` batch OpenAI-compat embedding requests to respect
+  provider batch limits
+- `feat(memory)` inject ancestor `AGENTS.md` into `list_directory`,
+  not only `read_file`
+- `perf(session)` skip cross-workspace jsonls + byte-scan line count
+  — sidebar list ~10× faster
+- `feat(config)` support pricing overrides and per-model rpm limits
+- `feat(dashboard)` new / switch / delete sessions in-place, no CLI
+  bounce
+- `fix(mcp)` runtime schema validation for MCP server responses; ESC
+  aborts hung handshakes during startup; surface the real bridge-
+  failure reason in the dashboard
+- `fix(cli)` preserve flash-preset auto-escalate semantics
+- `ci` split desktop + npm releases into separate tag namespaces:
+  `v*` → npm, `desktop-v*` → Tauri bundles
+
+## [0.46.0] — 2026-05-17
+
+**Breaking — Rust renderer removed.** Reasonix is back to a pure Ink/Node
+TUI. The `reasonix-render` ratatui crate, the five
+`@reasonix/render-{platform}-{arch}` optional sub-packages, the NAPI
+loader (`src/cli/ui/scene/`), and the `--node` opt-out flag are all
+gone. Cross-terminal compat issues (Termux #1149 / #1026, mac eager-spawn
+chain, Windows alt-screen handoff, integrated-mode keyboard collisions)
+disappear with them — at the cost of the streaming/animation perf the
+rust renderer was supposed to buy us.
+
+Notes for users:
+- `REASONIX_RENDERER`, `REASONIX_RENDER_BIN`, `REASONIX_RENDER_CMD`,
+  `REASONIX_INPUT_CMD`, `REASONIX_RENDERER_INTEGRATED` env vars are no-ops
+  — drop them from your shell config.
+- `--node` flag is no-op (and unrecognized; will error). Just drop it.
+- `--no-alt-screen` / `--no-mouse` flags also gone — Ink defaults take
+  over end-to-end.
+- `npm install [email protected]` no longer pulls a per-platform binary —
+  one dep tree on every OS, no optional resolution step.
+
+**TUI overhaul** — same pass that removed the rust path also cleared
+the Ink-side workarounds we'd accumulated on top of it:
+- Card primitive drops the left `▎` stripe; cards are plain column
+  boxes with a top margin
+- CardHeader drops the colored pill background behind titles
+- Single consistent glyph vocabulary: `●` running, `✓` done, `✗`
+  failed, `⊘` aborted, `○` queued, `⚠` warn, `⎿` child row, `█`/`░`
+  bars, braille spinner
+- Composer wrapped in a rounded border box; status row moved to the
+  bottom; on narrow terminals status pills wrap to a new line instead
+  of being truncated away (#1149)
+- `/dashboard` URL surfaces as a startup info row (was easy to miss)
+- `/copy` permanently in the startup hint list — vim-style copy mode
+  was undiscoverable before
+
+## [0.44.2-rc.2] — 2026-05-17
+
+**Fix:** macOS hang on `npx reasonix@next code` — keep-alive interval
+from rc.1 prevented Node from exiting, but the rust child was never
+actually spawned. Root cause: spawn was triggered by a React
+`useEffect` (`useSceneTrace` → `emitSceneMessage` → `trace.ts`
+`ensureInitialized`), and that effect simply never fired in some
+macOS npx contexts. Node sat alive with the keep-alive holding the
+event loop open, nothing on screen, no rust process.
+
+Fix: spawn rust eagerly in `chat.tsx` via new
+`ensureSceneTraceReady()` export, after `setIntegratedEventHandler` so
+the integrated event callback is wired before spawn. Also:
+- `renderer-process.ts` synthesizes an `exit` event when the rust child
+  dies on its own (panic / SIGKILL / terminal close) so the integrated
+  event handler tears Node down instead of hanging forever.
+- `trace.ts` now logs a clear warning to stderr when `resolveRenderer`
+  returns no usable command, instead of bailing silently — anyone
+  hitting "TUI never appears" can find the cause in
+  `~/.reasonix/rust-render-stderr.log`.
+
+## [0.44.2-rc.1] — 2026-05-17
+
+**Fix:** macOS `npx reasonix code` (default rust + integrated TUI) exited
+back to the shell prompt immediately without rendering. Root cause:
+`makeNullStdin` / `makeNullStdout` are pure-JS Node streams with no
+underlying libuv handles, so they don't keep the event loop alive. The
+rust trace child is spawned by a React `useEffect` (via `useSceneTrace`
+→ `emitSceneMessage`) — that effect is enqueued microseconds AFTER
+`render()` returns, but on macOS the event loop sees no active handles
+in that window and exits before the effect runs. Linux/Windows happen
+to keep the loop alive via other handles in the boot path; macOS
+doesn't.
+
+Defensive `setInterval(()=>{}, 0x7fffffff)` keep-alive held for the
+lifetime of `waitUntilExit()` and cleared in `finally`. Same renderer
+binary as 0.44.0; only chat.tsx changed.
+
 ## [0.44.1] — 2026-05-17
 
 **Fix:** Mac/Linux `npx reasonix@latest` failed with `EACCES` when spawning

Cargo.toml

@@ -1,9 +0,0 @@
-[workspace]
-members = ["crates/reasonix-render"]
-exclude = ["desktop"]
-resolver = "2"
-
-[workspace.package]
-edition = "2021"
-license = "MIT"
-publish = false

README.ja-JP.md

@@ -0,0 +1,339 @@
+<p align="center">
+  <img src="docs/logo.svg" alt="Reasonix" width="640"/>
+</p>
+
+> [!WARNING]
+> **これはレガシーの TypeScript 系列(Reasonix 0.x)で、メンテナンスのみです。**
+> 開発は **Go 版の書き直し** に移行しました —— 新しいデフォルトの [`main-v2`](https://github.com/esengine/DeepSeek-Reasonix/tree/main-v2) ブランチと[移行ガイド](https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/MIGRATING.md)を参照してください。ここではバグ修正のみ反映されます。
+
+
+<p align="center">
+  <a href="./README.md">English</a>
+  &nbsp;·&nbsp;
+  <a href="./README.zh-CN.md">简体中文</a>
+  &nbsp;·&nbsp;
+  <strong>日本語</strong>
+  &nbsp;·&nbsp;
+  <a href="https://esengine.github.io/DeepSeek-Reasonix/">公式サイト</a>
+  &nbsp;·&nbsp;
+  <a href="https://esengine.github.io/DeepSeek-Reasonix/configuration.html">ガイド</a>
+  &nbsp;·&nbsp;
+  <a href="./docs/ARCHITECTURE.md">アーキテクチャ</a>
+  &nbsp;·&nbsp;
+  <a href="./benchmarks/">ベンチマーク</a>
+  &nbsp;·&nbsp;
+  <strong><a href="https://discord.gg/XF78rEME2D">Discord</a></strong>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/reasonix"><img src="https://img.shields.io/npm/v/reasonix.svg?style=flat-square&color=cb3837&labelColor=161b22&logo=npm&logoColor=white" alt="npm version"/></a>
+  <a href="https://github.com/esengine/reasonix/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/esengine/reasonix/ci.yml?style=flat-square&label=ci&labelColor=161b22&logo=githubactions&logoColor=white" alt="CI"/></a>
+  <a href="./LICENSE"><img src="https://img.shields.io/npm/l/reasonix.svg?style=flat-square&color=8b949e&labelColor=161b22" alt="license"/></a>
+  <a href="https://www.npmjs.com/package/reasonix"><img src="https://img.shields.io/npm/dm/reasonix.svg?style=flat-square&color=3fb950&labelColor=161b22&label=downloads" alt="downloads"/></a>
+  <a href="./package.json"><img src="https://img.shields.io/node/v/reasonix.svg?style=flat-square&color=5fa04e&labelColor=161b22&logo=nodedotjs&logoColor=white" alt="node"/></a>
+  <a href="https://github.com/esengine/reasonix/stargazers"><img src="https://img.shields.io/github/stars/esengine/reasonix.svg?style=flat-square&color=dbab09&labelColor=161b22&logo=github&logoColor=white" alt="GitHub stars"/></a>
+  <a href="https://atomgit.com/esengine/DeepSeek-Reasonix"><img src="https://atomgit.com/esengine/DeepSeek-Reasonix/star/badge.svg" alt="AtomGit stars"/></a>
+  <a href="https://github.com/esengine/reasonix/graphs/contributors"><img src="https://img.shields.io/github/contributors/esengine/reasonix.svg?style=flat-square&color=bc8cff&labelColor=161b22&logo=github&logoColor=white" alt="contributors"/></a>
+  <a href="https://github.com/esengine/reasonix/discussions"><img src="https://img.shields.io/github/discussions/esengine/reasonix.svg?style=flat-square&color=58a6ff&labelColor=161b22&logo=github&logoColor=white" alt="Discussions"/></a>
+  <a href="https://discord.gg/XF78rEME2D"><img src="https://img.shields.io/badge/discord-join-5865F2.svg?style=flat-square&labelColor=161b22&logo=discord&logoColor=white" alt="Discord"/></a>
+</p>
+
+<p align="center">
+  <a href="https://oosmetrics.com/repo/esengine/reasonix"><img src="https://api.oosmetrics.com/api/v1/badge/achievement/9e931d80-2050-4b10-902e-44970cc133ad.svg" alt="oosmetrics — Top 2 in Agents by velocity"/></a>
+  <a href="https://oosmetrics.com/repo/esengine/reasonix"><img src="https://api.oosmetrics.com/api/v1/badge/achievement/556d94b3-61b7-486b-baf2-888b9327deab.svg" alt="oosmetrics — Top 3 in LLMs by velocity"/></a>
+  <a href="https://oosmetrics.com/repo/esengine/reasonix"><img src="https://api.oosmetrics.com/api/v1/badge/achievement/0f457d4c-efca-4d15-ad2b-139691ff342c.svg" alt="oosmetrics — Top 3 in CLI by velocity"/></a>
+</p>
+
+<br/>
+
+<h3 align="center">ターミナルで動く DeepSeek ネイティブの AI コーディングエージェント。</h3>
+<p align="center">プレフィックスキャッシュの安定性を中心に設計されているため、長時間のセッションでもトークンコストを低く保ち、動かしっぱなしにできます。</p>
+
+<br/>
+
+<p align="center">
+  <img src="docs/assets/hero-terminal.svg" alt="Reasonix code mode — assistant proposes a SEARCH/REPLACE edit; nothing on disk until /apply" width="860"/>
+</p>
+
+<br/>
+
+> [!TIP]
+> **キャッシュの安定性はオンにする「機能」ではなく、ループそのものが前提として設計された不変条件です。** これこそが Reasonix が DeepSeek 専用である理由であり、すべてのレイヤーがバイト単位で安定したプレフィックスキャッシュの仕組みに合わせて調整されています。
+
+> [!NOTE]
+> **実ユーザーの1日（2026-05-01）:** 入力トークン 4億3,500万、**キャッシュヒット率 99.82%**、同じワークロードを `v4-flash` でキャッシュなしに実行した場合の約 \$61 に対して、わずか約 \$12 で済んでいます — 詳しくは[ケーススタディ](./benchmarks/real-world-cache/README.md)を参照。キャッシュ可能なバイト列を提供するのは DeepSeek ですが、それを長時間のセッションにわたってキャッシュ可能に保つのが [Pillar 1](./docs/ARCHITECTURE.md#pillar-1--cache-first-loop) の4つの仕組みです。
+
+> [!IMPORTANT]
+> **Community · 加入社区** — セットアップのヘルプ（`#help` / `#求助`）、ワークフローのショーケース、機能アイデア、コントリビューター限定の PR 調整用チャンネルを備えたバイリンガル Discord。サーバー内で GitHub を認証すると、自動的に **Contributor** ロールが付与されます。→ **<https://discord.gg/XF78rEME2D>**
+
+<br/>
+
+## インストール
+
+Node ≥ 22 が必要です。macOS · Linux · Windows（PowerShell · Git Bash · Windows Terminal）で動作します。
+
+`reasonix` コマンドを `PATH` 上で使えるようにしたい場合は、Reasonix をグローバルにインストールします:
+
+~~~bash
+npm install -g reasonix
+reasonix code my-project   # 初回実行時に DeepSeek API キーを貼り付け。以降は保存される
+~~~
+
+または、グローバルインストールせずに一度だけ実行することもできます:
+
+~~~bash
+cd my-project
+npx reasonix code          # デフォルトでは常に最新のパッケージを使用
+~~~
+
+[DeepSeek API キーを取得 →](https://platform.deepseek.com/api_keys) · フラグは `reasonix code --help` を参照。
+
+Reasonix を毎日使うなら、グローバルインストールが最もシンプルな方法です。とりあえず試してみたいだけなら `npx` を使ってください。
+
+**キー入力を減らしたい？** より短い `dsnix` エイリアスが同じ CLI を指します:
+
+~~~bash
+npm install -g dsnix       # PATH 上に `dsnix` を公開。reasonix に依存
+npx dsnix@latest code      # より短いコマンドで一度だけ実行
+~~~
+
+`npm install -g reasonix` でグローバルインストールすると `dsnix` のシムも PATH 上に配置されるため、2つは相互に置き換え可能です。
+
+サブコマンドなしの `reasonix`（裸の `reasonix`）はカレントディレクトリで `code` を起動します — `reasonix` と入力するのは `reasonix code` と等価です。
+
+| コマンド | 用途 |
+|---|---|
+| `reasonix` / `reasonix code [dir]` | コーディングエージェント。**ここから始めてください。** |
+| `reasonix chat` | プレーンなチャット — ファイルシステムやシェルのツールなし。 |
+| `reasonix run "task"` | 一度だけ実行し、stdout にストリーミング。パイプ向き。 |
+| `reasonix doctor` | ヘルスチェック: Node、API キー、MCP の配線。 |
+| `reasonix update` | Reasonix 自体をアップグレード。 |
+
+その他のサブコマンド（`replay` · `diff` · `events` · `stats` · `index` · `mcp` · `prune-sessions`）は `reasonix --help` と [CLI リファレンス](https://esengine.github.io/DeepSeek-Reasonix/#cli)にあります。
+
+### QQ チャンネル
+
+QQ は既存の `chat`、`code`、またはデスクトップのセッションをリモートチャンネルとして拡張できます。これは独立したランタイムモードではなく、現在のセッションフローの一部です。
+
+- CLI: セッションを開始し、`/qq connect` を実行
+- デスクトップ: `Settings -> General -> QQ Channel` を開く
+
+接続すると、QQ のメッセージを現在のセッションに取り込み、アシスタントの返信を QQ に転送し、その後のやり取りをリモートで継続できます。
+
+詳しいセットアップ、デスクトップのクイックスタート、トラブルシューティングは [QQ チャンネルのセットアップ](./docs/qq-connect.md)を参照してください。
+
+### デスクトップクライアント（プレリリース）
+
+同じループの GUI が欲しいユーザー向けのネイティブ Tauri クライアント。マルチタブ対応で、右パネルにはこのセッションでエージェントが読み取り・編集したファイルが表示され、下部には同じコスト / キャッシュ / トークンのメーターがリアルタイムで表示されます。同じ DeepSeek API キー、同じ `~/.reasonix` 設定を使い、デスクトップ版は独自の Node ランタイムを同梱するため、別途 `npm install` する必要はありません。
+
+各プラットフォームのインストーラーは [GitHub Releases](https://github.com/esengine/DeepSeek-Reasonix/releases) からダウンロードできます。デスクトップ版は **プレリリース** として提供されます: ループとプロトコルは CLI と同じですが、UI はまだ磨き込み中で、インストーラーはまだコード署名されていません。
+
+- **macOS** — 初回起動時に Gatekeeper に引っかかります。一度きりの対処: `xattr -dr com.apple.quarantine /Applications/Reasonix.app`（または右クリック → 開く → 確認）。
+- **Windows** — SmartScreen が「不明な発行元」と警告します。**詳細情報 → 実行** をクリックしてください。
+- **Linux** — `.deb` と `.AppImage` はそのまま起動でき、追加の手順は不要です。
+
+CLI が引き続き正規のインターフェースです。CLI に入った機能はすべてデスクトップのコンポーザーからも利用できます。
+
+<details>
+<summary><strong>別のフォルダで作業する · chat と code の違い · スキルを書く</strong></summary>
+
+**別のフォルダで作業する。** Reasonix はファイルシステムツールを起動ディレクトリにスコープします。対象を変えるには `--dir` を渡してください。セッション途中での切り替えは設計上サポートされていません（メモリのパスが古いルートと絡まってしまうため）— 一度終了して再起動してください。
+
+~~~bash
+npx reasonix code --dir /path/to/project
+~~~
+
+**`chat` と `code` の選び方。** `code` がデフォルトであり、ファイルシステム / シェルツールと SEARCH/REPLACE レビューを備えた唯一のモードです。`chat` はより軽量でツールをオフにしたシェルです — MCP は接続しつつディスクアクセスのない思考のパートナーが欲しいときに使ってください。
+
+| 得られるもの | `code` | `chat` |
+|---|---|---|
+| ファイルシステムツール + `edit_file` | ✓ | — |
+| SEARCH/REPLACE → `/apply` レビュー | ✓ | — |
+| シェルツール（ゲート付き） | ✓ | — |
+| プランモード · `/todo` · `/skill new` · `/mcp add` | ✓ | — |
+| メモリ（`remember` / `recall_memory`） | プロジェクト + グローバル | グローバルのみ |
+| 設定からの MCP サーバー · ウェブ検索 · `ask_choice` | ✓ | ✓ |
+| コーディング用システムプロンプト | ✓ | 汎用 |
+| セッションのスコープ | ディレクトリごと | 共有デフォルト |
+
+**最初のスキルを書く。** リモートレジストリはありません — 直接書きます。ファイル（`description:` フロントマター + 本文）を編集し、`/skill list` を実行します。本文をインライン展開する代わりに分離したサブエージェントループを生成するには `runAs: subagent` を追加します。
+
+~~~bash
+/skill new my-skill              # <project>/.reasonix/skills/my-skill.md
+/skill new my-skill --global     # プロジェクト横断で使うなら ~/.reasonix/skills
+~~~
+
+**Claude 形式のスキルも読み込まれます。** `<project>/.claude/skills/<name>/SKILL.md` と `~/.claude/skills/` が Reasonix のネイティブパスと並んで読み込まれるため、Claude 形式のスキルを出力するツールはそのまま動きます。例 — 上流アダプターなしで OpenSpec ワークフローを投入する:
+
+~~~bash
+npx openspec init --tools claude    # .claude/skills/openspec-*/SKILL.md を書き出す
+/skill openspec-propose <task>      # その後 Reasonix から呼び出す
+~~~
+
+</details>
+
+<br/>
+
+## 設定
+
+`~/.reasonix/config.json` の1つの JSON ファイルと、`<project>/.reasonix/` 配下のプロジェクトごとのオーバーライドで設定します。すべてのキー、すべてのスラッシュコマンド、スキル / メモリ / フックのオンディスク構造を網羅した完全なバイリンガルリファレンスはこちら:
+
+> 📘 **[設定ガイド](https://esengine.github.io/DeepSeek-Reasonix/configuration.html)** · [中文](https://esengine.github.io/DeepSeek-Reasonix/configuration.html?lang=zh)
+
+| トピック | 概要 |
+|---|---|
+| [MCP サーバー](https://esengine.github.io/DeepSeek-Reasonix/configuration.html#mcp) | stdio · SSE · Streamable HTTP。1つの仕様形式が `config.json` と `--mcp` の両方で動作。 |
+| [スキル](https://esengine.github.io/DeepSeek-Reasonix/configuration.html#skills) | モデルが呼び出せる Markdown のプレイブック。`inline` または `subagent` モード。 |
+| [メモリ](https://esengine.github.io/DeepSeek-Reasonix/configuration.html#memory) | プレフィックスにピン留めされるユーザー専用の知識。`user` / `feedback` / `project` / `reference` の型。 |
+| [フック](https://esengine.github.io/DeepSeek-Reasonix/configuration.html#hooks) | ライフサイクルイベント時のシェルコマンド。`PreToolUse`（ゲート） · `PostToolUse` · `UserPromptSubmit` · `Stop`。 |
+| [権限](https://esengine.github.io/DeepSeek-Reasonix/configuration.html#permissions) | ワークスペースごとのシェル許可リスト。完全な前方一致。 |
+| [ウェブ検索](https://esengine.github.io/DeepSeek-Reasonix/configuration.html#search) | デフォルトは Mojeek。`/search-engine` でセルフホストの SearXNG や Metaso に切り替え可能。 |
+| [セマンティックインデックス](https://esengine.github.io/DeepSeek-Reasonix/configuration.html#index) | `reasonix index` — ローカルの Ollama または任意の OpenAI 互換の埋め込みエンドポイント。 |
+
+<br/>
+
+## Reasonix の何が違うのか
+
+ループは3つの柱を中心に構成されています。それぞれが、汎用的なエージェントフレームワークには見えてすらいない問題を解決します — それらは別のキャッシュの仕組み向けに設計されているからです。
+
+<sub align="center">
+
+完全なアーキテクチャ解説はこちらから → [Pillar 1 — キャッシュファーストのループ](./docs/ARCHITECTURE.md#pillar-1--cache-first-loop) · [Pillar 2 — ツール呼び出しの修復](./docs/ARCHITECTURE.md#pillar-2--tool-call-repair) · [Pillar 3 — コスト制御](./docs/ARCHITECTURE.md#pillar-3--cost-control-v06)
+
+</sub>
+
+<br/>
+
+## 機能
+
+<p align="center">
+  <img src="docs/assets/feature-grid.svg" alt="Reasonix capabilities — cell-diff renderer, MCP, plan mode, permissions, dashboard, persistent sessions, hooks/skills/memory, semantic search, auto-checkpoints, /effort knob, transcript replay, event log" width="880"/>
+</p>
+
+<br/>
+
+## 比較
+
+|                                   | Reasonix         | Claude Code       | Cursor              | Aider              |
+|-----------------------------------|------------------|-------------------|---------------------|--------------------|
+| バックエンド                       | DeepSeek         | Anthropic         | OpenAI / Anthropic  | 任意（OpenRouter） |
+| ライセンス                         | **MIT**          | クローズド        | クローズド          | Apache 2           |
+| コストプロファイル                 | **タスクあたり低コスト** | プレミアム  | サブスク + 従量     | まちまち           |
+| DeepSeek プレフィックスキャッシュ  | **設計込み**     | 該当なし          | 該当なし            | 偶発的             |
+| 組み込みウェブダッシュボード       | あり             | —                 | 該当なし（IDE）     | —                  |
+| 設定可能なウェブ検索エンジン       | `/search-engine` | —             | —                   | —                  |
+| ワークスペースごとの永続セッション | あり             | 一部              | 該当なし            | —                  |
+| プランモード · MCP · フック · スキル | あり           | あり              | あり                | 一部               |
+| ウェブ検索（Mojeek + SearXNG + Metaso） | あり        | あり              | あり                | あり               |
+| オープンなコミュニティ開発         | あり             | —                 | —                   | あり               |
+
+リアルタイムのキャッシュヒット率、コスト、手法については [`benchmarks/`](./benchmarks/) を参照してください — 数値はモデルの料金とともに変動するため、README ではなくハーネスとともに置いています。
+
+<br/>
+
+## ドキュメント
+
+- [**アーキテクチャ**](./docs/ARCHITECTURE.md) — 3つの柱: キャッシュファーストのループ、ツール呼び出しの修復、コスト制御
+- [**CLI リファレンス**](./docs/CLI-REFERENCE.md) — すべてのシェルサブコマンド、すべてのスラッシュコマンド、すべてのキーバインド
+- [**QQ チャンネルのセットアップ**](./docs/qq-connect.md) — CLI の初回接続フロー、デスクトップのエントリ、QQ Open Platform の認証情報
+- [**ベンチマーク**](./benchmarks/) — τ-bench-lite ハーネス、トランスクリプト、コスト算出手法
+- [**公式サイト**](https://esengine.github.io/DeepSeek-Reasonix/) — はじめに、ダッシュボードのモックアップ、TUI のモックアップ
+- [**コントリビューション**](./CONTRIBUTING.md) — コメントポリシー、エラーハンドリングのルール、自作よりライブラリを優先
+- [**行動規範**](./CODE_OF_CONDUCT.md) · [**セキュリティポリシー**](./SECURITY.md)
+
+<br/>
+
+## コミュニティ
+
+> [!NOTE]
+> Reasonix はオープンソースであり、コミュニティによって開発されています。このファイル末尾の謝辞ウォールにあるすべてのアバターは、実際にマージされた PR です。
+
+スコープが切られた入門用チケット — それぞれ背景、コードの参照ポイント、受け入れ基準、ヒント付き — は [`good first issue`](https://github.com/esengine/reasonix/labels/good%20first%20issue) ラベルの下にあります。オープンなものなら何でも選んでください。
+
+**オープンな Discussions — 意見募集中:**
+
+- [#20 · CLI / TUI デザイン](https://github.com/esengine/reasonix/discussions/20) — 何が壊れていて、何が足りず、何を変えますか？
+- [#21 · ダッシュボードデザイン](https://github.com/esengine/reasonix/discussions/21) — [提案中のモックアップ](https://esengine.github.io/DeepSeek-Reasonix/design/agent-dashboard.html)への反応をどうぞ
+- [#22 · 今後の機能ウィッシュリスト](https://github.com/esengine/reasonix/discussions/22) — 次に Reasonix に組み込みたいものは？
+
+**すでに Reasonix を使っていて、他の人に広める手伝いをしてもいい？** ブログ記事、記事、スクリーンショット、講演、動画を [**Show and tell**](https://github.com/esengine/reasonix/discussions/categories/show-and-tell) に公開してください。このプロジェクトにはマーケティング予算がありません — 新しいユーザーは口コミで見つけてくれます。継続的に応援してくれる人は、以下のバッジを獲得でき、付与されるとコントリビューターウォールの横に表示されます:
+
+<p align="center">
+  <a href="https://github.com/esengine/reasonix/discussions/categories/show-and-tell">
+    <img src="https://img.shields.io/badge/REASONIX-📣%20ADVOCATE-c4b5fd?style=for-the-badge&labelColor=0d1117" alt="Reasonix Advocate badge — earned by sustained advocates"/>
+  </a>
+</p>
+
+**最初の PR の前に**: [`CONTRIBUTING.md`](./CONTRIBUTING.md) を読んでください — 短く厳格なルール（コメント、エラー、自作よりライブラリを優先）。`tests/comment-policy.test.ts` がコメントのルールを強制します。`npm run verify` がプッシュ前のゲートです。参加することで [行動規範](./CODE_OF_CONDUCT.md) に同意したものとみなされます。セキュリティの問題は → [SECURITY.md](./SECURITY.md)。
+
+<br/>
+
+## 非目標
+
+> [!IMPORTANT]
+> Reasonix には明確な方針があります。あえて *やらない* ことがいくつかあります — あなたの作業に合ったツールを選べるよう、ここに挙げておきます。
+
+- **マルチプロバイダーの柔軟性。** あえて DeepSeek 専用にしています。1つのバックエンドに密結合していることは制限ではなく機能です。
+- **IDE 統合。** ターミナルファースト。差分は `git diff` に、ファイルツリーは `ls` にあります。ダッシュボードはあくまで補助であり、Cursor の代替ではありません。
+- **最難関リーダーボードの推論。** Claude Opus はいまだに一部のベンチマークで勝っています。DeepSeek はコーディングで競争力がありますが、もしあなたの作業が「この認証バグを直す」ではなく「この博士課程レベルの証明を解く」ものなら、Claude から始めてください。
+- **エアギャップ / 完全無料。** Reasonix には有料の DeepSeek API キーが必要です。エアギャップ環境やゼロコストでの実行には Aider + Ollama または [Continue](https://continue.dev) を参照してください。
+
+<br/>
+
+## スター履歴
+
+<a href="https://www.star-history.com/?repos=esengine%2FDeepSeek-Reasonix&type=date&legend=top-left">
+ <picture>
+   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/chart?repos=esengine/DeepSeek-Reasonix&type=date&theme=dark&legend=top-left" />
+   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/chart?repos=esengine/DeepSeek-Reasonix&type=date&legend=top-left" />
+   <img alt="Star History Chart" src="https://api.star-history.com/chart?repos=esengine/DeepSeek-Reasonix&type=date&legend=top-left" />
+ </picture>
+</a>
+
+<br/>
+
+## サポート
+
+Reasonix が役に立って、お礼を言いたいと思ったらどうぞ。これはあくまでコーヒー一杯であって契約ではありません — 寄付で機能の優先順位が買えるわけでも、issue のトリアージのされ方が変わるわけでもありません。
+
+- **International** — PayPal: [paypal.me/yuhuahui](https://paypal.me/yuhuahui)
+- **国内** — 微信支付（扫码）
+
+<p align="center">
+  <img src=".github/sponsor/wechat-pay.jpg" alt="WeChat Pay QR code" width="240"/>
+</p>
+
+<br/>
+
+## 謝辞
+
+Reasonix を最も形づくってくれた人々の小さなリストです — コミット数とコード量の両方で測っています。**重要度の順位付けはなく、アルファベット順に記載しています。** 完全なコントリビューターグラフは
+[GitHub](https://github.com/esengine/DeepSeek-Reasonix/graphs/contributors) にあります。
+
+- [**ctharvey**](https://github.com/ctharvey)
+- [**dimasd-angga**](https://github.com/dimasd-angga) (Dimas D. Angga)
+- [**Evan-Pycraft**](https://github.com/Evan-Pycraft)
+- [**ForeverYoungPp**](https://github.com/ForeverYoungPp)
+- [**GTC2080**](https://github.com/GTC2080) (TaoMu)
+- [**kabaka9527**](https://github.com/kabaka9527)
+- [**lisniuse**](https://github.com/lisniuse) (Richie)
+- [**wade19990814-hue**](https://github.com/wade19990814-hue)
+- [**wviana**](https://github.com/wviana) (Wesley Viana)
+
+また、プロジェクトのロゴをデザインしてくれた [**Bernardxu123**](https://github.com/Bernardxu123)（[`docs/brand/`](./docs/brand/) を参照）と、小紅書（XiaoHongShu）でプロジェクトを宣伝してくれた [AIGC Link](https://xhslink.com/m/80ngts127cA) にも別途感謝します。
+
+<p align="center">
+  <a href="https://github.com/esengine/DeepSeek-Reasonix/graphs/contributors">
+    <img src="https://contrib.rocks/image?repo=esengine/DeepSeek-Reasonix&max=100&columns=12" alt="Contributors to esengine/DeepSeek-Reasonix" width="860"/>
+  </a>
+</p>
+
+<br/>
+
+---
+
+<p align="center">
+  <sub>MIT — <a href="./LICENSE">LICENSE</a> を参照</sub>
+  <br/>
+  <sub><a href="https://github.com/esengine/DeepSeek-Reasonix/graphs/contributors">esengine/DeepSeek-Reasonix</a> のコミュニティによって構築</sub>
+</p>

README.md

@@ -2,11 +2,18 @@
   <img src="docs/logo.svg" alt="Reasonix" width="640"/>
 </p>
 
+> [!WARNING]
+> **This is the legacy TypeScript line (Reasonix 0.x), in maintenance mode.**
+> Active development moved to the **Go rewrite** — see the [`main-v2`](https://github.com/esengine/DeepSeek-Reasonix/tree/main-v2) branch (the new default) and the [migration guide](https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/MIGRATING.md). Only bug fixes land here.
+
+
 <p align="center">
   <strong>English</strong>
   &nbsp;·&nbsp;
   <a href="./README.zh-CN.md">简体中文</a>
   &nbsp;·&nbsp;
+  <a href="./README.ja-JP.md">日本語</a>
+  &nbsp;·&nbsp;
   <a href="https://esengine.github.io/DeepSeek-Reasonix/">Website</a>
   &nbsp;·&nbsp;
   <a href="https://esengine.github.io/DeepSeek-Reasonix/configuration.html">Guide</a>
@@ -14,6 +21,8 @@
   <a href="./docs/ARCHITECTURE.md">Architecture</a>
   &nbsp;·&nbsp;
   <a href="./benchmarks/">Benchmarks</a>
+  &nbsp;·&nbsp;
+  <strong><a href="https://discord.gg/XF78rEME2D">Discord</a></strong>
 </p>
 
 <p align="center">
@@ -23,8 +32,10 @@
   <a href="https://www.npmjs.com/package/reasonix"><img src="https://img.shields.io/npm/dm/reasonix.svg?style=flat-square&color=3fb950&labelColor=161b22&label=downloads" alt="downloads"/></a>
   <a href="./package.json"><img src="https://img.shields.io/node/v/reasonix.svg?style=flat-square&color=5fa04e&labelColor=161b22&logo=nodedotjs&logoColor=white" alt="node"/></a>
   <a href="https://github.com/esengine/reasonix/stargazers"><img src="https://img.shields.io/github/stars/esengine/reasonix.svg?style=flat-square&color=dbab09&labelColor=161b22&logo=github&logoColor=white" alt="GitHub stars"/></a>
+  <a href="https://atomgit.com/esengine/DeepSeek-Reasonix"><img src="https://atomgit.com/esengine/DeepSeek-Reasonix/star/badge.svg" alt="AtomGit stars"/></a>
   <a href="https://github.com/esengine/reasonix/graphs/contributors"><img src="https://img.shields.io/github/contributors/esengine/reasonix.svg?style=flat-square&color=bc8cff&labelColor=161b22&logo=github&logoColor=white" alt="contributors"/></a>
   <a href="https://github.com/esengine/reasonix/discussions"><img src="https://img.shields.io/github/discussions/esengine/reasonix.svg?style=flat-square&color=58a6ff&labelColor=161b22&logo=github&logoColor=white" alt="Discussions"/></a>
+  <a href="https://discord.gg/XF78rEME2D"><img src="https://img.shields.io/badge/discord-join-5865F2.svg?style=flat-square&labelColor=161b22&logo=discord&logoColor=white" alt="Discord"/></a>
 </p>
 
 <p align="center">
@@ -52,6 +63,9 @@
 > [!NOTE]
 > **Real user, single day (2026-05-01):** 435M input tokens, **99.82% cache hit**, ~$12 instead of the ~$61 the same workload would cost with no cache on `v4-flash` — see the [case study](./benchmarks/real-world-cache/README.md). DeepSeek provides the cacheable bytes; the four mechanisms in [Pillar 1](./docs/ARCHITECTURE.md#pillar-1--cache-first-loop) are how Reasonix keeps them cacheable across long sessions.
 
+> [!IMPORTANT]
+> **Community · 加入社区** — bilingual Discord with channels for setup help (`#help` / `#求助`), workflow showcases, feature ideas, and contributor-only PR coordination. Verify your GitHub in-server to get the **Contributor** role automatically. → **<https://discord.gg/XF78rEME2D>**
+
 <br/>
 
 ## Install
@@ -76,6 +90,15 @@ Grab a [DeepSeek API key →](https://platform.deepseek.com/api_keys) · `reason
 
 If you use Reasonix daily, global install is the simplest path. If you just want to try it, use `npx`.
 
+**Prefer fewer keystrokes?** The shorter `dsnix` alias resolves to the same CLI:
+
+~~~bash
+npm install -g dsnix       # exposes `dsnix` on PATH, depends on reasonix
+npx dsnix@latest code      # one-shot via the shorter command
+~~~
+
+A global `npm install -g reasonix` also drops a `dsnix` shim on PATH, so the two are interchangeable.
+
 Bare `reasonix` (no subcommand) launches `code` in the current directory — typing `reasonix` and `reasonix code` are equivalent.
 
 | Command | When |
@@ -86,43 +109,19 @@ Bare `reasonix` (no subcommand) launches `code` in the current directory — typ
 | `reasonix doctor` | Health check: Node, API key, MCP wiring. |
 | `reasonix update` | Upgrade Reasonix itself. |
 
-### Terminal renderer (Rust by default)
-
-Since 0.44.0, Reasonix ships a native ratatui renderer (`reasonix-render`) as the default TUI. `npm install` resolves one of five pre-built `@reasonix/render-{platform}-{arch}` sub-packages via `optionalDependencies` so install is zero-config on **win32-x64 · linux-x64 · linux-arm64 · darwin-x64 · darwin-arm64**. No cargo, no toolchain, nothing extra to fetch.
-
-- Want the old Ink/Node TUI back? Pass `--node` to any subcommand (`reasonix --node`, `reasonix code --node`, `reasonix chat --node`) or set `REASONIX_RENDERER=node` in your shell.
-- Running on a platform without a published sub-package (Linux musl, FreeBSD, ARM v7, etc.)? Reasonix prints a one-line warning and auto-falls-back to the Ink renderer — nothing breaks.
-- Building rust from source? `cargo build --release --bin reasonix-render` inside the repo; the dev flow (`npm run dev`) does this automatically. The resolver also accepts `REASONIX_RENDER_BIN=/path/to/binary` to pin a specific build for testing.
-
 Other subcommands (`replay` · `diff` · `events` · `stats` · `index` · `mcp` · `prune-sessions`) are in `reasonix --help` and the [CLI reference](https://esengine.github.io/DeepSeek-Reasonix/#cli).
 
 ### QQ channel
 
-Reasonix can attach QQ as a remote communication channel for existing `chat` and `code` sessions. It is not a separate runtime mode.
+QQ can extend an existing `chat`, `code`, or desktop session as a remote channel. It is part of the current session flow, not a separate runtime mode.
 
-Start a session first:
+- CLI: start a session, then run `/qq connect`
+- Desktop: open `Settings -> General -> QQ Channel`
 
-~~~bash
-reasonix code
-# or
-reasonix chat
-~~~
+Once connected, QQ messages can enter the current session, assistant replies route back to QQ, and follow-up interactions can continue remotely.
 
-Then connect QQ from inside the session:
+For full setup, desktop quick start, and troubleshooting, see [QQ channel setup](./docs/qq-connect.md).
 
-~~~text
-/qq connect
-~~~
-
-Available commands:
-
-- `/qq connect`
-- `/qq status`
-- `/qq disconnect`
-
-Once enabled, later `chat` / `code` sessions auto-start the QQ channel. Slash commands, confirmation prompts, and follow-up assistant replies can continue through QQ without terminal-side input.
-
-See [QQ channel setup](./docs/qq-connect.md) for setup details and QQ Open Platform bot registration.
 ### Desktop client (prerelease)
 
 A native Tauri client for users who want a GUI over the same loop. Multi-tab, the right-panel shows files the agent has read or edited this session, the same cost / cache / token meters live at the bottom. Same DeepSeek API key, same `~/.reasonix` config — the desktop bundles its own Node runtime, no separate `npm install` step.
@@ -164,6 +163,13 @@ npx reasonix code --dir /path/to/project
 /skill new my-skill --global     # ~/.reasonix/skills for cross-project use
 ~~~
 
+**Claude-format skills also load.** `<project>/.claude/skills/<name>/SKILL.md` and `~/.claude/skills/` are read alongside Reasonix's native paths, so tooling that emits Claude-format skills works out of the box. Example — drop OpenSpec workflows in without an upstream adapter:
+
+~~~bash
+npx openspec init --tools claude    # writes .claude/skills/openspec-*/SKILL.md
+/skill openspec-propose <task>      # then invoke from Reasonix
+~~~
+
 </details>
 
 <br/>
@@ -181,7 +187,7 @@ One JSON file at `~/.reasonix/config.json` plus per-project overrides under `<pr
 | [Memory](https://esengine.github.io/DeepSeek-Reasonix/configuration.html#memory) | User-private knowledge pinned into the prefix. `user` / `feedback` / `project` / `reference` types. |
 | [Hooks](https://esengine.github.io/DeepSeek-Reasonix/configuration.html#hooks) | Shell commands on lifecycle events. `PreToolUse` (gating) · `PostToolUse` · `UserPromptSubmit` · `Stop`. |
 | [Permissions](https://esengine.github.io/DeepSeek-Reasonix/configuration.html#permissions) | Per-workspace shell allowlist. Exact-prefix match. |
-| [Web search](https://esengine.github.io/DeepSeek-Reasonix/configuration.html#search) | Mojeek by default; switch to self-hosted SearXNG or Metaso with `/search-engine`. |
+| [Web search](https://esengine.github.io/DeepSeek-Reasonix/configuration.html#search) | Bing by default; switch to Baidu AI Search, self-hosted SearXNG, Metaso, Tavily, Perplexity, Exa, Brave, or Ollama with `/search-engine`. |
 | [Semantic index](https://esengine.github.io/DeepSeek-Reasonix/configuration.html#index) | `reasonix index` — local Ollama or any OpenAI-compatible embedding endpoint. |
 
 <br/>
@@ -218,7 +224,7 @@ Click through to the full architecture writeup → [Pillar 1 — Cache-first loo
 | Configurable web search engine    | `/search-engine` | —             | —                   | —                  |
 | Persistent per-workspace sessions | yes              | partial           | n/a                 | —                  |
 | Plan mode · MCP · hooks · skills  | yes              | yes               | yes                 | partial            |
-| Web search (Mojeek + SearXNG + Metaso)   | yes              | yes               | yes                 | yes                |
+| Web search (Bing + Baidu + SearXNG + API engines) | yes              | yes               | yes                 | yes                |
 | Open community development        | yes              | —                 | —                   | yes                |
 
 For live cache-hit rates, costs, and methodology, see [`benchmarks/`](./benchmarks/) — the numbers move with model pricing, so they live with the harness, not in the README.
@@ -229,7 +235,7 @@ For live cache-hit rates, costs, and methodology, see [`benchmarks/`](./benchmar
 
 - [**Architecture**](./docs/ARCHITECTURE.md) — three pillars: cache-first loop, tool-call repair, cost control
 - [**CLI Reference**](./docs/CLI-REFERENCE.md) — every shell subcommand, every slash command, every keybinding
-- [**QQ channel setup**](./docs/qq-connect.md) — what it is, commands, setup flow, and QQ Open Platform credentials
+- [**QQ channel setup**](./docs/qq-connect.md) — CLI first-connect flow, desktop entry, and QQ Open Platform credentials
 - [**Benchmarks**](./benchmarks/) — τ-bench-lite harness, transcripts, cost methodology
 - [**Website**](https://esengine.github.io/DeepSeek-Reasonix/) — getting started, dashboard mockup, TUI mockup
 - [**Contributing**](./CONTRIBUTING.md) — comment policy, error-handling rules, library-over-hand-rolled
@@ -240,7 +246,7 @@ For live cache-hit rates, costs, and methodology, see [`benchmarks/`](./benchmar
 ## Community
 
 > [!NOTE]
-> Reasonix is open source and community-developed. The contributors wall below isn't decoration — every avatar is a real PR that shipped.
+> Reasonix is open source and community-developed. Every avatar in the Acknowledgments wall at the bottom of this file is a real PR that shipped.
 
 Scoped starter tickets — each with background, code pointers, acceptance criteria, and hints — live under the [`good first issue`](https://github.com/esengine/reasonix/labels/good%20first%20issue) label. Pick anything open.
 
@@ -260,12 +266,6 @@ Scoped starter tickets — each with background, code pointers, acceptance crite
 
 **Before your first PR**: read [`CONTRIBUTING.md`](./CONTRIBUTING.md) — short, strict rules (comments, errors, libraries-over-hand-rolled). `tests/comment-policy.test.ts` enforces the comment ones; `npm run verify` is the pre-push gate. By participating you agree to the [Code of Conduct](./CODE_OF_CONDUCT.md). Security issues → [SECURITY.md](./SECURITY.md).
 
-<p align="center">
-  <a href="https://github.com/esengine/reasonix/graphs/contributors">
-    <img src="https://contrib.rocks/image?repo=esengine/DeepSeek-Reasonix&max=100&columns=12" alt="Contributors to esengine/DeepSeek-Reasonix" width="860"/>
-  </a>
-</p>
-
 <br/>
 
 ## Non-goals
@@ -292,12 +292,52 @@ Scoped starter tickets — each with background, code pointers, acceptance crite
 
 <br/>
 
+## Support
+
+If Reasonix has been useful and you'd like to say thanks, you can. It stays a coffee, not a contract — donations don't buy feature priority or change how issues get triaged.
+
+- **International** — PayPal: [paypal.me/yuhuahui](https://paypal.me/yuhuahui)
+- **国内** — 微信支付（扫码）
+
+<p align="center">
+  <img src=".github/sponsor/wechat-pay.jpg" alt="WeChat Pay QR code" width="240"/>
+</p>
+
+<br/>
+
+## Acknowledgments
+
+A small list of folks whose work has shaped Reasonix the most — measured
+by both commit count and code volume. **Listed alphabetically, no ordering
+of importance.** The full contributor graph is on
+[GitHub](https://github.com/esengine/DeepSeek-Reasonix/graphs/contributors).
+
+- [**ctharvey**](https://github.com/ctharvey)
+- [**dimasd-angga**](https://github.com/dimasd-angga) (Dimas D. Angga)
+- [**Evan-Pycraft**](https://github.com/Evan-Pycraft)
+- [**ForeverYoungPp**](https://github.com/ForeverYoungPp)
+- [**GTC2080**](https://github.com/GTC2080) (TaoMu)
+- [**kabaka9527**](https://github.com/kabaka9527)
+- [**lisniuse**](https://github.com/lisniuse) (Richie)
+- [**wade19990814-hue**](https://github.com/wade19990814-hue)
+- [**wviana**](https://github.com/wviana) (Wesley Viana)
+
+Also a separate thank-you to [**Bernardxu123**](https://github.com/Bernardxu123)
+for designing the project logo (see [`docs/brand/`](./docs/brand/)), and to
+[AIGC Link](https://xhslink.com/m/80ngts127cA) for promoting the project on XiaoHongShu.
+
+<p align="center">
+  <a href="https://github.com/esengine/DeepSeek-Reasonix/graphs/contributors">
+    <img src="https://contrib.rocks/image?repo=esengine/DeepSeek-Reasonix&max=100&columns=12" alt="Contributors to esengine/DeepSeek-Reasonix" width="860"/>
+  </a>
+</p>
+
+<br/>
+
 ---
 
 <p align="center">
   <sub>MIT — see <a href="./LICENSE">LICENSE</a></sub>
   <br/>
-  <sub>Built by the community at <a href="https://github.com/esengine/reasonix/graphs/contributors">esengine/reasonix</a></sub>
-  <br/>
-  <sub>Special thanks to <a href="https://xhslink.com/m/80ngts127cA">AIGC Link</a> for the promotions on XiaoHongShu.</sub>
+  <sub>Built by the community at <a href="https://github.com/esengine/DeepSeek-Reasonix/graphs/contributors">esengine/DeepSeek-Reasonix</a></sub>
 </p>

README.zh-CN.md

@@ -2,11 +2,18 @@
   <img src="docs/logo.svg" alt="Reasonix" width="640"/>
 </p>
 
+> [!WARNING]
+> **这是 legacy TypeScript 线(Reasonix 0.x),仅维护。**
+> 开发已转移到 **Go 重写版** —— 见 [`main-v2`](https://github.com/esengine/DeepSeek-Reasonix/tree/main-v2) 分支(新的默认分支)与[迁移指南](https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/MIGRATING.md)。此处仅修复 bug。
+
+
 <p align="center">
   <a href="./README.md">English</a>
   &nbsp;·&nbsp;
   <strong>简体中文</strong>
   &nbsp;·&nbsp;
+  <a href="./README.ja-JP.md">日本語</a>
+  &nbsp;·&nbsp;
   <a href="https://esengine.github.io/DeepSeek-Reasonix/">官方网站</a>
   &nbsp;·&nbsp;
   <a href="https://esengine.github.io/DeepSeek-Reasonix/configuration.html?lang=zh">配置指南</a>
@@ -14,6 +21,8 @@
   <a href="./docs/ARCHITECTURE.md">架构文档</a>
   &nbsp;·&nbsp;
   <a href="./benchmarks/">基准测试</a>
+  &nbsp;·&nbsp;
+  <strong><a href="https://discord.gg/XF78rEME2D">Discord</a></strong>
 </p>
 
 <p align="center">
@@ -23,8 +32,10 @@
   <a href="https://www.npmjs.com/package/reasonix"><img src="https://img.shields.io/npm/dm/reasonix.svg?style=flat-square&color=3fb950&labelColor=161b22&label=downloads" alt="downloads"/></a>
   <a href="./package.json"><img src="https://img.shields.io/node/v/reasonix.svg?style=flat-square&color=5fa04e&labelColor=161b22&logo=nodedotjs&logoColor=white" alt="node"/></a>
   <a href="https://github.com/esengine/reasonix/stargazers"><img src="https://img.shields.io/github/stars/esengine/reasonix.svg?style=flat-square&color=dbab09&labelColor=161b22&logo=github&logoColor=white" alt="GitHub stars"/></a>
+  <a href="https://atomgit.com/esengine/DeepSeek-Reasonix"><img src="https://atomgit.com/esengine/DeepSeek-Reasonix/star/badge.svg" alt="AtomGit stars"/></a>
   <a href="https://github.com/esengine/reasonix/graphs/contributors"><img src="https://img.shields.io/github/contributors/esengine/reasonix.svg?style=flat-square&color=bc8cff&labelColor=161b22&logo=github&logoColor=white" alt="contributors"/></a>
   <a href="https://github.com/esengine/reasonix/discussions"><img src="https://img.shields.io/github/discussions/esengine/reasonix.svg?style=flat-square&color=58a6ff&labelColor=161b22&logo=github&logoColor=white" alt="Discussions"/></a>
+  <a href="https://discord.gg/XF78rEME2D"><img src="https://img.shields.io/badge/discord-join-5865F2.svg?style=flat-square&labelColor=161b22&logo=discord&logoColor=white" alt="Discord"/></a>
 </p>
 
 <p align="center">
@@ -49,6 +60,9 @@
 > [!TIP]
 > **缓存稳定不是开关，而是循环要围绕设计的不变量。** 这就是 Reasonix 只支持 DeepSeek 的根本原因 —— 每一层都为 DeepSeek 字节稳定的前缀缓存机制调过。
 
+> [!IMPORTANT]
+> **加入社区 · Community** — 中英双语 Discord，频道包括 `#求助` / `#help`、`#分享` / `#showcase`、`#想法反馈`、贡献者专属 PR 协调区。在群内绑定 GitHub 后自动识别贡献者身份。→ **<https://discord.gg/XF78rEME2D>**
+
 <br/>
 
 ## 安装
@@ -74,31 +88,15 @@ npx reasonix code   # 首次运行粘贴 DeepSeek API Key，之后会记住
 
 ### QQ 通道
 
-Reasonix 可以把 QQ 挂到现有的 `chat` / `code` 会话上，作为远程通信通道使用。它不是一个独立的新模式。
+Reasonix 可以把现有的 `chat`、`code` 或桌面端会话延伸到 QQ 上，作为远程通道使用；它扩展的是当前会话，不是独立的新运行模式。
 
-先启动一个会话：
+- CLI：先启动会话，再执行 `/qq connect`
+- 桌面端：打开 `设置 -> 通用 -> QQ通道`
 
-~~~bash
-reasonix code
-# 或
-reasonix chat
-~~~
+连接成功后，QQ 消息可以进入当前会话，助手回复会回到 QQ，后续确认和跟进交互也可以继续在 QQ 上完成。
 
-然后在会话里连接 QQ：
+完整配置、桌面端快速上手与排障说明见：[QQ 连接指南](./docs/qq-connect.zh-CN.md)。
 
-~~~text
-/qq connect
-~~~
-
-可用命令：
-
-- `/qq connect`
-- `/qq status`
-- `/qq disconnect`
-
-启用后，后续的 `chat` / `code` 会话会自动启动 QQ 通道。斜杠命令、确认提示，以及后续助手回复都可以通过 QQ 继续完成，不需要回到终端交互。
-
-详细说明见 [QQ 连接指南](./docs/qq-connect.zh-CN.md)。
 <details>
 <summary><strong>切换工作区 · chat vs. code · 写第一个 Skill</strong></summary>
 
@@ -145,7 +143,7 @@ npx reasonix code --dir /path/to/project
 | [Memory](https://esengine.github.io/DeepSeek-Reasonix/configuration.html?lang=zh#memory) | 用户私有的知识，钉进前缀。`user` / `feedback` / `project` / `reference` 四类。 |
 | [Hooks](https://esengine.github.io/DeepSeek-Reasonix/configuration.html?lang=zh#hooks) | 生命周期事件触发的 shell 命令。`PreToolUse`（拦截）· `PostToolUse` · `UserPromptSubmit` · `Stop`。 |
 | [权限](https://esengine.github.io/DeepSeek-Reasonix/configuration.html?lang=zh#permissions) | 按工作区的 shell 白名单，精确前缀匹配。 |
-| [Web 搜索](https://esengine.github.io/DeepSeek-Reasonix/configuration.html?lang=zh#search) | 默认 Mojeek；用 `/search-engine` 可切到自托管的 SearXNG 或 Metaso。 |
+| [Web 搜索](https://esengine.github.io/DeepSeek-Reasonix/configuration.html?lang=zh#search) | 默认 Bing；可用 `/search-engine` 切到百度 AI Search、自托管 SearXNG、Metaso、Tavily、Perplexity、Exa、Brave 或 Ollama。 |
 | [语义索引](https://esengine.github.io/DeepSeek-Reasonix/configuration.html?lang=zh#index) | `reasonix index` —— 本地 Ollama，或任何 OpenAI 兼容的 embedding 接口。 |
 
 <br/>
@@ -191,7 +189,7 @@ npx reasonix code --dir /path/to/project
 
 - [**架构**](./docs/ARCHITECTURE.md) —— 四大支柱、缓存优先循环、思维提取、脚手架
 - [**CLI 参考**](./docs/CLI-REFERENCE.md) —— 每个 shell 子命令、每个 slash 命令、每个快捷键
-- [**QQ 连接指南**](./docs/qq-connect.zh-CN.md) —— 通道定位、命令、配置流程和 QQ 开放平台凭据
+- [**QQ 连接指南**](./docs/qq-connect.zh-CN.md) —— CLI 首次连接流程、桌面端入口和 QQ 开放平台凭据
 - [**基准测试**](./benchmarks/) —— τ-bench-lite harness、transcript、成本方法论
 - [**官方网站**](https://esengine.github.io/DeepSeek-Reasonix/) —— 入门、Dashboard 设计稿、TUI 设计稿
 - [**贡献指南**](./CONTRIBUTING.md) —— 注释规则、错误处理、用现成库不手写
@@ -202,7 +200,7 @@ npx reasonix code --dir /path/to/project
 ## 社区
 
 > [!NOTE]
-> Reasonix 是开源、社区共建的项目。下面贡献者墙不是装饰 —— 每一个头像都对应一次真实合并的 PR。
+> Reasonix 是开源、社区共建的项目。文末"致谢"那面贡献者墙上的每一个头像，都对应一次真实合并的 PR。
 
 给新手准备的入门 issue —— 每个都带背景说明、代码定位、验收标准、提示 —— 全部挂在 [`good first issue`](https://github.com/esengine/reasonix/labels/good%20first%20issue) 标签下。挑任意一个还没人认领的就行。
 
@@ -222,12 +220,6 @@ npx reasonix code --dir /path/to/project
 
 **第一次提 PR 之前**：先读 [`CONTRIBUTING.md`](./CONTRIBUTING.md) —— 短小、严格的项目规则（注释、错误处理、用现成库不手写）。`tests/comment-policy.test.ts` 静态强制执行注释那部分，`npm run verify` 是 push 前的闸。参与本项目即同意 [行为准则](./CODE_OF_CONDUCT.md)。安全相关问题请走 [SECURITY.md](./SECURITY.md)。
 
-<p align="center">
-  <a href="https://github.com/esengine/reasonix/graphs/contributors">
-    <img src="https://contrib.rocks/image?repo=esengine/DeepSeek-Reasonix&max=100&columns=12" alt="esengine/DeepSeek-Reasonix 贡献者" width="860"/>
-  </a>
-</p>
-
 <br/>
 
 ## 不做的事
@@ -254,10 +246,50 @@ npx reasonix code --dir /path/to/project
 
 <br/>
 
+## 支持本项目
+
+如果 Reasonix 帮你省了时间或 token，欢迎请杯咖啡。捐助不会换来 feature 优先级，也不会影响 issue 的处理顺序——就是「谢谢」。
+
+- **国内** — 微信支付（扫下方二维码）
+- **海外** — PayPal: [paypal.me/yuhuahui](https://paypal.me/yuhuahui)
+
+<p align="center">
+  <img src=".github/sponsor/wechat-pay.jpg" alt="微信支付收款码" width="240"/>
+</p>
+
+<br/>
+
+## 致谢
+
+下面这些朋友的工作塑造了 Reasonix 今天的样子 —— 综合 commit 数和代码量两个维度。
+**按字母顺序排列，排名不分先后。** 完整贡献者列表在
+[GitHub](https://github.com/esengine/DeepSeek-Reasonix/graphs/contributors)。
+
+- [**ctharvey**](https://github.com/ctharvey)
+- [**dimasd-angga**](https://github.com/dimasd-angga)（Dimas D. Angga）
+- [**Evan-Pycraft**](https://github.com/Evan-Pycraft)
+- [**ForeverYoungPp**](https://github.com/ForeverYoungPp)
+- [**GTC2080**](https://github.com/GTC2080)（TaoMu）
+- [**kabaka9527**](https://github.com/kabaka9527)
+- [**lisniuse**](https://github.com/lisniuse)（Richie）
+- [**wade19990814-hue**](https://github.com/wade19990814-hue)
+- [**wviana**](https://github.com/wviana)（Wesley Viana）
+
+另外特别感谢 [**Bernardxu123**](https://github.com/Bernardxu123) 设计的项目 logo
+（见 [`docs/brand/`](./docs/brand/)），以及 [AIGC Link](https://xhslink.com/m/80ngts127cA) 在小红书上的推广。
+
+<p align="center">
+  <a href="https://github.com/esengine/DeepSeek-Reasonix/graphs/contributors">
+    <img src="https://contrib.rocks/image?repo=esengine/DeepSeek-Reasonix&max=100&columns=12" alt="esengine/DeepSeek-Reasonix 贡献者" width="860"/>
+  </a>
+</p>
+
+<br/>
+
 ---
 
 <p align="center">
   <sub>MIT —— 见 <a href="./LICENSE">LICENSE</a></sub>
   <br/>
-  <sub>由 <a href="https://github.com/esengine/reasonix/graphs/contributors">esengine/reasonix</a> 社区共建</sub>
+  <sub>由 <a href="https://github.com/esengine/DeepSeek-Reasonix/graphs/contributors">esengine/DeepSeek-Reasonix</a> 社区共建</sub>
 </p>

benchmarks/behavior-stability/harness.ts

@@ -0,0 +1,39 @@
+/** Evaluation harness — runs scenarios and collects results. */
+
+import type { EvalReport, EvalResult, EvalScenario } from "./types.js";
+
+export async function runScenarios(
+  scenarios: EvalScenario[],
+  opts: {
+    onResult?: (r: EvalResult) => void;
+  } = {},
+): Promise<EvalReport> {
+  const results: EvalResult[] = [];
+  for (const sc of scenarios) {
+    const t0 = Date.now();
+    let result: EvalResult;
+    try {
+      result = await sc.run();
+      result.durationMs = Date.now() - t0;
+    } catch (err) {
+      result = {
+        scenarioId: sc.id,
+        pass: false,
+        durationMs: Date.now() - t0,
+        details: `UNEXPECTED ERROR: ${(err as Error).message}`,
+      };
+    }
+    results.push(result);
+    opts.onResult?.(result);
+  }
+
+  // Dynamic import avoids bundling VERSION into the harness module.
+  const { VERSION } = await import("../../src/version.js");
+  return {
+    meta: {
+      date: new Date().toISOString(),
+      reasonixVersion: VERSION,
+    },
+    results,
+  };
+}

benchmarks/behavior-stability/report.ts

@@ -0,0 +1,81 @@
+/** Render behavior-stability results.json → markdown report. */
+
+import { readFileSync, writeFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import type { EvalReport } from "./types.js";
+
+interface CliArgs {
+  input: string;
+  outPath: string;
+}
+
+function parseArgs(argv: string[]): CliArgs {
+  const out: CliArgs = { input: "", outPath: "benchmarks/behavior-stability/report.md" };
+  const positional: string[] = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--out") out.outPath = argv[++i] ?? out.outPath;
+    else if (a && !a.startsWith("--")) positional.push(a);
+  }
+  out.input = positional[0] ?? "";
+  if (!out.input) {
+    throw new Error(
+      "usage: npx tsx benchmarks/behavior-stability/report.ts <results.json> [--out report.md]",
+    );
+  }
+  return out;
+}
+
+function renderHeader(report: EvalReport): string {
+  return `# Reasonix Behavior-Stability Evaluation
+
+**Date:** ${report.meta.date}
+**Version:** ${report.meta.reasonixVersion}
+`;
+}
+
+function renderSummary(report: EvalReport): string {
+  const passed = report.results.filter((r) => r.pass).length;
+  const total = report.results.length;
+  const pct = total > 0 ? ((passed / total) * 100).toFixed(0) : "0";
+
+  const rows = report.results.map((r) => {
+    const icon = r.pass ? "✅" : "❌";
+    return `| ${icon} | \`${r.scenarioId}\` | ${r.durationMs}ms | ${r.details} |`;
+  });
+
+  return `## Summary
+
+**${passed}/${total} passed (${pct}%)**
+
+| status | scenario | time | details |
+|---|---:|---:|:---|
+${rows.join("\n")}
+`;
+}
+
+function render(report: EvalReport): string {
+  return [renderHeader(report), renderSummary(report)].join("\n\n");
+}
+
+function isMain(): boolean {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  return import.meta.url === pathToFileURL(entry).href;
+}
+
+async function main(): Promise<void> {
+  const args = parseArgs(process.argv.slice(2));
+  const raw = readFileSync(args.input, "utf8");
+  const report = JSON.parse(raw) as EvalReport;
+  const md = render(report);
+  writeFileSync(args.outPath, md, "utf8");
+  console.log(`Wrote ${args.outPath} (${report.results.length} results)`);
+}
+
+if (isMain()) {
+  main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}

benchmarks/behavior-stability/runner.ts

@@ -0,0 +1,87 @@
+/** CLI runner for behavior-stability evaluation. */
+
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { loadDotenv } from "../../src/index.js";
+import { ALL_SCENARIOS, API_SCENARIOS, LOCAL_SCENARIOS } from "./scenarios.js";
+import { runScenarios } from "./harness.js";
+import type { EvalScenario } from "./types.js";
+
+loadDotenv();
+
+interface CliArgs {
+  local: boolean;
+  api: boolean;
+  outPath: string | null;
+}
+
+function parseArgs(argv: string[]): CliArgs {
+  const out: CliArgs = { local: false, api: false, outPath: null };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--local") out.local = true;
+    else if (a === "--api") out.api = true;
+    else if (a === "--out") out.outPath = argv[++i] ?? null;
+  }
+  // Default to local-only when neither flag is provided.
+  if (!out.local && !out.api) out.local = true;
+  return out;
+}
+
+function pickScenarios(args: CliArgs): EvalScenario[] {
+  const scenarios: EvalScenario[] = [];
+  if (args.local) scenarios.push(...LOCAL_SCENARIOS);
+  if (args.api) scenarios.push(...API_SCENARIOS);
+  return scenarios;
+}
+
+function isMain(): boolean {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  return import.meta.url === pathToFileURL(entry).href;
+}
+
+async function main(): Promise<void> {
+  const args = parseArgs(process.argv.slice(2));
+  const scenarios = pickScenarios(args);
+
+  if (scenarios.length === 0) {
+    console.log("No scenarios selected. Use --local, --api, or both.");
+    process.exit(0);
+  }
+
+  const categories = new Set(scenarios.map((s) => s.category));
+  console.log(`Running ${scenarios.length} scenario(s) [${[...categories].join(", ")}] …\n`);
+
+  const report = await runScenarios(scenarios, {
+    onResult: (r) => {
+      const icon = r.pass ? "✅" : "❌";
+      console.log(`${icon} ${r.scenarioId} (${r.durationMs}ms)`);
+      console.log(`   ${r.details}\n`);
+    },
+  });
+
+  const passed = report.results.filter((r) => r.pass).length;
+  const total = report.results.length;
+  console.log(`────────────────────────────────────────`);
+  console.log(`Results: ${passed}/${total} passed`);
+  console.log(`Version: ${report.meta.reasonixVersion}`);
+  console.log(`Date:    ${report.meta.date}`);
+
+  if (args.outPath) {
+    const dir = dirname(args.outPath);
+    if (dir !== ".") mkdirSync(dir, { recursive: true });
+    writeFileSync(args.outPath, `${JSON.stringify(report, null, 2)}\n`, "utf8");
+    console.log(`Wrote ${args.outPath}`);
+  }
+
+  if (passed < total) process.exit(1);
+}
+
+if (isMain()) {
+  main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}

benchmarks/behavior-stability/scenarios.ts

@@ -0,0 +1,147 @@
+/** Behavior-stability scenario for PR #1462 — constraint persistence across context folds. */
+
+import { AppendOnlyLog, SessionStats } from "../../src/index.js";
+import { ContextManager } from "../../src/context-manager.js";
+import { Usage } from "../../src/client.js";
+import type { EvalResult, EvalScenario } from "./types.js";
+
+/* ------------------------------------------------------------------ */
+/*  Helpers                                                            */
+/* ------------------------------------------------------------------ */
+
+function withTiming(fn: () => Promise<EvalResult>): Promise<EvalResult> {
+  const t0 = Date.now();
+  return fn().then((r) => ({ ...r, durationMs: Date.now() - t0 }));
+}
+
+function pass(id: string, details: string): EvalResult {
+  return { scenarioId: id, pass: true, durationMs: 0, details };
+}
+
+function fail(id: string, details: string): EvalResult {
+  return { scenarioId: id, pass: false, durationMs: 0, details };
+}
+
+/* ------------------------------------------------------------------ */
+/*  Mock client — returns a fixed summary for fold testing             */
+/* ------------------------------------------------------------------ */
+
+class MockDeepSeekClient {
+  private _replyContent: string;
+  constructor(replyContent: string) {
+    this._replyContent = replyContent;
+  }
+  async chat(): Promise<{
+    content: string;
+    reasoningContent: string;
+    usage: Usage;
+  }> {
+    return {
+      content: this._replyContent,
+      reasoningContent: "",
+      usage: new Usage(100, 50, 150, 0, 100),
+    };
+  }
+}
+
+/* ------------------------------------------------------------------ */
+/*  #1462 — Constraint persistence across folds (local)                */
+/* ------------------------------------------------------------------ */
+
+const constraintPersistence: EvalScenario = {
+  id: "constraint-persistence",
+  name: "Context fold preserves pinned constraints from system prompt",
+  category: "context",
+  requiresApi: false,
+  run: () =>
+    withTiming(async () => {
+      const systemPrompt = `You are a coding assistant.
+
+# HIGH PRIORITY constraints
+
+- DO NOT use npm install without asking.
+- Never delete files without confirmation.
+
+# User memory
+
+The user prefers TypeScript over JavaScript.
+
+# Project memory
+
+This project uses pnpm instead of npm.`;
+
+      const log = new AppendOnlyLog();
+      // Fill log with synthetic long history to trigger a fold boundary > 0.
+      for (let i = 0; i < 40; i++) {
+        log.append({
+          role: "user",
+          content: `Turn ${i}: Please review the codebase and tell me what you found.`,
+        });
+        log.append({
+          role: "assistant",
+          content: `Turn ${i} summary: I reviewed the codebase and found several issues including unused imports, missing type annotations, and inconsistent formatting.`,
+        });
+      }
+
+      const client = new MockDeepSeekClient("Summary of all prior turns.");
+      const stats = new SessionStats();
+      const ctx = new ContextManager({
+        client: client as any,
+        log,
+        stats,
+        sessionName: null,
+        getAbortSignal: () => new AbortController().signal,
+        getCurrentTurn: () => 1,
+        getSystemPrompt: () => systemPrompt,
+      });
+
+      // Use a tiny tail budget so almost everything becomes head and gets summarized.
+      const result = await ctx.fold("deepseek-v4-flash", { keepRecentTokens: 200 });
+
+      if (!result.folded) {
+        return fail(
+          "constraint-persistence",
+          `Fold did not happen (before=${result.beforeMessages}, after=${result.afterMessages}).`,
+        );
+      }
+
+      const foldedSystem = log.toMessages()[0];
+      if (foldedSystem?.role !== "assistant") {
+        return fail(
+          "constraint-persistence",
+          `Expected first folded message to be assistant summary, got ${foldedSystem?.role}.`,
+        );
+      }
+
+      const content = foldedSystem.content as string;
+      const checks = [
+        { text: "DO NOT use npm install without asking", label: "HIGH PRIORITY constraint" },
+        { text: "Never delete files without confirmation", label: "HIGH PRIORITY constraint 2" },
+        { text: "TypeScript over JavaScript", label: "User memory" },
+        { text: "pnpm instead of npm", label: "Project memory" },
+      ];
+
+      const missing = checks.filter((c) => !content.includes(c.text));
+      if (missing.length > 0) {
+        return fail(
+          "constraint-persistence",
+          `Folded summary missing ${missing.length} constraint(s): ${missing.map((m) => m.label).join(", ")}.`,
+        );
+      }
+
+      return pass(
+        "constraint-persistence",
+        `Fold reduced ${result.beforeMessages} → ${result.afterMessages} messages and preserved all ${checks.length} pinned constraints.`,
+      );
+    }),
+};
+
+/* ------------------------------------------------------------------ */
+/*  Exports                                                            */
+/* ------------------------------------------------------------------ */
+
+export const LOCAL_SCENARIOS: EvalScenario[] = [constraintPersistence];
+
+export const API_SCENARIOS: EvalScenario[] = [];
+
+export const ALL_SCENARIOS: EvalScenario[] = [...LOCAL_SCENARIOS, ...API_SCENARIOS];

benchmarks/behavior-stability/types.ts

@@ -0,0 +1,26 @@
+/** Behavior-stability evaluation types — lightweight, local-first regression suite. */
+
+export interface EvalScenario {
+  id: string;
+  name: string;
+  category: "shell" | "context" | "integrity";
+  /** True when the scenario calls the live LLM API (costs money). */
+  requiresApi: boolean;
+  run: () => Promise<EvalResult>;
+}
+
+export interface EvalResult {
+  scenarioId: string;
+  pass: boolean;
+  durationMs: number;
+  details: string;
+}
+
+export interface EvalReport {
+  meta: {
+    date: string;
+    reasonixVersion: string;
+    model?: string;
+  };
+  results: EvalResult[];
+}

benchmarks/compression-eval/.gitignore

@@ -0,0 +1 @@
+runs/

benchmarks/compression-eval/driver.ts

@@ -0,0 +1,165 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { resolvePreset } from "../../src/cli/ui/presets.js";
+import { DeepSeekClient } from "../../src/client.js";
+import { codeSystemPrompt } from "../../src/code/prompt.js";
+import { buildCodeToolset } from "../../src/code/setup.js";
+import { loadApiKey, loadBaseUrl, loadPreset } from "../../src/config.js";
+import { loadDotenv } from "../../src/env.js";
+import { CacheFirstLoop } from "../../src/loop.js";
+import { ImmutablePrefix } from "../../src/memory/runtime.js";
+import { DEEPSEEK_CONTEXT_TOKENS } from "../../src/telemetry/stats.js";
+
+interface DriverOptions {
+  taskFile: string;
+  transcriptOut: string;
+  budgetUsd: number;
+  rootDir: string;
+  /** Override DEEPSEEK_CONTEXT_TOKENS to force fold triggers on short tasks. */
+  fakeCtxMax: number | null;
+}
+
+function parseArgs(argv: string[]): DriverOptions {
+  let taskFile = "";
+  let transcriptOut = "";
+  let budgetUsd = 2.0;
+  let rootDir = process.cwd();
+  let fakeCtxMax: number | null = null;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]!;
+    if (a === "--task-file") taskFile = argv[++i]!;
+    else if (a === "--transcript-out") transcriptOut = argv[++i]!;
+    else if (a === "--budget") budgetUsd = Number(argv[++i]);
+    else if (a === "--root") rootDir = argv[++i]!;
+    else if (a === "--fake-ctxmax") fakeCtxMax = Number(argv[++i]);
+  }
+  if (!taskFile || !transcriptOut) {
+    console.error(
+      "usage: driver.ts --task-file <p> --transcript-out <p> [--budget 2] [--root <dir>] [--fake-ctxmax N]",
+    );
+    process.exit(1);
+  }
+  return { taskFile, transcriptOut, budgetUsd, rootDir, fakeCtxMax };
+}
+
+interface TurnRecord {
+  turn: number;
+  role: string;
+  prompt_tokens?: number;
+  cache_hit_tokens?: number;
+  cache_miss_tokens?: number;
+  cost_usd?: number;
+  tool?: string;
+  content_preview?: string;
+}
+
+async function main(): Promise<void> {
+  loadDotenv();
+  const opts = parseArgs(process.argv.slice(2));
+  const key = loadApiKey();
+  if (!key) {
+    console.error("DEEPSEEK_API_KEY missing — run `reasonix setup` first");
+    process.exit(1);
+  }
+  process.env.DEEPSEEK_API_KEY = key;
+
+  const presetSettings = resolvePreset(loadPreset());
+  const model = presetSettings.model;
+  if (opts.fakeCtxMax !== null && opts.fakeCtxMax > 0) {
+    for (const k of Object.keys(DEEPSEEK_CONTEXT_TOKENS)) {
+      DEEPSEEK_CONTEXT_TOKENS[k] = opts.fakeCtxMax;
+    }
+    console.log(`ctxMax override (ALL deepseek models): -> ${opts.fakeCtxMax}`);
+  }
+  console.log(`model: ${model}`);
+  console.log(`root:  ${opts.rootDir}`);
+  console.log(`budget: $${opts.budgetUsd}`);
+
+  const task = readFileSync(opts.taskFile, "utf8").trim();
+  console.log(`task: ${task.length} chars`);
+
+  const toolset = await buildCodeToolset({ rootDir: opts.rootDir });
+  console.log(`tools: ${toolset.tools.specs().length} registered`);
+
+  const client = new DeepSeekClient({ baseUrl: loadBaseUrl() });
+  const prefix = new ImmutablePrefix({
+    system: codeSystemPrompt(opts.rootDir),
+    toolSpecs: toolset.tools.specs(),
+  });
+  const loop = new CacheFirstLoop({
+    client,
+    prefix,
+    tools: toolset.tools,
+    model,
+    budgetUsd: opts.budgetUsd,
+  });
+
+  const records: TurnRecord[] = [];
+  const t0 = Date.now();
+  let lastTurn = 0;
+  try {
+    for await (const ev of loop.step(task)) {
+      if (ev.role === "assistant_final" && ev.stats?.usage) {
+        const u = ev.stats.usage;
+        const rec: TurnRecord = {
+          turn: ev.turn,
+          role: "assistant_final",
+          prompt_tokens: u.promptTokens,
+          cache_hit_tokens: u.promptCacheHitTokens,
+          cache_miss_tokens: u.promptCacheMissTokens,
+          cost_usd: ev.stats.cost,
+          content_preview: (ev.content ?? "").slice(0, 200),
+        };
+        records.push(rec);
+        lastTurn = ev.turn;
+        const ratio = u.promptCacheHitTokens / (u.promptTokens || 1);
+        process.stdout.write(
+          `  turn ${ev.turn}: pt=${u.promptTokens} hit=${(ratio * 100).toFixed(1)}% cost=$${ev.stats.cost.toFixed(4)}\n`,
+        );
+      } else if (ev.role === "tool" && ev.toolName) {
+        records.push({
+          turn: ev.turn,
+          role: "tool",
+          tool: ev.toolName,
+          content_preview: (ev.content ?? "").slice(0, 200),
+        });
+      } else if (ev.role === "warning" || ev.role === "status") {
+        const lc = (ev.content ?? "").toLowerCase();
+        const isFold = lc.includes("fold") || lc.includes("compact") || lc.includes("summar");
+        records.push({
+          turn: ev.turn,
+          role: isFold ? "fold_event" : `${ev.role}_event`,
+          content_preview: ev.content,
+        });
+        if (isFold) {
+          process.stdout.write(
+            `  ⟳ ${ev.role.toUpperCase()} at turn ${ev.turn}: ${ev.content.slice(0, 120)}\n`,
+          );
+        }
+      } else if (ev.role === "error") {
+        records.push({ turn: ev.turn, role: "error", content_preview: ev.error });
+        process.stdout.write(`  ✗ error turn ${ev.turn}: ${ev.error}\n`);
+      } else if (ev.role === "done") {
+        process.stdout.write(`  ✓ done (turn ${ev.turn})\n`);
+      }
+    }
+  } catch (err) {
+    process.stdout.write(`  ✗ loop threw: ${(err as Error).message}\n`);
+  }
+
+  const elapsed = Math.round((Date.now() - t0) / 1000);
+  const s = loop.stats.summary();
+  console.log(
+    `\nDONE turns=${lastTurn} elapsed=${elapsed}s cache=${(s.cacheHitRatio * 100).toFixed(1)}% cost=$${s.totalCostUsd.toFixed(4)}`,
+  );
+
+  writeFileSync(
+    opts.transcriptOut,
+    `${JSON.stringify({ _meta: { model, task_length: task.length, elapsed_s: elapsed, summary: s } })}\n${records.map((r) => JSON.stringify(r)).join("\n")}\n`,
+  );
+  console.log(`transcript: ${opts.transcriptOut}`);
+}
+
+main().catch((err) => {
+  console.error("driver crashed:", err);
+  process.exit(1);
+});

benchmarks/compression-eval/e2e.ts

@@ -0,0 +1,325 @@
+import { spawnSync } from "node:child_process";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+interface RunSpec {
+  name: string;
+  foldThreshold: number;
+  aggressiveThreshold: number;
+}
+
+interface RunSummary {
+  name: string;
+  repeat: number;
+  turns: number;
+  cacheHitRatio: number;
+  costUsd: number;
+  totalInputTokens: number;
+  cacheHitTokens: number;
+  cacheMissTokens: number;
+  foldCount: number;
+  exitCode: number;
+}
+
+const RUNS: RunSpec[] = [
+  { name: "no-fold", foldThreshold: 0.99, aggressiveThreshold: 0.99 },
+  { name: "current_50_70", foldThreshold: 0.5, aggressiveThreshold: 0.7 },
+  { name: "very_late_75_90", foldThreshold: 0.75, aggressiveThreshold: 0.9 },
+  { name: "aggressive_90_95", foldThreshold: 0.9, aggressiveThreshold: 0.95 },
+];
+
+function parseArgs(argv: string[]): {
+  taskFile: string;
+  budget: number;
+  outDir: string;
+  only: string | null;
+  fakeCtxMax: number | null;
+  repeats: number;
+} {
+  let taskFile = "";
+  let budget = 2.0;
+  let outDir = "";
+  let only: string | null = null;
+  let fakeCtxMax: number | null = null;
+  let repeats = 1;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]!;
+    if (a === "--task-file") taskFile = argv[++i]!;
+    else if (a === "--budget") budget = Number(argv[++i]);
+    else if (a === "--out-dir") outDir = argv[++i]!;
+    else if (a === "--only") only = argv[++i]!;
+    else if (a === "--fake-ctxmax") fakeCtxMax = Number(argv[++i]);
+    else if (a === "--repeats") repeats = Number(argv[++i]);
+  }
+  if (!taskFile) {
+    console.error(
+      "usage: tsx e2e.ts --task-file <p> [--budget N] [--out-dir <p>] [--only <n>] [--fake-ctxmax N] [--repeats N]",
+    );
+    process.exit(1);
+  }
+  if (!outDir) {
+    const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    outDir = `benchmarks/compression-eval/runs/${ts}`;
+  }
+  return { taskFile, budget, outDir, only, fakeCtxMax, repeats };
+}
+
+function loadTranscriptSummary(path: string): Partial<RunSummary> {
+  let turns = 0;
+  let inputTokens = 0;
+  let cacheHit = 0;
+  let cacheMiss = 0;
+  let costUsd = 0;
+  let foldCount = 0;
+  const promptSeq: number[] = [];
+  try {
+    const lines = readFileSync(path, "utf8").split("\n");
+    for (const ln of lines) {
+      const t = ln.trim();
+      if (!t) continue;
+      let rec: {
+        role?: string;
+        prompt_tokens?: number;
+        cache_hit_tokens?: number;
+        cache_miss_tokens?: number;
+        cost_usd?: number;
+      };
+      try {
+        rec = JSON.parse(t);
+      } catch {
+        continue;
+      }
+      if (rec.role === "assistant_final") {
+        turns++;
+        const pt = rec.prompt_tokens ?? 0;
+        inputTokens += pt;
+        cacheHit += rec.cache_hit_tokens ?? 0;
+        cacheMiss += rec.cache_miss_tokens ?? 0;
+        costUsd += rec.cost_usd ?? 0;
+        if (pt > 0) promptSeq.push(pt);
+      } else if (rec.role === "fold_event") {
+        foldCount++;
+      }
+    }
+  } catch {
+    /* file missing — caller will see exitCode and zeros */
+  }
+  if (foldCount === 0) {
+    for (let i = 1; i < promptSeq.length; i++) {
+      if (promptSeq[i]! < promptSeq[i - 1]! * 0.6) foldCount++;
+    }
+  }
+  return {
+    turns,
+    totalInputTokens: inputTokens,
+    cacheHitTokens: cacheHit,
+    cacheMissTokens: cacheMiss,
+    cacheHitRatio: inputTokens > 0 ? cacheHit / inputTokens : 0,
+    costUsd,
+    foldCount,
+  };
+}
+
+function runOne(
+  spec: RunSpec,
+  task: string,
+  budget: number,
+  outDir: string,
+  fakeCtxMax: number | null,
+  repeat: number,
+): RunSummary {
+  const runName = repeat > 1 ? `${spec.name}_r${repeat}` : spec.name;
+  const runDir = join(outDir, runName);
+  mkdirSync(runDir, { recursive: true });
+  const transcript = join(runDir, "transcript.jsonl");
+  const logPath = join(runDir, "stdout.log");
+
+  console.log(
+    `\n>>> [${spec.name}] fold=${spec.foldThreshold} agg=${spec.aggressiveThreshold}`,
+  );
+  const tsxCli = join("node_modules", "tsx", "dist", "cli.mjs");
+  const taskFilePath = join(runDir, "task.txt");
+  writeFileSync(taskFilePath, task);
+  const t0 = Date.now();
+  const res = spawnSync(
+    process.execPath,
+    [
+      tsxCli,
+      "benchmarks/compression-eval/driver.ts",
+      "--task-file",
+      taskFilePath,
+      "--transcript-out",
+      transcript,
+      "--budget",
+      String(budget),
+      ...(fakeCtxMax ? ["--fake-ctxmax", String(fakeCtxMax)] : []),
+    ],
+    {
+      env: {
+        ...process.env,
+        REASONIX_FOLD_THRESHOLD: String(spec.foldThreshold),
+        REASONIX_FOLD_AGGRESSIVE_THRESHOLD: String(spec.aggressiveThreshold),
+      },
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: false,
+      maxBuffer: 1024 * 1024 * 128,
+    },
+  );
+  const exitCode = res.status ?? -1;
+  const stdout = res.stdout ?? "";
+  const stderr = res.stderr ?? "";
+  const elapsedS = Math.round((Date.now() - t0) / 1000);
+  writeFileSync(logPath, `${stdout}\n--- stderr ---\n${stderr}`);
+  console.log(`    exit=${exitCode} elapsed=${elapsedS}s log=${logPath}`);
+
+  const parsed = loadTranscriptSummary(transcript);
+  return {
+    name: spec.name,
+    repeat,
+    turns: parsed.turns ?? 0,
+    cacheHitRatio: parsed.cacheHitRatio ?? 0,
+    costUsd: parsed.costUsd ?? 0,
+    totalInputTokens: parsed.totalInputTokens ?? 0,
+    cacheHitTokens: parsed.cacheHitTokens ?? 0,
+    cacheMissTokens: parsed.cacheMissTokens ?? 0,
+    foldCount: parsed.foldCount ?? 0,
+    exitCode,
+  };
+}
+
+function pct(n: number): string {
+  return `${(n * 100).toFixed(1)}%`;
+}
+function fmtTok(n: number): string {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(2)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+  return String(n);
+}
+
+interface AggregateRow {
+  name: string;
+  n: number;
+  meanCost: number;
+  stdCost: number;
+  meanMiss: number;
+  stdMiss: number;
+  meanHitPct: number;
+  stdHitPct: number;
+  meanTurns: number;
+  meanFolds: number;
+}
+
+function meanStd(xs: number[]): [number, number] {
+  if (xs.length === 0) return [0, 0];
+  const m = xs.reduce((a, b) => a + b, 0) / xs.length;
+  const v = xs.reduce((a, b) => a + (b - m) ** 2, 0) / xs.length;
+  return [m, Math.sqrt(v)];
+}
+
+function aggregateByConfig(rows: RunSummary[]): AggregateRow[] {
+  const groups = new Map<string, RunSummary[]>();
+  for (const r of rows) {
+    if (!groups.has(r.name)) groups.set(r.name, []);
+    groups.get(r.name)!.push(r);
+  }
+  const result: AggregateRow[] = [];
+  for (const [name, group] of groups) {
+    const [meanCost, stdCost] = meanStd(group.map((r) => r.costUsd));
+    const [meanMiss, stdMiss] = meanStd(group.map((r) => r.cacheMissTokens));
+    const [meanHitPct, stdHitPct] = meanStd(group.map((r) => r.cacheHitRatio * 100));
+    const [meanTurns] = meanStd(group.map((r) => r.turns));
+    const [meanFolds] = meanStd(group.map((r) => r.foldCount));
+    result.push({
+      name,
+      n: group.length,
+      meanCost,
+      stdCost,
+      meanMiss,
+      stdMiss,
+      meanHitPct,
+      stdHitPct,
+      meanTurns,
+      meanFolds,
+    });
+  }
+  return result;
+}
+
+function reportAggregate(rows: AggregateRow[]): string {
+  const cols: Array<[string, (r: AggregateRow) => string]> = [
+    ["config", (r) => r.name],
+    ["n", (r) => String(r.n)],
+    ["turns", (r) => r.meanTurns.toFixed(1)],
+    ["folds", (r) => r.meanFolds.toFixed(1)],
+    ["hit%", (r) => `${r.meanHitPct.toFixed(1)}±${r.stdHitPct.toFixed(1)}`],
+    ["miss", (r) => `${fmtTok(r.meanMiss)}±${fmtTok(r.stdMiss)}`],
+    ["cost$", (r) => `${r.meanCost.toFixed(4)}±${r.stdCost.toFixed(4)}`],
+  ];
+  const widths = cols.map(([h, f]) => Math.max(h.length, ...rows.map((r) => f(r).length)));
+  const head = cols.map(([h], i) => h.padEnd(widths[i]!)).join("│ ");
+  const sep = "─".repeat(widths.reduce((a, b) => a + b + 2, 0));
+  const body = rows
+    .map((r) => cols.map(([_, f], i) => f(r).padEnd(widths[i]!)).join("│ "))
+    .join("\n");
+  return `${head}\n${sep}\n${body}`;
+}
+
+function reportTable(rows: RunSummary[]): string {
+  const cols: Array<[string, (r: RunSummary) => string]> = [
+    ["config", (r) => r.name],
+    ["turns", (r) => String(r.turns)],
+    ["input", (r) => fmtTok(r.totalInputTokens)],
+    ["hit", (r) => fmtTok(r.cacheHitTokens)],
+    ["hit%", (r) => pct(r.cacheHitRatio)],
+    ["miss", (r) => fmtTok(r.cacheMissTokens)],
+    ["folds", (r) => String(r.foldCount)],
+    ["cost", (r) => `$${r.costUsd.toFixed(4)}`],
+    ["exit", (r) => String(r.exitCode)],
+  ];
+  const widths = cols.map(([h, f]) => Math.max(h.length, ...rows.map((r) => f(r).length)));
+  const head = cols.map(([h], i) => h.padEnd(widths[i]!)).join("│ ");
+  const sep = "─".repeat(widths.reduce((a, b) => a + b + 2, 0));
+  const body = rows
+    .map((r) => cols.map(([_, f], i) => f(r).padEnd(widths[i]!)).join("│ "))
+    .join("\n");
+  return `${head}\n${sep}\n${body}`;
+}
+
+function main(): void {
+  const { taskFile, budget, outDir, only, fakeCtxMax, repeats } = parseArgs(process.argv.slice(2));
+  const task = readFileSync(taskFile, "utf8").trim();
+  mkdirSync(outDir, { recursive: true });
+  const specs = only ? RUNS.filter((r) => r.name === only) : RUNS;
+  if (specs.length === 0) {
+    console.error(`no config matches --only=${only}; available: ${RUNS.map((r) => r.name).join(", ")}`);
+    process.exit(1);
+  }
+  console.log(`task: ${taskFile} (${task.length} chars)`);
+  console.log(`out:  ${outDir}`);
+  console.log(`budget per run: $${budget}`);
+  console.log(`configs: ${specs.map((s) => s.name).join(", ")}`);
+  console.log(`repeats: ${repeats}`);
+  if (fakeCtxMax) console.log(`fake ctxMax: ${fakeCtxMax}`);
+
+  const summaries: RunSummary[] = [];
+  for (let r = 1; r <= repeats; r++) {
+    for (const spec of specs) {
+      summaries.push(runOne(spec, task, budget, outDir, fakeCtxMax, r));
+    }
+  }
+
+  const table = reportTable(summaries);
+  console.log(`\n=== Raw runs ===\n${table}`);
+  if (repeats > 1) {
+    const agg = aggregateByConfig(summaries);
+    const aggTable = reportAggregate(agg);
+    console.log(`\n=== Aggregate (mean ± std) ===\n${aggTable}`);
+    writeFileSync(join(outDir, "aggregate.txt"), aggTable);
+  }
+  writeFileSync(join(outDir, "summary.json"), JSON.stringify(summaries, null, 2));
+  writeFileSync(join(outDir, "summary.txt"), table);
+  console.log(`\nsaved: ${join(outDir, "summary.json")}`);
+}
+
+main();

benchmarks/compression-eval/run.ts

@@ -0,0 +1,89 @@
+import { basename } from "node:path";
+import { loadSession, simulate, type RunResult, type ThresholdConfig } from "./simulator.js";
+
+const BASELINE: ThresholdConfig = {
+  ctxMax: 1_000_000,
+  foldThreshold: 0.5,
+  tailFraction: 0.2,
+  aggressiveThreshold: 0.7,
+  aggressiveTailFraction: 0.1,
+  minSavingsFraction: 0.3,
+  summaryRatio: 0.05,
+};
+
+interface NamedConfig {
+  name: string;
+  config: ThresholdConfig;
+}
+
+function configs(ctxMax: number): NamedConfig[] {
+  const mk = (over: Partial<ThresholdConfig>): ThresholdConfig => ({ ...BASELINE, ...over, ctxMax });
+  return [
+    { name: "no-fold", config: mk({ foldThreshold: 999, aggressiveThreshold: 999 }) },
+    { name: "current (50/70)", config: mk({ foldThreshold: 0.5, aggressiveThreshold: 0.7 }) },
+    { name: "late (60/80)", config: mk({ foldThreshold: 0.6, aggressiveThreshold: 0.8 }) },
+    { name: "very-late (75/90)", config: mk({ foldThreshold: 0.75, aggressiveThreshold: 0.9 }) },
+    { name: "early (35/55)", config: mk({ foldThreshold: 0.35, aggressiveThreshold: 0.55 }) },
+  ];
+}
+
+function parseArgs(argv: string[]): { sessions: string[]; ctxMax: number } {
+  const sessions: string[] = [];
+  let ctxMax = 1_000_000;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]!;
+    if (a === "--ctx-max") ctxMax = Number(argv[++i]);
+    else if (a === "--session") sessions.push(argv[++i]!);
+    else if (!a.startsWith("--")) sessions.push(a);
+  }
+  return { sessions, ctxMax };
+}
+
+function fmt(n: number): string {
+  if (n >= 1e9) return `${(n / 1e9).toFixed(2)}G`;
+  if (n >= 1e6) return `${(n / 1e6).toFixed(2)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+  return String(n);
+}
+
+function pct(n: number): string {
+  return `${(n * 100).toFixed(1)}%`;
+}
+
+function report(label: string, rows: Array<{ name: string; result: RunResult }>): void {
+  console.log(`\n=== ${label} ===`);
+  const w = [22, 10, 10, 8, 10, 6, 10];
+  const headers = ["config", "input", "cache_hit", "hit%", "miss", "folds", "peak"];
+  console.log(headers.map((h, i) => h.padEnd(w[i]!)).join("│ "));
+  console.log("─".repeat(w.reduce((a, b) => a + b + 2, 0)));
+  for (const { name, result: r } of rows) {
+    const peak = r.perTurn.reduce((m, t) => Math.max(m, t.ratio), 0);
+    console.log(
+      [
+        name.padEnd(w[0]!),
+        fmt(r.totalInputTokens).padEnd(w[1]!),
+        fmt(r.totalCacheHitTokens).padEnd(w[2]!),
+        pct(r.cacheHitRatio).padEnd(w[3]!),
+        fmt(r.totalCacheMissTokens).padEnd(w[4]!),
+        String(r.foldCount).padEnd(w[5]!),
+        pct(peak).padEnd(w[6]!),
+      ].join("│ "),
+    );
+  }
+}
+
+function main(): void {
+  const { sessions, ctxMax } = parseArgs(process.argv.slice(2));
+  if (sessions.length === 0) {
+    console.error("usage: tsx run.ts [--ctx-max N] <session.jsonl> [more...]");
+    process.exit(1);
+  }
+  for (const path of sessions) {
+    const msgs = loadSession(path);
+    const cfgs = configs(ctxMax);
+    const rows = cfgs.map(({ name, config }) => ({ name, result: simulate(msgs, config, path) }));
+    report(`${basename(path)}  (${msgs.length} msgs, ctxMax=${fmt(ctxMax)})`, rows);
+  }
+}
+
+main();

benchmarks/compression-eval/simulator.ts

@@ -0,0 +1,197 @@
+import { readFileSync } from "node:fs";
+import {
+  countTokensBounded,
+  estimateConversationTokens,
+  estimateRequestTokens,
+} from "../../src/tokenizer.js";
+import type { ChatMessage } from "../../src/types.js";
+
+export interface ThresholdConfig {
+  ctxMax: number;
+  foldThreshold: number;
+  tailFraction: number;
+  aggressiveThreshold: number;
+  aggressiveTailFraction: number;
+  minSavingsFraction: number;
+  summaryRatio: number;
+}
+
+export interface FoldEvent {
+  turn: number;
+  ratioBeforeFold: number;
+  promptTokensBefore: number;
+  headMessages: number;
+  tailMessages: number;
+  headTokens: number;
+  summaryTokens: number;
+  aggressive: boolean;
+}
+
+export interface TurnRecord {
+  turn: number;
+  promptTokens: number;
+  cacheHitTokens: number;
+  cacheMissTokens: number;
+  ratio: number;
+  folded: boolean;
+}
+
+export interface RunResult {
+  config: ThresholdConfig;
+  sessionPath: string;
+  totalTurns: number;
+  totalInputTokens: number;
+  totalCacheHitTokens: number;
+  totalCacheMissTokens: number;
+  cacheHitRatio: number;
+  foldCount: number;
+  folds: FoldEvent[];
+  perTurn: TurnRecord[];
+}
+
+export function loadSession(path: string): ChatMessage[] {
+  const lines = readFileSync(path, "utf8").split("\n");
+  const out: ChatMessage[] = [];
+  for (const ln of lines) {
+    const t = ln.trim();
+    if (!t) continue;
+    try {
+      out.push(JSON.parse(t) as ChatMessage);
+    } catch {
+      continue;
+    }
+  }
+  return out;
+}
+
+function messageTokens(m: ChatMessage): number {
+  return estimateConversationTokens([m], true);
+}
+
+function messageKey(m: ChatMessage): string {
+  return JSON.stringify({
+    r: m.role,
+    c: m.content ?? "",
+    tc: m.tool_calls ?? null,
+    tcid: m.tool_call_id ?? null,
+  });
+}
+
+function commonPrefixTokens(curr: ChatMessage[], prev: ChatMessage[]): number {
+  const n = Math.min(curr.length, prev.length);
+  let tokens = 0;
+  for (let i = 0; i < n; i++) {
+    if (messageKey(curr[i]!) !== messageKey(prev[i]!)) break;
+    tokens += messageTokens(curr[i]!);
+  }
+  return tokens;
+}
+
+function findFoldBoundary(log: ChatMessage[], tailBudget: number): number {
+  let cum = 0;
+  let boundary = log.length;
+  for (let i = log.length - 1; i >= 0; i--) {
+    const t = messageTokens(log[i]!);
+    if (cum + t > tailBudget) break;
+    cum += t;
+    if (log[i]!.role === "user") boundary = i;
+  }
+  return boundary;
+}
+
+function synthesizeSummary(head: ChatMessage[], targetTokens: number): ChatMessage {
+  const userBits: string[] = [];
+  for (const m of head) {
+    if (m.role === "user" && typeof m.content === "string") userBits.push(m.content);
+  }
+  const seed = userBits.join("\n") || "earlier turns folded";
+  let text = `[CONVERSATION HISTORY SUMMARY — fold of ${head.length} messages]\n\n${seed}`;
+  const currentTokens = countTokensBounded(text);
+  if (currentTokens > targetTokens) {
+    const ratio = targetTokens / currentTokens;
+    text = text.slice(0, Math.max(80, Math.floor(text.length * ratio)));
+  }
+  return { role: "assistant", content: text, reasoning_content: "" };
+}
+
+function turnBoundaries(messages: ChatMessage[]): number[] {
+  const ends: number[] = [];
+  for (let i = 0; i < messages.length; i++) {
+    if (messages[i]!.role === "assistant") ends.push(i);
+  }
+  return ends;
+}
+
+export function simulate(messages: ChatMessage[], config: ThresholdConfig, sessionPath: string): RunResult {
+  const ends = turnBoundaries(messages);
+  const log: ChatMessage[] = [];
+  let prevSnapshot: ChatMessage[] = [];
+  const perTurn: TurnRecord[] = [];
+  const folds: FoldEvent[] = [];
+  let totalInput = 0;
+  let totalHit = 0;
+  let totalMiss = 0;
+  let cursor = 0;
+
+  for (let turn = 0; turn < ends.length; turn++) {
+    const end = ends[turn]!;
+    for (let i = cursor; i < end; i++) log.push(messages[i]!);
+    cursor = end;
+
+    const promptTokens = estimateRequestTokens(log, null, true);
+    const ratio = promptTokens / config.ctxMax;
+    const hit = commonPrefixTokens(log, prevSnapshot);
+    const miss = Math.max(0, promptTokens - hit);
+    let folded = false;
+
+    if (ratio > config.foldThreshold) {
+      const aggressive = ratio > config.aggressiveThreshold;
+      const tailFrac = aggressive ? config.aggressiveTailFraction : config.tailFraction;
+      const tailBudget = Math.floor(config.ctxMax * tailFrac);
+      const boundary = findFoldBoundary(log, tailBudget);
+      if (boundary > 0) {
+        const head = log.slice(0, boundary);
+        const tail = log.slice(boundary);
+        const headTokens = head.reduce((a, m) => a + messageTokens(m), 0);
+        const totalTokens = log.reduce((a, m) => a + messageTokens(m), 0);
+        if (headTokens >= totalTokens * config.minSavingsFraction) {
+          const summaryTokens = Math.max(64, Math.floor(headTokens * config.summaryRatio));
+          const summary = synthesizeSummary(head, summaryTokens);
+          const next = [summary, ...tail];
+          log.length = 0;
+          for (const m of next) log.push(m);
+          folds.push({
+            turn,
+            ratioBeforeFold: ratio,
+            promptTokensBefore: promptTokens,
+            headMessages: head.length,
+            tailMessages: tail.length,
+            headTokens,
+            summaryTokens,
+            aggressive,
+          });
+          folded = true;
+        }
+      }
+    }
+
+    totalInput += promptTokens;
+    totalHit += hit;
+    totalMiss += miss;
+    perTurn.push({ turn, promptTokens, cacheHitTokens: hit, cacheMissTokens: miss, ratio, folded });
+    prevSnapshot = log.slice();
+  }
+
+  return {
+    config,
+    sessionPath,
+    totalTurns: ends.length,
+    totalInputTokens: totalInput,
+    totalCacheHitTokens: totalHit,
+    totalCacheMissTokens: totalMiss,
+    cacheHitRatio: totalInput > 0 ? totalHit / totalInput : 0,
+    foldCount: folds.length,
+    folds,
+    perTurn,
+  };
+}

benchmarks/compression-eval/task.txt

@@ -0,0 +1,13 @@
+为这个仓库的 src/ 目录写一份完整的架构总览文档。
+
+要求：
+1. 用 read_file / directory_tree / grep_search 等工具，**逐个**读取 src/ 下每个子目录（cli/, mcp/, memory/, telemetry/, transcript/, tools/, ui/, i18n/, loop/ 等）的代表性文件。每个子目录至少读 3-5 个核心 .ts 文件。
+2. 不要只 grep 关键词就下结论 —— 必须打开文件读真实内容，从代码里抽出"这个模块的职责 / 它的核心数据结构 / 它对外暴露什么"。
+3. 边读边在心里搭建依赖图。
+4. 全部读完后，输出一份 markdown 报告，包含：
+   - 整体架构图（mermaid 或 ASCII，模块之间的依赖关系）
+   - 按模块列出：职责 / 关键文件 / 对外接口 / 内部依赖
+   - 至少 8 个具体的代码引用（路径:行号），证明你真读了
+   - 结尾给出"如果新人加入项目，应该按什么顺序读代码"的建议
+
+这是一个真实的代码审计任务，请不要偷懒、不要瞎编、不要用通用模板。文件读得不够多就直接说"我读得不够"。

benchmarks/real-world-cache/README.md

@@ -20,22 +20,22 @@ Used with permission, anonymized.
 ## Cost — using the prices Reasonix bills against (`src/telemetry/stats.ts`)
 
 USD per 1M tokens — `inputCacheHit / inputCacheMiss / output`:
-- `deepseek-v4-flash` — `0.028 / 0.139 / 0.278`
-- `deepseek-v4-pro` — `0.139 / 1.667 / 3.333`
+- `deepseek-v4-flash` — `0.0028 / 0.14 / 0.28`
+- `deepseek-v4-pro` — `0.003625 / 0.435 / 0.87`
 
 Assuming **v4-flash** (the project default):
 
 | | This user (99.82% hit) | Same workload, **0% cache** |
 |---|---:|---:|
-| Cache-hit input | $12.18 | — |
-| Cache-miss input | $0.11 | $60.58 |
+| Cache-hit input | $1.22 | — |
+| Cache-miss input | $0.11 | $61.01 |
 | Output | $0.05 | $0.05 |
-| **Total / day** | **$12.34** | **$60.63** |
+| **Total / day** | **$1.38** | **$61.06** |
 
-→ Cache saved this user **$48.29**, or **~80%** off the un-cached baseline, on a single day.
+→ Cache saved this user **$59.68**, or **~97.7%** off the un-cached baseline, on a single day.
 
-On **v4-pro** (5× the prefix-cache discount) the same workload would cost
-**~$62.35** vs **~$727.08** without cache — a **~91% saving**.
+On **v4-pro** (6.25% of uncached input cost) the same workload would cost
+**~$2.07** vs **~$189.73** without cache — a **~98.9%** saving.
 
 ## "Isn't that just DeepSeek's prefix cache?"
 
@@ -59,8 +59,9 @@ hit rates:
 3. **`VolatileScratch`** — chain-of-thought / per-turn scratch lives outside
    the cached prefix so it never poisons the next hit.
 4. **Auto-compact** — when context approaches the cap, older turns fold into
-   a summary message *appended* to the prefix; the prefix itself isn't
-   rewritten, so the cache survives the fold.
+   a summary message. The summary request is shaped to reuse the main agent's
+   already-cached system/tool/history prefix; the following main-agent request
+   still pays a cold miss for the newly synthesized summary segment.
 
 DeepSeek gave us cacheable bytes. The four mechanisms above are how we keep
 the bytes cacheable.

biome.json

@@ -24,6 +24,13 @@
     }
   },
   "files": {
-    "ignore": ["dist", "node_modules", "coverage", "*.d.ts", "dashboard/codemirror.js"]
+    "ignore": [
+      "dist",
+      "node_modules",
+      "coverage",
+      "*.d.ts",
+      "dashboard/codemirror.js",
+      "packages/ink/**"
+    ]
   }
 }

crates/reasonix-render/Cargo.toml

@@ -1,18 +0,0 @@
-[package]
-name = "reasonix-render"
-version = "0.1.0"
-edition.workspace = true
-license.workspace = true
-publish.workspace = true
-
-[dependencies]
-anyhow = "1"
-arboard = { version = "3", default-features = false }
-chrono = { version = "0.4", features = ["clock"] }
-crossterm = "0.29"
-ctrlc = { version = "3", features = ["termination"] }
-pulldown-cmark = { version = "0.13", default-features = false }
-ratatui = "0.30"
-serde = { version = "1", features = ["derive"] }
-serde_json = "1"
-unicode-width = "0.2"

crates/reasonix-render/src/decode_only.rs

@@ -1,18 +0,0 @@
-use std::io::{BufRead, Write};
-
-use anyhow::{Context, Result};
-
-pub fn run_decode_only<R: BufRead, W: Write>(input: R, mut output: W) -> Result<u64> {
-    let mut count = 0u64;
-    for (lineno, line) in input.lines().enumerate() {
-        let line = line.with_context(|| format!("read line {}", lineno + 1))?;
-        if line.trim().is_empty() {
-            continue;
-        }
-        let _value: serde_json::Value =
-            serde_json::from_str(&line).with_context(|| format!("decode line {}", lineno + 1))?;
-        count += 1;
-        writeln!(output, "frame {count}").ok();
-    }
-    Ok(count)
-}

crates/reasonix-render/src/editor.rs

@@ -1,110 +0,0 @@
-pub fn insert_char_at(buffer: &mut String, char_idx: usize, ch: char) {
-    let byte_idx = char_to_byte(buffer, char_idx);
-    buffer.insert(byte_idx, ch);
-}
-
-pub fn remove_char_at(buffer: &mut String, char_idx: usize) {
-    let Some((byte_idx, _)) = buffer.char_indices().nth(char_idx) else {
-        return;
-    };
-    buffer.remove(byte_idx);
-}
-
-pub fn char_to_byte(buffer: &str, char_idx: usize) -> usize {
-    buffer
-        .char_indices()
-        .nth(char_idx)
-        .map(|(b, _)| b)
-        .unwrap_or(buffer.len())
-}
-
-pub fn prev_word_boundary(buffer: &str, from: usize) -> usize {
-    let chars: Vec<char> = buffer.chars().collect();
-    let mut i = from.min(chars.len());
-    while i > 0 && chars[i - 1].is_whitespace() {
-        i -= 1;
-    }
-    while i > 0 && !chars[i - 1].is_whitespace() {
-        i -= 1;
-    }
-    i
-}
-
-pub fn next_word_boundary(buffer: &str, from: usize) -> usize {
-    let chars: Vec<char> = buffer.chars().collect();
-    let mut i = from.min(chars.len());
-    let n = chars.len();
-    while i < n && !chars[i].is_whitespace() {
-        i += 1;
-    }
-    while i < n && chars[i].is_whitespace() {
-        i += 1;
-    }
-    i
-}
-
-pub fn locate_cursor_in(buffer: &str, cursor: usize) -> (usize, usize) {
-    let mut line = 0usize;
-    let mut col = 0usize;
-    for (idx, ch) in buffer.chars().enumerate() {
-        if idx == cursor {
-            return (line, col);
-        }
-        if ch == '\n' {
-            line += 1;
-            col = 0;
-        } else {
-            col += 1;
-        }
-    }
-    (line, col)
-}
-
-pub fn line_col_to_cursor(buffer: &str, target_line: usize, target_col: usize) -> usize {
-    let mut line = 0usize;
-    let mut col = 0usize;
-    let mut idx = 0usize;
-    for ch in buffer.chars() {
-        if line == target_line && col == target_col {
-            return idx;
-        }
-        if ch == '\n' {
-            if line == target_line {
-                return idx;
-            }
-            line += 1;
-            col = 0;
-        } else {
-            col += 1;
-        }
-        idx += 1;
-    }
-    idx
-}
-
-pub fn move_cursor_line(buffer: &str, cursor: usize, delta: isize) -> usize {
-    let (line, col) = locate_cursor_in(buffer, cursor);
-    let new_line = if delta < 0 {
-        line.saturating_sub((-delta) as usize)
-    } else {
-        line + delta as usize
-    };
-    let max_line = buffer.chars().filter(|c| *c == '\n').count();
-    if new_line > max_line {
-        return buffer.chars().count();
-    }
-    if new_line == line {
-        return cursor;
-    }
-    line_col_to_cursor(buffer, new_line, col)
-}
-
-pub fn cursor_on_first_line(buffer: &str, cursor: usize) -> bool {
-    locate_cursor_in(buffer, cursor).0 == 0
-}
-
-pub fn cursor_on_last_line(buffer: &str, cursor: usize) -> bool {
-    let (line, _) = locate_cursor_in(buffer, cursor);
-    let last_line = buffer.chars().filter(|c| *c == '\n').count();
-    line >= last_line
-}

crates/reasonix-render/src/frame_cache.rs

@@ -1,81 +0,0 @@
-/// Frame identity cache — skips deserialization and rendering when consecutive
-/// frames are byte-identical. The trace scene emitted by useSceneTrace only
-/// changes when cards, model, or activity label change, so most frames between
-/// streaming deltas are duplicates.
-///
-/// Ratatui's Terminal::draw already diffs cells against the previous terminal
-/// state before emitting ANSI. This cache operates one layer above: it avoids
-/// the JSON parse + scene render + ratatui diff pipeline entirely for
-/// unchanged frames, saving CPU on both the JS and Rust sides of the bridge.
-#[derive(Default)]
-pub struct FrameCache {
-    /// Raw JSON line from the previous frame.
-    prev_raw: String,
-    /// Number of consecutive skipped frames.
-    skipped: u64,
-    /// False until the first frame is seen — guarantees is_new returns true for frame 0.
-    has_prev: bool,
-}
-
-impl FrameCache {
-    /// Returns true if this raw JSON line differs from the previous one
-    /// (or if no previous frame exists). False means the frame is a
-    /// byte-for-byte duplicate and can be skipped entirely.
-    pub fn is_new(&mut self, raw: &str) -> bool {
-        if !self.has_prev {
-            self.prev_raw.clear();
-            self.prev_raw.push_str(raw);
-            self.has_prev = true;
-            return true;
-        }
-        if raw == self.prev_raw {
-            self.skipped = self.skipped.saturating_add(1);
-            return false;
-        }
-        self.prev_raw.clear();
-        self.prev_raw.push_str(raw);
-        self.skipped = 0;
-        true
-    }
-
-    /// Number of consecutive frames skipped since the last rendered frame.
-    pub fn skipped_count(&self) -> u64 {
-        self.skipped
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn first_frame_is_always_new() {
-        let mut cache = FrameCache::default();
-        assert!(cache.is_new(r#"{"v":1}"#));
-    }
-
-    #[test]
-    fn identical_frame_is_skipped() {
-        let mut cache = FrameCache::default();
-        assert!(cache.is_new(r#"{"v":1}"#));
-        assert!(!cache.is_new(r#"{"v":1}"#));
-        assert_eq!(cache.skipped_count(), 1);
-    }
-
-    #[test]
-    fn changed_frame_is_not_skipped() {
-        let mut cache = FrameCache::default();
-        assert!(cache.is_new(r#"{"v":1}"#));
-        assert!(cache.is_new(r#"{"v":2}"#));
-        assert_eq!(cache.skipped_count(), 0);
-    }
-
-    #[test]
-    fn empty_string_is_valid_frame() {
-        let mut cache = FrameCache::default();
-        // Empty lines are filtered before reaching the cache in main.rs,
-        // but if one arrives it should be treated normally.
-        assert!(cache.is_new(""));
-        assert!(!cache.is_new(""));
-    }
-}

crates/reasonix-render/src/input.rs

@@ -1,113 +0,0 @@
-use crossterm::event::{
-    KeyCode, KeyEvent, KeyEventKind, KeyModifiers, MouseButton, MouseEvent, MouseEventKind,
-};
-use serde::Serialize;
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
-pub struct InputEvent {
-    pub event: &'static str,
-    pub code: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub char: Option<char>,
-    #[serde(skip_serializing_if = "Vec::is_empty", default)]
-    pub modifiers: Vec<&'static str>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
-pub struct PasteEvent {
-    pub event: &'static str,
-    pub text: String,
-}
-
-pub fn paste_event(text: String) -> PasteEvent {
-    PasteEvent {
-        event: "paste",
-        text,
-    }
-}
-
-pub fn translate_key(event: &KeyEvent) -> Option<InputEvent> {
-    if event.kind != KeyEventKind::Press {
-        return None;
-    }
-    let (code, ch) = match event.code {
-        KeyCode::Char(c) => ("Char".to_string(), Some(c)),
-        KeyCode::Enter => ("Enter".to_string(), None),
-        KeyCode::Esc => ("Esc".to_string(), None),
-        KeyCode::Up => ("Up".to_string(), None),
-        KeyCode::Down => ("Down".to_string(), None),
-        KeyCode::Left => ("Left".to_string(), None),
-        KeyCode::Right => ("Right".to_string(), None),
-        KeyCode::Backspace => ("Backspace".to_string(), None),
-        KeyCode::Tab => ("Tab".to_string(), None),
-        KeyCode::BackTab => ("BackTab".to_string(), None),
-        KeyCode::Home => ("Home".to_string(), None),
-        KeyCode::End => ("End".to_string(), None),
-        KeyCode::PageUp => ("PageUp".to_string(), None),
-        KeyCode::PageDown => ("PageDown".to_string(), None),
-        KeyCode::Delete => ("Delete".to_string(), None),
-        KeyCode::Insert => ("Insert".to_string(), None),
-        KeyCode::F(n) => (format!("F{n}"), None),
-        _ => return None,
-    };
-    Some(InputEvent {
-        event: "key",
-        code,
-        char: ch,
-        modifiers: collect_modifiers(event.modifiers),
-    })
-}
-
-fn collect_modifiers(m: KeyModifiers) -> Vec<&'static str> {
-    let mut out = Vec::new();
-    if m.contains(KeyModifiers::CONTROL) {
-        out.push("ctrl");
-    }
-    if m.contains(KeyModifiers::ALT) {
-        out.push("alt");
-    }
-    if m.contains(KeyModifiers::SHIFT) {
-        out.push("shift");
-    }
-    if m.contains(KeyModifiers::SUPER) {
-        out.push("super");
-    }
-    out
-}
-
-pub fn is_quit(event: &KeyEvent) -> bool {
-    event.kind == KeyEventKind::Press
-        && event.code == KeyCode::Char('c')
-        && event.modifiers.contains(KeyModifiers::CONTROL)
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
-pub struct MouseInputEvent {
-    pub event: &'static str,
-    pub kind: &'static str,
-    /// 1-based row, matching the VT mouse-report convention the JS side expects.
-    pub row: u16,
-    /// 1-based column, same convention as row.
-    pub col: u16,
-    #[serde(skip_serializing_if = "Vec::is_empty", default)]
-    pub modifiers: Vec<&'static str>,
-}
-
-pub fn translate_mouse(event: &MouseEvent) -> Option<MouseInputEvent> {
-    let kind = match event.kind {
-        MouseEventKind::Down(MouseButton::Left) => "click",
-        MouseEventKind::Drag(MouseButton::Left) => "drag",
-        MouseEventKind::Up(_) => "release",
-        MouseEventKind::ScrollUp => "scroll-up",
-        MouseEventKind::ScrollDown => "scroll-down",
-        _ => return None,
-    };
-    Some(MouseInputEvent {
-        event: "mouse",
-        kind,
-        // crossterm reports 0-based row/col; bump to 1-based on the wire.
-        row: event.row.saturating_add(1),
-        col: event.column.saturating_add(1),
-        modifiers: collect_modifiers(event.modifiers),
-    })
-}

crates/reasonix-render/src/lib.rs

@@ -1,9 +0,0 @@
-pub mod decode_only;
-pub mod editor;
-pub mod frame_cache;
-pub mod input;
-pub mod integrated;
-pub mod state;
-pub mod theme;
-pub mod view;
-pub mod whole_screen;

crates/reasonix-render/src/main.rs

@@ -1,768 +0,0 @@
-use std::io::{self, BufRead, BufWriter, Write};
-
-use anyhow::{Context, Result};
-use crossterm::event::{
-    self, DisableBracketedPaste, DisableMouseCapture, EnableBracketedPaste, EnableMouseCapture,
-    Event,
-};
-use crossterm::execute;
-use crossterm::terminal::{disable_raw_mode, enable_raw_mode};
-use ratatui::backend::CrosstermBackend;
-
-use reasonix_render::decode_only::run_decode_only;
-use reasonix_render::editor::{
-    char_to_byte, insert_char_at, move_cursor_line, next_word_boundary, prev_word_boundary,
-    remove_char_at,
-};
-use reasonix_render::frame_cache::FrameCache;
-use reasonix_render::input::{is_quit, paste_event, translate_key, translate_mouse};
-use reasonix_render::state::{decode_message, Payload};
-use reasonix_render::view::render_setup;
-use reasonix_render::whole_screen::{
-    at_completion, at_match_count, cards_layout, demo_state, extract_text, slash_completion,
-    slash_is_exact, slash_match_count, Selection, WholeScreen,
-};
-
-type RenderTerminal = ratatui::Terminal<CrosstermBackend<BufWriter<io::Stdout>>>;
-
-fn debug_log(msg: &str) {
-    let Ok(enabled) = std::env::var("REASONIX_RENDER_DEBUG") else {
-        return;
-    };
-    if enabled.is_empty() || enabled == "0" {
-        return;
-    }
-    let path = std::env::var("REASONIX_RENDER_DEBUG_LOG").unwrap_or_else(|_| {
-        let home = std::env::var("USERPROFILE")
-            .or_else(|_| std::env::var("HOME"))
-            .unwrap_or_default();
-        if home.is_empty() {
-            "reasonix-render-debug.log".to_string()
-        } else {
-            format!("{home}/.reasonix/rust-render-debug.log")
-        }
-    });
-    if let Some(parent) = std::path::Path::new(&path).parent() {
-        let _ = std::fs::create_dir_all(parent);
-    }
-    if let Ok(mut f) = std::fs::OpenOptions::new()
-        .create(true)
-        .append(true)
-        .open(&path)
-    {
-        let _ = writeln!(f, "[reasonix-render] {msg}");
-    }
-}
-
-fn main() -> Result<()> {
-    let args: Vec<String> = std::env::args().skip(1).collect();
-    if args.iter().any(|a| a == "--decode-only") {
-        let stdin = io::stdin();
-        let stdout = io::stdout();
-        run_decode_only(stdin.lock(), stdout.lock())?;
-        return Ok(());
-    }
-    if args.iter().any(|a| a == "--emit-input") {
-        install_signal_cleanup();
-        return run_emit_input();
-    }
-
-    install_panic_hook();
-    install_signal_cleanup();
-    let mut terminal = init_terminal().context("init terminal")?;
-    terminal.hide_cursor().ok();
-    terminal.clear().ok();
-
-    if let Ok(size) = terminal.size() {
-        debug_log(&format!(
-            "startup terminal.size = {}x{}",
-            size.width, size.height
-        ));
-    }
-
-    let result = if args.iter().any(|a| a == "--demo") {
-        run_demo_loop(&mut terminal)
-    } else if args.iter().any(|a| a == "--integrated") {
-        reasonix_render::integrated::run_integrated_loop(&mut terminal)
-    } else {
-        run_stream_loop(&mut terminal)
-    };
-
-    restore_terminal(&mut terminal);
-    result
-}
-
-fn init_terminal() -> Result<RenderTerminal> {
-    enable_raw_mode().context("enable raw mode")?;
-    let mut stdout = BufWriter::new(io::stdout());
-    crossterm::execute!(stdout, crossterm::terminal::EnterAlternateScreen)
-        .context("enter alt screen")?;
-    let backend = CrosstermBackend::new(stdout);
-    let terminal = ratatui::Terminal::new(backend).context("create terminal")?;
-    Ok(terminal)
-}
-
-fn restore_terminal(terminal: &mut RenderTerminal) {
-    terminal.show_cursor().ok();
-    crossterm::execute!(
-        terminal.backend_mut(),
-        crossterm::terminal::LeaveAlternateScreen
-    )
-    .ok();
-    disable_raw_mode().ok();
-}
-
-/// Best-effort terminal restore on SIGTERM / SIGHUP / Windows console-close.
-/// In raw mode ctrl+c is delivered as the byte 0x03 to crossterm and never
-/// fires SIGINT, so the existing `is_quit` event-loop branch handles
-/// interactive ctrl+c with a clean restore_terminal. This guard covers the
-/// other paths — `taskkill`, parent process death, terminal disconnect — that
-/// would otherwise leave the alt-screen + raw mode dirty and corrupt the
-/// next launch's rendering.
-fn install_signal_cleanup() {
-    let _ = ctrlc::set_handler(|| {
-        let _ = disable_raw_mode();
-        let _ = crossterm::execute!(
-            io::stdout(),
-            crossterm::terminal::LeaveAlternateScreen,
-            crossterm::cursor::Show,
-        );
-        std::process::exit(130);
-    });
-}
-
-fn install_panic_hook() {
-    let original = std::panic::take_hook();
-    std::panic::set_hook(Box::new(move |info| {
-        let home = std::env::var("USERPROFILE")
-            .or_else(|_| std::env::var("HOME"))
-            .unwrap_or_default();
-        if !home.is_empty() {
-            let path = format!("{home}/.reasonix/rust-panic.log");
-            if let Some(parent) = std::path::Path::new(&path).parent() {
-                let _ = std::fs::create_dir_all(parent);
-            }
-            if let Ok(mut f) = std::fs::OpenOptions::new()
-                .create(true)
-                .append(true)
-                .open(&path)
-            {
-                let now = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
-                let _ = writeln!(f, "[{now}] {info}");
-                let bt = std::backtrace::Backtrace::force_capture();
-                let _ = writeln!(f, "{bt}\n");
-            }
-        }
-        let _ = disable_raw_mode();
-        let _ = crossterm::execute!(io::stdout(), crossterm::terminal::LeaveAlternateScreen);
-        original(info);
-    }));
-}
-
-fn run_demo_loop(terminal: &mut RenderTerminal) -> Result<()> {
-    use crossterm::event::{
-        DisableMouseCapture, EnableMouseCapture, KeyCode, KeyEventKind, KeyModifiers, MouseButton,
-        MouseEventKind,
-    };
-    use reasonix_render::state::SceneCard;
-
-    let mut stdout = io::stdout();
-    let mouse_enabled = crossterm::execute!(stdout, EnableMouseCapture).is_ok();
-
-    let mut state = demo_state();
-    let mut buffer = String::new();
-    let mut cursor: usize = 0;
-    let mut scroll_offset: u16 = 0;
-    let mut selection: Option<Selection> = None;
-    let mut dragging = false;
-    let mut slash_idx: usize = 0;
-    let mut at_idx: usize = 0;
-    let mut sidebar_visible = true;
-    let mut tick: u32 = 0;
-    let tick_period = std::time::Duration::from_millis(80);
-    let scroll_step: u16 = 3;
-    let page_step: u16 = 10;
-
-    let result: Result<()> = (|| loop {
-        let buf_chars = buffer.chars().count();
-        if cursor > buf_chars {
-            cursor = buf_chars;
-        }
-        state.composer_text = Some(buffer.clone());
-        state.composer_cursor = Some(cursor);
-
-        let slash_count = slash_match_count(&buffer, &state);
-        if slash_count == 0 {
-            slash_idx = 0;
-        } else if slash_idx >= slash_count {
-            slash_idx = slash_count - 1;
-        }
-        let at_count = if slash_count > 0 {
-            0
-        } else {
-            at_match_count(&buffer, &state)
-        };
-        if at_count == 0 {
-            at_idx = 0;
-        } else if at_idx >= at_count {
-            at_idx = at_count - 1;
-        }
-
-        let _ = crossterm::execute!(
-            terminal.backend_mut(),
-            crossterm::terminal::BeginSynchronizedUpdate
-        );
-        terminal
-            .draw(|f| {
-                let area = f.area();
-                f.render_widget(
-                    WholeScreen::new(&state)
-                        .with_scroll(scroll_offset)
-                        .with_selection(selection)
-                        .with_slash_index(slash_idx)
-                        .with_at_index(at_idx)
-                        .with_sidebar_visible(sidebar_visible)
-                        .with_tick(tick),
-                    area,
-                );
-            })
-            .context("terminal draw")?;
-        let _ = crossterm::execute!(
-            terminal.backend_mut(),
-            crossterm::terminal::EndSynchronizedUpdate
-        );
-
-        if !event::poll(tick_period)? {
-            tick = tick.wrapping_add(1);
-            continue;
-        }
-
-        match event::read()? {
-            Event::Key(key) if key.kind != KeyEventKind::Press => continue,
-            Event::Key(key) => {
-                if is_quit(&key) {
-                    if let Some(sel) = selection {
-                        if let Ok(size) = terminal.size() {
-                            let rect = ratatui::layout::Rect::new(0, 0, size.width, size.height);
-                            let text =
-                                extract_text(&state, scroll_offset, rect, sel, sidebar_visible);
-                            if !text.is_empty() {
-                                if let Ok(mut cb) = arboard::Clipboard::new() {
-                                    let _ = cb.set_text(text);
-                                }
-                            }
-                        }
-                        selection = None;
-                        continue;
-                    }
-                    return Ok(());
-                }
-                if key.code == KeyCode::Char('d') && key.modifiers.contains(KeyModifiers::CONTROL) {
-                    return Ok(());
-                }
-                if key.code == KeyCode::Char('b') && key.modifiers.contains(KeyModifiers::CONTROL) {
-                    sidebar_visible = !sidebar_visible;
-                    continue;
-                }
-                let slash_active = slash_count > 0;
-                let at_active = !slash_active && at_count > 0;
-                let slash_complete_only = slash_active && !slash_is_exact(&buffer, &state);
-                match key.code {
-                    KeyCode::Up if slash_active => {
-                        slash_idx = slash_idx.saturating_sub(1);
-                    }
-                    KeyCode::Down if slash_active => {
-                        slash_idx = (slash_idx + 1).min(slash_count - 1);
-                    }
-                    KeyCode::Tab if slash_active => {
-                        if let Some(completion) = slash_completion(&buffer, slash_idx, &state) {
-                            buffer = completion.trim_end().to_string();
-                            cursor = buffer.chars().count();
-                        }
-                    }
-                    KeyCode::BackTab if slash_active => {
-                        slash_idx = if slash_idx == 0 {
-                            slash_count - 1
-                        } else {
-                            slash_idx - 1
-                        };
-                    }
-                    KeyCode::Enter if slash_complete_only => {
-                        if let Some(completion) = slash_completion(&buffer, slash_idx, &state) {
-                            cursor = completion.chars().count();
-                            buffer = completion;
-                        }
-                    }
-                    KeyCode::Up if at_active => {
-                        at_idx = at_idx.saturating_sub(1);
-                    }
-                    KeyCode::Down if at_active => {
-                        at_idx = (at_idx + 1).min(at_count - 1);
-                    }
-                    KeyCode::Tab if at_active => {
-                        if let Some(completion) = at_completion(&buffer, at_idx, &state) {
-                            cursor = completion.chars().count();
-                            buffer = completion;
-                        }
-                    }
-                    KeyCode::BackTab if at_active => {
-                        at_idx = if at_idx == 0 {
-                            at_count - 1
-                        } else {
-                            at_idx - 1
-                        };
-                    }
-                    KeyCode::Enter if at_active => {
-                        if let Some(completion) = at_completion(&buffer, at_idx, &state) {
-                            cursor = completion.chars().count();
-                            buffer = completion;
-                        }
-                    }
-                    KeyCode::Up => {
-                        cursor = move_cursor_line(&buffer, cursor, -1);
-                    }
-                    KeyCode::Down => {
-                        cursor = move_cursor_line(&buffer, cursor, 1);
-                    }
-                    KeyCode::Esc => {
-                        if selection.is_some() {
-                            selection = None;
-                        } else {
-                            buffer.clear();
-                            cursor = 0;
-                            slash_idx = 0;
-                            at_idx = 0;
-                        }
-                    }
-                    KeyCode::PageUp => {
-                        scroll_offset = scroll_offset.saturating_add(page_step);
-                    }
-                    KeyCode::PageDown => {
-                        scroll_offset = scroll_offset.saturating_sub(page_step);
-                    }
-                    KeyCode::Left if key.modifiers.contains(KeyModifiers::CONTROL) => {
-                        cursor = prev_word_boundary(&buffer, cursor);
-                    }
-                    KeyCode::Right if key.modifiers.contains(KeyModifiers::CONTROL) => {
-                        cursor = next_word_boundary(&buffer, cursor);
-                    }
-                    KeyCode::Left => {
-                        cursor = cursor.saturating_sub(1);
-                    }
-                    KeyCode::Right => {
-                        cursor = (cursor + 1).min(buffer.chars().count());
-                    }
-                    KeyCode::Home => {
-                        cursor = 0;
-                    }
-                    KeyCode::End => {
-                        cursor = buffer.chars().count();
-                    }
-                    KeyCode::Char(c) if !key.modifiers.contains(KeyModifiers::CONTROL) => {
-                        selection = None;
-                        insert_char_at(&mut buffer, cursor, c);
-                        cursor += 1;
-                        slash_idx = 0;
-                        at_idx = 0;
-                        scroll_offset = 0;
-                    }
-                    KeyCode::Backspace if key.modifiers.contains(KeyModifiers::CONTROL) => {
-                        selection = None;
-                        let new_cursor = prev_word_boundary(&buffer, cursor);
-                        let from_byte = char_to_byte(&buffer, new_cursor);
-                        let to_byte = char_to_byte(&buffer, cursor);
-                        buffer.drain(from_byte..to_byte);
-                        cursor = new_cursor;
-                        slash_idx = 0;
-                        at_idx = 0;
-                    }
-                    KeyCode::Backspace => {
-                        selection = None;
-                        if cursor > 0 {
-                            remove_char_at(&mut buffer, cursor - 1);
-                            cursor -= 1;
-                        }
-                        slash_idx = 0;
-                        at_idx = 0;
-                    }
-                    KeyCode::Delete => {
-                        if cursor < buffer.chars().count() {
-                            remove_char_at(&mut buffer, cursor);
-                        }
-                        slash_idx = 0;
-                        at_idx = 0;
-                    }
-                    KeyCode::Enter if key.modifiers.contains(KeyModifiers::SHIFT) => {
-                        selection = None;
-                        insert_char_at(&mut buffer, cursor, '\n');
-                        cursor += 1;
-                        slash_idx = 0;
-                        at_idx = 0;
-                    }
-                    KeyCode::Enter => {
-                        selection = None;
-                        let text = buffer.trim().to_string();
-                        if !text.is_empty() {
-                            state.cards.push(SceneCard {
-                                kind: "user".to_string(),
-                                body: Some(text),
-                                ts: Some(chrono::Local::now().timestamp()),
-                                ..Default::default()
-                            });
-                        }
-                        buffer.clear();
-                        cursor = 0;
-                        slash_idx = 0;
-                        at_idx = 0;
-                        scroll_offset = 0;
-                    }
-                    _ => {}
-                }
-            }
-            Event::Mouse(m) => {
-                let term_size = terminal.size().ok();
-                let term_rect =
-                    term_size.map(|s| ratatui::layout::Rect::new(0, 0, s.width, s.height));
-                match m.kind {
-                    MouseEventKind::Down(MouseButton::Left) => {
-                        if let Some(rect) = term_rect {
-                            let layout = cards_layout(rect, &state, scroll_offset, sidebar_visible);
-                            if layout.contains_screen(m.column, m.row) {
-                                let (col, virt_y) = layout.project_clamped(m.column, m.row);
-                                selection = Some(Selection::new(col, virt_y));
-                                dragging = true;
-                            } else {
-                                selection = None;
-                                dragging = false;
-                            }
-                        }
-                    }
-                    MouseEventKind::Drag(MouseButton::Left) if dragging => {
-                        if let Some(rect) = term_rect {
-                            let layout = cards_layout(rect, &state, scroll_offset, sidebar_visible);
-                            let (col, virt_y) = layout.project_clamped(m.column, m.row);
-                            if let Some(s) = selection.as_mut() {
-                                s.extend(col, virt_y);
-                            }
-                            let top = layout.screen_rect.y;
-                            let bottom = layout.screen_rect.bottom();
-                            if m.row < top {
-                                scroll_offset = scroll_offset.saturating_add(1);
-                            } else if bottom > 0 && m.row >= bottom.saturating_sub(1) {
-                                scroll_offset = scroll_offset.saturating_sub(1);
-                            }
-                        }
-                    }
-                    MouseEventKind::Up(MouseButton::Left) => {
-                        dragging = false;
-                        if let Some(sel) = selection {
-                            if !sel.is_empty() {
-                                if let Ok(size) = terminal.size() {
-                                    let rect =
-                                        ratatui::layout::Rect::new(0, 0, size.width, size.height);
-                                    let text = extract_text(
-                                        &state,
-                                        scroll_offset,
-                                        rect,
-                                        sel,
-                                        sidebar_visible,
-                                    );
-                                    if !text.is_empty() {
-                                        if let Ok(mut cb) = arboard::Clipboard::new() {
-                                            let _ = cb.set_text(text);
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    MouseEventKind::ScrollUp => {
-                        scroll_offset = scroll_offset.saturating_add(scroll_step);
-                    }
-                    MouseEventKind::ScrollDown => {
-                        scroll_offset = scroll_offset.saturating_sub(scroll_step);
-                    }
-                    _ => {}
-                }
-            }
-            Event::Resize(_, _) => {}
-            _ => {}
-        }
-        tick = tick.wrapping_add(1);
-    })();
-
-    if mouse_enabled {
-        let _ = crossterm::execute!(io::stdout(), DisableMouseCapture);
-    }
-    result
-}
-
-fn run_stream_loop(terminal: &mut RenderTerminal) -> Result<()> {
-    use crossterm::event::{DisableMouseCapture, EnableMouseCapture, MouseButton, MouseEventKind};
-    use std::sync::mpsc;
-    use std::thread;
-    use std::time::Duration;
-
-    let mouse_enabled = crossterm::execute!(io::stdout(), EnableMouseCapture).is_ok();
-
-    let (tx, rx) = mpsc::channel::<String>();
-    let _reader = thread::spawn(move || {
-        let stdin = io::stdin();
-        for line in stdin.lock().lines() {
-            let Ok(l) = line else {
-                break;
-            };
-            if tx.send(l).is_err() {
-                break;
-            }
-        }
-    });
-
-    let mut logged_first_frame = false;
-    let mut last_size = terminal.size().ok();
-    let mut current_state: Option<Payload> = None;
-    let mut scroll_offset: u16 = 0;
-    let mut selection: Option<Selection> = None;
-    let mut dragging = false;
-    let mut tick: u32 = 0;
-    let tick_period = Duration::from_millis(80);
-    let scroll_step: u16 = 3;
-    let mut frame_cache = FrameCache::default();
-
-    let result: Result<()> = (|| loop {
-        let mut state_changed = false;
-        let mut stdin_closed = false;
-        loop {
-            match rx.try_recv() {
-                Ok(line) => {
-                    if line.trim().is_empty() {
-                        continue;
-                    }
-                    if !frame_cache.is_new(&line) {
-                        continue;
-                    }
-                    if let Ok(p) = decode_message(&line) {
-                        current_state = Some(p);
-                        state_changed = true;
-                    }
-                }
-                Err(mpsc::TryRecvError::Empty) => break,
-                Err(mpsc::TryRecvError::Disconnected) => {
-                    stdin_closed = true;
-                    break;
-                }
-            }
-        }
-
-        let current_size = terminal.size().ok();
-        if current_size != last_size {
-            terminal.clear().ok();
-            last_size = current_size;
-            state_changed = true;
-        }
-
-        if state_changed {
-            if let Some(payload) = &current_state {
-                draw_atomic_with_ui(
-                    terminal,
-                    payload,
-                    &mut logged_first_frame,
-                    scroll_offset,
-                    selection,
-                    tick,
-                )?;
-            }
-        }
-
-        if stdin_closed && current_state.is_none() {
-            return Ok(());
-        }
-
-        if crossterm::event::poll(tick_period)? {
-            let evt = crossterm::event::read()?;
-            let mut dirty = false;
-            if let Event::Mouse(m) = evt {
-                if let Some(Payload::Trace(state)) = current_state.as_ref() {
-                    if let Ok(size) = terminal.size() {
-                        let rect = ratatui::layout::Rect::new(0, 0, size.width, size.height);
-                        let layout = cards_layout(rect, state, scroll_offset, true);
-                        match m.kind {
-                            MouseEventKind::Down(MouseButton::Left) => {
-                                if layout.contains_screen(m.column, m.row) {
-                                    let (col, virt_y) = layout.project_clamped(m.column, m.row);
-                                    selection = Some(Selection::new(col, virt_y));
-                                    dragging = true;
-                                } else {
-                                    selection = None;
-                                    dragging = false;
-                                }
-                                dirty = true;
-                            }
-                            MouseEventKind::Drag(MouseButton::Left) if dragging => {
-                                let (col, virt_y) = layout.project_clamped(m.column, m.row);
-                                if let Some(s) = selection.as_mut() {
-                                    s.extend(col, virt_y);
-                                }
-                                let top = layout.screen_rect.y;
-                                let bottom = layout.screen_rect.bottom();
-                                if m.row < top {
-                                    scroll_offset = scroll_offset.saturating_add(1);
-                                } else if bottom > 0 && m.row >= bottom.saturating_sub(1) {
-                                    scroll_offset = scroll_offset.saturating_sub(1);
-                                }
-                                dirty = true;
-                            }
-                            MouseEventKind::Up(MouseButton::Left) => {
-                                dragging = false;
-                                if let Some(sel) = selection {
-                                    if !sel.is_empty() {
-                                        let text =
-                                            extract_text(state, scroll_offset, rect, sel, true);
-                                        if !text.is_empty() {
-                                            if let Ok(mut cb) = arboard::Clipboard::new() {
-                                                let _ = cb.set_text(text);
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                            MouseEventKind::ScrollUp => {
-                                scroll_offset = scroll_offset.saturating_add(scroll_step);
-                                dirty = true;
-                            }
-                            MouseEventKind::ScrollDown => {
-                                scroll_offset = scroll_offset.saturating_sub(scroll_step);
-                                dirty = true;
-                            }
-                            _ => {}
-                        }
-                    }
-                }
-            }
-            if dirty {
-                if let Some(payload) = &current_state {
-                    draw_atomic_with_ui(
-                        terminal,
-                        payload,
-                        &mut logged_first_frame,
-                        scroll_offset,
-                        selection,
-                        tick,
-                    )?;
-                }
-            }
-        } else if let Some(payload) = &current_state {
-            tick = tick.wrapping_add(1);
-            draw_atomic_with_ui(
-                terminal,
-                payload,
-                &mut logged_first_frame,
-                scroll_offset,
-                selection,
-                tick,
-            )?;
-        }
-    })();
-
-    if mouse_enabled {
-        let _ = crossterm::execute!(io::stdout(), DisableMouseCapture);
-    }
-    result
-}
-
-fn draw_atomic_with_ui(
-    terminal: &mut RenderTerminal,
-    payload: &Payload,
-    logged_first_frame: &mut bool,
-    scroll_offset: u16,
-    selection: Option<Selection>,
-    tick: u32,
-) -> Result<()> {
-    let _ = crossterm::execute!(
-        terminal.backend_mut(),
-        crossterm::terminal::BeginSynchronizedUpdate
-    );
-    let draw_err = terminal
-        .draw(|f| {
-            let area = f.area();
-            if !*logged_first_frame {
-                debug_log(&format!(
-                    "first frame area = x={} y={} w={} h={}",
-                    area.x, area.y, area.width, area.height
-                ));
-                *logged_first_frame = true;
-            }
-            match payload {
-                Payload::Trace(state) => {
-                    f.render_widget(
-                        WholeScreen::new(state)
-                            .with_scroll(scroll_offset)
-                            .with_selection(selection)
-                            .with_tick(tick),
-                        area,
-                    );
-                }
-                Payload::Setup(state) => render_setup(state, f),
-            }
-        })
-        .err();
-    let _ = crossterm::execute!(
-        terminal.backend_mut(),
-        crossterm::terminal::EndSynchronizedUpdate
-    );
-    if let Some(e) = draw_err {
-        return Err(e).context("terminal draw");
-    }
-    Ok(())
-}
-
-fn run_emit_input() -> Result<()> {
-    enable_raw_mode().context("enable raw mode")?;
-    let mut stdout_for_setup = io::stdout();
-    let paste_enabled = execute!(stdout_for_setup, EnableBracketedPaste).is_ok();
-    let mouse_enabled = execute!(stdout_for_setup, EnableMouseCapture).is_ok();
-    let result = emit_input_loop();
-    if mouse_enabled {
-        execute!(stdout_for_setup, DisableMouseCapture).ok();
-    }
-    if paste_enabled {
-        execute!(stdout_for_setup, DisableBracketedPaste).ok();
-    }
-    disable_raw_mode().ok();
-    result
-}
-
-fn emit_input_loop() -> Result<()> {
-    let stdout = io::stdout();
-    let mut out = stdout.lock();
-    loop {
-        match event::read()? {
-            Event::Key(key) => {
-                if is_quit(&key) {
-                    return Ok(());
-                }
-                let Some(translated) = translate_key(&key) else {
-                    continue;
-                };
-                let json = serde_json::to_string(&translated).context("serialize input event")?;
-                writeln!(out, "{json}").context("write input event")?;
-                out.flush().context("flush stdout")?;
-            }
-            Event::Paste(text) => {
-                let event = paste_event(text);
-                let json = serde_json::to_string(&event).context("serialize paste event")?;
-                writeln!(out, "{json}").context("write paste event")?;
-                out.flush().context("flush stdout")?;
-            }
-            Event::Mouse(m) => {
-                let Some(translated) = translate_mouse(&m) else {
-                    continue;
-                };
-                let json = serde_json::to_string(&translated).context("serialize mouse event")?;
-                writeln!(out, "{json}").context("write mouse event")?;
-                out.flush().context("flush stdout")?;
-            }
-            _ => {}
-        }
-    }
-}

crates/reasonix-render/src/state.rs

@@ -1,325 +0,0 @@
-use serde::Deserialize;
-
-#[derive(Debug, Clone, Default, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SceneState {
-    #[serde(default)]
-    pub model: Option<String>,
-    #[serde(default)]
-    pub card_count: u32,
-    #[serde(default)]
-    pub cards: Vec<SceneCard>,
-    #[serde(default)]
-    pub busy: bool,
-    #[serde(default)]
-    pub activity: Option<String>,
-    #[serde(default)]
-    pub composer_text: Option<String>,
-    #[serde(default)]
-    pub composer_cursor: Option<usize>,
-    #[serde(default)]
-    pub slash_matches: Option<Vec<SlashMatch>>,
-    #[serde(default)]
-    pub slash_selected_index: Option<usize>,
-    #[serde(default)]
-    pub approval_kind: Option<String>,
-    #[serde(default)]
-    pub approval_prompt: Option<String>,
-    #[serde(default)]
-    pub sessions: Option<Vec<SessionItem>>,
-    #[serde(default)]
-    pub sessions_focused_index: Option<usize>,
-    #[serde(default)]
-    pub wallet_balance: Option<f64>,
-    #[serde(default)]
-    pub wallet_currency: Option<String>,
-    #[serde(default)]
-    pub mcp_server_count: Option<u32>,
-    #[serde(default)]
-    pub edit_mode: Option<EditMode>,
-    #[serde(default)]
-    pub preset: Option<String>,
-    #[serde(default)]
-    pub cwd: Option<String>,
-    #[serde(default, rename = "dashboardUrl")]
-    pub dashboard_url: Option<String>,
-    #[serde(default)]
-    pub ctx_tokens: Option<u32>,
-    #[serde(default)]
-    pub ctx_cap: Option<u32>,
-    #[serde(default)]
-    pub session_cost_usd: Option<f64>,
-    #[serde(default)]
-    pub last_turn_cost_usd: Option<f64>,
-    #[serde(default)]
-    pub cache_hit_ratio: Option<f64>,
-    #[serde(default)]
-    pub last_turn_ms: Option<u64>,
-    #[serde(default)]
-    pub session_input_tokens: Option<u32>,
-    #[serde(default)]
-    pub session_output_tokens: Option<u32>,
-    #[serde(default)]
-    pub slash_catalog: Option<Vec<SlashMatch>>,
-    #[serde(default)]
-    pub slash_arg_state: Option<SlashArgState>,
-    #[serde(default)]
-    pub prompt_history: Option<Vec<String>>,
-    #[serde(default)]
-    pub approval: Option<Approval>,
-    #[serde(default)]
-    pub at_state: Option<AtState>,
-    #[serde(default)]
-    pub prompt_input: Option<PromptInput>,
-    #[serde(default)]
-    pub list_picker: Option<ListPicker>,
-}
-
-#[derive(Debug, Clone, Deserialize, Default)]
-pub struct ListPicker {
-    #[serde(default)]
-    pub id: String,
-    #[serde(default)]
-    pub title: String,
-    #[serde(default)]
-    pub hint: Option<String>,
-    #[serde(default)]
-    pub options: Vec<ListPickerOption>,
-}
-
-#[derive(Debug, Clone, Deserialize, Default)]
-pub struct ListPickerOption {
-    #[serde(default)]
-    pub key: String,
-    #[serde(default)]
-    pub label: String,
-    #[serde(default)]
-    pub sublabel: Option<String>,
-    #[serde(default)]
-    pub meta: Option<String>,
-}
-
-#[derive(Debug, Clone, Deserialize, Default)]
-pub struct PromptInput {
-    #[serde(default)]
-    pub id: String,
-    #[serde(default)]
-    pub label: String,
-    #[serde(default, rename = "defaultValue")]
-    pub default_value: Option<String>,
-    #[serde(default)]
-    pub secret: bool,
-}
-
-#[derive(Debug, Clone, Deserialize, Default)]
-pub struct SlashArgState {
-    #[serde(default)]
-    pub cmd: String,
-    #[serde(default)]
-    pub partial: String,
-    #[serde(default)]
-    pub matches: Vec<String>,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-#[serde(tag = "kind", rename_all = "kebab-case")]
-pub enum Approval {
-    Plan {
-        #[serde(default)]
-        body: String,
-        #[serde(default)]
-        steps: Vec<PlanStepItem>,
-    },
-    Shell {
-        command: String,
-        #[serde(default)]
-        cwd: Option<String>,
-        #[serde(default, rename = "timeoutSec")]
-        timeout_sec: Option<u32>,
-    },
-    Path {
-        path: String,
-        #[serde(default)]
-        intent: String,
-        #[serde(default, rename = "toolName")]
-        tool_name: String,
-    },
-    Edit {
-        path: String,
-        #[serde(default)]
-        search: String,
-        #[serde(default)]
-        replace: String,
-    },
-    Choice {
-        question: String,
-        #[serde(default)]
-        options: Vec<ApprovalChoiceOption>,
-        #[serde(default, rename = "allowCustom")]
-        allow_custom: bool,
-    },
-    Checkpoint {
-        #[serde(default)]
-        title: Option<String>,
-        #[serde(default)]
-        completed: u32,
-        #[serde(default)]
-        total: u32,
-    },
-}
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct ApprovalChoiceOption {
-    pub id: String,
-    pub title: String,
-    #[serde(default)]
-    pub summary: Option<String>,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct PlanStepItem {
-    pub title: String,
-    #[serde(default)]
-    pub status: String,
-}
-
-#[derive(Debug, Clone, Default, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SceneCard {
-    pub kind: String,
-    #[serde(default)]
-    pub summary: String,
-    #[serde(default)]
-    pub args: Option<String>,
-    #[serde(default)]
-    pub status: Option<ToolStatus>,
-    #[serde(default)]
-    pub elapsed: Option<String>,
-    #[serde(default)]
-    pub id: Option<String>,
-    #[serde(default)]
-    pub body: Option<String>,
-    #[serde(default)]
-    pub ts: Option<i64>,
-    #[serde(default)]
-    pub meta: Option<String>,
-}
-
-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Eq)]
-#[serde(rename_all = "lowercase")]
-pub enum ToolStatus {
-    Ok,
-    Err,
-    Running,
-}
-
-#[derive(Debug, Clone, Deserialize, PartialEq, Eq)]
-#[serde(rename_all = "lowercase")]
-pub enum EditMode {
-    Review,
-    Auto,
-    Yolo,
-}
-
-impl EditMode {
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            EditMode::Review => "review",
-            EditMode::Auto => "auto",
-            EditMode::Yolo => "yolo",
-        }
-    }
-}
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct SlashMatch {
-    pub cmd: String,
-    #[serde(default)]
-    pub summary: String,
-    #[serde(default)]
-    pub group: Option<String>,
-    #[serde(default, rename = "argsHint")]
-    pub args_hint: Option<String>,
-    #[serde(default)]
-    pub aliases: Vec<String>,
-    #[serde(default, rename = "argCompleter")]
-    pub arg_completer: Option<Vec<String>>,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct AtPickerEntry {
-    pub label: String,
-    pub insert_path: String,
-    #[serde(default)]
-    pub dir_suffix: String,
-    #[serde(default)]
-    pub is_dir: bool,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-#[serde(tag = "kind", rename_all = "lowercase")]
-pub enum AtState {
-    Browse {
-        #[serde(default, rename = "baseDir")]
-        base_dir: String,
-        #[serde(default)]
-        entries: Vec<AtPickerEntry>,
-        #[serde(default)]
-        loading: bool,
-    },
-    Search {
-        #[serde(default)]
-        filter: String,
-        #[serde(default)]
-        entries: Vec<AtPickerEntry>,
-        #[serde(default)]
-        scanned: u32,
-        #[serde(default)]
-        searching: bool,
-    },
-}
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct SessionItem {
-    pub title: String,
-    #[serde(default)]
-    pub meta: Option<String>,
-}
-
-#[derive(Debug, Clone, Default, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SetupState {
-    #[serde(default)]
-    pub buffer_length: usize,
-    #[serde(default)]
-    pub error: Option<String>,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-#[serde(tag = "type", rename_all = "camelCase")]
-#[allow(clippy::large_enum_variant)]
-pub enum Message {
-    Trace(SceneState),
-    Setup(SetupState),
-}
-
-#[allow(clippy::large_enum_variant)]
-pub enum Payload {
-    Trace(SceneState),
-    Setup(SetupState),
-}
-
-pub fn decode_message(line: &str) -> Result<Payload, serde_json::Error> {
-    if let Ok(msg) = serde_json::from_str::<Message>(line) {
-        return Ok(match msg {
-            Message::Trace(state) => Payload::Trace(state),
-            Message::Setup(state) => Payload::Setup(state),
-        });
-    }
-    if let Ok(state) = serde_json::from_str::<SceneState>(line) {
-        return Ok(Payload::Trace(state));
-    }
-    let state: SetupState = serde_json::from_str(line)?;
-    Ok(Payload::Setup(state))
-}

crates/reasonix-render/src/theme.rs

@@ -1,68 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(untagged)]
-pub enum Color {
-    Named(NamedColor),
-    Hex { hex: String },
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
-pub enum NamedColor {
-    Default,
-    Black,
-    Red,
-    Green,
-    Yellow,
-    Blue,
-    Magenta,
-    Cyan,
-    White,
-    Gray,
-}
-
-pub fn hex(s: &'static str) -> Color {
-    Color::Hex { hex: s.to_string() }
-}
-
-pub mod palette {
-    use super::{hex, Color};
-
-    pub fn bg() -> Color {
-        hex("#0f1018")
-    }
-    pub fn bg2() -> Color {
-        hex("#161824")
-    }
-    pub fn fg() -> Color {
-        hex("#e8e9f3")
-    }
-    pub fn fg1() -> Color {
-        hex("#a8aabd")
-    }
-    pub fn fg2() -> Color {
-        hex("#6b6e85")
-    }
-    pub fn fg3() -> Color {
-        hex("#3d4055")
-    }
-    pub fn ds() -> Color {
-        hex("#6b85ff")
-    }
-    pub fn ds_bright() -> Color {
-        hex("#8b9fff")
-    }
-    pub fn ds_purple() -> Color {
-        hex("#a78bfa")
-    }
-    pub fn ok() -> Color {
-        hex("#5eead4")
-    }
-    pub fn warn() -> Color {
-        hex("#fbbf24")
-    }
-    pub fn err() -> Color {
-        hex("#fb7185")
-    }
-}

crates/reasonix-render/src/view.rs

@@ -1,97 +0,0 @@
-use ratatui::style::{Color as RColor, Modifier, Style};
-use ratatui::text::{Line, Span, Text};
-use ratatui::widgets::{Block, Paragraph, Wrap};
-use ratatui::Frame;
-
-use crate::state::SetupState;
-use crate::theme::{palette, Color, NamedColor};
-
-pub fn render_setup(state: &SetupState, frame: &mut Frame<'_>) {
-    let area = frame.area();
-    frame.render_widget(canvas_block(), area);
-    let mut lines: Vec<Line<'_>> = vec![Line::from(vec![
-        styled(" ● ", palette::ds(), Modifier::BOLD),
-        styled("REASONIX", palette::ds_bright(), Modifier::BOLD),
-        styled("  welcome", palette::fg2(), Modifier::empty()),
-    ])];
-    lines.push(Line::raw(""));
-    lines.push(Line::from(styled(
-        " Enter your DeepSeek API key:",
-        palette::ds(),
-        Modifier::empty(),
-    )));
-    lines.push(Line::from(styled(
-        "   get one at https://platform.deepseek.com",
-        palette::fg2(),
-        Modifier::empty(),
-    )));
-    let mut masked: Vec<Span<'_>> = vec![styled(" ❯ ", palette::ds(), Modifier::BOLD)];
-    if state.buffer_length == 0 {
-        masked.push(styled(
-            "(start typing your key)",
-            palette::fg2(),
-            Modifier::empty(),
-        ));
-    } else {
-        let dots = "•".repeat(state.buffer_length);
-        masked.push(styled(dots, palette::fg(), Modifier::empty()));
-        masked.push(styled("▮", palette::ds(), Modifier::empty()));
-    }
-    lines.push(Line::from(masked));
-    if let Some(err) = state.error.as_deref() {
-        lines.push(Line::from(vec![
-            styled(" ✗ ", palette::err(), Modifier::BOLD),
-            styled(err.to_string(), palette::err(), Modifier::empty()),
-        ]));
-    }
-    lines.push(Line::raw(""));
-    lines.push(Line::from(styled(
-        " Ctrl+C to exit · /exit to quit",
-        palette::fg2(),
-        Modifier::empty(),
-    )));
-    let paragraph = Paragraph::new(Text::from(lines))
-        .wrap(Wrap { trim: false })
-        .style(Style::default().bg(to_rcolor(palette::bg())));
-    frame.render_widget(paragraph, area);
-}
-
-fn canvas_block() -> Block<'static> {
-    Block::default().style(Style::default().bg(to_rcolor(palette::bg())))
-}
-
-fn styled<S: Into<String>>(text: S, color: Color, modifier: Modifier) -> Span<'static> {
-    Span::styled(
-        text.into(),
-        Style::default().fg(to_rcolor(color)).add_modifier(modifier),
-    )
-}
-
-fn to_rcolor(c: Color) -> RColor {
-    match c {
-        Color::Named(n) => match n {
-            NamedColor::Default => RColor::Reset,
-            NamedColor::Black => RColor::Black,
-            NamedColor::Red => RColor::Red,
-            NamedColor::Green => RColor::Green,
-            NamedColor::Yellow => RColor::Yellow,
-            NamedColor::Blue => RColor::Blue,
-            NamedColor::Magenta => RColor::Magenta,
-            NamedColor::Cyan => RColor::Cyan,
-            NamedColor::White => RColor::White,
-            NamedColor::Gray => RColor::Gray,
-        },
-        Color::Hex { hex } => parse_hex(&hex).unwrap_or(RColor::Reset),
-    }
-}
-
-fn parse_hex(hex: &str) -> Option<RColor> {
-    let s = hex.strip_prefix('#')?;
-    if s.len() != 6 {
-        return None;
-    }
-    let r = u8::from_str_radix(&s[0..2], 16).ok()?;
-    let g = u8::from_str_radix(&s[2..4], 16).ok()?;
-    let b = u8::from_str_radix(&s[4..6], 16).ok()?;
-    Some(RColor::Rgb(r, g, b))
-}

crates/reasonix-render/src/whole_screen/approval.rs

@@ -1,384 +0,0 @@
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::style::{Color, Modifier};
-use unicode_width::UnicodeWidthStr;
-
-use crate::state::Approval;
-
-use super::paint::{paint, paint_str};
-use super::theme::{BG, DS_BRIGHT, DS_PURPLE, ERR, FG, FG1, FG2, FG3, OK, WARN};
-
-const MAX_BODY_ROWS: u16 = 12;
-
-pub fn render_approval(
-    buf: &mut Buffer,
-    screen: Rect,
-    approval: &Approval,
-    choice_idx: usize,
-    dock_h: u16,
-) {
-    let popup_w = screen.width.saturating_sub(8).min(110);
-    if popup_w < 50 {
-        return;
-    }
-    let popup_x = screen.x + 2;
-    let accent = accent_for(approval);
-    let body = body_lines(
-        approval,
-        popup_w.saturating_sub(6) as usize,
-        choice_idx,
-        accent,
-    );
-    let actions = action_cells(approval);
-    let body_h = body.len().min(MAX_BODY_ROWS as usize) as u16;
-    let popup_h = 2 + body_h + 3;
-    let bottom_margin = dock_h.max(5) + 1;
-    if popup_h + bottom_margin > screen.height {
-        return;
-    }
-    let popup_y = screen.bottom().saturating_sub(popup_h + bottom_margin);
-    if popup_y < screen.y {
-        return;
-    }
-    let popup = Rect::new(popup_x, popup_y, popup_w, popup_h);
-
-    draw_box(buf, popup, accent);
-    draw_title(buf, popup, approval, accent);
-    let body_top = popup.y + 1;
-    for (i, line) in body.iter().take(MAX_BODY_ROWS as usize).enumerate() {
-        paint_str(
-            buf,
-            popup.x + 2,
-            body_top + 1 + i as u16,
-            line,
-            FG,
-            BG,
-            Modifier::empty(),
-        );
-    }
-    let footer_y = popup.y + popup.height - 2;
-    draw_actions(buf, popup, footer_y, &actions);
-}
-
-fn accent_for(approval: &Approval) -> Color {
-    match approval {
-        Approval::Plan { .. } | Approval::Edit { .. } => DS_PURPLE,
-        Approval::Shell { .. } => OK,
-        Approval::Path { .. } | Approval::Choice { .. } => DS_BRIGHT,
-        Approval::Checkpoint { .. } => OK,
-    }
-}
-
-fn draw_title(buf: &mut Buffer, area: Rect, approval: &Approval, accent: Color) {
-    let row = area.y;
-    let (glyph, kind, subtitle, dismiss) = title_parts(approval);
-    let mut col = area.x + 2;
-    col = paint_str(buf, col, row, glyph, accent, BG, Modifier::BOLD);
-    col = col.saturating_add(1);
-    col = paint_str(buf, col, row, kind, accent, BG, Modifier::BOLD);
-    if !subtitle.is_empty() {
-        col = col.saturating_add(2);
-        paint_str(buf, col, row, &subtitle, FG2, BG, Modifier::empty());
-    }
-    let hint = format!("esc {dismiss}");
-    let hint_col = area.x + area.width.saturating_sub(hint.width() as u16 + 2);
-    paint_str(buf, hint_col, row, &hint, FG3, BG, Modifier::empty());
-}
-
-fn title_parts(approval: &Approval) -> (&'static str, &'static str, String, &'static str) {
-    match approval {
-        Approval::Plan { body, steps } => {
-            let n = if steps.is_empty() {
-                body.lines().filter(|l| !l.trim().is_empty()).count()
-            } else {
-                steps.len()
-            };
-            (
-                "◇",
-                "REVIEW PLAN",
-                format!("{n} step{}", if n == 1 { "" } else { "s" }),
-                "skip",
-            )
-        }
-        Approval::Shell { command, .. } => {
-            let head = first_chunk(command, 40);
-            ("⚡", "SHELL EXEC", head, "dismiss")
-        }
-        Approval::Path { path, intent, .. } => (
-            "▸",
-            "PATH ACCESS",
-            format!("{intent} {}", first_chunk(path, 50)),
-            "deny",
-        ),
-        Approval::Edit { path, .. } => ("▣", "EDIT PREVIEW", first_chunk(path, 50), "dismiss"),
-        Approval::Choice { options, .. } => {
-            let n = options.len();
-            (
-                "◆",
-                "CHOOSE",
-                format!("{n} option{}", if n == 1 { "" } else { "s" }),
-                "skip",
-            )
-        }
-        Approval::Checkpoint {
-            completed, total, ..
-        } => (
-            "◉",
-            "STEP CHECKPOINT",
-            format!("{completed}/{total}"),
-            "stop",
-        ),
-    }
-}
-
-fn wrap_inline(line: &str, max: usize) -> Vec<String> {
-    if line.is_empty() {
-        return vec![String::new()];
-    }
-    let w = max.max(10);
-    let mut out = Vec::new();
-    let mut current = String::new();
-    let mut current_w = 0usize;
-    for ch in line.chars() {
-        let cw = unicode_width::UnicodeWidthChar::width(ch).unwrap_or(0);
-        if current_w + cw > w && !current.is_empty() {
-            out.push(std::mem::take(&mut current));
-            current_w = 0;
-        }
-        current.push(ch);
-        current_w += cw;
-    }
-    if !current.is_empty() {
-        out.push(current);
-    }
-    if out.is_empty() {
-        out.push(String::new());
-    }
-    out
-}
-
-fn first_chunk(s: &str, max: usize) -> String {
-    let mut out = String::new();
-    let mut w = 0usize;
-    for ch in s.chars() {
-        let cw = unicode_width::UnicodeWidthChar::width(ch).unwrap_or(0);
-        if w + cw > max {
-            out.push('…');
-            break;
-        }
-        out.push(ch);
-        w += cw;
-    }
-    out
-}
-
-fn body_lines(approval: &Approval, max_w: usize, choice_idx: usize, accent: Color) -> Vec<String> {
-    let _ = accent;
-    match approval {
-        Approval::Plan { body, steps } => {
-            let mut out = Vec::new();
-            if !steps.is_empty() {
-                for (i, step) in steps.iter().enumerate().take(MAX_BODY_ROWS as usize) {
-                    let marker = match step.status.as_str() {
-                        "done" => "✓",
-                        "running" => "◆",
-                        "failed" => "✕",
-                        "blocked" => "⊘",
-                        "skipped" => "·",
-                        _ => "○",
-                    };
-                    let label = first_chunk(&step.title, max_w.saturating_sub(8));
-                    out.push(format!("{marker} [{}] {label}", i + 1));
-                }
-            } else {
-                for raw in body.lines() {
-                    for line in wrap_inline(raw, max_w) {
-                        out.push(line);
-                        if out.len() >= MAX_BODY_ROWS as usize {
-                            return out;
-                        }
-                    }
-                }
-            }
-            if out.is_empty() {
-                out.push("(plan body is empty)".to_string());
-            }
-            out
-        }
-        Approval::Shell {
-            command,
-            cwd,
-            timeout_sec,
-        } => {
-            let mut out = Vec::new();
-            out.push(format!(
-                "$ {}",
-                first_chunk(command, max_w.saturating_sub(2))
-            ));
-            let mut meta = Vec::new();
-            if let Some(dir) = cwd.as_deref() {
-                meta.push(format!("cwd {dir}"));
-            }
-            if let Some(s) = timeout_sec {
-                meta.push(format!("timeout {s}s"));
-            }
-            if !meta.is_empty() {
-                out.push(String::new());
-                out.push(meta.join("   "));
-            }
-            out
-        }
-        Approval::Path {
-            path,
-            intent,
-            tool_name,
-        } => {
-            let mut out = Vec::new();
-            out.push(format!("intent  {intent}"));
-            out.push(format!("tool    {tool_name}"));
-            out.push(format!(
-                "path    {}",
-                first_chunk(path, max_w.saturating_sub(8))
-            ));
-            out
-        }
-        Approval::Edit {
-            path,
-            search,
-            replace,
-        } => {
-            let mut out = Vec::new();
-            let s_lines = search.lines().count();
-            let r_lines = replace.lines().count();
-            out.push(format!("{path}   -{s_lines}  +{r_lines}"));
-            out.push(String::new());
-            for line in search.lines().take(4) {
-                out.push(format!("- {}", first_chunk(line, max_w.saturating_sub(2))));
-            }
-            for line in replace.lines().take(4) {
-                out.push(format!("+ {}", first_chunk(line, max_w.saturating_sub(2))));
-            }
-            out
-        }
-        Approval::Checkpoint {
-            title,
-            completed,
-            total,
-        } => {
-            let mut out = Vec::new();
-            if let Some(t) = title.as_deref() {
-                out.push(format!(
-                    "just finished: {}",
-                    first_chunk(t, max_w.saturating_sub(15))
-                ));
-            }
-            out.push(String::new());
-            out.push(format!("progress: {completed} of {total} step(s) done"));
-            out.push(String::new());
-            out.push("continue executing, type a refinement, or stop here?".to_string());
-            out
-        }
-        Approval::Choice {
-            question, options, ..
-        } => {
-            let mut out = Vec::new();
-            out.push(first_chunk(question, max_w));
-            out.push(String::new());
-            let sel = choice_idx.min(options.len().saturating_sub(1));
-            for (i, opt) in options.iter().enumerate().take(MAX_BODY_ROWS as usize - 2) {
-                let marker = if i == sel { "●" } else { "○" };
-                let letter = (b'a' + i as u8) as char;
-                out.push(format!(
-                    "{letter})  {marker}  {}",
-                    first_chunk(&opt.title, max_w.saturating_sub(8))
-                ));
-                if let Some(summary) = opt.summary.as_deref() {
-                    if !summary.is_empty() {
-                        out.push(format!(
-                            "        {}",
-                            first_chunk(summary, max_w.saturating_sub(8))
-                        ));
-                    }
-                }
-            }
-            out
-        }
-    }
-}
-
-fn action_cells(approval: &Approval) -> Vec<(&'static str, &'static str)> {
-    match approval {
-        Approval::Plan { .. } => vec![
-            ("↵", "approve"),
-            ("r", "refine"),
-            ("v", "revise"),
-            ("n", "cancel"),
-        ],
-        Approval::Shell { .. } => vec![
-            ("↵", "run"),
-            ("a", "always allow this command"),
-            ("n", "cancel"),
-        ],
-        Approval::Path { .. } => vec![("↵", "allow once"), ("a", "always allow"), ("n", "deny")],
-        Approval::Edit { .. } => vec![
-            ("↵", "apply"),
-            ("r", "reject"),
-            ("t", "rest of turn"),
-            ("y", "flip to auto"),
-        ],
-        Approval::Checkpoint { .. } => vec![("↵", "continue"), ("r", "revise"), ("s", "stop")],
-        Approval::Choice { allow_custom, .. } => {
-            let mut v = vec![("↑↓", "move"), ("↵", "pick"), ("1-9", "jump")];
-            if *allow_custom {
-                v.push(("c", "custom"));
-            }
-            v.push(("esc", "cancel"));
-            v
-        }
-    }
-}
-
-fn draw_actions(buf: &mut Buffer, area: Rect, row: u16, actions: &[(&str, &str)]) {
-    let sep_row = row.saturating_sub(1);
-    for x in (area.x + 1)..(area.x + area.width - 1) {
-        paint(buf, x, sep_row, '┄', FG3, BG, Modifier::empty());
-    }
-    let mut col = area.x + 2;
-    for (i, (key, label)) in actions.iter().enumerate() {
-        if i > 0 {
-            col = col.saturating_add(3);
-        }
-        col = paint_str(buf, col, row, key, FG1, BG, Modifier::BOLD);
-        col = col.saturating_add(1);
-        col = paint_str(buf, col, row, label, FG2, BG, Modifier::empty());
-    }
-}
-
-fn draw_box(buf: &mut Buffer, area: Rect, accent: Color) {
-    let w = area.width;
-    if w < 2 {
-        return;
-    }
-    let top = area.y;
-    let bot = area.y + area.height - 1;
-    let right = area.x + w - 1;
-
-    paint(buf, area.x, top, '╭', accent, BG, Modifier::empty());
-    paint(buf, right, top, '╮', accent, BG, Modifier::empty());
-    for x in 1..w - 1 {
-        paint(buf, area.x + x, top, '─', accent, BG, Modifier::empty());
-    }
-    for y in (top + 1)..bot {
-        paint(buf, area.x, y, '│', accent, BG, Modifier::empty());
-        paint(buf, right, y, '│', accent, BG, Modifier::empty());
-        for x in 1..w - 1 {
-            paint(buf, area.x + x, y, ' ', FG, BG, Modifier::empty());
-        }
-    }
-    paint(buf, area.x, bot, '╰', accent, BG, Modifier::empty());
-    paint(buf, right, bot, '╯', accent, BG, Modifier::empty());
-    for x in 1..w - 1 {
-        paint(buf, area.x + x, bot, '─', accent, BG, Modifier::empty());
-    }
-    let _ = (ERR, WARN); // reserved for risk-tag highlights
-}

crates/reasonix-render/src/whole_screen/boot.rs

@@ -1,188 +0,0 @@
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::style::Modifier;
-
-use crate::state::SceneState;
-
-use super::cards::render_cards;
-use super::paint::{paint_link_wrapped, paint_str_to};
-use super::theme::{DS, FG, FG2, FG3, LOGO};
-
-pub fn render_scroll(
-    buf: &mut Buffer,
-    area: Rect,
-    state: &SceneState,
-    scroll_offset: u16,
-    tick: u32,
-) {
-    if area.height == 0 {
-        return;
-    }
-    let mut row = area.y + 1;
-    row = render_logo(buf, area, row);
-    row = row.saturating_add(1);
-    row = render_boot_meta(buf, area, row, state);
-    row = row.saturating_add(1);
-    row = render_hint_line(buf, area, row);
-    row = row.saturating_add(1);
-    render_cards(buf, area, row, state, scroll_offset, tick);
-}
-
-fn render_logo(buf: &mut Buffer, area: Rect, start_row: u16) -> u16 {
-    use super::theme::BG;
-    let end_x = area.x.saturating_add(area.width);
-    let mut row = start_row;
-    for line in LOGO {
-        if row >= area.y + area.height {
-            break;
-        }
-        paint_str_to(buf, area.x + 2, row, line, end_x, DS, BG, Modifier::BOLD);
-        row += 1;
-    }
-    row
-}
-
-fn render_boot_meta(buf: &mut Buffer, area: Rect, start_row: u16, state: &SceneState) -> u16 {
-    use super::theme::{BG, DS_BRIGHT};
-    let bottom = area.y + area.height;
-    let end_x = area.x.saturating_add(area.width);
-    let key_col = area.x + 2;
-    let val_col = area.x + 14;
-    let mut row = start_row;
-
-    if row < bottom {
-        if let Some(model) = state.model.as_deref() {
-            paint_str_to(
-                buf,
-                key_col,
-                row,
-                "model",
-                end_x,
-                FG2,
-                BG,
-                Modifier::empty(),
-            );
-            let after = paint_str_to(
-                buf,
-                val_col,
-                row,
-                model,
-                end_x,
-                DS_BRIGHT,
-                BG,
-                Modifier::empty(),
-            );
-            if let Some(cap) = state.ctx_cap {
-                let ctx_col = after.saturating_add(4);
-                paint_str_to(
-                    buf,
-                    ctx_col,
-                    row,
-                    "context",
-                    end_x,
-                    FG2,
-                    BG,
-                    Modifier::empty(),
-                );
-                let ctx_text = match (state.ctx_tokens, cap) {
-                    (Some(used), cap) if cap > 0 => {
-                        let pct = (f64::from(used) / f64::from(cap) * 100.0) as i32;
-                        format!("{} · {pct}% used", short_tokens(cap))
-                    }
-                    _ => short_tokens(cap),
-                };
-                paint_str_to(
-                    buf,
-                    ctx_col.saturating_add(10),
-                    row,
-                    &ctx_text,
-                    end_x,
-                    FG,
-                    BG,
-                    Modifier::empty(),
-                );
-            }
-            row += 1;
-        }
-    }
-
-    if row < bottom {
-        if let Some(cwd) = state.cwd.as_deref() {
-            paint_str_to(
-                buf,
-                key_col,
-                row,
-                "workdir",
-                end_x,
-                FG2,
-                BG,
-                Modifier::empty(),
-            );
-            paint_str_to(buf, val_col, row, cwd, end_x, FG, BG, Modifier::empty());
-            row += 1;
-        }
-    }
-
-    if row < bottom {
-        if let Some(url) = state.dashboard_url.as_deref() {
-            paint_str_to(
-                buf,
-                key_col,
-                row,
-                "dashboard",
-                end_x,
-                FG2,
-                BG,
-                Modifier::empty(),
-            );
-            let used =
-                paint_link_wrapped(buf, val_col, row, end_x, bottom, url, url, DS_BRIGHT, BG);
-            row += used.max(1);
-        }
-    }
-
-    row
-}
-
-fn short_tokens(n: u32) -> String {
-    if n >= 1_000_000 {
-        format!("{:.1}M", f64::from(n) / 1_000_000.0)
-    } else if n >= 1_000 {
-        format!("{}k", n / 1000)
-    } else {
-        format!("{n}")
-    }
-}
-
-fn render_hint_line(buf: &mut Buffer, area: Rect, row: u16) -> u16 {
-    use super::theme::BG;
-    if row >= area.y + area.height {
-        return row;
-    }
-    let end_x = area.x.saturating_add(area.width);
-    let mut col = area.x + 2;
-    let pairs: [(&str, &str); 6] = [
-        ("type to chat", ""),
-        ("/", "commands"),
-        ("@", "file refs"),
-        ("!", "shell"),
-        ("Ctrl+C", "cancel"),
-        ("Ctrl+D", "exit"),
-    ];
-    for (i, (key, label)) in pairs.iter().enumerate() {
-        if col >= end_x {
-            break;
-        }
-        if i > 0 {
-            col = paint_str_to(buf, col, row, "  ·  ", end_x, FG3, BG, Modifier::empty());
-        }
-        if label.is_empty() {
-            col = paint_str_to(buf, col, row, key, end_x, FG2, BG, Modifier::empty());
-        } else {
-            col = paint_str_to(buf, col, row, key, end_x, DS, BG, Modifier::BOLD);
-            col = paint_str_to(buf, col, row, " ", end_x, FG2, BG, Modifier::empty());
-            col = paint_str_to(buf, col, row, label, end_x, FG2, BG, Modifier::empty());
-        }
-    }
-    row + 1
-}

crates/reasonix-render/src/whole_screen/cards/diff.rs

@@ -1,180 +0,0 @@
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::style::Modifier;
-
-use crate::state::SceneCard;
-
-use super::super::paint::{paint, paint_str};
-use super::super::theme::{BG, DS_BRIGHT, ERR, FG1, FG2, FG3, OK};
-
-pub(super) fn render_diff_card(
-    buf: &mut Buffer,
-    area: Rect,
-    start_row: u16,
-    card: &SceneCard,
-) -> u16 {
-    let mut row = render_diff_header(buf, area, start_row, card);
-    if let Some(body) = card.body.as_deref() {
-        row = render_diff_body(buf, area, row, body);
-    }
-    row.saturating_add(1)
-}
-
-fn render_diff_header(buf: &mut Buffer, area: Rect, row: u16, card: &SceneCard) -> u16 {
-    let bottom = area.y + area.height;
-    if row >= bottom {
-        return row;
-    }
-    let mut col = area.x;
-    col = paint_str(buf, col, row, "▎ ", DS_BRIGHT, BG, Modifier::empty());
-    col = paint_str(buf, col, row, "± ", DS_BRIGHT, BG, Modifier::BOLD);
-    col = paint_str(
-        buf,
-        col,
-        row,
-        &card.summary,
-        DS_BRIGHT,
-        BG,
-        Modifier::empty(),
-    );
-    if let Some(meta) = card.meta.as_deref() {
-        col = col.saturating_add(2);
-        paint_meta(buf, col, row, meta);
-    }
-    row + 1
-}
-
-fn paint_meta(buf: &mut Buffer, x: u16, row: u16, meta: &str) {
-    let mut col = x;
-    for tok in meta.split_whitespace() {
-        let (fg, modifier) = match tok.chars().next() {
-            Some('+') => (OK, Modifier::BOLD),
-            Some('-') | Some('−') => (ERR, Modifier::BOLD),
-            _ => (FG2, Modifier::empty()),
-        };
-        col = paint_str(buf, col, row, tok, fg, BG, modifier);
-        col = col.saturating_add(1);
-    }
-}
-
-fn render_diff_body(buf: &mut Buffer, area: Rect, start_row: u16, body: &str) -> u16 {
-    let bottom = area.y + area.height;
-    let mut row = start_row;
-    let mut old_ln: u32 = 0;
-    let mut new_ln: u32 = 0;
-    for line in body.split('\n') {
-        if row >= bottom {
-            break;
-        }
-        if let Some((o, n)) = parse_hunk_header(line) {
-            old_ln = o;
-            new_ln = n;
-            render_hunk_line(buf, area, row, line);
-            row += 1;
-            continue;
-        }
-        let (kind, rest) = classify_line(line);
-        render_diff_line(buf, area, row, kind, &mut old_ln, &mut new_ln, rest);
-        row += 1;
-    }
-    row
-}
-
-fn render_hunk_line(buf: &mut Buffer, area: Rect, row: u16, line: &str) {
-    let mut col = area.x;
-    col = paint_str(buf, col, row, "▎", DS_BRIGHT, BG, Modifier::empty());
-    col = col.saturating_add(1);
-    paint_str(buf, col, row, line, FG2, BG, Modifier::ITALIC);
-}
-
-#[derive(Clone, Copy)]
-enum DiffKind {
-    Ctx,
-    Add,
-    Del,
-}
-
-fn classify_line(line: &str) -> (DiffKind, &str) {
-    match line.chars().next() {
-        Some('+') => (DiffKind::Add, &line[1..]),
-        Some('-') => (DiffKind::Del, &line[1..]),
-        _ => (DiffKind::Ctx, line.strip_prefix(' ').unwrap_or(line)),
-    }
-}
-
-fn render_diff_line(
-    buf: &mut Buffer,
-    area: Rect,
-    row: u16,
-    kind: DiffKind,
-    old_ln: &mut u32,
-    new_ln: &mut u32,
-    code: &str,
-) {
-    let mut col = area.x;
-    col = paint_str(buf, col, row, "▎", DS_BRIGHT, BG, Modifier::empty());
-    col = col.saturating_add(1);
-
-    let (ol_show, nl_show, sign_ch, code_fg, sign_fg) = match kind {
-        DiffKind::Ctx => (Some(*old_ln), Some(*new_ln), ' ', FG1, FG2),
-        DiffKind::Add => (None, Some(*new_ln), '+', OK, OK),
-        DiffKind::Del => (Some(*old_ln), None, '-', ERR, ERR),
-    };
-
-    col = paint_str(
-        buf,
-        col,
-        row,
-        &fmt_lineno(ol_show),
-        FG3,
-        BG,
-        Modifier::empty(),
-    );
-    col = col.saturating_add(1);
-    col = paint_str(
-        buf,
-        col,
-        row,
-        &fmt_lineno(nl_show),
-        FG3,
-        BG,
-        Modifier::empty(),
-    );
-    col = col.saturating_add(1);
-    paint(buf, col, row, sign_ch, sign_fg, BG, Modifier::empty());
-    col = col.saturating_add(2);
-
-    paint_str(buf, col, row, code, code_fg, BG, Modifier::empty());
-
-    match kind {
-        DiffKind::Ctx => {
-            *old_ln += 1;
-            *new_ln += 1;
-        }
-        DiffKind::Add => *new_ln += 1,
-        DiffKind::Del => *old_ln += 1,
-    }
-}
-
-fn fmt_lineno(n: Option<u32>) -> String {
-    match n {
-        Some(v) => format!("{v:>3}"),
-        None => "   ".to_string(),
-    }
-}
-
-fn parse_hunk_header(line: &str) -> Option<(u32, u32)> {
-    let s = line.strip_prefix("@@ -")?;
-    let (old_part, rest) = s.split_once(' ')?;
-    let old_start = old_part.split_once(',').map(|(a, _)| a).unwrap_or(old_part);
-    let new_part = rest.strip_prefix('+')?;
-    let new_end = new_part
-        .find(|c: char| !c.is_ascii_digit() && c != ',')
-        .unwrap_or(new_part.len());
-    let new_section = &new_part[..new_end];
-    let new_start = new_section
-        .split_once(',')
-        .map(|(a, _)| a)
-        .unwrap_or(new_section);
-    Some((old_start.parse().ok()?, new_start.parse().ok()?))
-}

crates/reasonix-render/src/whole_screen/cards/message.rs

@@ -1,135 +0,0 @@
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::style::Modifier;
-
-use crate::state::SceneCard;
-
-use super::super::md_render::render_markdown;
-use super::super::paint::{format_ts, paint};
-use super::super::theme::{BG, DS_BRIGHT, DS_PURPLE, FG, FG1, FG3};
-use super::{
-    body_indent_col, body_width_for, paint_blank_after, paint_body_line, render_card_header,
-    wrap_visual,
-};
-
-pub(super) fn render_user_card(
-    buf: &mut Buffer,
-    area: Rect,
-    start_row: u16,
-    card: &SceneCard,
-) -> u16 {
-    let bottom = area.y + area.height;
-    let mut row = start_row;
-    let ts = card.ts.map(format_ts);
-    render_card_header(
-        buf,
-        area,
-        row,
-        FG,
-        "❯",
-        FG,
-        "YOU",
-        FG,
-        ts.as_deref().map(|s| (s, FG3)),
-    );
-    row += 1;
-    let width = body_width_for(area);
-    if let Some(body) = card.body.as_deref() {
-        for raw in body.split('\n') {
-            for line in wrap_visual(raw, width) {
-                if row >= bottom {
-                    return row;
-                }
-                paint_body_line(buf, area, row, FG, &line, FG, Modifier::empty());
-                row += 1;
-            }
-        }
-    }
-    paint_blank_after(buf, area, row, FG)
-}
-
-pub(super) fn render_reasoning_card(
-    buf: &mut Buffer,
-    area: Rect,
-    start_row: u16,
-    card: &SceneCard,
-) -> u16 {
-    let bottom = area.y + area.height;
-    let mut row = start_row;
-    render_card_header(
-        buf,
-        area,
-        row,
-        DS_PURPLE,
-        "◇",
-        DS_PURPLE,
-        "THINKING",
-        DS_PURPLE,
-        card.meta.as_deref().map(|s| (s, FG3)),
-    );
-    row += 1;
-    let width = body_width_for(area);
-    if let Some(body) = card.body.as_deref() {
-        for raw in body.split('\n') {
-            for line in wrap_visual(raw, width) {
-                if row >= bottom {
-                    return row;
-                }
-                paint_body_line(buf, area, row, DS_PURPLE, &line, FG1, Modifier::ITALIC);
-                row += 1;
-            }
-        }
-    }
-    paint_blank_after(buf, area, row, DS_PURPLE)
-}
-
-pub(super) fn render_assistant_card(
-    buf: &mut Buffer,
-    area: Rect,
-    start_row: u16,
-    card: &SceneCard,
-    streaming: bool,
-    tick: u32,
-) -> u16 {
-    let bottom = area.y + area.height;
-    let mut row = start_row;
-    let meta_text = if streaming {
-        Some("streaming…".to_string())
-    } else {
-        card.ts.map(format_ts)
-    };
-    render_card_header(
-        buf,
-        area,
-        row,
-        DS_BRIGHT,
-        "◆",
-        DS_BRIGHT,
-        "REASONIX",
-        DS_BRIGHT,
-        meta_text.as_deref().map(|s| (s, FG3)),
-    );
-    row += 1;
-    if let Some(body) = card.body.as_deref() {
-        let revealed: String = if streaming {
-            let total_chars = body.chars().count();
-            let n = ((tick as usize) / 2).min(total_chars);
-            body.chars().take(n).collect()
-        } else {
-            body.to_string()
-        };
-        let prev_row = row;
-        row = render_markdown(buf, area, row, bottom, DS_BRIGHT, FG, &revealed);
-        if streaming && (tick / 6).is_multiple_of(2) {
-            let caret_row = if row > prev_row { row - 1 } else { prev_row };
-            if caret_row < bottom {
-                let col = body_indent_col(area) + 4;
-                paint(buf, col, caret_row, '▊', DS_BRIGHT, BG, Modifier::empty());
-            }
-        }
-        if streaming && row == prev_row {
-            row = (prev_row + 1).min(bottom);
-        }
-    }
-    paint_blank_after(buf, area, row, DS_BRIGHT)
-}

crates/reasonix-render/src/whole_screen/cards/mod.rs

@@ -1,344 +0,0 @@
-mod diff;
-mod message;
-mod notify;
-mod output;
-mod todo;
-mod tool;
-
-pub(super) use todo::{parse_todo_items, TodoState};
-
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::style::{Color, Modifier};
-use unicode_width::UnicodeWidthStr;
-
-use crate::state::{SceneCard, SceneState};
-
-use super::paint::{paint, paint_str};
-use super::theme::{BG, DS, FG1, FG2, FG3, OK};
-
-pub fn render_cards(
-    buf: &mut Buffer,
-    area: Rect,
-    start_row: u16,
-    state: &SceneState,
-    scroll_offset: u16,
-    tick: u32,
-) {
-    let bottom = area.y + area.height;
-    if start_row >= bottom {
-        return;
-    }
-    if state.cards.is_empty() {
-        render_idle_banner(buf, area, start_row);
-        return;
-    }
-    let avail = bottom - start_row;
-    let scroll_w = if area.width > 0 { area.width - 1 } else { 0 };
-    if scroll_w == 0 {
-        return;
-    }
-    let body_w = body_width_for(Rect::new(0, 0, scroll_w, 1));
-    let total: u16 = state.cards.iter().map(|c| card_height(c, body_w)).sum();
-    if total == 0 {
-        return;
-    }
-    let virt_rect = Rect::new(0, 0, scroll_w, total);
-    let mut virt = Buffer::empty(virt_rect);
-    let mut row = 0u16;
-    let last_idx = state.cards.len().saturating_sub(1);
-    for (i, card) in state.cards.iter().enumerate() {
-        let streaming = state.busy && i == last_idx;
-        row = render_card(&mut virt, virt_rect, row, card, streaming, tick);
-    }
-
-    let max_offset = total.saturating_sub(avail);
-    let offset = scroll_offset.min(max_offset);
-    let view_h = avail.min(total);
-    let view_top = total.saturating_sub(view_h).saturating_sub(offset);
-    let dest_top = bottom.saturating_sub(view_h);
-
-    for dy in 0..view_h {
-        let src_y = view_top + dy;
-        if src_y >= total {
-            break;
-        }
-        for dx in 0..scroll_w {
-            buf[(area.x + dx, dest_top + dy)] = virt[(dx, src_y)].clone();
-        }
-    }
-
-    render_scrollbar(buf, area, start_row, total, view_h, offset);
-}
-
-fn render_scrollbar(
-    buf: &mut Buffer,
-    area: Rect,
-    start_row: u16,
-    total: u16,
-    view_h: u16,
-    offset: u16,
-) {
-    if area.width == 0 || view_h == 0 || total <= view_h {
-        return;
-    }
-    let track_x = area.x + area.width - 1;
-    let track_top = area.y + area.height.saturating_sub(view_h);
-    let max_offset = total - view_h;
-    let thumb_size = ((view_h as f32 / total as f32) * view_h as f32).round() as u16;
-    let thumb_size = thumb_size.max(1).min(view_h);
-    let track_space = view_h - thumb_size;
-    let thumb_top = if max_offset == 0 {
-        track_space
-    } else {
-        let ratio = 1.0 - (offset as f32 / max_offset as f32);
-        (ratio * track_space as f32).round() as u16
-    };
-
-    for y in 0..view_h {
-        let abs_y = track_top + y;
-        if abs_y < start_row {
-            continue;
-        }
-        let in_thumb = y >= thumb_top && y < thumb_top + thumb_size;
-        let (ch, fg) = if in_thumb { ('█', FG2) } else { ('│', FG3) };
-        paint(buf, track_x, abs_y, ch, fg, BG, Modifier::empty());
-    }
-}
-
-fn render_idle_banner(buf: &mut Buffer, area: Rect, start_row: u16) {
-    let bottom = area.y + area.height;
-    if start_row >= bottom {
-        return;
-    }
-    paint_rail(buf, area, start_row, OK);
-    let mut col = area.x + 2;
-    col = paint_str(buf, col, start_row, "● ", OK, BG, Modifier::BOLD);
-    col = paint_str(buf, col, start_row, "idle", OK, BG, Modifier::BOLD);
-    let meta = "ready for next task";
-    let mcol = area.x + area.width.saturating_sub(meta.len() as u16 + 1);
-    paint_str(
-        buf,
-        mcol.max(col + 2),
-        start_row,
-        meta,
-        FG3,
-        BG,
-        Modifier::empty(),
-    );
-
-    let row = start_row + 1;
-    if row >= bottom {
-        return;
-    }
-    paint_rail(buf, area, row, OK);
-    let mut tcol = area.x + 4;
-    tcol = paint_str(buf, tcol, row, "type below", FG1, BG, Modifier::empty());
-    let pairs: [(&str, &str); 3] = [("/", "commands"), ("@", "file refs"), ("!", "shell")];
-    for (key, label) in pairs {
-        tcol = paint_str(buf, tcol, row, "  ·  ", FG3, BG, Modifier::empty());
-        tcol = paint_str(buf, tcol, row, key, DS, BG, Modifier::BOLD);
-        tcol = paint_str(buf, tcol, row, " ", FG2, BG, Modifier::empty());
-        tcol = paint_str(buf, tcol, row, label, FG2, BG, Modifier::empty());
-    }
-
-    // Starter hints — surfaces the most-likely-useful slash commands
-    // upfront, matches the Node TUI WelcomeBanner; helps brand-new
-    // users discover the surface without /help.
-    let starters: [(&str, &str); 4] = [
-        ("/help", "see all commands"),
-        ("/cost", "session spend + tokens"),
-        ("/init", "scan repo into REASONIX.md"),
-        ("/sessions", "switch / resume past sessions"),
-    ];
-    for (i, (cmd, desc)) in starters.iter().enumerate() {
-        let r = start_row + 3 + i as u16;
-        if r >= bottom {
-            break;
-        }
-        paint_rail(buf, area, r, OK);
-        let mut sc = area.x + 4;
-        sc = paint_str(buf, sc, r, cmd, DS, BG, Modifier::BOLD);
-        sc = paint_str(buf, sc, r, "  ", FG3, BG, Modifier::empty());
-        paint_str(buf, sc, r, desc, FG2, BG, Modifier::empty());
-    }
-}
-
-pub(super) fn total_cards_height(state: &SceneState, body_width: u16) -> u16 {
-    state.cards.iter().map(|c| card_height(c, body_width)).sum()
-}
-
-pub(super) fn render_card_to(
-    buf: &mut Buffer,
-    area: Rect,
-    row: u16,
-    card: &SceneCard,
-    streaming: bool,
-) -> u16 {
-    render_card(buf, area, row, card, streaming, u32::MAX)
-}
-
-pub(super) fn body_width_for(area: Rect) -> u16 {
-    area.width.saturating_sub(4)
-}
-
-pub(super) fn wrap_visual(line: &str, width: u16) -> Vec<String> {
-    let w = width as usize;
-    if w == 0 {
-        return vec![String::new()];
-    }
-    if line.is_empty() {
-        return vec![String::new()];
-    }
-    if UnicodeWidthStr::width(line) <= w {
-        return vec![line.to_string()];
-    }
-    let mut out = Vec::new();
-    let mut current = String::new();
-    let mut current_w = 0usize;
-    for ch in line.chars() {
-        let ch_w = unicode_width::UnicodeWidthChar::width(ch).unwrap_or(0);
-        if current_w + ch_w > w && !current.is_empty() {
-            out.push(std::mem::take(&mut current));
-            current_w = 0;
-        }
-        current.push(ch);
-        current_w += ch_w;
-    }
-    if !current.is_empty() {
-        out.push(current);
-    }
-    if out.is_empty() {
-        out.push(String::new());
-    }
-    out
-}
-
-fn body_lines_height(body: &str, width: u16) -> u16 {
-    let mut total = 0u32;
-    for line in body.split('\n') {
-        let count = wrap_visual(line, width).len().max(1) as u32;
-        total += count;
-    }
-    total.min(u16::MAX as u32) as u16
-}
-
-fn card_height(card: &SceneCard, body_width: u16) -> u16 {
-    let is_md = matches!(card.kind.as_str(), "assistant" | "streaming");
-    let body_lines = card
-        .body
-        .as_deref()
-        .map(|b| {
-            if is_md {
-                super::md_render::count_visual_rows(b, body_width).min(u16::MAX as usize) as u16
-            } else {
-                body_lines_height(b, body_width)
-            }
-        })
-        .unwrap_or(0);
-    match card.kind.as_str() {
-        "user" | "reasoning" | "think" | "thinking" | "assistant" | "streaming" | "diff"
-        | "cmd" | "fileview" | "search" | "subagent" | "confirm" | "await" | "await_input"
-        | "error" | "info" | "warn" | "usage" | "doctor" | "memory" | "ctx" | "plan-card"
-        | "task" => 1 + body_lines + 1,
-        "todo" | "plan" => {
-            let items = card
-                .body
-                .as_deref()
-                .map(|b| parse_todo_items(b).len() as u16)
-                .unwrap_or(0);
-            1 + items + 1
-        }
-        "tool" => 1,
-        _ => 0,
-    }
-}
-
-fn render_card(
-    buf: &mut Buffer,
-    area: Rect,
-    row: u16,
-    card: &SceneCard,
-    streaming: bool,
-    tick: u32,
-) -> u16 {
-    match card.kind.as_str() {
-        "user" => message::render_user_card(buf, area, row, card),
-        "reasoning" | "think" | "thinking" => message::render_reasoning_card(buf, area, row, card),
-        "tool" => tool::render_tool_card(buf, area, row, card, tick),
-        "assistant" | "streaming" => {
-            message::render_assistant_card(buf, area, row, card, streaming, tick)
-        }
-        "todo" | "plan" => todo::render_todo_card(buf, area, row, card),
-        "diff" => diff::render_diff_card(buf, area, row, card),
-        "cmd" => output::render_cmd_card(buf, area, row, card),
-        "fileview" => output::render_fileview_card(buf, area, row, card),
-        "search" => output::render_search_card(buf, area, row, card),
-        "subagent" => notify::render_subagent_card(buf, area, row, card),
-        "confirm" => notify::render_confirm_card(buf, area, row, card),
-        "await" | "await_input" => notify::render_await_card(buf, area, row, card),
-        "error" => notify::render_error_card(buf, area, row, card),
-        "info" => notify::render_info_card(buf, area, row, card, super::theme::INFO, "ⓘ"),
-        "warn" => notify::render_info_card(buf, area, row, card, super::theme::WARN, "▲"),
-        "usage" => notify::render_info_card(buf, area, row, card, super::theme::DS_BRIGHT, "$"),
-        "doctor" => notify::render_info_card(buf, area, row, card, super::theme::OK, "✚"),
-        "memory" => notify::render_info_card(buf, area, row, card, super::theme::DS_PURPLE, "◈"),
-        "ctx" => notify::render_info_card(buf, area, row, card, super::theme::INFO, "▦"),
-        "plan-card" => notify::render_info_card(buf, area, row, card, super::theme::DS_PURPLE, "◆"),
-        "task" => notify::render_info_card(buf, area, row, card, super::theme::DS_BRIGHT, "▸"),
-        _ => row,
-    }
-}
-
-pub(super) fn paint_rail(buf: &mut Buffer, area: Rect, row: u16, color: Color) {
-    paint(buf, area.x, row, '▎', color, BG, Modifier::empty());
-}
-
-#[allow(clippy::too_many_arguments)]
-pub(super) fn render_card_header(
-    buf: &mut Buffer,
-    area: Rect,
-    row: u16,
-    rail_color: Color,
-    glyph: &str,
-    glyph_fg: Color,
-    label: &str,
-    label_fg: Color,
-    meta_right: Option<(&str, Color)>,
-) {
-    paint_rail(buf, area, row, rail_color);
-    let mut col = area.x + 2;
-    col = paint_str(buf, col, row, glyph, glyph_fg, BG, Modifier::BOLD);
-    col = col.saturating_add(1);
-    paint_str(buf, col, row, label, label_fg, BG, Modifier::BOLD);
-    if let Some((text, fg)) = meta_right {
-        let w = text.width() as u16;
-        let mcol = area.x + area.width.saturating_sub(w + 1);
-        paint_str(buf, mcol, row, text, fg, BG, Modifier::empty());
-    }
-}
-
-pub(super) fn body_indent_col(area: Rect) -> u16 {
-    area.x + 4
-}
-
-pub(super) fn paint_body_line(
-    buf: &mut Buffer,
-    area: Rect,
-    row: u16,
-    rail_color: Color,
-    line: &str,
-    fg: Color,
-    modifier: Modifier,
-) {
-    paint_rail(buf, area, row, rail_color);
-    paint_str(buf, body_indent_col(area), row, line, fg, BG, modifier);
-}
-
-pub(super) fn paint_blank_after(buf: &mut Buffer, area: Rect, row: u16, rail_color: Color) -> u16 {
-    if row >= area.y + area.height {
-        return row;
-    }
-    paint_rail(buf, area, row, rail_color);
-    row + 1
-}

crates/reasonix-render/src/whole_screen/cards/notify.rs

@@ -1,246 +0,0 @@
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::style::Modifier;
-use unicode_width::UnicodeWidthStr;
-
-use crate::state::SceneCard;
-
-use super::super::paint::{paint, paint_str};
-use super::super::theme::{BG, DS_BRIGHT, ERR, FG, FG1, FG2, FG3, INFO, WARN};
-use super::{
-    body_indent_col, body_width_for, paint_blank_after, paint_body_line, paint_rail,
-    render_card_header, wrap_visual,
-};
-
-pub(super) fn render_subagent_card(
-    buf: &mut Buffer,
-    area: Rect,
-    start_row: u16,
-    card: &SceneCard,
-) -> u16 {
-    let bottom = area.y + area.height;
-    let mut row = start_row;
-    render_card_header(
-        buf,
-        area,
-        row,
-        INFO,
-        "⧪",
-        INFO,
-        &card.summary,
-        INFO,
-        card.meta.as_deref().map(|s| (s, FG3)),
-    );
-    row += 1;
-    let width = body_width_for(area);
-    if let Some(body) = card.body.as_deref() {
-        for (i, raw) in body.split('\n').enumerate() {
-            let wrap_w = if i == 0 {
-                width
-            } else {
-                width.saturating_sub(2)
-            };
-            for (wi, line) in wrap_visual(raw, wrap_w).iter().enumerate() {
-                if row >= bottom {
-                    return row;
-                }
-                if i == 0 || wi > 0 {
-                    paint_body_line(buf, area, row, INFO, line, FG1, Modifier::empty());
-                } else {
-                    paint_rail(buf, area, row, INFO);
-                    let col = body_indent_col(area);
-                    paint(buf, col, row, '→', INFO, BG, Modifier::BOLD);
-                    paint_str(buf, col + 2, row, line, FG1, BG, Modifier::empty());
-                }
-                row += 1;
-            }
-        }
-    }
-    paint_blank_after(buf, area, row, INFO)
-}
-
-pub(super) fn render_confirm_card(
-    buf: &mut Buffer,
-    area: Rect,
-    start_row: u16,
-    card: &SceneCard,
-) -> u16 {
-    let bottom = area.y + area.height;
-    let mut row = start_row;
-    let title = format!("permission required · {}", card.summary);
-    render_card_header(buf, area, row, WARN, "⚠", WARN, &title, WARN, None);
-    row += 1;
-    if let Some(body) = card.body.as_deref() {
-        let mut lines = body.split('\n');
-        if let Some(question) = lines.next() {
-            if row < bottom {
-                paint_body_line(buf, area, row, WARN, question, FG, Modifier::empty());
-                row += 1;
-            }
-        }
-        for opts in lines {
-            if row >= bottom {
-                return row;
-            }
-            paint_rail(buf, area, row, WARN);
-            let mut col = body_indent_col(area);
-            for tok in opts.split_whitespace() {
-                col = paint_option_token(buf, col, row, tok);
-                col = col.saturating_add(2);
-            }
-            row += 1;
-        }
-    }
-    paint_blank_after(buf, area, row, WARN)
-}
-
-fn paint_option_token(buf: &mut Buffer, x: u16, row: u16, tok: &str) -> u16 {
-    let (key, label) = match tok.find(']') {
-        Some(close) if tok.starts_with('[') => {
-            let key = &tok[1..close];
-            let label = &tok[close + 1..];
-            (key, label)
-        }
-        _ => ("", tok),
-    };
-    let mut col = x;
-    if !key.is_empty() {
-        let key_fg = match key {
-            "y" | "Y" => DS_BRIGHT,
-            "n" | "N" => FG2,
-            "a" | "A" => ERR,
-            _ => FG1,
-        };
-        col = paint_str(buf, col, row, "[", FG3, BG, Modifier::empty());
-        col = paint_str(buf, col, row, key, key_fg, BG, Modifier::BOLD);
-        col = paint_str(buf, col, row, "]", FG3, BG, Modifier::empty());
-        col = col.saturating_add(1);
-    }
-    paint_str(buf, col, row, label, FG1, BG, Modifier::empty())
-}
-
-pub(super) fn render_await_card(
-    buf: &mut Buffer,
-    area: Rect,
-    start_row: u16,
-    card: &SceneCard,
-) -> u16 {
-    let bottom = area.y + area.height;
-    let mut row = start_row;
-    render_card_header(
-        buf,
-        area,
-        row,
-        DS_BRIGHT,
-        "?",
-        DS_BRIGHT,
-        if card.summary.is_empty() {
-            "awaiting input"
-        } else {
-            &card.summary
-        },
-        DS_BRIGHT,
-        None,
-    );
-    row += 1;
-    if let Some(body) = card.body.as_deref() {
-        let mut lines = body.split('\n');
-        if let Some(question) = lines.next() {
-            if row < bottom {
-                paint_body_line(buf, area, row, DS_BRIGHT, question, FG, Modifier::empty());
-                row += 1;
-            }
-        }
-        for line in lines {
-            if row >= bottom {
-                return row;
-            }
-            paint_rail(buf, area, row, DS_BRIGHT);
-            let col = body_indent_col(area);
-            paint_await_option(buf, col, row, line);
-            row += 1;
-        }
-    }
-    paint_blank_after(buf, area, row, DS_BRIGHT)
-}
-
-fn paint_await_option(buf: &mut Buffer, x: u16, row: u16, line: &str) {
-    if let Some(close) = line.find(')') {
-        let key = &line[..close];
-        let label = line[close + 1..].trim_start();
-        let key_w = key.width() as u16;
-        paint_str(buf, x, row, key, DS_BRIGHT, BG, Modifier::BOLD);
-        paint_str(buf, x + key_w, row, ")", FG2, BG, Modifier::empty());
-        paint_str(buf, x + key_w + 2, row, label, FG1, BG, Modifier::empty());
-    } else {
-        paint_str(buf, x, row, line, FG1, BG, Modifier::empty());
-    }
-}
-
-pub(super) fn render_info_card(
-    buf: &mut Buffer,
-    area: Rect,
-    start_row: u16,
-    card: &SceneCard,
-    accent: ratatui::style::Color,
-    glyph: &str,
-) -> u16 {
-    let bottom = area.y + area.height;
-    let mut row = start_row;
-    let meta = card.meta.as_deref().map(|m| (m, FG2));
-    render_card_header(
-        buf,
-        area,
-        row,
-        accent,
-        glyph,
-        accent,
-        &card.summary,
-        accent,
-        meta,
-    );
-    row += 1;
-    if let Some(body) = card.body.as_deref() {
-        let width = body_width_for(area);
-        for raw in body.split('\n') {
-            for line in wrap_visual(raw, width) {
-                if row >= bottom {
-                    return row;
-                }
-                paint_body_line(buf, area, row, accent, &line, FG1, Modifier::empty());
-                row += 1;
-            }
-        }
-    }
-    paint_blank_after(buf, area, row, accent)
-}
-
-pub(super) fn render_error_card(
-    buf: &mut Buffer,
-    area: Rect,
-    start_row: u16,
-    card: &SceneCard,
-) -> u16 {
-    let bottom = area.y + area.height;
-    let mut row = start_row;
-    render_card_header(buf, area, row, ERR, "✕", ERR, &card.summary, ERR, None);
-    row += 1;
-    if let Some(body) = card.body.as_deref() {
-        let width = body_width_for(area);
-        for raw in body.split('\n') {
-            let fg = if raw.trim_start().starts_with("at ") {
-                FG2
-            } else {
-                FG
-            };
-            for line in wrap_visual(raw, width) {
-                if row >= bottom {
-                    return row;
-                }
-                paint_body_line(buf, area, row, ERR, &line, fg, Modifier::empty());
-                row += 1;
-            }
-        }
-    }
-    paint_blank_after(buf, area, row, ERR)
-}

crates/reasonix-render/src/whole_screen/cards/output.rs

@@ -1,157 +0,0 @@
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::style::Modifier;
-use unicode_width::UnicodeWidthStr;
-
-use crate::state::SceneCard;
-
-use super::super::paint::paint_str;
-use super::super::theme::{BG, DS_BRIGHT, ERR, FG, FG1, FG2, FG3, INFO, OK};
-use super::{
-    body_width_for, paint_blank_after, paint_body_line, paint_rail, render_card_header, wrap_visual,
-};
-
-pub(super) fn render_cmd_card(
-    buf: &mut Buffer,
-    area: Rect,
-    start_row: u16,
-    card: &SceneCard,
-) -> u16 {
-    let bottom = area.y + area.height;
-    let mut row = start_row;
-    paint_rail(buf, area, row, OK);
-    let mut col = area.x + 2;
-    col = paint_str(buf, col, row, "$ ", OK, BG, Modifier::BOLD);
-    col = paint_str(buf, col, row, &card.summary, FG, BG, Modifier::empty());
-    if let Some(meta) = card.meta.as_deref() {
-        let w = meta.width() as u16;
-        let mcol = area.x + area.width.saturating_sub(w + 1);
-        let fg = if meta.contains("0") && meta.starts_with("exit 0") {
-            OK
-        } else if meta.starts_with("exit ") {
-            ERR
-        } else {
-            FG2
-        };
-        paint_str(buf, mcol.max(col + 2), row, meta, fg, BG, Modifier::empty());
-    }
-    row += 1;
-    if let Some(body) = card.body.as_deref() {
-        let width = body_width_for(area);
-        for raw in body.split('\n') {
-            let trimmed = raw.trim_end();
-            let fg = if trimmed.starts_with("  ✓") || trimmed.contains("passed") {
-                OK
-            } else if trimmed.starts_with("  ✕") || trimmed.contains("failed") {
-                ERR
-            } else if trimmed.starts_with("stdout")
-                || trimmed.starts_with("stderr")
-                || trimmed.starts_with(" RUN")
-            {
-                FG2
-            } else {
-                FG1
-            };
-            for line in wrap_visual(trimmed, width) {
-                if row >= bottom {
-                    return row;
-                }
-                paint_body_line(buf, area, row, OK, &line, fg, Modifier::empty());
-                row += 1;
-            }
-        }
-    }
-    paint_blank_after(buf, area, row, OK)
-}
-
-pub(super) fn render_fileview_card(
-    buf: &mut Buffer,
-    area: Rect,
-    start_row: u16,
-    card: &SceneCard,
-) -> u16 {
-    let bottom = area.y + area.height;
-    let mut row = start_row;
-    render_card_header(
-        buf,
-        area,
-        row,
-        DS_BRIGHT,
-        "📄",
-        DS_BRIGHT,
-        &card.summary,
-        DS_BRIGHT,
-        card.meta.as_deref().map(|s| (s, FG3)),
-    );
-    row += 1;
-    if let Some(body) = card.body.as_deref() {
-        for line in body.split('\n') {
-            if row >= bottom {
-                return row;
-            }
-            paint_rail(buf, area, row, DS_BRIGHT);
-            let (ln, code) = split_first_colon(line);
-            let mut col = area.x + 2;
-            col = paint_str(
-                buf,
-                col,
-                row,
-                &format!("{ln:>4}"),
-                FG3,
-                BG,
-                Modifier::empty(),
-            );
-            col = col.saturating_add(2);
-            paint_str(buf, col, row, code, FG1, BG, Modifier::empty());
-            row += 1;
-        }
-    }
-    paint_blank_after(buf, area, row, DS_BRIGHT)
-}
-
-pub(super) fn render_search_card(
-    buf: &mut Buffer,
-    area: Rect,
-    start_row: u16,
-    card: &SceneCard,
-) -> u16 {
-    let bottom = area.y + area.height;
-    let mut row = start_row;
-    render_card_header(
-        buf,
-        area,
-        row,
-        INFO,
-        "⌕",
-        INFO,
-        &card.summary,
-        INFO,
-        card.meta.as_deref().map(|s| (s, FG3)),
-    );
-    row += 1;
-    if let Some(body) = card.body.as_deref() {
-        for line in body.split('\n') {
-            if row >= bottom {
-                return row;
-            }
-            paint_rail(buf, area, row, INFO);
-            let (file_part, rest) = split_first_colon(line);
-            let (ln_part, code_part) = split_first_colon(rest);
-            let mut col = area.x + 2;
-            col = paint_str(buf, col, row, file_part, DS_BRIGHT, BG, Modifier::empty());
-            col = paint_str(buf, col, row, ":", FG3, BG, Modifier::empty());
-            col = paint_str(buf, col, row, ln_part, FG2, BG, Modifier::empty());
-            col = col.saturating_add(2);
-            paint_str(buf, col, row, code_part, FG1, BG, Modifier::empty());
-            row += 1;
-        }
-    }
-    paint_blank_after(buf, area, row, INFO)
-}
-
-fn split_first_colon(s: &str) -> (&str, &str) {
-    match s.split_once(':') {
-        Some((a, b)) => (a, b),
-        None => (s, ""),
-    }
-}

crates/reasonix-render/src/whole_screen/cards/todo.rs

@@ -1,79 +0,0 @@
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::style::Modifier;
-
-use crate::state::SceneCard;
-
-use super::super::paint::paint_str;
-use super::super::theme::{BG, DS_BRIGHT, DS_PURPLE, FG, FG1, FG2, FG3, OK};
-use super::{paint_blank_after, paint_rail, render_card_header};
-
-#[derive(Clone, Copy)]
-pub(in crate::whole_screen) enum TodoState {
-    Done,
-    Active,
-    Pending,
-}
-
-pub(in crate::whole_screen) fn parse_todo_items(body: &str) -> Vec<(TodoState, &str)> {
-    body.lines()
-        .filter_map(|line| {
-            let t = line.trim_start();
-            if let Some(rest) = t.strip_prefix("[x]") {
-                Some((TodoState::Done, rest.trim_start()))
-            } else if let Some(rest) = t.strip_prefix("[~]") {
-                Some((TodoState::Active, rest.trim_start()))
-            } else if let Some(rest) = t.strip_prefix("[ ]") {
-                Some((TodoState::Pending, rest.trim_start()))
-            } else {
-                None
-            }
-        })
-        .collect()
-}
-
-pub(super) fn render_todo_card(
-    buf: &mut Buffer,
-    area: Rect,
-    start_row: u16,
-    card: &SceneCard,
-) -> u16 {
-    let bottom = area.y + area.height;
-    let body = card.body.as_deref().unwrap_or("");
-    let items = parse_todo_items(body);
-    let done = items
-        .iter()
-        .filter(|(s, _)| matches!(s, TodoState::Done))
-        .count();
-    let meta = format!("{} of {} complete", done, items.len());
-    let mut row = start_row;
-    render_card_header(
-        buf,
-        area,
-        row,
-        DS_PURPLE,
-        "◆",
-        DS_PURPLE,
-        "PLAN",
-        DS_PURPLE,
-        Some((&meta, FG3)),
-    );
-    row += 1;
-    for (state, label) in items {
-        if row >= bottom {
-            return row;
-        }
-        paint_rail(buf, area, row, DS_PURPLE);
-        let (marker, marker_fg, label_fg, label_mod) = match state {
-            TodoState::Done => ("[x]", OK, FG2, Modifier::empty()),
-            TodoState::Active => ("[~]", DS_BRIGHT, FG, Modifier::BOLD),
-            TodoState::Pending => ("[ ]", FG3, FG1, Modifier::empty()),
-        };
-        let mut c = area.x + 2;
-        c = paint_str(buf, c, row, marker, marker_fg, BG, Modifier::BOLD);
-        c = c.saturating_add(1);
-        paint_str(buf, c, row, label, label_fg, BG, label_mod);
-        row += 1;
-    }
-    paint_blank_after(buf, area, row, DS_PURPLE)
-}

crates/reasonix-render/src/whole_screen/cards/tool.rs

@@ -1,78 +0,0 @@
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::style::{Color, Modifier};
-use unicode_width::UnicodeWidthStr;
-
-use crate::state::{SceneCard, ToolStatus};
-
-use super::super::paint::paint_str;
-use super::super::theme::{BG, DS_BRIGHT, DS_PURPLE, ERR, FG, FG1, FG2, FG3, INFO, OK, WARN};
-use super::paint_rail;
-
-const SPINNER: [char; 10] = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-
-fn spinner_frame(tick: u32) -> char {
-    SPINNER[(tick as usize) % SPINNER.len()]
-}
-
-pub(super) fn render_tool_card(
-    buf: &mut Buffer,
-    area: Rect,
-    row: u16,
-    card: &SceneCard,
-    tick: u32,
-) -> u16 {
-    let bottom = area.y + area.height;
-    if row >= bottom {
-        return row;
-    }
-    paint_rail(buf, area, row, FG2);
-    let mut col = area.x + 2;
-    col = paint_str(buf, col, row, "▸ ", FG2, BG, Modifier::empty());
-    let name = card.summary.as_str();
-    let name_fg = tool_name_color(name);
-    col = paint_str(buf, col, row, name, name_fg, BG, Modifier::BOLD);
-    if let Some(args) = card.args.as_deref() {
-        col = paint_str(buf, col, row, " (", FG2, BG, Modifier::empty());
-        col = paint_str(buf, col, row, args, FG1, BG, Modifier::empty());
-        col = paint_str(buf, col, row, ")", FG2, BG, Modifier::empty());
-    }
-    let elapsed = card.elapsed.as_deref().unwrap_or("");
-    let id = card.id.as_deref().unwrap_or("");
-    let mut spin_buf = [0u8; 4];
-    let (status_glyph, status_fg): (&str, _) = match card.status {
-        Some(ToolStatus::Ok) => ("✓", OK),
-        Some(ToolStatus::Err) => ("✕", ERR),
-        Some(ToolStatus::Running) => (spinner_frame(tick).encode_utf8(&mut spin_buf), WARN),
-        None => ("", FG3),
-    };
-    let right_w =
-        status_glyph.width() as u16 + 1 + elapsed.width() as u16 + 2 + id.width() as u16 + 1;
-    let mut rcol = area.x + area.width.saturating_sub(right_w);
-    if rcol < col + 2 {
-        rcol = col + 2;
-    }
-    if !status_glyph.is_empty() {
-        rcol = paint_str(buf, rcol, row, status_glyph, status_fg, BG, Modifier::BOLD);
-        rcol = rcol.saturating_add(1);
-    }
-    if !elapsed.is_empty() {
-        rcol = paint_str(buf, rcol, row, elapsed, FG2, BG, Modifier::empty());
-        rcol = rcol.saturating_add(2);
-    }
-    if !id.is_empty() {
-        paint_str(buf, rcol, row, id, FG3, BG, Modifier::empty());
-    }
-    row + 1
-}
-
-fn tool_name_color(name: &str) -> Color {
-    match name {
-        "Read" | "FileView" => DS_BRIGHT,
-        "Grep" | "Search" => INFO,
-        "Edit" | "Write" => DS_PURPLE,
-        "Bash" => OK,
-        "Fetch" | "WebFetch" => WARN,
-        _ => FG,
-    }
-}

crates/reasonix-render/src/whole_screen/demo.rs

@@ -1,173 +0,0 @@
-use chrono::Local;
-
-use crate::state::{SceneCard, SceneState, SlashMatch, ToolStatus};
-
-pub fn demo_state() -> SceneState {
-    let ts = Local::now().timestamp();
-    SceneState {
-        model: Some("deepseek-v3.2-coder".to_string()),
-        cwd: Some("~/work/reasonix-core".to_string()),
-        mcp_server_count: Some(0),
-        composer_text: Some(String::new()),
-        composer_cursor: Some(0),
-        busy: true,
-        activity: Some("streaming".to_string()),
-        ctx_tokens: Some(19_200),
-        ctx_cap: Some(128_000),
-        session_cost_usd: Some(0.043),
-        last_turn_cost_usd: Some(0.012),
-        cache_hit_ratio: Some(0.87),
-        last_turn_ms: Some(2_100),
-        session_input_tokens: Some(12_408),
-        session_output_tokens: Some(3_194),
-        edit_mode: Some(crate::state::EditMode::Auto),
-        preset: Some("pro".to_string()),
-        slash_catalog: Some(
-            [
-                ("clear", "reset conversation context"),
-                ("compact", "summarize history to free up tokens"),
-                ("commit", "create a git commit from current changes"),
-                ("diff", "show pending edits as a diff"),
-                ("undo", "revert the last file edit"),
-                ("help", "show help"),
-            ]
-            .iter()
-            .map(|(cmd, summary)| SlashMatch {
-                cmd: (*cmd).to_string(),
-                summary: (*summary).to_string(),
-                group: Some("chat".to_string()),
-                args_hint: None,
-                aliases: Vec::new(),
-                arg_completer: None,
-            })
-            .collect(),
-        ),
-        cards: vec![
-            SceneCard {
-                kind: "user".to_string(),
-                body: Some(
-                    "帮我把 parser.ts 里的 token 流处理改成异步迭代器，顺便加点测试。".to_string(),
-                ),
-                ts: Some(ts),
-                ..Default::default()
-            },
-            SceneCard {
-                kind: "reasoning".to_string(),
-                body: Some(
-                    "需要先看下当前 parser.ts 结构，再决定怎么改。\n\
-                     流式场景下 AsyncIterator 比 callback 更自然。\n\
-                     调用方有 7 处用到 parseStream，要确认接口形态变化是否会破坏外层。"
-                        .to_string(),
-                ),
-                meta: Some("8 steps · 2.1s".to_string()),
-                ..Default::default()
-            },
-            SceneCard {
-                kind: "todo".to_string(),
-                body: Some(
-                    "[x] 阅读 parser.ts 当前实现\n\
-                     [x] 检查调用方依赖\n\
-                     [~] 改写为 AsyncIterator 接口\n\
-                     [ ] 迁移现有 callback 调用\n\
-                     [ ] 编写 vitest 单元测试"
-                        .to_string(),
-                ),
-                ..Default::default()
-            },
-            SceneCard {
-                kind: "tool".to_string(),
-                summary: "Read".to_string(),
-                args: Some("src/parser.ts".to_string()),
-                status: Some(ToolStatus::Ok),
-                elapsed: Some("0.12s".to_string()),
-                id: Some("#a4f1".to_string()),
-                ..Default::default()
-            },
-            SceneCard {
-                kind: "tool".to_string(),
-                summary: "Grep".to_string(),
-                args: Some("\"parseStream\", in: src/".to_string()),
-                status: Some(ToolStatus::Ok),
-                elapsed: Some("0.08s".to_string()),
-                id: Some("#a4f2".to_string()),
-                ..Default::default()
-            },
-            SceneCard {
-                kind: "subagent".to_string(),
-                summary: "subagent: code-reviewer".to_string(),
-                meta: Some("3 steps · 1.4s".to_string()),
-                body: Some(
-                    "审查 parseStream 调用方是否依赖旧返回值形状\n\
-                     scanned 7 call-sites in src/render/, src/parser.ts, tests/\n\
-                     all callers expect AsyncIterable<Token>\n\
-                     safe to rewrite, no caller migration needed"
-                        .to_string(),
-                ),
-                ..Default::default()
-            },
-            SceneCard {
-                kind: "tool".to_string(),
-                summary: "Edit".to_string(),
-                args: Some("src/parser.ts, +34 -18".to_string()),
-                status: Some(ToolStatus::Running),
-                ..Default::default()
-            },
-            SceneCard {
-                kind: "fileview".to_string(),
-                summary: "src/parser.ts".to_string(),
-                meta: Some("36 more lines".to_string()),
-                body: Some(
-                    "14:import { escape } from \"./html\";\n\
-                     15:\n\
-                     16:// renders a single token to its display form\n\
-                     17:export function formatToken(t: Token) {\n\
-                     18:  const { kind, value } = t;\n\
-                     19:  if (kind === \"text\") return value;\n\
-                     20:  return `<${kind}>${value}</${kind}>`;\n\
-                     21:}"
-                        .to_string(),
-                ),
-                ..Default::default()
-            },
-            SceneCard {
-                kind: "search".to_string(),
-                summary: "grep \"parseStream\" in src/".to_string(),
-                meta: Some("4 matches · 3 files".to_string()),
-                body: Some(
-                    "src/render/output.ts:42:return chunks.map(parseStream).join(\"\");\n\
-                     src/render/output.ts:88:const out = parseStream(token);\n\
-                     src/parser.ts:134:stream.push(parseStream(t));\n\
-                     tests/format.spec.ts:11:expect(parseStream({kind:\"text\"})).toBe(\"hi\");"
-                        .to_string(),
-                ),
-                ..Default::default()
-            },
-            SceneCard {
-                kind: "cmd".to_string(),
-                summary: "pnpm test parser".to_string(),
-                meta: Some("exit 0 · 2.1s".to_string()),
-                body: Some(
-                    " RUN  v1.6.0 ~/work/reasonix-core\n\
-                     \n\
-                     stdout | parser.spec.ts > StreamParser\n\
-                       ✓ yields tokens from async iterable        (3 ms)\n\
-                       ✓ handles split chunks across boundaries    (5 ms)\n\
-                     \n\
-                     Test Files  1 passed (1)\n\
-                          Tests  24 passed (24)"
-                        .to_string(),
-                ),
-                ..Default::default()
-            },
-            SceneCard {
-                kind: "streaming".to_string(),
-                body: Some(
-                    "已经把 parseStream 改成 async *parse() 异步生成器，并把 7 处调用迁移完成。"
-                        .to_string(),
-                ),
-                ..Default::default()
-            },
-        ],
-        ..Default::default()
-    }
-}

crates/reasonix-render/src/whole_screen/dock.rs

@@ -1,459 +0,0 @@
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::style::{Color, Modifier};
-use unicode_width::UnicodeWidthStr;
-
-use crate::state::SceneState;
-
-use super::paint::{paint, paint_str};
-use super::theme::{
-    BG, COMPOSER_PLACEHOLDER, DS_BRIGHT, DS_PURPLE, ERR, FG, FG1, FG2, FG3, INFO, OK, WARN,
-};
-
-pub fn render_dock(buf: &mut Buffer, area: Rect, state: &SceneState, tick: u32) {
-    if area.height < 3 {
-        return;
-    }
-    let inner_w = area.width;
-    let box_h = area.height.saturating_sub(2).max(3);
-    render_input_box(buf, area, box_h, state, tick);
-
-    let mut row = area.y + box_h;
-    if row < area.y + area.height {
-        render_input_meta(buf, area, row, inner_w);
-        row += 1;
-    }
-    if row < area.y + area.height {
-        render_status_bar(buf, area, row, inner_w, state);
-    }
-}
-
-fn render_input_box(buf: &mut Buffer, area: Rect, rows: u16, state: &SceneState, tick: u32) {
-    let w = area.width;
-    if w < 4 || rows < 3 {
-        return;
-    }
-    let top = area.y;
-    let bot = top + rows.saturating_sub(1);
-    let right = area.x + w - 1;
-
-    paint(buf, area.x, top, '╭', FG3, BG, Modifier::empty());
-    for x in 1..w - 1 {
-        paint(buf, area.x + x, top, '─', FG3, BG, Modifier::empty());
-    }
-    paint(buf, right, top, '╮', FG3, BG, Modifier::empty());
-
-    for y in (top + 1)..bot {
-        paint(buf, area.x, y, '│', FG3, BG, Modifier::empty());
-        paint(buf, right, y, '│', FG3, BG, Modifier::empty());
-    }
-
-    paint(buf, area.x, bot, '╰', FG3, BG, Modifier::empty());
-    for x in 1..w - 1 {
-        paint(buf, area.x + x, bot, '─', FG3, BG, Modifier::empty());
-    }
-    paint(buf, right, bot, '╯', FG3, BG, Modifier::empty());
-
-    let content_rows = rows.saturating_sub(2);
-    let prompt_input = state.prompt_input.as_ref();
-    let prompt_color = if prompt_input.is_some() {
-        WARN
-    } else {
-        match state
-            .composer_text
-            .as_deref()
-            .and_then(|s| s.chars().next())
-        {
-            Some('!') => OK,
-            Some('/') => DS_BRIGHT,
-            Some('@') => DS_PURPLE,
-            _ => DS_BRIGHT,
-        }
-    };
-    let raw_text = state.composer_text.as_deref().unwrap_or("");
-    let masked_storage: String;
-    let text: &str = if let Some(p) = prompt_input {
-        if p.secret {
-            masked_storage = "•".repeat(raw_text.chars().count());
-            &masked_storage
-        } else {
-            raw_text
-        }
-    } else {
-        raw_text
-    };
-    let placeholder: &str = if let Some(p) = prompt_input {
-        &p.label
-    } else {
-        COMPOSER_PLACEHOLDER
-    };
-    let prompt_glyph: &str = if prompt_input.is_some() { "? " } else { "❯ " };
-    let show_caret = (tick / 6).is_multiple_of(2);
-    let total_chars = text.chars().count();
-    let cursor = state
-        .composer_cursor
-        .unwrap_or(total_chars)
-        .min(total_chars);
-    let col_start = area.x + 2;
-    let text_start = col_start + 2;
-    let inner_w = if right > text_start + 1 {
-        (right - text_start - 1) as usize
-    } else {
-        0
-    };
-
-    let (visual_lines, cursor_visual_row, cursor_visual_col) =
-        build_composer_visual_lines(text, cursor, inner_w);
-
-    let visual_count = visual_lines.len();
-    let scroll_off = (cursor_visual_row + 1).saturating_sub(content_rows as usize);
-    let has_more_above = scroll_off > 0;
-    let has_more_below = scroll_off + (content_rows as usize) < visual_count;
-
-    for i in 0..content_rows {
-        let y = top + 1 + i;
-        if i == 0 {
-            paint_str(
-                buf,
-                col_start,
-                y,
-                prompt_glyph,
-                prompt_color,
-                BG,
-                Modifier::BOLD,
-            );
-        }
-        let vidx = scroll_off + i as usize;
-        if text.is_empty() && i == 0 {
-            paint_str(buf, text_start, y, placeholder, FG3, BG, Modifier::empty());
-            if show_caret {
-                paint(buf, text_start, y, '▮', DS_BRIGHT, BG, Modifier::empty());
-            }
-            continue;
-        }
-        let Some(line) = visual_lines.get(vidx) else {
-            continue;
-        };
-        if vidx == cursor_visual_row {
-            let before: String = line.chars().take(cursor_visual_col).collect();
-            let after: String = line.chars().skip(cursor_visual_col).collect();
-            let after_col = paint_str(buf, text_start, y, &before, FG, BG, Modifier::empty());
-            if show_caret {
-                paint(buf, after_col, y, '▮', DS_BRIGHT, BG, Modifier::empty());
-                paint_str(buf, after_col + 1, y, &after, FG, BG, Modifier::empty());
-            } else {
-                paint_str(buf, after_col, y, &after, FG, BG, Modifier::empty());
-            }
-        } else {
-            paint_str(buf, text_start, y, line, FG, BG, Modifier::empty());
-        }
-    }
-
-    if has_more_above && rows >= 3 {
-        paint(
-            buf,
-            right.saturating_sub(1),
-            top + 1,
-            '↑',
-            FG3,
-            BG,
-            Modifier::empty(),
-        );
-    }
-    if has_more_below && rows >= 3 {
-        paint(
-            buf,
-            right.saturating_sub(1),
-            bot.saturating_sub(1),
-            '↓',
-            FG3,
-            BG,
-            Modifier::empty(),
-        );
-    }
-}
-
-fn build_composer_visual_lines(
-    text: &str,
-    cursor: usize,
-    width: usize,
-) -> (Vec<String>, usize, usize) {
-    let mut out: Vec<String> = Vec::new();
-    let mut cur_row = 0usize;
-    let mut cur_col = 0usize;
-    if text.is_empty() {
-        out.push(String::new());
-        return (out, 0, 0);
-    }
-    let w = width.max(1);
-    let mut chars_so_far = 0usize;
-    let logical: Vec<&str> = text.split('\n').collect();
-    for (li, line) in logical.iter().enumerate() {
-        let segs: Vec<String> = if line.is_empty() {
-            vec![String::new()]
-        } else {
-            wrap_visual_chars(line, w)
-        };
-        for seg in segs {
-            let seg_chars = seg.chars().count();
-            let seg_start = chars_so_far;
-            let seg_end = chars_so_far + seg_chars;
-            if cursor >= seg_start && cursor <= seg_end {
-                cur_row = out.len();
-                cur_col = cursor - seg_start;
-            }
-            chars_so_far = seg_end;
-            out.push(seg);
-        }
-        if li + 1 < logical.len() {
-            chars_so_far += 1;
-        }
-    }
-    (out, cur_row, cur_col)
-}
-
-fn wrap_visual_chars(line: &str, width: usize) -> Vec<String> {
-    if line.is_empty() {
-        return vec![String::new()];
-    }
-    let mut out = Vec::new();
-    let mut current = String::new();
-    let mut current_w = 0usize;
-    for ch in line.chars() {
-        let ch_w = unicode_width::UnicodeWidthChar::width(ch).unwrap_or(0);
-        if current_w + ch_w > width && !current.is_empty() {
-            out.push(std::mem::take(&mut current));
-            current_w = 0;
-        }
-        current.push(ch);
-        current_w += ch_w;
-    }
-    if !current.is_empty() || out.is_empty() {
-        out.push(current);
-    }
-    out
-}
-
-fn render_input_meta(buf: &mut Buffer, area: Rect, row: u16, w: u16) {
-    let mut col = area.x + 1;
-    let left: [(&str, &str); 5] = [
-        ("↵", "send"),
-        ("⇧↵", "newline"),
-        ("/", "cmd"),
-        ("@", "file"),
-        ("!", "shell"),
-    ];
-    for (i, (key, label)) in left.iter().enumerate() {
-        if i > 0 {
-            col = col.saturating_add(2);
-        }
-        col = paint_str(buf, col, row, key, FG1, BG, Modifier::BOLD);
-        col = col.saturating_add(1);
-        col = paint_str(buf, col, row, label, FG2, BG, Modifier::empty());
-    }
-
-    let right: [(&str, &str); 2] = [("esc", "cancel"), ("↑", "history")];
-    let right_w = right_block_width(&right);
-    let mut rcol = area.x + w.saturating_sub(right_w + 1);
-    for (i, (key, label)) in right.iter().enumerate() {
-        if i > 0 {
-            rcol = rcol.saturating_add(2);
-        }
-        rcol = paint_str(buf, rcol, row, key, FG1, BG, Modifier::BOLD);
-        rcol = rcol.saturating_add(1);
-        rcol = paint_str(buf, rcol, row, label, FG2, BG, Modifier::empty());
-    }
-}
-
-fn right_block_width(pairs: &[(&str, &str)]) -> u16 {
-    let mut w = 0u16;
-    for (i, (key, label)) in pairs.iter().enumerate() {
-        if i > 0 {
-            w = w.saturating_add(2);
-        }
-        w = w.saturating_add(key.width() as u16 + 1 + label.width() as u16);
-    }
-    w
-}
-
-fn render_status_bar(buf: &mut Buffer, area: Rect, row: u16, w: u16, state: &SceneState) {
-    let mut col = area.x + 1;
-
-    // Brand dot pulses to a brighter color while busy so the user can
-    // tell the agent is actually doing something even when the cards
-    // pane is scrolled off-screen. Visual width stays at 1 cell so the
-    // rest of the status bar layout doesn't shift.
-    let dot_color = if state.busy { DS_BRIGHT } else { OK };
-    paint(buf, col, row, '●', dot_color, BG, Modifier::BOLD);
-    col = col.saturating_add(2);
-    let label = if state.busy {
-        activity_label(state.activity.as_deref())
-    } else {
-        "reasonix"
-    };
-    col = paint_str(buf, col, row, label, DS_BRIGHT, BG, Modifier::BOLD);
-    col = col.saturating_add(2);
-
-    if let Some(mode) = state.edit_mode.as_ref() {
-        let (label, color) = match mode {
-            crate::state::EditMode::Review => ("REVIEW", INFO),
-            crate::state::EditMode::Auto => ("AUTO", DS_PURPLE),
-            crate::state::EditMode::Yolo => ("YOLO", ERR),
-        };
-        col = paint_pill(buf, col, row, "MODE", label, color);
-        col = col.saturating_add(1);
-    }
-
-    if let Some(preset) = state.preset.as_deref() {
-        let (label, color) = match preset {
-            "auto" => ("AUTO", DS_BRIGHT),
-            "flash" => ("FLASH", OK),
-            "pro" => ("PRO", DS_BRIGHT),
-            _ => (preset, FG2),
-        };
-        let label_upper: String = label.chars().flat_map(char::to_uppercase).collect();
-        col = paint_pill(buf, col, row, "MODEL", &label_upper, color);
-        col = col.saturating_add(1);
-    }
-
-    col = paint_sep(buf, col, row);
-
-    let ctx_tokens = state.ctx_tokens.unwrap_or(0);
-    let ctx_cap = state.ctx_cap.unwrap_or(0);
-    let ctx_pct = if ctx_cap > 0 {
-        (f64::from(ctx_tokens) / f64::from(ctx_cap) * 100.0) as f32
-    } else {
-        0.0
-    };
-    col = paint_str(buf, col, row, "ctx ", FG2, BG, Modifier::empty());
-    col = paint_ctx_bar(buf, col, row, ctx_pct);
-    let ctx_text = if ctx_cap > 0 {
-        format!(" {}/{}", format_tokens(ctx_tokens), format_tokens(ctx_cap))
-    } else {
-        " —".to_string()
-    };
-    col = paint_str(buf, col, row, &ctx_text, FG, BG, Modifier::empty());
-    col = paint_sep(buf, col, row);
-
-    if state.session_input_tokens.is_some() || state.session_output_tokens.is_some() {
-        col = paint_str(buf, col, row, "tok ", FG2, BG, Modifier::empty());
-        let up = format!(
-            "↑{} ",
-            format_tokens(state.session_input_tokens.unwrap_or(0))
-        );
-        col = paint_str(buf, col, row, &up, OK, BG, Modifier::empty());
-        let dn = format!(
-            "↓{}",
-            format_tokens(state.session_output_tokens.unwrap_or(0))
-        );
-        col = paint_str(buf, col, row, &dn, FG1, BG, Modifier::empty());
-        col = paint_sep(buf, col, row);
-    }
-
-    col = paint_str(buf, col, row, "cache ", FG2, BG, Modifier::empty());
-    let cache_text = state
-        .cache_hit_ratio
-        .map(|r| format!("{}%", (r * 100.0).round() as i32))
-        .unwrap_or_else(|| "—".to_string());
-    col = paint_str(buf, col, row, &cache_text, OK, BG, Modifier::empty());
-    col = paint_sep(buf, col, row);
-
-    col = paint_str(buf, col, row, "cost ", FG2, BG, Modifier::empty());
-    let cost_text = format_cost(state.session_cost_usd, state.wallet_currency.as_deref());
-    col = paint_str(buf, col, row, &cost_text, FG, BG, Modifier::empty());
-
-    if let (Some(balance), Some(curr)) = (state.wallet_balance, state.wallet_currency.as_deref()) {
-        let bal_text = format!("{} {}", format_balance(balance), curr);
-        let bal_w = bal_text.width() as u16 + 2;
-        if col + bal_w < area.x + w {
-            let rcol = area.x + w.saturating_sub(bal_w);
-            paint_str(buf, rcol, row, &bal_text, FG2, BG, Modifier::empty());
-        }
-    }
-}
-
-fn activity_label(activity: Option<&str>) -> &'static str {
-    match activity.unwrap_or("") {
-        "reasoning" | "thinking" => "reasoning…",
-        "streaming" => "streaming…",
-        "tool" | "tools" => "running tool…",
-        "planning" | "plan" => "planning…",
-        "compacting" | "compact" => "compacting context…",
-        "" => "working…",
-        _ => "working…",
-    }
-}
-
-fn format_tokens(n: u32) -> String {
-    if n >= 1_000_000 {
-        format!("{:.1}M", f64::from(n) / 1_000_000.0)
-    } else if n >= 100_000 {
-        format!("{}k", n / 1000)
-    } else if n >= 1_000 {
-        format!("{:.1}k", f64::from(n) / 1000.0)
-    } else {
-        format!("{n}")
-    }
-}
-
-fn format_cost(usd: Option<f64>, currency: Option<&str>) -> String {
-    let Some(v) = usd else {
-        return "—".to_string();
-    };
-    match currency {
-        Some("CNY") | Some("RMB") => format!("¥{:.3}", v * 7.2),
-        _ => format!("${v:.3}"),
-    }
-}
-
-fn format_balance(n: f64) -> String {
-    if n >= 1000.0 {
-        format!("{:.1}", n)
-    } else if n >= 100.0 {
-        format!("{:.2}", n)
-    } else {
-        format!("{:.3}", n)
-    }
-}
-
-fn paint_sep(buf: &mut Buffer, col: u16, row: u16) -> u16 {
-    paint_str(buf, col, row, " │ ", FG3, BG, Modifier::empty())
-}
-
-fn paint_pill(
-    buf: &mut Buffer,
-    col: u16,
-    row: u16,
-    label: &str,
-    value: &str,
-    accent: ratatui::style::Color,
-) -> u16 {
-    let mut c = col;
-    c = paint_str(buf, c, row, "◇ ", accent, BG, Modifier::BOLD);
-    c = paint_str(buf, c, row, label, FG3, BG, Modifier::empty());
-    c = paint_str(buf, c, row, " ", BG, BG, Modifier::empty());
-    c = paint_str(buf, c, row, value, accent, BG, Modifier::BOLD);
-    c
-}
-
-fn paint_ctx_bar(buf: &mut Buffer, x: u16, row: u16, pct: f32) -> u16 {
-    let cells = 12u16;
-    let filled = ((pct.clamp(0.0, 100.0) / 100.0) * f32::from(cells)).round() as u16;
-    let bar_fg = ctx_color(pct);
-    for i in 0..cells {
-        let ch = if i < filled { '▰' } else { '▱' };
-        let fg = if i < filled { bar_fg } else { FG3 };
-        paint(buf, x + i, row, ch, fg, BG, Modifier::empty());
-    }
-    x + cells
-}
-
-fn ctx_color(pct: f32) -> Color {
-    if pct > 80.0 {
-        ERR
-    } else if pct > 60.0 {
-        WARN
-    } else {
-        DS_BRIGHT
-    }
-}

crates/reasonix-render/src/whole_screen/list_picker.rs

@@ -1,143 +0,0 @@
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::style::Modifier;
-use unicode_width::UnicodeWidthStr;
-
-use crate::state::ListPicker;
-
-use super::paint::{paint, paint_str};
-use super::theme::{BG, DS, DS_BRIGHT, FG, FG2, FG3};
-
-pub fn render_list_picker(buf: &mut Buffer, area: Rect, picker: &ListPicker, selected: usize) {
-    if picker.options.is_empty() {
-        return;
-    }
-    let max_label_w = picker
-        .options
-        .iter()
-        .map(|o| o.label.width() + o.sublabel.as_deref().map(|s| s.width() + 4).unwrap_or(0))
-        .max()
-        .unwrap_or(20);
-    let max_meta_w = picker
-        .options
-        .iter()
-        .map(|o| o.meta.as_deref().map(UnicodeWidthStr::width).unwrap_or(0))
-        .max()
-        .unwrap_or(0);
-    let title_w = picker.title.width();
-    let inner_w = title_w
-        .max(max_label_w + if max_meta_w > 0 { max_meta_w + 4 } else { 0 })
-        .max(40);
-    let popup_w = (inner_w as u16 + 6).min(area.width.saturating_sub(4));
-    if popup_w < 30 {
-        return;
-    }
-    let visible_cap = (area.height as usize).saturating_sub(6).clamp(3, 16);
-    let visible = picker.options.len().min(visible_cap) as u16;
-    let popup_h = 4 + visible + if picker.hint.is_some() { 1 } else { 0 };
-    if popup_h > area.height {
-        return;
-    }
-    let popup_x = area.x + (area.width.saturating_sub(popup_w)) / 2;
-    let popup_y = area.y + (area.height.saturating_sub(popup_h)) / 2;
-    let popup = Rect::new(popup_x, popup_y, popup_w, popup_h);
-
-    draw_box(buf, popup);
-    paint_str(
-        buf,
-        popup.x + 2,
-        popup.y + 1,
-        &picker.title,
-        DS_BRIGHT,
-        BG,
-        Modifier::BOLD,
-    );
-    let count_text = format!(
-        "{} option{}",
-        picker.options.len(),
-        if picker.options.len() == 1 { "" } else { "s" }
-    );
-    let ccol = popup.x + popup.width.saturating_sub(count_text.width() as u16 + 2);
-    paint_str(
-        buf,
-        ccol,
-        popup.y + 1,
-        &count_text,
-        FG3,
-        BG,
-        Modifier::empty(),
-    );
-
-    let chosen = selected.min(picker.options.len().saturating_sub(1));
-    let visible_usz = visible as usize;
-    let start = if chosen >= visible_usz {
-        chosen + 1 - visible_usz
-    } else {
-        0
-    };
-    let row_top = popup.y + 3;
-    for (i, opt) in picker
-        .options
-        .iter()
-        .enumerate()
-        .skip(start)
-        .take(visible_usz)
-    {
-        let row = row_top + (i - start) as u16;
-        let is_sel = i == chosen;
-        let label_fg = if is_sel { FG } else { DS_BRIGHT };
-        let modifier = if is_sel {
-            Modifier::BOLD
-        } else {
-            Modifier::empty()
-        };
-        if is_sel {
-            paint_str(buf, popup.x + 2, row, "▸", DS_BRIGHT, BG, Modifier::BOLD);
-        }
-        let mut col = popup.x + 4;
-        col = paint_str(buf, col, row, &opt.label, label_fg, BG, modifier);
-        if let Some(sub) = opt.sublabel.as_deref() {
-            col = col.saturating_add(2);
-            paint_str(buf, col, row, sub, FG2, BG, Modifier::empty());
-        }
-        if let Some(meta) = opt.meta.as_deref() {
-            let mw = meta.width() as u16;
-            let mcol = popup.x + popup.width.saturating_sub(mw + 2);
-            paint_str(buf, mcol, row, meta, FG3, BG, Modifier::ITALIC);
-        }
-    }
-
-    let hint_row = popup.y + popup.height.saturating_sub(2);
-    let hint = picker
-        .hint
-        .as_deref()
-        .unwrap_or("↑↓ move  ↵ select  esc cancel");
-    paint_str(buf, popup.x + 2, hint_row, hint, FG2, BG, Modifier::empty());
-}
-
-fn draw_box(buf: &mut Buffer, area: Rect) {
-    let w = area.width;
-    if w < 2 {
-        return;
-    }
-    let top = area.y;
-    let bot = area.y + area.height - 1;
-    let right = area.x + w - 1;
-    paint(buf, area.x, top, '╭', DS, BG, Modifier::empty());
-    paint(buf, right, top, '╮', DS, BG, Modifier::empty());
-    for x in 1..w - 1 {
-        paint(buf, area.x + x, top, '─', DS, BG, Modifier::empty());
-    }
-    for y in (top + 1)..bot {
-        paint(buf, area.x, y, '│', DS, BG, Modifier::empty());
-        paint(buf, right, y, '│', DS, BG, Modifier::empty());
-        for x in 1..w - 1 {
-            paint(buf, area.x + x, y, ' ', FG, BG, Modifier::empty());
-        }
-    }
-    paint(buf, area.x, bot, '╰', DS, BG, Modifier::empty());
-    paint(buf, right, bot, '╯', DS, BG, Modifier::empty());
-    for x in 1..w - 1 {
-        paint(buf, area.x + x, bot, '─', DS, BG, Modifier::empty());
-    }
-}

crates/reasonix-render/src/whole_screen/markdown.rs

@@ -1,363 +0,0 @@
-use pulldown_cmark::{Alignment, CodeBlockKind, Event, HeadingLevel, Options, Parser, Tag, TagEnd};
-
-#[derive(Clone, Debug, Default)]
-pub struct InlineStyle {
-    pub bold: bool,
-    pub italic: bool,
-    pub code: bool,
-    pub strike: bool,
-    pub link: bool,
-}
-
-#[derive(Clone, Debug)]
-pub struct InlineSpan {
-    pub text: String,
-    pub style: InlineStyle,
-}
-
-#[derive(Clone, Copy, Debug)]
-pub enum CellAlign {
-    Left,
-    Center,
-    Right,
-}
-
-#[derive(Clone, Debug)]
-pub enum MdBlock {
-    Paragraph(Vec<InlineSpan>),
-    Heading {
-        level: u8,
-        spans: Vec<InlineSpan>,
-    },
-    Code {
-        #[allow(dead_code)]
-        lang: String,
-        text: String,
-    },
-    ListItem {
-        ordered: bool,
-        index: u32,
-        depth: u8,
-        spans: Vec<InlineSpan>,
-    },
-    BlockQuote(Vec<InlineSpan>),
-    Hr,
-    Table {
-        aligns: Vec<CellAlign>,
-        head: Vec<Vec<InlineSpan>>,
-        rows: Vec<Vec<Vec<InlineSpan>>>,
-    },
-}
-
-pub fn parse(text: &str) -> Vec<MdBlock> {
-    let mut opts = Options::empty();
-    opts.insert(Options::ENABLE_STRIKETHROUGH);
-    opts.insert(Options::ENABLE_TASKLISTS);
-    opts.insert(Options::ENABLE_TABLES);
-    let parser = Parser::new_ext(text, opts);
-
-    let mut out: Vec<MdBlock> = Vec::new();
-    let mut style = InlineStyle::default();
-    let mut current_spans: Vec<InlineSpan> = Vec::new();
-    let mut current_kind: Option<TagKind> = None;
-    let mut list_stack: Vec<ListFrame> = Vec::new();
-    let mut code_lang = String::new();
-    let mut code_buf = String::new();
-    let mut in_code = false;
-    let mut table_aligns: Vec<CellAlign> = Vec::new();
-    let mut table_head: Vec<Vec<InlineSpan>> = Vec::new();
-    let mut table_rows: Vec<Vec<Vec<InlineSpan>>> = Vec::new();
-    let mut current_row: Vec<Vec<InlineSpan>> = Vec::new();
-
-    for ev in parser {
-        match ev {
-            Event::Start(Tag::Paragraph) => {
-                start_block(
-                    &mut out,
-                    &mut current_spans,
-                    &mut current_kind,
-                    TagKind::Paragraph,
-                );
-            }
-            Event::End(TagEnd::Paragraph) => {
-                end_block(
-                    &mut out,
-                    &mut current_spans,
-                    &mut current_kind,
-                    list_stack.last(),
-                );
-            }
-            Event::Start(Tag::Heading { level, .. }) => {
-                start_block(
-                    &mut out,
-                    &mut current_spans,
-                    &mut current_kind,
-                    TagKind::Heading(heading_level(level)),
-                );
-            }
-            Event::End(TagEnd::Heading(_)) => {
-                end_block(
-                    &mut out,
-                    &mut current_spans,
-                    &mut current_kind,
-                    list_stack.last(),
-                );
-            }
-            Event::Start(Tag::CodeBlock(kind)) => {
-                in_code = true;
-                code_lang = match kind {
-                    CodeBlockKind::Fenced(s) => {
-                        s.split_whitespace().next().unwrap_or("").to_string()
-                    }
-                    CodeBlockKind::Indented => String::new(),
-                };
-                code_buf.clear();
-            }
-            Event::End(TagEnd::CodeBlock) => {
-                let text = code_buf.trim_end_matches('\n').to_string();
-                out.push(MdBlock::Code {
-                    lang: std::mem::take(&mut code_lang),
-                    text,
-                });
-                in_code = false;
-                code_buf.clear();
-            }
-            Event::Start(Tag::BlockQuote(_)) => {
-                start_block(
-                    &mut out,
-                    &mut current_spans,
-                    &mut current_kind,
-                    TagKind::BlockQuote,
-                );
-            }
-            Event::End(TagEnd::BlockQuote(_)) => {
-                end_block(
-                    &mut out,
-                    &mut current_spans,
-                    &mut current_kind,
-                    list_stack.last(),
-                );
-            }
-            Event::Start(Tag::List(start)) => {
-                list_stack.push(ListFrame {
-                    ordered: start.is_some(),
-                    next_index: start.unwrap_or(1) as u32,
-                    depth: list_stack.len() as u8,
-                });
-            }
-            Event::End(TagEnd::List(_)) => {
-                list_stack.pop();
-            }
-            Event::Start(Tag::Item) => {
-                let frame = list_stack.last().copied();
-                start_block(
-                    &mut out,
-                    &mut current_spans,
-                    &mut current_kind,
-                    TagKind::ListItem,
-                );
-                if let Some(f) = frame {
-                    current_kind = Some(TagKind::ListItemFor(f));
-                }
-            }
-            Event::End(TagEnd::Item) => {
-                end_block(
-                    &mut out,
-                    &mut current_spans,
-                    &mut current_kind,
-                    list_stack.last(),
-                );
-                if let Some(frame) = list_stack.last_mut() {
-                    if frame.ordered {
-                        frame.next_index += 1;
-                    }
-                }
-            }
-            Event::Rule => {
-                out.push(MdBlock::Hr);
-            }
-            Event::Start(Tag::Table(aligns)) => {
-                table_aligns = aligns.into_iter().map(map_align).collect();
-                table_head.clear();
-                table_rows.clear();
-            }
-            Event::End(TagEnd::Table) => {
-                out.push(MdBlock::Table {
-                    aligns: std::mem::take(&mut table_aligns),
-                    head: std::mem::take(&mut table_head),
-                    rows: std::mem::take(&mut table_rows),
-                });
-            }
-            Event::Start(Tag::TableHead) => {
-                current_row = Vec::new();
-            }
-            Event::End(TagEnd::TableHead) => {
-                table_head = std::mem::take(&mut current_row);
-            }
-            Event::Start(Tag::TableRow) => {
-                current_row = Vec::new();
-            }
-            Event::End(TagEnd::TableRow) => {
-                table_rows.push(std::mem::take(&mut current_row));
-            }
-            Event::Start(Tag::TableCell) => {
-                current_spans.clear();
-            }
-            Event::End(TagEnd::TableCell) => {
-                current_row.push(std::mem::take(&mut current_spans));
-            }
-            Event::Start(Tag::Strong) => {
-                style.bold = true;
-            }
-            Event::End(TagEnd::Strong) => {
-                style.bold = false;
-            }
-            Event::Start(Tag::Emphasis) => {
-                style.italic = true;
-            }
-            Event::End(TagEnd::Emphasis) => {
-                style.italic = false;
-            }
-            Event::Start(Tag::Strikethrough) => {
-                style.strike = true;
-            }
-            Event::End(TagEnd::Strikethrough) => {
-                style.strike = false;
-            }
-            Event::Start(Tag::Link { .. }) => {
-                style.link = true;
-            }
-            Event::End(TagEnd::Link) => {
-                style.link = false;
-            }
-            Event::Code(s) => {
-                let mut code_style = style.clone();
-                code_style.code = true;
-                current_spans.push(InlineSpan {
-                    text: s.into_string(),
-                    style: code_style,
-                });
-            }
-            Event::Text(s) => {
-                if in_code {
-                    code_buf.push_str(&s);
-                } else {
-                    current_spans.push(InlineSpan {
-                        text: s.into_string(),
-                        style: style.clone(),
-                    });
-                }
-            }
-            Event::SoftBreak | Event::HardBreak if !in_code => {
-                current_spans.push(InlineSpan {
-                    text: " ".to_string(),
-                    style: style.clone(),
-                });
-            }
-            _ => {}
-        }
-    }
-    end_block(
-        &mut out,
-        &mut current_spans,
-        &mut current_kind,
-        list_stack.last(),
-    );
-    out
-}
-
-fn map_align(a: Alignment) -> CellAlign {
-    match a {
-        Alignment::Left | Alignment::None => CellAlign::Left,
-        Alignment::Center => CellAlign::Center,
-        Alignment::Right => CellAlign::Right,
-    }
-}
-
-fn heading_level(level: HeadingLevel) -> u8 {
-    match level {
-        HeadingLevel::H1 => 1,
-        HeadingLevel::H2 => 2,
-        HeadingLevel::H3 => 3,
-        HeadingLevel::H4 => 4,
-        HeadingLevel::H5 => 5,
-        HeadingLevel::H6 => 6,
-    }
-}
-
-#[derive(Clone, Copy, Debug)]
-struct ListFrame {
-    ordered: bool,
-    next_index: u32,
-    depth: u8,
-}
-
-#[derive(Clone, Copy, Debug)]
-enum TagKind {
-    Paragraph,
-    Heading(u8),
-    BlockQuote,
-    ListItem,
-    ListItemFor(ListFrame),
-}
-
-fn start_block(
-    out: &mut Vec<MdBlock>,
-    spans: &mut Vec<InlineSpan>,
-    kind: &mut Option<TagKind>,
-    new_kind: TagKind,
-) {
-    if !spans.is_empty() {
-        flush(out, std::mem::take(spans), *kind, None);
-    }
-    *kind = Some(new_kind);
-}
-
-fn end_block(
-    out: &mut Vec<MdBlock>,
-    spans: &mut Vec<InlineSpan>,
-    kind: &mut Option<TagKind>,
-    active_frame: Option<&ListFrame>,
-) {
-    let taken = std::mem::take(spans);
-    let k = kind.take();
-    if !taken.is_empty() || matches!(k, Some(TagKind::ListItem) | Some(TagKind::ListItemFor(_))) {
-        flush(out, taken, k, active_frame);
-    }
-}
-
-fn flush(
-    out: &mut Vec<MdBlock>,
-    spans: Vec<InlineSpan>,
-    kind: Option<TagKind>,
-    active_frame: Option<&ListFrame>,
-) {
-    match kind {
-        Some(TagKind::Heading(level)) => out.push(MdBlock::Heading { level, spans }),
-        Some(TagKind::BlockQuote) => out.push(MdBlock::BlockQuote(spans)),
-        Some(TagKind::ListItem) => {
-            let frame = active_frame.copied().unwrap_or(ListFrame {
-                ordered: false,
-                next_index: 1,
-                depth: 0,
-            });
-            out.push(MdBlock::ListItem {
-                ordered: frame.ordered,
-                index: frame.next_index,
-                depth: frame.depth,
-                spans,
-            });
-        }
-        Some(TagKind::ListItemFor(frame)) => out.push(MdBlock::ListItem {
-            ordered: frame.ordered,
-            index: frame.next_index,
-            depth: frame.depth,
-            spans,
-        }),
-        Some(TagKind::Paragraph) | None => {
-            if !spans.is_empty() {
-                out.push(MdBlock::Paragraph(spans));
-            }
-        }
-    }
-}

crates/reasonix-render/src/whole_screen/md_render.rs

@@ -1,492 +0,0 @@
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::style::{Color, Modifier};
-use unicode_width::UnicodeWidthChar;
-
-use super::cards::{body_indent_col, paint_rail};
-use super::markdown::{parse, CellAlign, InlineSpan, InlineStyle, MdBlock};
-use super::paint::paint_str;
-use super::theme::{BG, DS_BRIGHT, FG2, FG3, INFO, OK, WARN};
-
-pub fn count_visual_rows(text: &str, width: u16) -> usize {
-    let blocks = parse(text);
-    let mut total = 0usize;
-    for block in &blocks {
-        total += block_rows(block, width);
-    }
-    total
-}
-
-pub fn render_markdown(
-    buf: &mut Buffer,
-    area: Rect,
-    start_row: u16,
-    bottom: u16,
-    rail_color: Color,
-    default_fg: Color,
-    text: &str,
-) -> u16 {
-    let blocks = parse(text);
-    let mut row = start_row;
-    let width = area.width.saturating_sub(4);
-    for block in blocks {
-        if row >= bottom {
-            return row;
-        }
-        row = render_block(
-            buf, area, row, bottom, rail_color, default_fg, &block, width,
-        );
-    }
-    row
-}
-
-#[allow(clippy::too_many_arguments)]
-fn render_block(
-    buf: &mut Buffer,
-    area: Rect,
-    mut row: u16,
-    bottom: u16,
-    rail_color: Color,
-    default_fg: Color,
-    block: &MdBlock,
-    width: u16,
-) -> u16 {
-    match block {
-        MdBlock::Paragraph(spans) => {
-            let lines = wrap_spans(spans, width);
-            for line in lines {
-                if row >= bottom {
-                    return row;
-                }
-                paint_rail(buf, area, row, rail_color);
-                paint_styled(buf, body_indent_col(area), row, &line, default_fg);
-                row += 1;
-            }
-        }
-        MdBlock::Heading { level, spans } => {
-            if row >= bottom {
-                return row;
-            }
-            paint_rail(buf, area, row, rail_color);
-            let prefix = match level {
-                1 => "▎ ",
-                2 => "▍ ",
-                _ => "▏ ",
-            };
-            let mut col = body_indent_col(area);
-            col = paint_str(buf, col, row, prefix, DS_BRIGHT, BG, Modifier::BOLD);
-            let bold_spans: Vec<InlineSpan> = spans
-                .iter()
-                .map(|s| {
-                    let mut style = s.style.clone();
-                    style.bold = true;
-                    InlineSpan {
-                        text: s.text.clone(),
-                        style,
-                    }
-                })
-                .collect();
-            paint_styled(buf, col, row, &bold_spans, DS_BRIGHT);
-            row += 1;
-        }
-        MdBlock::Code { lang: _, text } => {
-            for line in text.lines() {
-                if row >= bottom {
-                    return row;
-                }
-                paint_rail(buf, area, row, rail_color);
-                let col = body_indent_col(area);
-                paint_str(buf, col, row, "┃ ", FG3, BG, Modifier::empty());
-                paint_str(buf, col + 2, row, line, OK, BG, Modifier::empty());
-                row += 1;
-            }
-        }
-        MdBlock::ListItem {
-            ordered,
-            index,
-            depth,
-            spans,
-        } => {
-            let indent = " ".repeat(*depth as usize * 2);
-            let marker = if *ordered {
-                format!("{indent}{index}. ")
-            } else {
-                format!("{indent}• ")
-            };
-            let marker_w = marker
-                .chars()
-                .map(|c| UnicodeWidthChar::width(c).unwrap_or(0))
-                .sum::<usize>() as u16;
-            let body_w = width.saturating_sub(marker_w);
-            let lines = wrap_spans(spans, body_w);
-            for (i, line) in lines.iter().enumerate() {
-                if row >= bottom {
-                    return row;
-                }
-                paint_rail(buf, area, row, rail_color);
-                let mut col = body_indent_col(area);
-                if i == 0 {
-                    col = paint_str(buf, col, row, &marker, FG2, BG, Modifier::BOLD);
-                } else {
-                    col = paint_str(
-                        buf,
-                        col,
-                        row,
-                        &" ".repeat(marker_w as usize),
-                        default_fg,
-                        BG,
-                        Modifier::empty(),
-                    );
-                }
-                paint_styled(buf, col, row, line, default_fg);
-                row += 1;
-            }
-        }
-        MdBlock::BlockQuote(spans) => {
-            let lines = wrap_spans(spans, width.saturating_sub(2));
-            for line in lines {
-                if row >= bottom {
-                    return row;
-                }
-                paint_rail(buf, area, row, rail_color);
-                let col = body_indent_col(area);
-                paint_str(buf, col, row, "▌ ", FG3, BG, Modifier::empty());
-                paint_styled(buf, col + 2, row, &line, FG2);
-                row += 1;
-            }
-        }
-        MdBlock::Hr => {
-            if row >= bottom {
-                return row;
-            }
-            paint_rail(buf, area, row, rail_color);
-            let col = body_indent_col(area);
-            let dash: String = "─".repeat(width as usize);
-            paint_str(buf, col, row, &dash, FG3, BG, Modifier::empty());
-            row += 1;
-        }
-        MdBlock::Table { aligns, head, rows } => {
-            row = render_table(
-                buf, area, row, bottom, rail_color, default_fg, width, aligns, head, rows,
-            );
-        }
-    }
-    row
-}
-
-#[allow(clippy::too_many_arguments)]
-fn render_table(
-    buf: &mut Buffer,
-    area: Rect,
-    mut row: u16,
-    bottom: u16,
-    rail_color: Color,
-    default_fg: Color,
-    width: u16,
-    aligns: &[CellAlign],
-    head: &[Vec<InlineSpan>],
-    rows: &[Vec<Vec<InlineSpan>>],
-) -> u16 {
-    let n_cols = head
-        .len()
-        .max(rows.iter().map(|r| r.len()).max().unwrap_or(0));
-    if n_cols == 0 {
-        return row;
-    }
-    let mut col_widths = vec![0usize; n_cols];
-    for (i, cell) in head.iter().enumerate() {
-        if i < n_cols {
-            col_widths[i] = col_widths[i].max(span_text_width(cell));
-        }
-    }
-    for r in rows {
-        for (i, cell) in r.iter().enumerate() {
-            if i < n_cols {
-                col_widths[i] = col_widths[i].max(span_text_width(cell));
-            }
-        }
-    }
-    let frame_cols = n_cols * 3 + 1;
-    let total_min: usize = col_widths.iter().sum::<usize>() + frame_cols;
-    let avail = width as usize;
-    if total_min > avail {
-        let overflow = total_min - avail;
-        let mut remaining = overflow;
-        while remaining > 0 {
-            let max_idx = col_widths
-                .iter()
-                .enumerate()
-                .max_by_key(|(_, w)| **w)
-                .map(|(i, _)| i)
-                .unwrap_or(0);
-            if col_widths[max_idx] <= 3 {
-                break;
-            }
-            col_widths[max_idx] -= 1;
-            remaining -= 1;
-        }
-    }
-    let base = body_indent_col(area);
-
-    let draw_border = |buf: &mut Buffer, y: u16, l: char, m: char, r: char, h: char| {
-        paint_rail(buf, area, y, rail_color);
-        let mut c = base;
-        let lc = l.to_string();
-        c = paint_str(buf, c, y, &lc, FG3, BG, Modifier::empty());
-        for (i, cw) in col_widths.iter().enumerate() {
-            let bar: String = (0..*cw + 2).map(|_| h).collect();
-            c = paint_str(buf, c, y, &bar, FG3, BG, Modifier::empty());
-            let sep = if i + 1 == col_widths.len() {
-                r.to_string()
-            } else {
-                m.to_string()
-            };
-            c = paint_str(buf, c, y, &sep, FG3, BG, Modifier::empty());
-        }
-        let _ = c;
-    };
-
-    if row < bottom {
-        draw_border(buf, row, '╭', '┬', '╮', '─');
-        row += 1;
-    }
-    if !head.is_empty() && row < bottom {
-        paint_rail(buf, area, row, rail_color);
-        let mut c = base;
-        c = paint_str(buf, c, row, "│", FG3, BG, Modifier::empty());
-        for (i, cell) in head.iter().enumerate() {
-            if i >= n_cols {
-                break;
-            }
-            c = paint_str(buf, c, row, " ", default_fg, BG, Modifier::empty());
-            let align = aligns.get(i).copied().unwrap_or(CellAlign::Left);
-            c = paint_cell(buf, c, row, cell, col_widths[i], align, default_fg, true);
-            c = paint_str(buf, c, row, " │", FG3, BG, Modifier::empty());
-        }
-        let _ = c;
-        row += 1;
-        if row < bottom {
-            draw_border(buf, row, '├', '┼', '┤', '─');
-            row += 1;
-        }
-    }
-    for r in rows {
-        if row >= bottom {
-            break;
-        }
-        paint_rail(buf, area, row, rail_color);
-        let mut c = base;
-        c = paint_str(buf, c, row, "│", FG3, BG, Modifier::empty());
-        for (i, &col_w) in col_widths.iter().enumerate().take(n_cols) {
-            c = paint_str(buf, c, row, " ", default_fg, BG, Modifier::empty());
-            let empty: Vec<InlineSpan> = Vec::new();
-            let cell = r.get(i).unwrap_or(&empty);
-            let align = aligns.get(i).copied().unwrap_or(CellAlign::Left);
-            c = paint_cell(buf, c, row, cell, col_w, align, default_fg, false);
-            c = paint_str(buf, c, row, " │", FG3, BG, Modifier::empty());
-        }
-        let _ = c;
-        row += 1;
-    }
-    if row < bottom {
-        draw_border(buf, row, '╰', '┴', '╯', '─');
-        row += 1;
-    }
-    row
-}
-
-fn span_text_width(spans: &[InlineSpan]) -> usize {
-    spans
-        .iter()
-        .flat_map(|s| s.text.chars())
-        .map(|c| UnicodeWidthChar::width(c).unwrap_or(0))
-        .sum()
-}
-
-#[allow(clippy::too_many_arguments)]
-fn paint_cell(
-    buf: &mut Buffer,
-    x: u16,
-    row: u16,
-    cell: &[InlineSpan],
-    width: usize,
-    align: CellAlign,
-    default_fg: Color,
-    bold: bool,
-) -> u16 {
-    let cell_w = span_text_width(cell);
-    let trimmed = clip_spans(cell, width);
-    let used = span_text_width(&trimmed).min(width);
-    let pad_total = width.saturating_sub(used);
-    let (left_pad, right_pad) = match align {
-        CellAlign::Left => (0, pad_total),
-        CellAlign::Right => (pad_total, 0),
-        CellAlign::Center => (pad_total / 2, pad_total - pad_total / 2),
-    };
-    let mut col = x;
-    if left_pad > 0 {
-        col = paint_str(
-            buf,
-            col,
-            row,
-            &" ".repeat(left_pad),
-            default_fg,
-            BG,
-            Modifier::empty(),
-        );
-    }
-    for span in &trimmed {
-        let (fg, mut mods) = style_to_paint(&span.style, default_fg);
-        if bold {
-            mods |= Modifier::BOLD;
-        }
-        col = paint_str(buf, col, row, &span.text, fg, BG, mods);
-    }
-    if right_pad > 0 {
-        col = paint_str(
-            buf,
-            col,
-            row,
-            &" ".repeat(right_pad),
-            default_fg,
-            BG,
-            Modifier::empty(),
-        );
-    }
-    let _ = cell_w;
-    col
-}
-
-fn clip_spans(spans: &[InlineSpan], width: usize) -> Vec<InlineSpan> {
-    let mut out: Vec<InlineSpan> = Vec::new();
-    let mut used = 0usize;
-    for span in spans {
-        let mut buf = String::new();
-        for ch in span.text.chars() {
-            let cw = UnicodeWidthChar::width(ch).unwrap_or(0);
-            if used + cw > width {
-                if width > 0 && used < width {
-                    buf.push('…');
-                }
-                if !buf.is_empty() {
-                    out.push(InlineSpan {
-                        text: buf,
-                        style: span.style.clone(),
-                    });
-                }
-                return out;
-            }
-            buf.push(ch);
-            used += cw;
-        }
-        if !buf.is_empty() {
-            out.push(InlineSpan {
-                text: buf,
-                style: span.style.clone(),
-            });
-        }
-    }
-    out
-}
-
-fn block_rows(block: &MdBlock, width: u16) -> usize {
-    let body_w = width;
-    match block {
-        MdBlock::Paragraph(spans) => wrap_spans(spans, body_w).len().max(1),
-        MdBlock::Heading { .. } => 1,
-        MdBlock::Code { text, .. } => text.lines().count().max(1),
-        MdBlock::ListItem {
-            ordered,
-            index,
-            depth,
-            spans,
-        } => {
-            let indent = (*depth as usize * 2) as u16;
-            let marker_w = indent
-                + if *ordered {
-                    let digits = ((*index as f64).log10().floor() as u16) + 1;
-                    digits + 2
-                } else {
-                    2
-                };
-            wrap_spans(spans, body_w.saturating_sub(marker_w))
-                .len()
-                .max(1)
-        }
-        MdBlock::BlockQuote(spans) => wrap_spans(spans, body_w.saturating_sub(2)).len().max(1),
-        MdBlock::Hr => 1,
-        MdBlock::Table { head, rows, .. } => {
-            let head_rows = if head.is_empty() { 0 } else { 2 };
-            2 + head_rows + rows.len()
-        }
-    }
-}
-
-fn wrap_spans(spans: &[InlineSpan], width: u16) -> Vec<Vec<InlineSpan>> {
-    let w = width.max(1) as usize;
-    let mut out: Vec<Vec<InlineSpan>> = Vec::new();
-    let mut current: Vec<InlineSpan> = Vec::new();
-    let mut current_w = 0usize;
-    let mut buf = String::new();
-    for span in spans {
-        buf.clear();
-        for ch in span.text.chars() {
-            let cw = UnicodeWidthChar::width(ch).unwrap_or(0);
-            if current_w + cw > w && (current_w > 0 || !buf.is_empty()) {
-                if !buf.is_empty() {
-                    current.push(InlineSpan {
-                        text: std::mem::take(&mut buf),
-                        style: span.style.clone(),
-                    });
-                }
-                out.push(std::mem::take(&mut current));
-                current_w = 0;
-            }
-            buf.push(ch);
-            current_w += cw;
-        }
-        if !buf.is_empty() {
-            current.push(InlineSpan {
-                text: std::mem::take(&mut buf),
-                style: span.style.clone(),
-            });
-        }
-    }
-    if !current.is_empty() {
-        out.push(current);
-    }
-    if out.is_empty() {
-        out.push(Vec::new());
-    }
-    out
-}
-
-fn paint_styled(buf: &mut Buffer, x: u16, row: u16, spans: &[InlineSpan], default_fg: Color) {
-    let mut col = x;
-    for span in spans {
-        let (fg, modifier) = style_to_paint(&span.style, default_fg);
-        col = paint_str(buf, col, row, &span.text, fg, BG, modifier);
-    }
-}
-
-fn style_to_paint(style: &InlineStyle, default_fg: Color) -> (Color, Modifier) {
-    let mut mods = Modifier::empty();
-    let mut fg = default_fg;
-    if style.bold {
-        mods |= Modifier::BOLD;
-    }
-    if style.italic {
-        mods |= Modifier::ITALIC;
-    }
-    if style.strike {
-        mods |= Modifier::CROSSED_OUT;
-    }
-    if style.code {
-        fg = WARN;
-    }
-    if style.link {
-        mods |= Modifier::UNDERLINED;
-        fg = INFO;
-    }
-    (fg, mods)
-}

crates/reasonix-render/src/whole_screen/mod.rs

@@ -1,212 +0,0 @@
-mod approval;
-mod boot;
-mod cards;
-mod demo;
-mod dock;
-mod list_picker;
-mod markdown;
-mod md_render;
-mod mode_picker;
-mod overlay;
-mod overlay_at;
-mod paint;
-mod selection;
-mod sidebar;
-mod theme;
-
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::widgets::Widget;
-
-use crate::state::SceneState;
-
-pub use demo::demo_state;
-pub use overlay::{
-    slash_arg_completion, slash_arg_match_count, slash_completion, slash_is_exact,
-    slash_match_count,
-};
-pub use overlay_at::{at_completion, at_match_count};
-pub use paint::{paint, paint_str};
-pub use selection::{cards_layout, extract_text, CardsLayout, ScrollbarGeom, Selection};
-
-use approval::render_approval;
-use boot::render_scroll;
-use dock::render_dock;
-use list_picker::render_list_picker;
-use mode_picker::{mode_picker_options, preset_picker_options, render_picker};
-use overlay::{render_slash_arg_overlay, render_slash_overlay};
-use overlay_at::render_at_overlay;
-use paint::fill_bg;
-use selection::apply_highlight;
-use sidebar::render_sidebar;
-use theme::{BG, DOCK_HEIGHT, MAX_COMPOSER_ROWS, SIDEBAR_WIDTH};
-use theme::{DS_BRIGHT, DS_PURPLE};
-
-pub struct WholeScreen<'a> {
-    state: &'a SceneState,
-    scroll_offset: u16,
-    selection: Option<Selection>,
-    slash_idx: usize,
-    slash_arg_idx: usize,
-    at_idx: usize,
-    approval_idx: usize,
-    mode_picker_idx: Option<usize>,
-    preset_picker_idx: Option<usize>,
-    list_picker_idx: usize,
-    sidebar_visible: bool,
-    tick: u32,
-}
-
-impl<'a> WholeScreen<'a> {
-    pub fn new(state: &'a SceneState) -> Self {
-        Self {
-            state,
-            scroll_offset: 0,
-            selection: None,
-            slash_idx: 0,
-            slash_arg_idx: 0,
-            at_idx: 0,
-            approval_idx: 0,
-            mode_picker_idx: None,
-            preset_picker_idx: None,
-            list_picker_idx: 0,
-            sidebar_visible: true,
-            tick: 0,
-        }
-    }
-
-    pub fn with_sidebar_visible(mut self, visible: bool) -> Self {
-        self.sidebar_visible = visible;
-        self
-    }
-
-    pub fn with_tick(mut self, tick: u32) -> Self {
-        self.tick = tick;
-        self
-    }
-
-    pub fn with_scroll(mut self, offset: u16) -> Self {
-        self.scroll_offset = offset;
-        self
-    }
-
-    pub fn with_selection(mut self, sel: Option<Selection>) -> Self {
-        self.selection = sel;
-        self
-    }
-
-    pub fn with_slash_index(mut self, idx: usize) -> Self {
-        self.slash_idx = idx;
-        self
-    }
-
-    pub fn with_at_index(mut self, idx: usize) -> Self {
-        self.at_idx = idx;
-        self
-    }
-
-    pub fn with_slash_arg_index(mut self, idx: usize) -> Self {
-        self.slash_arg_idx = idx;
-        self
-    }
-
-    pub fn with_approval_index(mut self, idx: usize) -> Self {
-        self.approval_idx = idx;
-        self
-    }
-
-    pub fn with_mode_picker(mut self, idx: Option<usize>) -> Self {
-        self.mode_picker_idx = idx;
-        self
-    }
-
-    pub fn with_preset_picker(mut self, idx: Option<usize>) -> Self {
-        self.preset_picker_idx = idx;
-        self
-    }
-
-    pub fn with_list_picker_index(mut self, idx: usize) -> Self {
-        self.list_picker_idx = idx;
-        self
-    }
-}
-
-impl Widget for WholeScreen<'_> {
-    fn render(self, area: Rect, buf: &mut Buffer) {
-        fill_bg(buf, area, BG);
-        let (main, side) = split_main_sidebar(area, self.sidebar_visible);
-        render_main(buf, main, self.state, self.scroll_offset, self.tick);
-        if side.width > 0 {
-            render_sidebar(buf, side, self.state);
-        }
-        if let Some(sel) = self.selection {
-            let layout = cards_layout(area, self.state, self.scroll_offset, self.sidebar_visible);
-            apply_highlight(buf, &layout, sel);
-        }
-        let dock_h = dock_height_for(self.state).min(area.height);
-        let full_dock = Rect::new(area.x, area.y + area.height - dock_h, area.width, dock_h);
-        render_slash_overlay(buf, full_dock, self.state, self.slash_idx);
-        render_slash_arg_overlay(buf, full_dock, self.state, self.slash_arg_idx);
-        render_at_overlay(buf, full_dock, self.state, self.at_idx);
-        if let Some(approval) = self.state.approval.as_ref() {
-            render_approval(buf, area, approval, self.approval_idx, dock_h);
-        }
-        if let Some(idx) = self.mode_picker_idx {
-            let opts = mode_picker_options();
-            render_picker(
-                buf,
-                full_dock,
-                "AUTONOMY MODE",
-                "controls when the agent asks before acting",
-                DS_PURPLE,
-                &opts,
-                idx,
-            );
-        } else if let Some(idx) = self.preset_picker_idx {
-            let opts = preset_picker_options();
-            render_picker(
-                buf,
-                full_dock,
-                "MODEL PRESET",
-                "picks the default DeepSeek model bundle",
-                DS_BRIGHT,
-                &opts,
-                idx,
-            );
-        }
-        if let Some(picker) = self.state.list_picker.as_ref() {
-            render_list_picker(buf, area, picker, self.list_picker_idx);
-        }
-    }
-}
-
-fn split_main_sidebar(area: Rect, sidebar_visible: bool) -> (Rect, Rect) {
-    if !sidebar_visible || area.width <= SIDEBAR_WIDTH + 30 {
-        return (area, Rect::new(area.x, area.y, 0, area.height));
-    }
-    let main_w = area.width - SIDEBAR_WIDTH;
-    let main = Rect::new(area.x, area.y, main_w, area.height);
-    let side = Rect::new(area.x + main_w, area.y, SIDEBAR_WIDTH, area.height);
-    (main, side)
-}
-
-fn render_main(buf: &mut Buffer, area: Rect, state: &SceneState, scroll_offset: u16, tick: u32) {
-    let dock_h = dock_height_for(state).min(area.height);
-    let scroll_h = area.height.saturating_sub(dock_h);
-    let scroll = Rect::new(area.x, area.y, area.width, scroll_h);
-    let dock = Rect::new(area.x, area.y + scroll_h, area.width, dock_h);
-    render_scroll(buf, scroll, state, scroll_offset, tick);
-    render_dock(buf, dock, state, tick);
-}
-
-pub(super) fn dock_height_for(state: &SceneState) -> u16 {
-    let text = state.composer_text.as_deref().unwrap_or("");
-    let lines = if text.is_empty() {
-        1u16
-    } else {
-        text.split('\n')
-            .count()
-            .clamp(1, MAX_COMPOSER_ROWS as usize) as u16
-    };
-    DOCK_HEIGHT + lines.saturating_sub(1)
-}

crates/reasonix-render/src/whole_screen/mode_picker.rs

@@ -1,188 +0,0 @@
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::style::{Color, Modifier};
-use unicode_width::UnicodeWidthStr;
-
-use super::paint::{paint, paint_str};
-use super::theme::{BG, DS_BRIGHT, DS_PURPLE, ERR, FG, FG1, FG2, FG3, INFO, OK, WARN};
-
-pub struct PickerOption {
-    pub marker: &'static str,
-    pub marker_color: Color,
-    pub title: &'static str,
-    pub summary: &'static str,
-    pub hot: &'static str,
-}
-
-pub fn mode_picker_options() -> [PickerOption; 3] {
-    [
-        PickerOption {
-            marker: "○",
-            marker_color: INFO,
-            title: "review",
-            summary: "每个工具调用都要确认 · 最安全",
-            hot: "shift+tab",
-        },
-        PickerOption {
-            marker: "◆",
-            marker_color: DS_PURPLE,
-            title: "auto",
-            summary: "只在编辑 / 删除 / shell 时确认 · 默认",
-            hot: "shift+tab",
-        },
-        PickerOption {
-            marker: "⚡",
-            marker_color: ERR,
-            title: "yolo",
-            summary: "完全自主 · 任何操作都不问 · 危险",
-            hot: "shift+tab",
-        },
-    ]
-}
-
-pub fn preset_picker_options() -> [PickerOption; 3] {
-    [
-        PickerOption {
-            marker: "◇",
-            marker_color: DS_BRIGHT,
-            title: "auto",
-            summary: "flash → pro on hard turns · default",
-            hot: "click",
-        },
-        PickerOption {
-            marker: "◇",
-            marker_color: OK,
-            title: "flash",
-            summary: "v4-flash always · cheapest, predictable",
-            hot: "click",
-        },
-        PickerOption {
-            marker: "◇",
-            marker_color: DS_BRIGHT,
-            title: "pro",
-            summary: "v4-pro always · ~3× flash, hard multi-turn work",
-            hot: "click",
-        },
-    ]
-}
-
-pub fn render_picker(
-    buf: &mut Buffer,
-    dock_area: Rect,
-    title: &str,
-    subtitle: &str,
-    accent: Color,
-    options: &[PickerOption],
-    selected_idx: usize,
-) {
-    let row_h: u16 = 2;
-    let inner_rows = (options.len() as u16) * row_h;
-    let popup_h = 3 + inner_rows;
-    let popup_w = dock_area.width.saturating_sub(4).min(110);
-    if popup_w < 40 || popup_h > dock_area.y {
-        return;
-    }
-    let popup_x = dock_area.x + 2;
-    let popup_y = dock_area.y.saturating_sub(popup_h);
-    let popup = Rect::new(popup_x, popup_y, popup_w, popup_h);
-
-    draw_box(buf, popup, accent);
-    draw_title(buf, popup, title, subtitle, accent);
-
-    let body_top = popup.y + 2;
-    for (i, opt) in options.iter().enumerate() {
-        let row = body_top + (i as u16) * row_h;
-        let selected = i == selected_idx;
-        let title_color = if selected { opt.marker_color } else { FG };
-        let title_mod = if selected {
-            Modifier::BOLD
-        } else {
-            Modifier::empty()
-        };
-
-        if selected {
-            paint_str(
-                buf,
-                popup.x + 2,
-                row,
-                "▸",
-                opt.marker_color,
-                BG,
-                Modifier::BOLD,
-            );
-        }
-        paint_str(
-            buf,
-            popup.x + 4,
-            row,
-            opt.marker,
-            opt.marker_color,
-            BG,
-            Modifier::BOLD,
-        );
-        let mut col = popup.x + 6;
-        col = paint_str(buf, col, row, opt.title, title_color, BG, title_mod);
-        let _ = col;
-
-        let hot_label = opt.hot;
-        let right_w = hot_label.width() as u16;
-        let hot_col = popup.x + popup.width.saturating_sub(right_w + 2);
-        paint_str(buf, hot_col, row, hot_label, FG3, BG, Modifier::empty());
-
-        if row + 1 < popup.y + popup.height - 1 {
-            paint_str(
-                buf,
-                popup.x + 6,
-                row + 1,
-                opt.summary,
-                FG2,
-                BG,
-                Modifier::empty(),
-            );
-        }
-    }
-    let _ = (FG1, WARN);
-}
-
-fn draw_title(buf: &mut Buffer, area: Rect, title: &str, subtitle: &str, accent: Color) {
-    let row = area.y;
-    let mut col = area.x + 2;
-    col = paint_str(buf, col, row, "▢", accent, BG, Modifier::BOLD);
-    col = col.saturating_add(1);
-    col = paint_str(buf, col, row, title, accent, BG, Modifier::BOLD);
-    if !subtitle.is_empty() {
-        col = col.saturating_add(2);
-        paint_str(buf, col, row, subtitle, FG2, BG, Modifier::empty());
-    }
-    let hint = "esc close";
-    let hint_col = area.x + area.width.saturating_sub(hint.width() as u16 + 2);
-    paint_str(buf, hint_col, row, hint, FG3, BG, Modifier::empty());
-}
-
-fn draw_box(buf: &mut Buffer, area: Rect, accent: Color) {
-    let w = area.width;
-    if w < 2 {
-        return;
-    }
-    let top = area.y;
-    let bot = area.y + area.height - 1;
-    let right = area.x + w - 1;
-
-    paint(buf, area.x, top, '╭', accent, BG, Modifier::empty());
-    paint(buf, right, top, '╮', accent, BG, Modifier::empty());
-    for x in 1..w - 1 {
-        paint(buf, area.x + x, top, '─', accent, BG, Modifier::empty());
-    }
-    for y in (top + 1)..bot {
-        paint(buf, area.x, y, '│', accent, BG, Modifier::empty());
-        paint(buf, right, y, '│', accent, BG, Modifier::empty());
-        for x in 1..w - 1 {
-            paint(buf, area.x + x, y, ' ', FG, BG, Modifier::empty());
-        }
-    }
-    paint(buf, area.x, bot, '╰', accent, BG, Modifier::empty());
-    paint(buf, right, bot, '╯', accent, BG, Modifier::empty());
-    for x in 1..w - 1 {
-        paint(buf, area.x + x, bot, '─', accent, BG, Modifier::empty());
-    }
-}

crates/reasonix-render/src/whole_screen/overlay.rs

@@ -1,758 +0,0 @@
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::style::Modifier;
-use unicode_width::UnicodeWidthStr;
-
-use crate::state::{SceneState, SlashMatch};
-
-use super::paint::{paint, paint_str};
-use super::theme::{BG, DS, DS_BRIGHT, FG, FG2, FG3};
-
-const FALLBACK_COMMANDS: &[(&str, &str)] = &[
-    ("/clear", "reset conversation context"),
-    ("/compact", "summarize history to free up tokens"),
-    ("/help", "show help"),
-];
-
-const ABS_MAX_ROWS: usize = 24;
-
-pub fn slash_match_count(query: &str, state: &SceneState) -> usize {
-    if !query.starts_with('/') {
-        return 0;
-    }
-    match_iter(query, state).count()
-}
-
-/// True when `query` is `/<cmd>` for a `<cmd>` that exists in the catalog
-/// (case-insensitive). The composer uses this to decide whether Enter
-/// should auto-complete the highlighted match or submit the typed command
-/// directly. Without this, typing the full name (e.g. `/cost`) re-completes
-/// to `/cost ` and the user has to press Enter twice.
-pub fn slash_is_exact(query: &str, state: &SceneState) -> bool {
-    let Some(needle) = query.strip_prefix('/') else {
-        return false;
-    };
-    if needle.is_empty() || needle.contains(' ') {
-        return false;
-    }
-    let needle_lower = needle.to_lowercase();
-    if let Some(catalog) = state.slash_catalog.as_ref() {
-        return catalog
-            .iter()
-            .any(|m| m.cmd.eq_ignore_ascii_case(&needle_lower));
-    }
-    FALLBACK_COMMANDS.iter().any(|(name, _)| {
-        name.trim_start_matches('/')
-            .eq_ignore_ascii_case(&needle_lower)
-    })
-}
-
-pub fn slash_completion(query: &str, idx: usize, state: &SceneState) -> Option<String> {
-    if !query.starts_with('/') {
-        return None;
-    }
-    match_iter(query, state)
-        .nth(idx)
-        .map(|name| format!("/{name} "))
-}
-
-/// Number of arg-completer matches for `/<cmd> <partial>`. Returns 0 when
-/// the command has no static argCompleter, partial already exact-matches a
-/// value, or partial has progressed past the first argument (contains a
-/// space). Dynamic completers (`"models"`, `"path"`, `"mcp-resources"`,
-/// `"mcp-prompts"`, `"skills"`) are not surfaced here yet — those live on
-/// the Node side.
-pub fn slash_arg_match_count(query: &str, state: &SceneState) -> usize {
-    slash_arg_matches(query, state)
-        .map(|v| v.len())
-        .unwrap_or(0)
-}
-
-/// Build the full composer text after picking arg `idx` — replaces the
-/// trailing partial with the chosen value. Returns None when there are
-/// no matches.
-pub fn slash_arg_completion(query: &str, idx: usize, state: &SceneState) -> Option<String> {
-    let matches = slash_arg_matches(query, state)?;
-    let chosen = matches.get(idx)?;
-    let (cmd, _partial) = split_slash_arg(query)?;
-    Some(format!("/{cmd} {chosen}"))
-}
-
-fn slash_arg_matches(query: &str, state: &SceneState) -> Option<Vec<String>> {
-    let (cmd, partial) = split_slash_arg(query)?;
-    if partial.contains(' ') {
-        return None;
-    }
-    // Prefer the Node-resolved scene field: it's the only way to surface
-    // dynamic completers (models / path / mcp-resources / mcp-prompts /
-    // skills) because rust can't read MCP catalogs or the filesystem from
-    // here. Match by cmd + partial so a stale push doesn't leak in.
-    if let Some(s) = state.slash_arg_state.as_ref() {
-        if s.cmd.eq_ignore_ascii_case(cmd) && s.partial == partial && !s.matches.is_empty() {
-            return Some(s.matches.clone());
-        }
-    }
-    let catalog = state.slash_catalog.as_ref()?;
-    let m = catalog.iter().find(|m| m.cmd.eq_ignore_ascii_case(cmd))?;
-    let completer = m.arg_completer.as_ref()?;
-    let needle = partial.to_lowercase();
-    if !partial.is_empty() && completer.iter().any(|v| v.to_lowercase() == needle) {
-        return None;
-    }
-    if partial.is_empty() {
-        return Some(completer.clone());
-    }
-    Some(
-        completer
-            .iter()
-            .filter(|v| v.to_lowercase().starts_with(&needle))
-            .cloned()
-            .collect(),
-    )
-}
-
-fn split_slash_arg(query: &str) -> Option<(&str, &str)> {
-    let stripped = query.strip_prefix('/')?;
-    let space_pos = stripped.find(' ')?;
-    let cmd = &stripped[..space_pos];
-    let partial = &stripped[space_pos + 1..];
-    Some((cmd, partial))
-}
-
-fn match_iter<'a>(query: &'a str, state: &'a SceneState) -> Box<dyn Iterator<Item = &'a str> + 'a> {
-    // strip_prefix removes ONE leading '/', not all of them — so "//" has
-    // needle "/" which matches nothing (intended: user typed two slashes
-    // as literal punctuation). trim_start_matches('/') would collapse
-    // them and surface the whole catalog instead.
-    let needle = query.strip_prefix('/').unwrap_or("").to_lowercase();
-    if let Some(catalog) = state.slash_catalog.as_ref() {
-        return Box::new(
-            catalog
-                .iter()
-                .filter(move |m| matches_query(&m.cmd, &needle))
-                .map(|m| m.cmd.as_str()),
-        );
-    }
-    Box::new(
-        FALLBACK_COMMANDS
-            .iter()
-            .filter(move |(name, _)| matches_query(name.trim_start_matches('/'), &needle))
-            .map(|(name, _)| name.trim_start_matches('/')),
-    )
-}
-
-fn matches_query(cmd: &str, needle_lower: &str) -> bool {
-    if needle_lower.is_empty() {
-        return true;
-    }
-    cmd.to_lowercase().starts_with(needle_lower)
-}
-
-pub fn render_slash_arg_overlay(
-    buf: &mut Buffer,
-    dock_area: Rect,
-    state: &SceneState,
-    selected_idx: usize,
-) {
-    let Some(text) = state.composer_text.as_deref() else {
-        return;
-    };
-    let Some(matches) = slash_arg_matches(text, state) else {
-        return;
-    };
-    if matches.is_empty() {
-        return;
-    }
-    let Some((cmd, partial)) = split_slash_arg(text) else {
-        return;
-    };
-    let max_value_w = matches.iter().map(|s| s.width()).max().unwrap_or(8);
-    let header = format!("/{cmd} <arg>");
-    let header_w = header.width();
-    let popup_w = (header_w.max(max_value_w + 4) as u16 + 4).min(dock_area.width.saturating_sub(4));
-    if popup_w < 12 {
-        return;
-    }
-    let cap = (dock_area.y as usize).saturating_sub(3).clamp(1, 10);
-    let visible = matches.len().min(cap) as u16;
-    let popup_h = 3 + visible;
-    if popup_h > dock_area.y {
-        return;
-    }
-    let popup_x = dock_area.x + 2;
-    let popup_y = dock_area.y - popup_h;
-    let popup = Rect::new(popup_x, popup_y, popup_w, popup_h);
-    draw_box(buf, popup);
-    paint_str(
-        buf,
-        popup.x + 2,
-        popup.y + 1,
-        &header,
-        DS_BRIGHT,
-        BG,
-        Modifier::BOLD,
-    );
-    let count_text = if matches.len() == 1 {
-        "1 option".to_string()
-    } else {
-        format!("{} options", matches.len())
-    };
-    let ccol = popup.x + popup.width.saturating_sub(count_text.width() as u16 + 2);
-    paint_str(
-        buf,
-        ccol,
-        popup.y + 1,
-        &count_text,
-        FG3,
-        BG,
-        Modifier::empty(),
-    );
-    let selected = selected_idx.min(matches.len().saturating_sub(1));
-    let start = if selected >= visible as usize {
-        selected + 1 - visible as usize
-    } else {
-        0
-    };
-    let needle = partial.to_lowercase();
-    for (i, value) in matches
-        .iter()
-        .enumerate()
-        .skip(start)
-        .take(visible as usize)
-    {
-        let row = popup.y + 2 + (i - start) as u16;
-        let is_sel = i == selected;
-        if is_sel {
-            paint_str(buf, popup.x + 2, row, "▸", DS_BRIGHT, BG, Modifier::BOLD);
-        }
-        let fg = if is_sel { FG } else { DS_BRIGHT };
-        let modifier = if is_sel {
-            Modifier::BOLD
-        } else {
-            Modifier::empty()
-        };
-        paint_str(buf, popup.x + 4, row, value, fg, BG, modifier);
-        if !partial.is_empty() && value.to_lowercase().starts_with(&needle) {
-            let suffix: String = value.chars().skip(partial.chars().count()).collect();
-            let typed_w = partial.width() as u16;
-            paint_str(
-                buf,
-                popup.x + 4 + typed_w,
-                row,
-                &suffix,
-                FG2,
-                BG,
-                Modifier::empty(),
-            );
-        }
-    }
-}
-
-pub fn render_slash_overlay(
-    buf: &mut Buffer,
-    dock_area: Rect,
-    state: &SceneState,
-    selected_idx: usize,
-) {
-    let Some(text) = state.composer_text.as_deref() else {
-        return;
-    };
-    if !text.starts_with('/') {
-        return;
-    }
-    let all_rows: Vec<SlashRow> = collect_rows(text, state);
-    if all_rows.is_empty() {
-        render_no_match(buf, dock_area, text);
-        return;
-    }
-    let total = all_rows.len();
-    let selected = selected_idx.min(total.saturating_sub(1));
-
-    let popup_w = dock_area.width.saturating_sub(4).min(140);
-    if popup_w < 40 {
-        return;
-    }
-    let layout = compute_columns(&all_rows, popup_w);
-    let heights: Vec<usize> = all_rows
-        .iter()
-        .enumerate()
-        .map(|(i, r)| row_visual_height(r, &layout, i == selected))
-        .collect();
-    let available_rows = (dock_area.y as usize).saturating_sub(3);
-    let max_visual_rows = available_rows.clamp(1, ABS_MAX_ROWS);
-
-    let mut window_start = selected;
-    let mut window_end = selected + 1;
-    let mut used = heights[selected];
-    while used < max_visual_rows {
-        let grew = grow_window(
-            &heights,
-            &mut window_start,
-            &mut window_end,
-            &mut used,
-            max_visual_rows,
-            total,
-        );
-        if !grew {
-            break;
-        }
-    }
-
-    let visible_rows: u16 = heights[window_start..window_end]
-        .iter()
-        .sum::<usize>()
-        .min(max_visual_rows) as u16;
-    let popup_h = 3 + visible_rows;
-    if popup_h > dock_area.y {
-        return;
-    }
-    let popup_x = dock_area.x + 2;
-    let popup_y = dock_area.y.saturating_sub(popup_h);
-    let popup = Rect::new(popup_x, popup_y, popup_w, popup_h);
-
-    draw_box(buf, popup);
-    draw_header(buf, popup, total, window_start, window_end - window_start);
-    draw_rows_wrapped(
-        buf,
-        popup,
-        &all_rows[window_start..window_end],
-        text,
-        selected - window_start,
-        &layout,
-    );
-}
-
-fn grow_window(
-    heights: &[usize],
-    start: &mut usize,
-    end: &mut usize,
-    used: &mut usize,
-    cap: usize,
-    total: usize,
-) -> bool {
-    let next_below = if *end < total {
-        Some(heights[*end])
-    } else {
-        None
-    };
-    let next_above = if *start > 0 {
-        Some(heights[*start - 1])
-    } else {
-        None
-    };
-    if let Some(h) = next_below {
-        if *used + h <= cap {
-            *used += h;
-            *end += 1;
-            return true;
-        }
-    }
-    if let Some(h) = next_above {
-        if *used + h <= cap {
-            *used += h;
-            *start -= 1;
-            return true;
-        }
-    }
-    false
-}
-
-#[derive(Clone, Copy)]
-struct ColumnLayout {
-    name_col_off: u16,
-    args_col_off: u16,
-    desc_col_off: u16,
-    desc_w: u16,
-}
-
-fn compute_columns(rows: &[SlashRow], popup_w: u16) -> ColumnLayout {
-    const MAX_ARGS_HINT_W: u16 = 28;
-    const MAX_NAME_W: u16 = 22;
-    let raw_name_w =
-        (rows.iter().map(|r| r.name.width()).max().unwrap_or(8) as u16).min(MAX_NAME_W);
-    let raw_args_w = (rows
-        .iter()
-        .map(|r| r.args_hint.as_deref().map(|s| s.width()).unwrap_or(0))
-        .max()
-        .unwrap_or(0) as u16)
-        .min(MAX_ARGS_HINT_W);
-    let right_edge_off = popup_w.saturating_sub(2);
-    let name_col_off = 4;
-    let min_desc_w = 25u16;
-
-    let want_args_col_off = name_col_off + raw_name_w + 2;
-    let want_desc_col_off = if raw_args_w > 0 {
-        want_args_col_off + raw_args_w + 2
-    } else {
-        want_args_col_off
-    };
-
-    if right_edge_off >= want_desc_col_off + min_desc_w {
-        return ColumnLayout {
-            name_col_off,
-            args_col_off: want_args_col_off,
-            desc_col_off: want_desc_col_off,
-            desc_w: right_edge_off - want_desc_col_off,
-        };
-    }
-    let gap_after_name = 2u16;
-    let gap_after_args = if raw_args_w > 0 { 2 } else { 0 };
-    let used_gaps = gap_after_name + gap_after_args;
-    let cols_budget = right_edge_off
-        .saturating_sub(name_col_off)
-        .saturating_sub(min_desc_w)
-        .saturating_sub(used_gaps);
-    let total_natural = raw_name_w + raw_args_w;
-    let max_name_w = if total_natural > 0 {
-        ((u32::from(cols_budget) * u32::from(raw_name_w)) / u32::from(total_natural)) as u16
-    } else {
-        cols_budget
-    };
-    let max_args_w = cols_budget.saturating_sub(max_name_w);
-    let args_col_off = name_col_off + max_name_w + gap_after_name;
-    let desc_col_off = if max_args_w > 0 {
-        args_col_off + max_args_w + gap_after_args
-    } else {
-        args_col_off
-    };
-    let desc_w = right_edge_off.saturating_sub(desc_col_off).max(10);
-    ColumnLayout {
-        name_col_off,
-        args_col_off,
-        desc_col_off,
-        desc_w,
-    }
-}
-
-fn description_with_aliases(row: &SlashRow) -> String {
-    if row.aliases.is_empty() {
-        row.desc.clone()
-    } else {
-        format!(
-            "{}  · {}",
-            row.desc,
-            row.aliases
-                .iter()
-                .map(|a| format!("/{a}"))
-                .collect::<Vec<_>>()
-                .join(" ")
-        )
-    }
-}
-
-fn row_visual_height(row: &SlashRow, layout: &ColumnLayout, selected: bool) -> usize {
-    let header = if row.header_above { 1 } else { 0 };
-    if !selected {
-        return header + 1;
-    }
-    let desc = description_with_aliases(row);
-    header + wrap_desc(&desc, layout.desc_w as usize).len().max(1)
-}
-
-fn wrap_desc(text: &str, width: usize) -> Vec<String> {
-    let w = width.max(1);
-    if text.is_empty() {
-        return vec![String::new()];
-    }
-    let mut out: Vec<String> = Vec::new();
-    let mut current = String::new();
-    let mut current_w = 0usize;
-    for word in text.split_inclusive(' ') {
-        let word_w: usize = word
-            .chars()
-            .map(|c| unicode_width::UnicodeWidthChar::width(c).unwrap_or(0))
-            .sum();
-        if current_w + word_w > w && !current.is_empty() {
-            out.push(std::mem::take(&mut current));
-            current_w = 0;
-        }
-        if word_w > w {
-            for ch in word.chars() {
-                let cw = unicode_width::UnicodeWidthChar::width(ch).unwrap_or(0);
-                if current_w + cw > w && !current.is_empty() {
-                    out.push(std::mem::take(&mut current));
-                    current_w = 0;
-                }
-                current.push(ch);
-                current_w += cw;
-            }
-        } else {
-            current.push_str(word);
-            current_w += word_w;
-        }
-    }
-    if !current.is_empty() {
-        out.push(current);
-    }
-    if out.is_empty() {
-        out.push(String::new());
-    }
-    out
-}
-
-#[derive(Clone)]
-struct SlashRow {
-    name: String,
-    desc: String,
-    args_hint: Option<String>,
-    aliases: Vec<String>,
-    group: Option<String>,
-    /// Render a group header row just above this command. Set true for
-    /// the first row of each group when the user is browsing the bare
-    /// `/` menu (group mode); always false in search mode.
-    header_above: bool,
-}
-
-fn collect_rows(query: &str, state: &SceneState) -> Vec<SlashRow> {
-    // See match_iter for why strip_prefix instead of trim_start_matches.
-    let needle = query.strip_prefix('/').unwrap_or("").to_lowercase();
-    let group_mode = needle.is_empty();
-    let raw: Vec<SlashRow> = if let Some(catalog) = state.slash_catalog.as_ref() {
-        catalog
-            .iter()
-            .filter(|m| matches_query(&m.cmd, &needle))
-            .map(|m: &SlashMatch| SlashRow {
-                name: format!("/{}", m.cmd),
-                desc: m.summary.clone(),
-                args_hint: m.args_hint.clone(),
-                aliases: m.aliases.clone(),
-                group: m.group.clone(),
-                header_above: false,
-            })
-            .collect()
-    } else {
-        FALLBACK_COMMANDS
-            .iter()
-            .filter(|(name, _)| matches_query(name.trim_start_matches('/'), &needle))
-            .map(|(name, desc)| SlashRow {
-                name: (*name).to_string(),
-                desc: (*desc).to_string(),
-                args_hint: None,
-                aliases: Vec::new(),
-                group: None,
-                header_above: false,
-            })
-            .collect()
-    };
-    if !group_mode {
-        return raw;
-    }
-    let mut out = raw;
-    let mut prev_group: Option<&str> = None;
-    for row in out.iter_mut() {
-        let g = row.group.as_deref();
-        if g != prev_group {
-            row.header_above = true;
-            prev_group = g;
-        }
-    }
-    out
-}
-
-fn render_no_match(buf: &mut Buffer, dock_area: Rect, query: &str) {
-    let popup_w = dock_area.width.saturating_sub(4).min(80);
-    if popup_w < 30 {
-        return;
-    }
-    let popup_h: u16 = 3;
-    if popup_h > dock_area.y {
-        return;
-    }
-    let popup_x = dock_area.x + 2;
-    let popup_y = dock_area.y - popup_h;
-    let popup = Rect::new(popup_x, popup_y, popup_w, popup_h);
-    draw_box(buf, popup);
-    let msg = format!("no command matches '{query}'");
-    paint_str(buf, popup.x + 2, popup.y + 1, "▲", FG2, BG, Modifier::BOLD);
-    paint_str(
-        buf,
-        popup.x + 4,
-        popup.y + 1,
-        &msg,
-        FG2,
-        BG,
-        Modifier::empty(),
-    );
-}
-
-fn group_label(group: &str) -> &'static str {
-    match group {
-        "setup" => "SETUP",
-        "info" => "INFO",
-        "chat" => "CHAT",
-        "extend" => "EXTEND",
-        "session" => "SESSION",
-        "code" => "CODE",
-        "jobs" => "JOBS",
-        "advanced" => "ADVANCED",
-        _ => "OTHER",
-    }
-}
-
-fn draw_box(buf: &mut Buffer, area: Rect) {
-    let w = area.width;
-    if w < 2 {
-        return;
-    }
-    let top = area.y;
-    let bot = area.y + area.height - 1;
-    let right = area.x + w - 1;
-
-    paint(buf, area.x, top, '╭', DS, BG, Modifier::empty());
-    paint(buf, right, top, '╮', DS, BG, Modifier::empty());
-    for x in 1..w - 1 {
-        paint(buf, area.x + x, top, '─', DS, BG, Modifier::empty());
-    }
-
-    for y in (top + 1)..bot {
-        paint(buf, area.x, y, '│', DS, BG, Modifier::empty());
-        paint(buf, right, y, '│', DS, BG, Modifier::empty());
-        for x in 1..w - 1 {
-            paint(buf, area.x + x, y, ' ', FG, BG, Modifier::empty());
-        }
-    }
-
-    paint(buf, area.x, bot, '╰', DS, BG, Modifier::empty());
-    paint(buf, right, bot, '╯', DS, BG, Modifier::empty());
-    for x in 1..w - 1 {
-        paint(buf, area.x + x, bot, '─', DS, BG, Modifier::empty());
-    }
-}
-
-fn draw_header(buf: &mut Buffer, area: Rect, total: usize, window_start: usize, visible: usize) {
-    let row = area.y + 1;
-    let mut col = paint_str(
-        buf,
-        area.x + 2,
-        row,
-        "/ SLASH COMMANDS",
-        DS_BRIGHT,
-        BG,
-        Modifier::BOLD,
-    );
-    let position = if total <= visible {
-        format!("  {total} commands")
-    } else {
-        let end = (window_start + visible).min(total);
-        format!("  {}-{}/{}", window_start + 1, end, total)
-    };
-    col = paint_str(buf, col, row, &position, FG2, BG, Modifier::empty());
-    let _ = col;
-    let hint = "↑↓ move  ↵ select  esc dismiss";
-    let hcol = area.x + area.width.saturating_sub(hint.width() as u16 + 2);
-    paint_str(buf, hcol, row, hint, FG2, BG, Modifier::empty());
-}
-
-fn draw_rows_wrapped(
-    buf: &mut Buffer,
-    area: Rect,
-    rows_data: &[SlashRow],
-    query: &str,
-    selected_idx: usize,
-    layout: &ColumnLayout,
-) {
-    let body_top = area.y + 2;
-    let name_col = area.x + layout.name_col_off;
-    let args_col = area.x + layout.args_col_off;
-    let desc_col = area.x + layout.desc_col_off;
-    let bottom = area.y + area.height - 1;
-    let name_budget = layout.args_col_off.saturating_sub(layout.name_col_off + 1) as usize;
-    let args_budget = layout.desc_col_off.saturating_sub(layout.args_col_off + 1) as usize;
-
-    let mut row = body_top;
-    for (i, row_data) in rows_data.iter().enumerate() {
-        if row >= bottom {
-            break;
-        }
-        if row_data.header_above {
-            let label = row_data
-                .group
-                .as_deref()
-                .map(group_label)
-                .unwrap_or("OTHER");
-            paint_str(buf, area.x + 2, row, label, FG3, BG, Modifier::BOLD);
-            row += 1;
-            if row >= bottom {
-                break;
-            }
-        }
-        let selected = i == selected_idx;
-
-        let name_clipped = clip_with_ellipsis(&row_data.name, name_budget);
-        if selected {
-            paint_str(buf, area.x + 2, row, "▸", DS_BRIGHT, BG, Modifier::BOLD);
-            paint_str(buf, name_col, row, &name_clipped, FG, BG, Modifier::BOLD);
-        } else {
-            paint_str(
-                buf,
-                name_col,
-                row,
-                &name_clipped,
-                DS_BRIGHT,
-                BG,
-                Modifier::BOLD,
-            );
-        }
-
-        if name_clipped.starts_with(query) && !name_clipped.ends_with('…') {
-            let typed_w = query.width() as u16;
-            let suffix: String = name_clipped.chars().skip(query.chars().count()).collect();
-            paint_str(
-                buf,
-                name_col + typed_w,
-                row,
-                &suffix,
-                FG2,
-                BG,
-                Modifier::empty(),
-            );
-        }
-
-        if let Some(hint) = row_data.args_hint.as_deref() {
-            let args_clipped = clip_with_ellipsis(hint, args_budget);
-            paint_str(buf, args_col, row, &args_clipped, FG2, BG, Modifier::ITALIC);
-        }
-
-        let desc_fg = if selected { FG } else { FG2 };
-        let desc = description_with_aliases(row_data);
-        if selected {
-            let lines = wrap_desc(&desc, layout.desc_w as usize);
-            for (li, line) in lines.iter().enumerate() {
-                let target = row + li as u16;
-                if target >= bottom {
-                    break;
-                }
-                paint_str(buf, desc_col, target, line, desc_fg, BG, Modifier::empty());
-            }
-            row += lines.len().max(1) as u16;
-        } else {
-            let clipped = clip_with_ellipsis(&desc, layout.desc_w as usize);
-            paint_str(buf, desc_col, row, &clipped, desc_fg, BG, Modifier::empty());
-            row += 1;
-        }
-    }
-}
-
-fn clip_with_ellipsis(text: &str, width: usize) -> String {
-    let w = width.max(1);
-    let total: usize = text
-        .chars()
-        .map(|c| unicode_width::UnicodeWidthChar::width(c).unwrap_or(0))
-        .sum();
-    if total <= w {
-        return text.to_string();
-    }
-    let budget = w.saturating_sub(1);
-    let mut out = String::new();
-    let mut used = 0usize;
-    for ch in text.chars() {
-        let cw = unicode_width::UnicodeWidthChar::width(ch).unwrap_or(0);
-        if used + cw > budget {
-            break;
-        }
-        out.push(ch);
-        used += cw;
-    }
-    out.push('…');
-    out
-}

crates/reasonix-render/src/whole_screen/overlay_at.rs

@@ -1,339 +0,0 @@
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::style::Modifier;
-use unicode_width::UnicodeWidthStr;
-
-use crate::state::{AtPickerEntry, AtState, SceneState};
-
-use super::paint::{paint, paint_str};
-use super::theme::{BG, DS_PURPLE, FG, FG2, FG3, WARN};
-
-const ABS_MAX_ROWS: usize = 24;
-
-fn at_token(buffer: &str) -> Option<(usize, &str)> {
-    let at_pos = buffer.rfind('@')?;
-    let prefix = &buffer[..at_pos];
-    let suffix = &buffer[at_pos + 1..];
-    let valid_prefix = prefix.is_empty() || prefix.chars().last().is_some_and(char::is_whitespace);
-    if !valid_prefix {
-        return None;
-    }
-    if suffix.chars().any(char::is_whitespace) {
-        return None;
-    }
-    Some((at_pos, suffix))
-}
-
-fn entries_for(state: &SceneState) -> Option<&[AtPickerEntry]> {
-    match state.at_state.as_ref()? {
-        AtState::Browse { entries, .. } | AtState::Search { entries, .. } => {
-            Some(entries.as_slice())
-        }
-    }
-}
-
-pub fn at_match_count(buffer: &str, state: &SceneState) -> usize {
-    if at_token(buffer).is_none() {
-        return 0;
-    }
-    entries_for(state).map(|e| e.len()).unwrap_or(0)
-}
-
-pub fn at_completion(buffer: &str, idx: usize, state: &SceneState) -> Option<String> {
-    let (at_pos, _) = at_token(buffer)?;
-    let entries = entries_for(state)?;
-    let entry = entries.get(idx)?;
-    let prefix = &buffer[..at_pos];
-    let suffix = if entry.is_dir {
-        format!("{}/", entry.insert_path.trim_end_matches('/'))
-    } else {
-        format!("{} ", entry.insert_path)
-    };
-    Some(format!("{prefix}@{suffix}"))
-}
-
-pub fn render_at_overlay(
-    buf: &mut Buffer,
-    dock_area: Rect,
-    state: &SceneState,
-    selected_idx: usize,
-) {
-    let Some(text) = state.composer_text.as_deref() else {
-        return;
-    };
-    if at_token(text).is_none() {
-        return;
-    }
-    let Some(at_state) = state.at_state.as_ref() else {
-        return;
-    };
-    let entries = match at_state {
-        AtState::Browse { entries, .. } | AtState::Search { entries, .. } => entries.as_slice(),
-    };
-
-    let total = entries.len();
-    let available_rows = (dock_area.y as usize).saturating_sub(3);
-    let cap = available_rows.clamp(1, ABS_MAX_ROWS);
-    let popup_w = dock_area.width.saturating_sub(4).min(120);
-    if popup_w < 30 {
-        return;
-    }
-    let popup_x = dock_area.x + 2;
-    if total == 0 {
-        let popup_h = 3u16;
-        if popup_h > dock_area.y {
-            return;
-        }
-        let popup_y = dock_area.y.saturating_sub(popup_h);
-        let popup = Rect::new(popup_x, popup_y, popup_w, popup_h);
-        draw_box(buf, popup);
-        draw_header(buf, popup, at_state, 0, 0, 0);
-        let label = match at_state {
-            AtState::Browse { loading: true, .. } => "loading…",
-            AtState::Browse { .. } => "(empty directory)",
-            AtState::Search {
-                searching: true, ..
-            } => "scanning…",
-            AtState::Search { .. } => "(no matches)",
-        };
-        paint_str(
-            buf,
-            popup.x + 4,
-            popup.y + 2,
-            label,
-            FG3,
-            BG,
-            Modifier::ITALIC,
-        );
-        return;
-    }
-    let selected = selected_idx.min(total - 1);
-    let visible_n = total.min(cap).max(1);
-    let mut window_start = selected.saturating_sub(visible_n.saturating_sub(1));
-    if selected < window_start {
-        window_start = selected;
-    }
-    if window_start + visible_n > total {
-        window_start = total.saturating_sub(visible_n);
-    }
-    let visible = visible_n as u16;
-    let popup_h = 3 + visible;
-    if popup_h > dock_area.y {
-        return;
-    }
-    let popup_y = dock_area.y.saturating_sub(popup_h);
-    let popup = Rect::new(popup_x, popup_y, popup_w, popup_h);
-    let window = &entries[window_start..window_start + visible_n];
-
-    draw_box(buf, popup);
-    draw_header(buf, popup, at_state, total, window_start, visible_n);
-    draw_rows(buf, popup, window, at_state, selected - window_start);
-}
-
-fn draw_box(buf: &mut Buffer, area: Rect) {
-    let w = area.width;
-    if w < 2 {
-        return;
-    }
-    let top = area.y;
-    let bot = area.y + area.height - 1;
-    let right = area.x + w - 1;
-    paint(buf, area.x, top, '╭', DS_PURPLE, BG, Modifier::empty());
-    paint(buf, right, top, '╮', DS_PURPLE, BG, Modifier::empty());
-    for x in 1..w - 1 {
-        paint(buf, area.x + x, top, '─', DS_PURPLE, BG, Modifier::empty());
-    }
-    for y in (top + 1)..bot {
-        paint(buf, area.x, y, '│', DS_PURPLE, BG, Modifier::empty());
-        paint(buf, right, y, '│', DS_PURPLE, BG, Modifier::empty());
-        for x in 1..w - 1 {
-            paint(buf, area.x + x, y, ' ', FG, BG, Modifier::empty());
-        }
-    }
-    paint(buf, area.x, bot, '╰', DS_PURPLE, BG, Modifier::empty());
-    paint(buf, right, bot, '╯', DS_PURPLE, BG, Modifier::empty());
-    for x in 1..w - 1 {
-        paint(buf, area.x + x, bot, '─', DS_PURPLE, BG, Modifier::empty());
-    }
-}
-
-fn draw_header(
-    buf: &mut Buffer,
-    area: Rect,
-    at_state: &AtState,
-    total: usize,
-    window_start: usize,
-    visible: usize,
-) {
-    let row = area.y + 1;
-    let mut col = area.x + 2;
-    col = paint_str(buf, col, row, "@ ", DS_PURPLE, BG, Modifier::BOLD);
-    let lead = match at_state {
-        AtState::Browse { base_dir, .. } => {
-            if base_dir.is_empty() {
-                "/".to_string()
-            } else {
-                format!("{base_dir}/")
-            }
-        }
-        AtState::Search { filter, .. } => format!("search: {filter}"),
-    };
-    col = paint_str(buf, col, row, &lead, DS_PURPLE, BG, Modifier::BOLD);
-    let position = if total <= visible {
-        format!("  {total} entries")
-    } else {
-        let end = (window_start + visible).min(total);
-        format!("  {}-{}/{}", window_start + 1, end, total)
-    };
-    col = paint_str(buf, col, row, &position, FG2, BG, Modifier::empty());
-    let status = match at_state {
-        AtState::Browse { loading: true, .. } => " · loading…",
-        AtState::Search {
-            searching: true, ..
-        } => " · scanning…",
-        _ => "",
-    };
-    if !status.is_empty() {
-        col = paint_str(buf, col, row, status, FG3, BG, Modifier::empty());
-    }
-    let _ = col;
-    let hint = "↑↓ move  ↵ select  ⇥ drill  esc dismiss";
-    let hcol = area.x + area.width.saturating_sub(hint.width() as u16 + 2);
-    paint_str(buf, hcol, row, hint, FG3, BG, Modifier::empty());
-}
-
-fn draw_rows(
-    buf: &mut Buffer,
-    area: Rect,
-    entries: &[AtPickerEntry],
-    at_state: &AtState,
-    selected_idx: usize,
-) {
-    let body_top = area.y + 2;
-    let max_w = area.width.saturating_sub(6);
-    let filter = match at_state {
-        AtState::Search { filter, .. } => filter.as_str(),
-        AtState::Browse { .. } => "",
-    };
-    for (i, entry) in entries.iter().enumerate().take(ABS_MAX_ROWS) {
-        let row = body_top + i as u16;
-        let selected = i == selected_idx;
-        if selected {
-            paint_str(buf, area.x + 2, row, "▸", DS_PURPLE, BG, Modifier::BOLD);
-        }
-        let name_col = area.x + 4;
-        let label = if entry.is_dir {
-            format!("{}/", entry.label.trim_end_matches('/'))
-        } else {
-            entry.label.clone()
-        };
-        let suffix_label = entry.dir_suffix.as_str();
-        paint_entry(
-            buf,
-            name_col,
-            row,
-            &label,
-            suffix_label,
-            filter,
-            max_w,
-            selected,
-            entry.is_dir,
-        );
-    }
-}
-
-#[allow(clippy::too_many_arguments)]
-fn paint_entry(
-    buf: &mut Buffer,
-    x: u16,
-    row: u16,
-    label: &str,
-    suffix: &str,
-    filter: &str,
-    max_w: u16,
-    selected: bool,
-    is_dir: bool,
-) {
-    let base_fg = if selected { FG } else { FG2 };
-    let base_mod = if selected || is_dir {
-        Modifier::BOLD
-    } else {
-        Modifier::empty()
-    };
-    let mut budget = max_w;
-    let mut col = x;
-    if let Some((before, mid, after)) = case_insensitive_split(label, filter) {
-        col = paint_clipped(buf, col, row, before, base_fg, base_mod, &mut budget);
-        col = paint_clipped(buf, col, row, mid, WARN, Modifier::BOLD, &mut budget);
-        col = paint_clipped(buf, col, row, after, base_fg, base_mod, &mut budget);
-    } else {
-        col = paint_clipped(buf, col, row, label, base_fg, base_mod, &mut budget);
-    }
-    if !suffix.is_empty() && budget > 1 {
-        col = paint_clipped(buf, col, row, "  ", FG3, Modifier::empty(), &mut budget);
-        let _ = paint_clipped(buf, col, row, suffix, FG3, Modifier::empty(), &mut budget);
-    }
-}
-
-/// Char-boundary-safe case-insensitive substring split. Returns (before, mid, after) byte slices of `label` where `mid` is the matched range. Avoids byte indexing into `label.to_lowercase()` whose char-boundary mapping is not preserved across casefolding.
-fn case_insensitive_split<'a>(label: &'a str, filter: &str) -> Option<(&'a str, &'a str, &'a str)> {
-    if filter.is_empty() {
-        return None;
-    }
-    let needle: Vec<char> = filter.chars().flat_map(char::to_lowercase).collect();
-    if needle.is_empty() {
-        return None;
-    }
-    let chars: Vec<(usize, char)> = label.char_indices().collect();
-    let n = chars.len();
-    'outer: for start in 0..n {
-        let mut j = 0usize;
-        let mut i = start;
-        while j < needle.len() {
-            if i >= n {
-                continue 'outer;
-            }
-            let lc: Vec<char> = chars[i].1.to_lowercase().collect();
-            if lc.len() != 1 || lc[0] != needle[j] {
-                continue 'outer;
-            }
-            i += 1;
-            j += 1;
-        }
-        let start_byte = chars[start].0;
-        let end_byte = if i >= n { label.len() } else { chars[i].0 };
-        return Some((
-            &label[..start_byte],
-            &label[start_byte..end_byte],
-            &label[end_byte..],
-        ));
-    }
-    None
-}
-
-fn paint_clipped(
-    buf: &mut Buffer,
-    x: u16,
-    row: u16,
-    s: &str,
-    fg: ratatui::style::Color,
-    modifier: Modifier,
-    budget: &mut u16,
-) -> u16 {
-    if *budget == 0 {
-        return x;
-    }
-    let mut w = 0u16;
-    let mut clipped = String::new();
-    for ch in s.chars() {
-        let cw = crate::whole_screen::paint::char_width(ch);
-        if w + cw > *budget {
-            break;
-        }
-        w += cw;
-        clipped.push(ch);
-    }
-    paint_str(buf, x, row, &clipped, fg, BG, modifier);
-    *budget = budget.saturating_sub(w);
-    x + w
-}

crates/reasonix-render/src/whole_screen/paint.rs

@@ -1,203 +0,0 @@
-use chrono::{Local, TimeZone};
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::style::{Color, Modifier, Style};
-use unicode_width::UnicodeWidthChar;
-
-/// Display width of a character.  Returns 0 for control characters
-/// (where unicode-width returns None) and combining marks, so the
-/// layout engine skips them instead of giving them a spurious width-1
-/// cell that overwrites the next character.
-pub fn char_width(ch: char) -> u16 {
-    UnicodeWidthChar::width(ch).unwrap_or(0) as u16
-}
-
-pub fn paint(buf: &mut Buffer, x: u16, y: u16, ch: char, fg: Color, bg: Color, modifier: Modifier) {
-    if x >= buf.area.right() || y >= buf.area.bottom() {
-        return;
-    }
-    let w = char_width(ch);
-    if w == 0 {
-        return;
-    }
-    let mut tmp = [0u8; 4];
-    let s = ch.encode_utf8(&mut tmp);
-    let style = Style::default().fg(fg).bg(bg).add_modifier(modifier);
-    buf[(x, y)].set_symbol(s).set_style(style).set_skip(false);
-    for off in 1..w {
-        let cx = x + off;
-        if cx >= buf.area.right() {
-            break;
-        }
-        buf[(cx, y)]
-            .set_symbol("")
-            .set_style(Style::default().bg(bg))
-            .set_skip(true);
-    }
-}
-
-pub fn paint_str(
-    buf: &mut Buffer,
-    x: u16,
-    y: u16,
-    s: &str,
-    fg: Color,
-    bg: Color,
-    modifier: Modifier,
-) -> u16 {
-    paint_str_to(buf, x, y, s, buf.area.right(), fg, bg, modifier)
-}
-
-#[allow(clippy::too_many_arguments)]
-pub fn paint_str_to(
-    buf: &mut Buffer,
-    x: u16,
-    y: u16,
-    s: &str,
-    end_x: u16,
-    fg: Color,
-    bg: Color,
-    modifier: Modifier,
-) -> u16 {
-    let limit = end_x.min(buf.area.right());
-    let mut col = x;
-    for ch in s.chars() {
-        // Tab → 2 spaces (terminal convention, matches common tab-stop width).
-        if ch == '\t' {
-            for _ in 0..2 {
-                if col >= limit {
-                    break;
-                }
-                paint(buf, col, y, ' ', fg, bg, modifier);
-                col += 1;
-            }
-            continue;
-        }
-        let w = char_width(ch);
-        // Zero-width characters (control chars, combining marks, ZWJ/ZWNJ,
-        // variation selectors) are skipped — they'd otherwise land at the
-        // same column as the next character and cause overwrite artifacts.
-        if w == 0 {
-            continue;
-        }
-        if col.saturating_add(w) > limit {
-            break;
-        }
-        paint(buf, col, y, ch, fg, bg, modifier);
-        col = col.saturating_add(w);
-    }
-    col
-}
-
-/// OSC 8 hyperlink — the entire escape sequence (open + visible text +
-/// close) lives in one cell's symbol; subsequent cells covered by the
-/// visible width are flagged `skip` so the diff layer doesn't repaint
-/// them. Terminals that understand OSC 8 (Windows Terminal, iTerm2,
-/// WezTerm, gnome-terminal ≥3.26, kitty, etc.) render this as a
-/// clickable link; older terminals print the escapes as no-ops and
-/// fall back to plain underlined text.
-pub fn paint_link(
-    buf: &mut Buffer,
-    x: u16,
-    y: u16,
-    url: &str,
-    visible: &str,
-    fg: Color,
-    bg: Color,
-) -> u16 {
-    use ratatui::style::Style;
-    use unicode_width::UnicodeWidthStr;
-    if x >= buf.area.right() || y >= buf.area.bottom() {
-        return x;
-    }
-    let width = UnicodeWidthStr::width(visible) as u16;
-    if width == 0 {
-        return x;
-    }
-    let symbol = format!("\x1b]8;;{url}\x1b\\{visible}\x1b]8;;\x1b\\");
-    let style = Style::default()
-        .fg(fg)
-        .bg(bg)
-        .add_modifier(Modifier::UNDERLINED);
-    buf[(x, y)]
-        .set_symbol(&symbol)
-        .set_style(style)
-        .set_skip(false);
-    for off in 1..width {
-        let cx = x + off;
-        if cx >= buf.area.right() {
-            break;
-        }
-        buf[(cx, y)]
-            .set_symbol("")
-            .set_style(Style::default().bg(bg))
-            .set_skip(true);
-    }
-    x + width
-}
-
-/// Multi-row variant of `paint_link`. Splits `visible` into chunks that fit
-/// `[x, end_x)` and stacks them on consecutive rows, each chunk a clickable
-/// link to the full `url`. Returns rows consumed (0 if nothing fit).
-#[allow(clippy::too_many_arguments)]
-pub fn paint_link_wrapped(
-    buf: &mut Buffer,
-    x: u16,
-    y: u16,
-    end_x: u16,
-    bottom: u16,
-    url: &str,
-    visible: &str,
-    fg: Color,
-    bg: Color,
-) -> u16 {
-    use unicode_width::UnicodeWidthChar;
-    let limit = end_x.min(buf.area.right());
-    let bottom = bottom.min(buf.area.bottom());
-    if x >= limit || y >= bottom {
-        return 0;
-    }
-    let max_w = (limit - x) as usize;
-    if max_w == 0 {
-        return 0;
-    }
-    let mut row = y;
-    let mut chunk = String::new();
-    let mut chunk_w = 0usize;
-    for ch in visible.chars() {
-        let cw = UnicodeWidthChar::width(ch).unwrap_or(1);
-        if chunk_w + cw > max_w && !chunk.is_empty() {
-            paint_link(buf, x, row, url, &chunk, fg, bg);
-            row += 1;
-            if row >= bottom {
-                return row - y;
-            }
-            chunk.clear();
-            chunk_w = 0;
-        }
-        chunk.push(ch);
-        chunk_w += cw;
-    }
-    if !chunk.is_empty() {
-        paint_link(buf, x, row, url, &chunk, fg, bg);
-        row += 1;
-    }
-    row - y
-}
-
-pub fn fill_bg(buf: &mut Buffer, area: Rect, bg: Color) {
-    let style = Style::default().bg(bg);
-    for y in area.y..area.y.saturating_add(area.height) {
-        for x in area.x..area.x.saturating_add(area.width) {
-            buf[(x, y)].set_style(style);
-        }
-    }
-}
-
-pub fn format_ts(ts: i64) -> String {
-    Local
-        .timestamp_opt(ts, 0)
-        .single()
-        .map(|dt| dt.format("%H:%M:%S").to_string())
-        .unwrap_or_default()
-}

crates/reasonix-render/src/whole_screen/selection.rs

@@ -1,260 +0,0 @@
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::style::Modifier;
-use unicode_width::UnicodeWidthStr;
-
-use crate::state::SceneState;
-
-use super::cards::{body_width_for, render_card_to, total_cards_height};
-use super::dock_height_for;
-use super::theme::SIDEBAR_WIDTH;
-
-const BOOT_HEIGHT: u16 = 15;
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct Selection {
-    pub anchor: (u16, u16),
-    pub head: (u16, u16),
-}
-
-impl Selection {
-    pub fn new(col: u16, virt_y: u16) -> Self {
-        Self {
-            anchor: (col, virt_y),
-            head: (col, virt_y),
-        }
-    }
-
-    pub fn extend(&mut self, col: u16, virt_y: u16) {
-        self.head = (col, virt_y);
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.anchor == self.head
-    }
-
-    pub fn normalized(&self) -> ((u16, u16), (u16, u16)) {
-        let (ac, ay) = self.anchor;
-        let (hc, hy) = self.head;
-        if (ay, ac) <= (hy, hc) {
-            (self.anchor, self.head)
-        } else {
-            (self.head, self.anchor)
-        }
-    }
-
-    pub fn contains_virt(&self, col: u16, virt_y: u16) -> bool {
-        let ((sc, sy), (ec, ey)) = self.normalized();
-        if virt_y < sy || virt_y > ey {
-            return false;
-        }
-        if sy == ey {
-            col >= sc && col <= ec
-        } else if virt_y == sy {
-            col >= sc
-        } else if virt_y == ey {
-            col <= ec
-        } else {
-            true
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug)]
-pub struct CardsLayout {
-    pub screen_rect: Rect,
-    pub view_top: u16,
-    pub view_h: u16,
-    pub total: u16,
-}
-
-#[derive(Clone, Copy, Debug)]
-pub struct ScrollbarGeom {
-    pub track_x: u16,
-    pub track_top: u16,
-    pub track_space: u16,
-    pub thumb_top: u16,
-    pub thumb_size: u16,
-    pub max_offset: u16,
-}
-
-impl CardsLayout {
-    pub fn contains_screen(&self, x: u16, y: u16) -> bool {
-        x >= self.screen_rect.x
-            && x < self.screen_rect.right()
-            && y >= self.screen_rect.y
-            && y < self.screen_rect.bottom()
-    }
-
-    pub fn project_clamped(&self, x: u16, y: u16) -> (u16, u16) {
-        let min_x = self.screen_rect.x;
-        let max_x = self.screen_rect.right().saturating_sub(2).max(min_x);
-        let min_y = self.screen_rect.y;
-        let max_y = self.screen_rect.bottom().saturating_sub(1).max(min_y);
-        let col = x.clamp(min_x, max_x);
-        let row = y.clamp(min_y, max_y);
-        let virt_y = self.view_top.saturating_add(row - min_y);
-        (col, virt_y)
-    }
-
-    pub fn scrollbar(&self, scroll_offset: u16) -> Option<ScrollbarGeom> {
-        if self.screen_rect.width == 0 || self.view_h == 0 || self.total <= self.view_h {
-            return None;
-        }
-        let track_x = self.screen_rect.right().saturating_sub(1);
-        let track_top = self.screen_rect.bottom().saturating_sub(self.view_h);
-        let max_offset = self.total - self.view_h;
-        let thumb_size_raw =
-            ((f32::from(self.view_h) / f32::from(self.total)) * f32::from(self.view_h)).round();
-        let thumb_size = (thumb_size_raw as u16).clamp(1, self.view_h);
-        let track_space = self.view_h - thumb_size;
-        let offset = scroll_offset.min(max_offset);
-        let thumb_top_rel = if max_offset == 0 {
-            track_space
-        } else {
-            let ratio = 1.0 - (f32::from(offset) / f32::from(max_offset));
-            (ratio * f32::from(track_space)).round() as u16
-        };
-        let thumb_top = track_top + thumb_top_rel.min(track_space);
-        Some(ScrollbarGeom {
-            track_x,
-            track_top,
-            track_space,
-            thumb_top,
-            thumb_size,
-            max_offset,
-        })
-    }
-}
-
-impl ScrollbarGeom {
-    pub fn contains(&self, x: u16, y: u16) -> bool {
-        x == self.track_x
-            && y >= self.track_top
-            && y < self.track_top + (self.track_space + self.thumb_size)
-    }
-
-    pub fn thumb_contains(&self, y: u16) -> bool {
-        y >= self.thumb_top && y < self.thumb_top + self.thumb_size
-    }
-
-    pub fn offset_for_thumb_top_rel(&self, thumb_top_rel: u16) -> u16 {
-        if self.track_space == 0 {
-            return self.max_offset;
-        }
-        let clamped = thumb_top_rel.min(self.track_space);
-        let ratio = 1.0 - (f32::from(clamped) / f32::from(self.track_space));
-        (ratio * f32::from(self.max_offset)).round() as u16
-    }
-}
-
-pub fn cards_layout(
-    terminal: Rect,
-    state: &SceneState,
-    scroll_offset: u16,
-    sidebar_visible: bool,
-) -> CardsLayout {
-    let main_w = if sidebar_visible && terminal.width > SIDEBAR_WIDTH + 30 {
-        terminal.width - SIDEBAR_WIDTH
-    } else {
-        terminal.width
-    };
-    let dock_h = dock_height_for(state).min(terminal.height);
-    let scroll_h = terminal.height.saturating_sub(dock_h);
-    let boot = BOOT_HEIGHT.min(scroll_h);
-    let cards_y = terminal.y + boot;
-    let cards_h = scroll_h.saturating_sub(boot);
-    let screen_rect = Rect::new(terminal.x, cards_y, main_w, cards_h);
-
-    let body_w = body_width_for(Rect::new(0, 0, main_w.saturating_sub(1), 1));
-    let total = total_cards_height(state, body_w);
-    let avail = cards_h;
-    let max_offset = total.saturating_sub(avail);
-    let offset = scroll_offset.min(max_offset);
-    let view_h = avail.min(total);
-    let view_top = total.saturating_sub(view_h).saturating_sub(offset);
-
-    CardsLayout {
-        screen_rect,
-        view_top,
-        view_h,
-        total,
-    }
-}
-
-pub fn apply_highlight(buf: &mut Buffer, layout: &CardsLayout, sel: Selection) {
-    if sel.is_empty() || layout.view_h == 0 {
-        return;
-    }
-    let top = layout.screen_rect.y;
-    let bottom = layout.screen_rect.bottom();
-    let left = layout.screen_rect.x;
-    let right = layout.screen_rect.right().saturating_sub(1);
-    for y in top..bottom {
-        let virt_y = layout.view_top + (y - top);
-        for x in left..right {
-            if sel.contains_virt(x, virt_y) {
-                let style = buf[(x, y)].style().add_modifier(Modifier::REVERSED);
-                buf[(x, y)].set_style(style);
-            }
-        }
-    }
-}
-
-pub fn extract_text(
-    state: &SceneState,
-    scroll_offset: u16,
-    terminal: Rect,
-    sel: Selection,
-    sidebar_visible: bool,
-) -> String {
-    if sel.is_empty() {
-        return String::new();
-    }
-    let layout = cards_layout(terminal, state, scroll_offset, sidebar_visible);
-    if layout.total == 0 {
-        return String::new();
-    }
-    let scroll_w = layout.screen_rect.width.saturating_sub(1);
-    if scroll_w == 0 {
-        return String::new();
-    }
-    let virt_rect = Rect::new(0, 0, scroll_w, layout.total);
-    let mut virt = Buffer::empty(virt_rect);
-    let mut row = 0u16;
-    let last_idx = state.cards.len().saturating_sub(1);
-    for (i, card) in state.cards.iter().enumerate() {
-        let streaming = state.busy && i == last_idx;
-        row = render_card_to(&mut virt, virt_rect, row, card, streaming);
-    }
-
-    let ((sc, sy), (ec, ey)) = sel.normalized();
-    let offset_x = layout.screen_rect.x;
-    let start_x = sc.saturating_sub(offset_x);
-    let end_x = ec.saturating_sub(offset_x);
-    let mut out = String::new();
-    for y in sy..=ey {
-        if y >= layout.total {
-            break;
-        }
-        let row_start = if y == sy { start_x } else { 0 };
-        let row_end = if y == ey {
-            end_x
-        } else {
-            scroll_w.saturating_sub(1)
-        };
-        let mut x = row_start;
-        let mut line = String::new();
-        while x <= row_end && x < scroll_w {
-            let sym = virt[(x, y)].symbol();
-            line.push_str(sym);
-            let cw = UnicodeWidthStr::width(sym).max(1) as u16;
-            x = x.saturating_add(cw);
-        }
-        out.push_str(line.trim_end());
-        if y < ey {
-            out.push('\n');
-        }
-    }
-    out
-}

crates/reasonix-render/src/whole_screen/sidebar.rs

@@ -1,298 +0,0 @@
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::style::{Color, Modifier};
-use unicode_width::UnicodeWidthStr;
-
-use crate::state::{SceneCard, SceneState, ToolStatus};
-
-use super::cards::{parse_todo_items, wrap_visual, TodoState};
-use super::paint::{paint, paint_str};
-use super::theme::{BG, DS_BRIGHT, DS_PURPLE, ERR, FG, FG1, FG2, FG3, OK, WARN};
-
-pub fn render_sidebar(buf: &mut Buffer, area: Rect, state: &SceneState) {
-    for y in area.y..area.y + area.height {
-        paint(buf, area.x, y, '│', FG3, BG, Modifier::empty());
-    }
-
-    let inner_x = area.x + 2;
-    let mut row = area.y + 1;
-    let bottom = area.y + area.height;
-
-    if row < bottom {
-        paint_str(buf, inner_x, row, "⚙ ", FG, BG, Modifier::empty());
-        paint_str(
-            buf,
-            inner_x + 2,
-            row,
-            "MISSION CONTROL",
-            DS_BRIGHT,
-            BG,
-            Modifier::BOLD,
-        );
-        let toggle = "^B hide";
-        let toggle_col = area.x + area.width.saturating_sub(toggle.width() as u16 + 1);
-        paint_str(buf, toggle_col, row, toggle, FG3, BG, Modifier::empty());
-        row += 1;
-    }
-    row += 1;
-
-    let plan_body = state
-        .cards
-        .iter()
-        .rev()
-        .find(|c| c.kind == "todo" || c.kind == "plan")
-        .and_then(|c| c.body.as_deref())
-        .unwrap_or("");
-    let plan_items = parse_todo_items(plan_body);
-    if plan_items.is_empty() {
-        row = sidebar_section(
-            buf,
-            area,
-            row,
-            "◇",
-            "PLAN",
-            DS_PURPLE,
-            "waiting for a task — type below",
-        );
-    } else {
-        row = sidebar_plan(buf, area, row, &plan_items);
-    }
-
-    let recent_tools: Vec<&SceneCard> = state
-        .cards
-        .iter()
-        .rev()
-        .filter(|c| c.kind == "tool")
-        .take(4)
-        .collect();
-    if recent_tools.is_empty() {
-        row = sidebar_section(buf, area, row, "⚡", "JOBS", WARN, "no jobs run yet");
-    } else {
-        row = sidebar_jobs(buf, area, row, &recent_tools);
-    }
-    row = sidebar_section(buf, area, row, "▣", "CHANGES", DS_BRIGHT, "no edits yet");
-
-    if row < bottom {
-        paint_str(buf, inner_x, row, "▥ ", OK, BG, Modifier::BOLD);
-        paint_str(buf, inner_x + 2, row, "SESSION", OK, BG, Modifier::BOLD);
-        row += 1;
-        let model_label = state.model.as_deref().unwrap_or("—");
-        row = sidebar_kv(buf, area, row, "model", model_label, DS_BRIGHT);
-        row = sidebar_kv(buf, area, row, "context", &format_ctx(state), FG);
-        if let Some(n) = state.session_input_tokens {
-            row = sidebar_kv(buf, area, row, "↑ input", &short_num(n), FG);
-        }
-        if let Some(n) = state.session_output_tokens {
-            row = sidebar_kv(buf, area, row, "↓ output", &short_num(n), FG);
-        }
-        row = sidebar_kv(buf, area, row, "cache", &format_cache(state), FG);
-        let currency = state.wallet_currency.as_deref();
-        row = sidebar_kv(
-            buf,
-            area,
-            row,
-            "cost",
-            &format_session_cost(state, currency),
-            FG,
-        );
-        if let (Some(balance), Some(cur)) = (state.wallet_balance, currency) {
-            row = sidebar_kv(
-                buf,
-                area,
-                row,
-                "balance",
-                &format!("{:.2} {}", balance, cur),
-                FG,
-            );
-        }
-        let _ = sidebar_kv(
-            buf,
-            area,
-            row,
-            "last turn",
-            &format_last_turn(state, currency),
-            FG,
-        );
-    }
-}
-
-fn format_ctx(state: &SceneState) -> String {
-    match (state.ctx_tokens, state.ctx_cap) {
-        (Some(t), Some(c)) if c > 0 => format!("{} / {}", short_num(t), short_num(c)),
-        _ => "—".to_string(),
-    }
-}
-
-fn format_cache(state: &SceneState) -> String {
-    state
-        .cache_hit_ratio
-        .map(|r| format!("{}%", (r * 100.0).round() as i32))
-        .unwrap_or_else(|| "—".to_string())
-}
-
-fn format_session_cost(state: &SceneState, currency: Option<&str>) -> String {
-    let Some(v) = state.session_cost_usd else {
-        return "—".to_string();
-    };
-    match currency {
-        Some("CNY") | Some("RMB") => format!("¥{:.3}", v * 7.2),
-        _ => format!("${v:.3}"),
-    }
-}
-
-fn format_last_turn(state: &SceneState, currency: Option<&str>) -> String {
-    let elapsed = state.last_turn_ms.map(|ms| {
-        if ms >= 60_000 {
-            format!("{:.1}m", ms as f64 / 60_000.0)
-        } else if ms >= 1000 {
-            format!("{:.1}s", ms as f64 / 1000.0)
-        } else {
-            format!("{ms}ms")
-        }
-    });
-    let cost = state.last_turn_cost_usd.map(|v| match currency {
-        Some("CNY") | Some("RMB") => format!("¥{:.3}", v * 7.2),
-        _ => format!("${v:.3}"),
-    });
-    match (elapsed, cost) {
-        (Some(t), Some(c)) => format!("{t} · {c}"),
-        (Some(t), None) => t,
-        (None, Some(c)) => c,
-        (None, None) => "—".to_string(),
-    }
-}
-
-fn short_num(n: u32) -> String {
-    if n >= 1_000_000 {
-        format!("{:.1}M", f64::from(n) / 1_000_000.0)
-    } else if n >= 100_000 {
-        format!("{}k", n / 1000)
-    } else if n >= 1_000 {
-        format!("{:.1}k", f64::from(n) / 1000.0)
-    } else {
-        format!("{n}")
-    }
-}
-
-fn sidebar_section(
-    buf: &mut Buffer,
-    area: Rect,
-    start_row: u16,
-    glyph: &str,
-    title: &str,
-    color: Color,
-    empty_hint: &str,
-) -> u16 {
-    let bottom = area.y + area.height;
-    let inner_x = area.x + 2;
-    let mut row = start_row;
-    if row >= bottom {
-        return row;
-    }
-    paint_str(buf, inner_x, row, glyph, color, BG, Modifier::BOLD);
-    paint_str(buf, inner_x + 2, row, title, color, BG, Modifier::BOLD);
-    row += 1;
-    if row < bottom {
-        paint_str(buf, inner_x + 2, row, empty_hint, FG3, BG, Modifier::ITALIC);
-        row += 1;
-    }
-    row + 1
-}
-
-fn sidebar_plan(buf: &mut Buffer, area: Rect, start_row: u16, items: &[(TodoState, &str)]) -> u16 {
-    let bottom = area.y + area.height;
-    let inner_x = area.x + 2;
-    let mut row = start_row;
-    if row >= bottom {
-        return row;
-    }
-    let done = items
-        .iter()
-        .filter(|(s, _)| matches!(s, TodoState::Done))
-        .count();
-    paint_str(buf, inner_x, row, "◇", DS_PURPLE, BG, Modifier::BOLD);
-    paint_str(buf, inner_x + 2, row, "PLAN", DS_PURPLE, BG, Modifier::BOLD);
-    let count = format!("{}/{}", done, items.len());
-    let ccol = area.x + area.width.saturating_sub(count.width() as u16 + 1);
-    paint_str(buf, ccol, row, &count, FG3, BG, Modifier::empty());
-    row += 1;
-    let inner_w = area.width.saturating_sub(5);
-    for (state, label) in items {
-        if row >= bottom {
-            return row;
-        }
-        let (marker, marker_fg, label_fg, label_mod) = match state {
-            TodoState::Done => ("✓", OK, FG2, Modifier::empty()),
-            TodoState::Active => ("◆", DS_BRIGHT, FG, Modifier::BOLD),
-            TodoState::Pending => ("○", FG3, FG1, Modifier::empty()),
-        };
-        paint_str(buf, inner_x, row, marker, marker_fg, BG, Modifier::BOLD);
-        for (i, seg) in wrap_visual(label, inner_w).iter().enumerate() {
-            if row >= bottom {
-                return row;
-            }
-            if i > 0 {
-                paint(buf, area.x, row, '│', FG3, BG, Modifier::empty());
-            }
-            paint_str(buf, inner_x + 2, row, seg, label_fg, BG, label_mod);
-            row += 1;
-        }
-    }
-    row + 1
-}
-
-fn sidebar_jobs(buf: &mut Buffer, area: Rect, start_row: u16, tools: &[&SceneCard]) -> u16 {
-    let bottom = area.y + area.height;
-    let inner_x = area.x + 2;
-    let mut row = start_row;
-    if row >= bottom {
-        return row;
-    }
-    paint_str(buf, inner_x, row, "⚡", WARN, BG, Modifier::BOLD);
-    paint_str(buf, inner_x + 2, row, "JOBS", WARN, BG, Modifier::BOLD);
-    let count = format!("{} recent", tools.len());
-    let ccol = area.x + area.width.saturating_sub(count.width() as u16 + 1);
-    paint_str(buf, ccol, row, &count, FG3, BG, Modifier::empty());
-    row += 1;
-    let inner_w = area.width.saturating_sub(5);
-    for tool in tools {
-        if row >= bottom {
-            return row;
-        }
-        let (glyph, gfg) = match tool.status {
-            Some(ToolStatus::Ok) => ("✓", OK),
-            Some(ToolStatus::Err) => ("✕", ERR),
-            Some(ToolStatus::Running) => ("…", WARN),
-            None => ("·", FG3),
-        };
-        paint_str(buf, inner_x, row, glyph, gfg, BG, Modifier::BOLD);
-        let mut label = tool.summary.clone();
-        if let Some(args) = tool.args.as_deref() {
-            label.push(' ');
-            label.push_str(args);
-        }
-        for (i, seg) in wrap_visual(&label, inner_w).iter().enumerate() {
-            if row >= bottom {
-                return row;
-            }
-            if i > 0 {
-                paint(buf, area.x, row, '│', FG3, BG, Modifier::empty());
-            }
-            paint_str(buf, inner_x + 2, row, seg, FG, BG, Modifier::empty());
-            row += 1;
-        }
-    }
-    row + 1
-}
-
-fn sidebar_kv(buf: &mut Buffer, area: Rect, row: u16, key: &str, val: &str, val_fg: Color) -> u16 {
-    let bottom = area.y + area.height;
-    if row >= bottom {
-        return row;
-    }
-    let inner_x = area.x + 4;
-    paint_str(buf, inner_x, row, key, FG2, BG, Modifier::empty());
-    let val_col = area.x + area.width.saturating_sub(val.width() as u16 + 1);
-    paint_str(buf, val_col, row, val, val_fg, BG, Modifier::empty());
-    row + 1
-}

crates/reasonix-render/src/whole_screen/theme.rs

@@ -1,28 +0,0 @@
-use ratatui::style::Color;
-
-pub const BG: Color = Color::Rgb(0x0f, 0x10, 0x18);
-pub const FG: Color = Color::Rgb(0xe8, 0xe9, 0xf3);
-pub const FG1: Color = Color::Rgb(0xa8, 0xaa, 0xbd);
-pub const FG2: Color = Color::Rgb(0x6b, 0x6e, 0x85);
-pub const FG3: Color = Color::Rgb(0x3d, 0x40, 0x55);
-pub const DS: Color = Color::Rgb(0x6b, 0x85, 0xff);
-pub const DS_BRIGHT: Color = Color::Rgb(0x8b, 0x9f, 0xff);
-pub const DS_PURPLE: Color = Color::Rgb(0xa7, 0x8b, 0xfa);
-pub const OK: Color = Color::Rgb(0x5e, 0xea, 0xd4);
-pub const WARN: Color = Color::Rgb(0xfb, 0xbf, 0x24);
-pub const ERR: Color = Color::Rgb(0xfb, 0x71, 0x85);
-pub const INFO: Color = Color::Rgb(0x60, 0xa5, 0xfa);
-
-pub const LOGO: [&str; 6] = [
-    "██████╗ ███████╗ █████╗ ███████╗ ██████╗ ███╗   ██╗██╗██╗  ██╗",
-    "██╔══██╗██╔════╝██╔══██╗██╔════╝██╔═══██╗████╗  ██║██║╚██╗██╔╝",
-    "██████╔╝█████╗  ███████║███████╗██║   ██║██╔██╗ ██║██║ ╚███╔╝ ",
-    "██╔══██╗██╔══╝  ██╔══██║╚════██║██║   ██║██║╚██╗██║██║ ██╔██╗ ",
-    "██║  ██║███████╗██║  ██║███████║╚██████╔╝██║ ╚████║██║██╔╝ ██╗",
-    "╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝╚══════╝ ╚═════╝ ╚═╝  ╚═══╝╚═╝╚═╝  ╚═╝",
-];
-
-pub const SIDEBAR_WIDTH: u16 = 34;
-pub const DOCK_HEIGHT: u16 = 5;
-pub const MAX_COMPOSER_ROWS: u16 = 5;
-pub const COMPOSER_PLACEHOLDER: &str = "type to chat   / for commands   @ for files";

crates/reasonix-render/tests/decode_only.rs

@@ -1,45 +0,0 @@
-use reasonix_render::decode_only::run_decode_only;
-
-#[test]
-fn counts_and_emits_one_line_per_frame() {
-    let input = concat!(
-        r#"{"schemaVersion":1,"cols":80,"rows":24,"root":{"kind":"text","runs":[{"text":"a"}]}}"#,
-        "\n",
-        r#"{"schemaVersion":1,"cols":80,"rows":24,"root":{"kind":"text","runs":[{"text":"b"}]}}"#,
-        "\n",
-    );
-    let mut out = Vec::<u8>::new();
-    let count = run_decode_only(input.as_bytes(), &mut out).expect("decode");
-    assert_eq!(count, 2);
-    let s = String::from_utf8(out).expect("utf8");
-    assert!(s.contains("frame 1"), "{s}");
-    assert!(s.contains("frame 2"), "{s}");
-}
-
-#[test]
-fn skips_blank_lines_and_keeps_counting() {
-    let input = concat!(
-        "\n",
-        r#"{"schemaVersion":1,"cols":80,"rows":24,"root":{"kind":"text","runs":[{"text":"a"}]}}"#,
-        "\n",
-        "   \n",
-        r#"{"schemaVersion":1,"cols":80,"rows":24,"root":{"kind":"text","runs":[{"text":"b"}]}}"#,
-        "\n",
-    );
-    let mut out = Vec::<u8>::new();
-    let count = run_decode_only(input.as_bytes(), &mut out).expect("decode");
-    assert_eq!(count, 2);
-}
-
-#[test]
-fn surfaces_decode_errors_with_line_context() {
-    let input = concat!(
-        r#"{"schemaVersion":1,"cols":80,"rows":24,"root":{"kind":"text","runs":[{"text":"a"}]}}"#,
-        "\n",
-        r#"{not valid json"#,
-        "\n",
-    );
-    let mut out = Vec::<u8>::new();
-    let err = run_decode_only(input.as_bytes(), &mut out).unwrap_err();
-    assert!(err.to_string().contains("line 2"), "{err}");
-}

crates/reasonix-render/tests/input.rs

@@ -1,96 +0,0 @@
-use crossterm::event::{KeyCode, KeyEvent, KeyEventKind, KeyEventState, KeyModifiers};
-
-use reasonix_render::input::{is_quit, translate_key};
-
-fn press(code: KeyCode, modifiers: KeyModifiers) -> KeyEvent {
-    KeyEvent {
-        code,
-        modifiers,
-        kind: KeyEventKind::Press,
-        state: KeyEventState::NONE,
-    }
-}
-
-#[test]
-fn translates_a_plain_char() {
-    let e = press(KeyCode::Char('a'), KeyModifiers::NONE);
-    let t = translate_key(&e).expect("translate");
-    assert_eq!(t.code, "Char");
-    assert_eq!(t.char, Some('a'));
-    assert!(t.modifiers.is_empty());
-}
-
-#[test]
-fn translates_enter_with_no_char() {
-    let e = press(KeyCode::Enter, KeyModifiers::NONE);
-    let t = translate_key(&e).expect("translate");
-    assert_eq!(t.code, "Enter");
-    assert_eq!(t.char, None);
-}
-
-#[test]
-fn translates_ctrl_a_with_a_ctrl_modifier() {
-    let e = press(KeyCode::Char('a'), KeyModifiers::CONTROL);
-    let t = translate_key(&e).expect("translate");
-    assert_eq!(t.char, Some('a'));
-    assert_eq!(t.modifiers, vec!["ctrl"]);
-}
-
-#[test]
-fn collects_multiple_modifiers_in_canonical_order() {
-    let e = press(
-        KeyCode::Char('x'),
-        KeyModifiers::CONTROL | KeyModifiers::ALT | KeyModifiers::SHIFT,
-    );
-    let t = translate_key(&e).expect("translate");
-    assert_eq!(t.modifiers, vec!["ctrl", "alt", "shift"]);
-}
-
-#[test]
-fn renders_function_keys_as_f1_through_f12() {
-    let t = translate_key(&press(KeyCode::F(5), KeyModifiers::NONE)).expect("translate");
-    assert_eq!(t.code, "F5");
-}
-
-#[test]
-fn skips_release_events_so_only_presses_emit() {
-    let e = KeyEvent {
-        code: KeyCode::Char('a'),
-        modifiers: KeyModifiers::NONE,
-        kind: KeyEventKind::Release,
-        state: KeyEventState::NONE,
-    };
-    assert!(translate_key(&e).is_none());
-}
-
-#[test]
-fn serializes_a_plain_key_to_one_compact_json_line() {
-    let t = translate_key(&press(KeyCode::Enter, KeyModifiers::NONE)).expect("translate");
-    let json = serde_json::to_string(&t).expect("serialize");
-    assert_eq!(json, r#"{"event":"key","code":"Enter"}"#);
-}
-
-#[test]
-fn serializes_a_char_event_with_a_char_field() {
-    let t = translate_key(&press(KeyCode::Char('z'), KeyModifiers::NONE)).expect("translate");
-    let json = serde_json::to_string(&t).expect("serialize");
-    assert_eq!(json, r#"{"event":"key","code":"Char","char":"z"}"#);
-}
-
-#[test]
-fn serializes_modifiers_as_a_string_array() {
-    let t = translate_key(&press(KeyCode::Char('c'), KeyModifiers::CONTROL)).expect("translate");
-    let json = serde_json::to_string(&t).expect("serialize");
-    assert_eq!(
-        json,
-        r#"{"event":"key","code":"Char","char":"c","modifiers":["ctrl"]}"#
-    );
-}
-
-#[test]
-fn is_quit_matches_only_ctrl_c() {
-    assert!(is_quit(&press(KeyCode::Char('c'), KeyModifiers::CONTROL)));
-    assert!(!is_quit(&press(KeyCode::Char('c'), KeyModifiers::NONE)));
-    assert!(!is_quit(&press(KeyCode::Char('d'), KeyModifiers::CONTROL)));
-    assert!(!is_quit(&press(KeyCode::Esc, KeyModifiers::NONE)));
-}

crates/reasonix-render/tests/view.rs

@@ -1,45 +0,0 @@
-use ratatui::backend::TestBackend;
-use ratatui::Terminal;
-use reasonix_render::state::SetupState;
-use reasonix_render::view::render_setup;
-
-fn draw_setup(state: &SetupState, cols: u16, rows: u16) -> String {
-    let backend = TestBackend::new(cols, rows);
-    let mut terminal = Terminal::new(backend).unwrap();
-    terminal.draw(|f| render_setup(state, f)).unwrap();
-    let buffer = terminal.backend().buffer().clone();
-    let mut out = String::new();
-    for y in 0..buffer.area.height {
-        for x in 0..buffer.area.width {
-            out.push_str(buffer[(x, y)].symbol());
-        }
-        out.push('\n');
-    }
-    out
-}
-
-#[test]
-fn setup_renders_welcome_and_masked_dots() {
-    let state = SetupState {
-        buffer_length: 4,
-        error: None,
-    };
-    let rendered = draw_setup(&state, 80, 24);
-    assert!(rendered.contains("REASONIX"));
-    assert!(rendered.contains("welcome"));
-    assert!(rendered.contains("API key"));
-    assert!(rendered.contains("••••"));
-    assert!(rendered.contains("▮"));
-    assert!(rendered.contains("Ctrl+C"));
-}
-
-#[test]
-fn setup_with_error_renders_error_row() {
-    let state = SetupState {
-        buffer_length: 0,
-        error: Some("key malformed".to_string()),
-    };
-    let rendered = draw_setup(&state, 80, 24);
-    assert!(rendered.contains("✗"));
-    assert!(rendered.contains("key malformed"));
-}

dashboard/index.html

@@ -2,13 +2,14 @@
 <html lang="en">
   <head>
     <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover, maximum-scale=1.0, user-scalable=no" />
+    <meta name="apple-mobile-web-app-capable" content="yes" />
+    <meta name="mobile-web-app-capable" content="yes" />
     <title>Reasonix</title>
     <meta name="reasonix-token" content="__REASONIX_TOKEN__" />
     <meta name="reasonix-mode" content="__REASONIX_MODE__" />
+    <!-- Production: served by CLI server; Vite dev: transformed by vite.config.ts -->
     <link rel="stylesheet" href="/assets/app.css?token=__REASONIX_TOKEN__" />
-    <link rel="stylesheet" href="/assets/vendor-uplot.css?token=__REASONIX_TOKEN__" />
-    <link rel="stylesheet" href="/assets/vendor-hljs.css?token=__REASONIX_TOKEN__" />
   </head>
   <body>
     <div id="root">

dashboard/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "reasonix-dashboard-v2",
+  "private": true,
+  "version": "0.47.2",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@fontsource/geist": "^5.2.8",
+    "@fontsource/geist-mono": "^5.2.7",
+    "@fontsource/inter": "^5.2.8",
+    "katex": "^0.16.21",
+    "lucide-react": "^0.469.0",
+    "prism-react-renderer": "^2.4.1",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "react-markdown": "^9.0.1",
+    "react-virtuoso": "^4.12.5",
+    "rehype-katex": "^7.0.1",
+    "remark-breaks": "^4.0.0",
+    "remark-gfm": "^4.0.0",
+    "remark-math": "^6.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.0",
+    "@types/react-dom": "^19.2.0",
+    "@vitejs/plugin-react": "^4.3.4",
+    "typescript": "^5.6.3",
+    "vite": "^5.4.10"
+  }
+}

dashboard/src/CodeView.tsx

@@ -0,0 +1,163 @@
+import { Highlight, type PrismTheme } from "prism-react-renderer";
+import { useEffect, useRef, useState } from "react";
+
+const DARK_THEME: PrismTheme = {
+  plain: { color: "#dde1ea", backgroundColor: "transparent" },
+  styles: [
+    { types: ["comment", "prolog", "doctype", "cdata"], style: { color: "#6d6e80", fontStyle: "italic" } },
+    { types: ["punctuation"], style: { color: "#a8a9b8" } },
+    { types: ["property", "tag", "boolean", "number", "constant", "symbol", "deleted"], style: { color: "#fbbf24" } },
+    { types: ["selector", "attr-name", "string", "char", "builtin", "inserted"], style: { color: "#86dcb1" } },
+    { types: ["operator", "entity", "url"], style: { color: "#84b9e8" } },
+    { types: ["atrule", "attr-value", "keyword"], style: { color: "#b4a8f0" } },
+    { types: ["function", "class-name", "maybe-class-name"], style: { color: "#84b9e8", fontWeight: "500" } },
+    { types: ["regex", "important", "variable"], style: { color: "#f0c062" } },
+    { types: ["important", "bold"], style: { fontWeight: "bold" } },
+    { types: ["italic"], style: { fontStyle: "italic" } },
+  ],
+};
+
+const LIGHT_THEME: PrismTheme = {
+  plain: { color: "#24292e", backgroundColor: "transparent" },
+  styles: [
+    { types: ["comment", "prolog", "doctype", "cdata"], style: { color: "#6a737d", fontStyle: "italic" } },
+    { types: ["punctuation"], style: { color: "#24292e" } },
+    { types: ["property", "tag", "boolean", "number", "constant", "symbol", "deleted"], style: { color: "#d73a49" } },
+    { types: ["selector", "attr-name", "string", "char", "builtin", "inserted"], style: { color: "#032f62" } },
+    { types: ["operator", "entity", "url"], style: { color: "#d73a49" } },
+    { types: ["atrule", "attr-value", "keyword"], style: { color: "#d73a49" } },
+    { types: ["function", "class-name", "maybe-class-name"], style: { color: "#6f42c1", fontWeight: "500" } },
+    { types: ["regex", "important", "variable"], style: { color: "#e36209" } },
+    { types: ["important", "bold"], style: { fontWeight: "bold" } },
+    { types: ["italic"], style: { fontStyle: "italic" } },
+  ],
+};
+
+function usePrismTheme(): PrismTheme {
+  const [theme, setTheme] = useState<"dark" | "light">(() =>
+    document.documentElement.dataset.theme === "light" ? "light" : "dark",
+  );
+  const prevRef = useRef(theme);
+  useEffect(() => {
+    const el = document.documentElement;
+    const cb = () => {
+      const t = el.dataset.theme === "light" ? "light" : "dark";
+      if (t !== prevRef.current) {
+        prevRef.current = t;
+        setTheme(t);
+      }
+    };
+    const mo = new MutationObserver(cb);
+    mo.observe(el, { attributes: true, attributeFilter: ["data-theme"] });
+    return () => mo.disconnect();
+  }, []);
+  return theme === "dark" ? DARK_THEME : LIGHT_THEME;
+}
+
+export const PRISM_THEME = DARK_THEME;
+
+const EXTS: Record<string, string> = {
+  ts: "typescript", tsx: "tsx", mts: "typescript", cts: "typescript",
+  js: "javascript", jsx: "jsx", mjs: "javascript", cjs: "javascript",
+  py: "python", pyi: "python",
+  rs: "rust",
+  go: "go",
+  json: "json", jsonc: "json",
+  md: "markdown", mdx: "markdown",
+  css: "css", scss: "scss", less: "less",
+  html: "markup", htm: "markup", xml: "markup", svg: "markup",
+  yaml: "yaml", yml: "yaml",
+  toml: "toml",
+  sh: "bash", bash: "bash", zsh: "bash", fish: "bash",
+  sql: "sql",
+  rb: "ruby",
+  java: "java", kt: "kotlin",
+  swift: "swift",
+  c: "c", h: "c",
+  cpp: "cpp", cc: "cpp", cxx: "cpp", hpp: "cpp", hxx: "cpp",
+  cs: "csharp",
+  php: "php",
+  lua: "lua",
+  dart: "dart",
+  ex: "elixir", exs: "elixir",
+  erl: "erlang",
+  hs: "haskell",
+  clj: "clojure", cljs: "clojure",
+  zig: "zig",
+  vue: "markup",
+  svelte: "markup",
+  graphql: "graphql", gql: "graphql",
+  proto: "protobuf",
+  dockerfile: "docker",
+};
+
+export function langFromPath(path: string | null | undefined): string | null {
+  if (!path) return null;
+  const base = path.split(/[\\/]/).pop() ?? "";
+  if (base.toLowerCase() === "dockerfile") return "docker";
+  if (base.toLowerCase() === "makefile") return "makefile";
+  const m = /\.([a-z0-9]+)$/i.exec(base);
+  if (!m) return null;
+  return EXTS[m[1].toLowerCase()] ?? null;
+}
+
+export function CodeView({
+  text,
+  lang,
+  startLine = 1,
+  showLineNumbers = true,
+}: {
+  text: string;
+  lang: string;
+  startLine?: number;
+  showLineNumbers?: boolean;
+}) {
+  const theme = usePrismTheme();
+  return (
+    <Highlight theme={theme} code={text} language={lang}>
+      {({ className, tokens, getLineProps, getTokenProps }) => (
+        <pre className={`codeview ${className}`}>
+          {tokens.map((line, i) => (
+            <div key={i} {...getLineProps({ line })} className="codeview-line">
+              {showLineNumbers && (
+                <span className="codeview-line-num">{i + startLine}</span>
+              )}
+              <span className="codeview-line-content">
+                {line.map((token, k) => (
+                  <span key={k} {...getTokenProps({ token })} />
+                ))}
+              </span>
+            </div>
+          ))}
+        </pre>
+      )}
+    </Highlight>
+  );
+}
+
+export function CollapsibleCode({
+  text,
+  lang,
+  startLine = 1,
+  maxLines = 20,
+}: {
+  text: string;
+  lang: string;
+  startLine?: number;
+  maxLines?: number;
+}) {
+  const [open, setOpen] = useState(false);
+  const lines = text.split("\n");
+  const tooLong = lines.length > maxLines;
+  const shown = open || !tooLong ? text : lines.slice(0, maxLines).join("\n");
+  return (
+    <>
+      <CodeView text={shown} lang={lang} startLine={startLine} />
+      {tooLong && (
+        <button type="button" className="tool-more" onClick={() => setOpen((v) => !v)}>
+          {open ? "less" : `+ ${lines.length - maxLines} more lines`}
+        </button>
+      )}
+    </>
+  );
+}

dashboard/src/CommandPalette.tsx

@@ -0,0 +1,345 @@
+import {
+  ClipboardCopy,
+  Download,
+  FilePlus,
+  FocusIcon,
+  FolderOpen,
+  Info,
+  Plus,
+  Search,
+  Settings,
+  SquareX,
+  StopCircle,
+  Trash2,
+} from "lucide-react";
+import { type ReactNode, useEffect, useMemo, useRef, useState } from "react";
+import { t, useLang } from "./i18n";
+import { Shortcut, type ShortcutKey } from "./ui/shortcut";
+
+export type CommandGroup = "nav" | "action" | "workspace" | "settings";
+
+export type Command = {
+  id: string;
+  label: string;
+  hint?: string;
+  icon: ReactNode;
+  shortcut?: ShortcutKey[];
+  group: CommandGroup;
+  run: () => void;
+};
+
+export function useCommandPalette(active: boolean = true) {
+  const [open, setOpen] = useState(false);
+  useEffect(() => {
+    // Skip in background tabs — each TabRuntime calls this hook, so without the gate Cmd+K toggles every tab's palette at once.
+    if (!active) return;
+    const onKey = (e: KeyboardEvent) => {
+      const mod = e.ctrlKey || e.metaKey;
+      if (mod && (e.key === "k" || e.key === "K")) {
+        e.preventDefault();
+        setOpen((v) => !v);
+      } else if (e.key === "Escape") {
+        setOpen(false);
+      }
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [active]);
+  return { open, setOpen };
+}
+
+export type CommandHandlers = {
+  newChat: () => void;
+  clearChat: () => void;
+  focusComposer: () => void;
+  openSettings: () => void;
+  about: () => void;
+  abort: () => void;
+  copyLast: () => void;
+  conversationCopy: () => void;
+  exportMarkdown: () => void;
+  pickWorkspace: () => void;
+  newTab: () => void;
+  closeTab: () => void;
+  busy: boolean;
+  canCloseTab: boolean;
+  hasMessages: boolean;
+};
+
+export function buildCommands(handlers: CommandHandlers): Command[] {
+  const list: Command[] = [
+    {
+      id: "new-chat",
+      group: "nav",
+      label: t("palette.newChat"),
+      hint: t("palette.newChatHint"),
+      icon: <FilePlus size={13} />,
+      shortcut: ["mod", "N"],
+      run: handlers.newChat,
+    },
+    {
+      id: "new-tab",
+      group: "nav",
+      label: t("palette.newTab"),
+      hint: t("palette.newTabHint"),
+      icon: <Plus size={13} />,
+      shortcut: ["mod", "T"],
+      run: handlers.newTab,
+    },
+  ];
+  if (handlers.canCloseTab) {
+    list.push({
+      id: "close-tab",
+      group: "nav",
+      label: t("palette.closeTab"),
+      hint: t("palette.closeTabHint"),
+      icon: <SquareX size={13} />,
+      shortcut: ["mod", "W"],
+      run: handlers.closeTab,
+    });
+  }
+  list.push({
+    id: "focus-composer",
+    group: "nav",
+    label: t("palette.focusComposer"),
+    icon: <FocusIcon size={13} />,
+    shortcut: ["mod", "L"],
+    run: handlers.focusComposer,
+  });
+  if (handlers.busy) {
+    list.push({
+      id: "abort",
+      group: "action",
+      label: t("palette.abort"),
+      hint: t("palette.abortHint"),
+      icon: <StopCircle size={13} />,
+      shortcut: ["esc"],
+      run: handlers.abort,
+    });
+  }
+  if (handlers.hasMessages) {
+    list.push({
+      id: "copy-last",
+      group: "action",
+      label: t("palette.copyLast"),
+      hint: t("palette.copyLastHint"),
+      icon: <ClipboardCopy size={13} />,
+      run: handlers.copyLast,
+    });
+    list.push({
+      id: "copy-conv",
+      group: "action",
+      label: t("palette.copyConv"),
+      hint: t("palette.copyConvHint"),
+      icon: <ClipboardCopy size={13} />,
+      run: handlers.conversationCopy,
+    });
+    list.push({
+      id: "export-md",
+      group: "action",
+      label: t("palette.exportMd"),
+      hint: t("palette.exportMdHint"),
+      icon: <Download size={13} />,
+      run: handlers.exportMarkdown,
+    });
+    list.push({
+      id: "clear-chat",
+      group: "action",
+      label: t("palette.clearChat"),
+      hint: t("palette.clearChatHint"),
+      icon: <Trash2 size={13} />,
+      run: handlers.clearChat,
+    });
+  }
+  list.push({
+    id: "pick-workspace",
+    group: "workspace",
+    label: t("palette.pickWorkspace"),
+    hint: t("palette.pickWorkspaceHint"),
+    icon: <FolderOpen size={13} />,
+    run: handlers.pickWorkspace,
+  });
+  list.push({
+    id: "settings",
+    group: "settings",
+    label: t("palette.settings"),
+    hint: t("palette.settingsHint"),
+    icon: <Settings size={13} />,
+    run: handlers.openSettings,
+  });
+  list.push({
+    id: "about",
+    group: "settings",
+    label: t("palette.about"),
+    icon: <Info size={13} />,
+    run: handlers.about,
+  });
+  return list;
+}
+
+const GROUP_ORDER: CommandGroup[] = ["nav", "action", "workspace", "settings"];
+
+function groupLabel(g: CommandGroup): string {
+  switch (g) {
+    case "nav": return t("palette.groupNav");
+    case "action": return t("palette.groupAction");
+    case "workspace": return t("palette.groupWorkspace");
+    case "settings": return t("palette.groupSettings");
+  }
+}
+
+export function CommandPalette({
+  open,
+  onClose,
+  commands,
+}: {
+  open: boolean;
+  onClose: () => void;
+  commands: Command[];
+}) {
+  useLang();
+  const [query, setQuery] = useState("");
+  const [active, setActive] = useState(0);
+  const inputRef = useRef<HTMLInputElement>(null);
+  const listRef = useRef<HTMLDivElement>(null);
+
+  const filtered = useMemo(() => {
+    const q = query.trim().toLowerCase();
+    if (!q) return commands;
+    return commands.filter((c) =>
+      [c.label, c.hint].filter(Boolean).join(" ").toLowerCase().includes(q),
+    );
+  }, [query, commands]);
+
+  useEffect(() => {
+    if (open) {
+      setQuery("");
+      setActive(0);
+      requestAnimationFrame(() => inputRef.current?.focus());
+    }
+  }, [open]);
+
+  useEffect(() => {
+    setActive((a) => Math.min(a, Math.max(0, filtered.length - 1)));
+  }, [filtered.length]);
+
+  useEffect(() => {
+    const el = listRef.current?.querySelector<HTMLElement>(`[data-idx="${active}"]`);
+    el?.scrollIntoView({ block: "nearest" });
+  }, [active]);
+
+  const grouped = useMemo(() => {
+    const byGroup = new Map<CommandGroup, Command[]>();
+    for (const c of filtered) {
+      const arr = byGroup.get(c.group) ?? [];
+      arr.push(c);
+      byGroup.set(c.group, arr);
+    }
+    return GROUP_ORDER
+      .map((g) => ({ group: g, items: byGroup.get(g) ?? [] }))
+      .filter((s) => s.items.length > 0);
+  }, [filtered]);
+
+  if (!open) return null;
+
+  const run = (cmd: Command) => {
+    cmd.run();
+    onClose();
+  };
+
+  return (
+    <div className="cmdk-mask" onMouseDown={onClose}>
+      <div className="cmdk" onMouseDown={(e) => e.stopPropagation()}>
+        <div className="cmdk-head">
+          <Search size={14} />
+          <input
+            ref={inputRef}
+            placeholder={t("palette.searchPlaceholder")}
+            value={query}
+            onChange={(e) => setQuery(e.target.value)}
+            onKeyDown={(e) => {
+              if (e.key === "ArrowDown") {
+                e.preventDefault();
+                setActive((a) => Math.min(a + 1, filtered.length - 1));
+              } else if (e.key === "ArrowUp") {
+                e.preventDefault();
+                setActive((a) => Math.max(a - 1, 0));
+              } else if (e.key === "Enter") {
+                e.preventDefault();
+                const cmd = filtered[active];
+                if (cmd) run(cmd);
+              }
+            }}
+          />
+          <span className="hint">
+            <Shortcut keys={["esc"]} />
+          </span>
+        </div>
+        <div className="cmdk-body" ref={listRef}>
+          {filtered.length === 0 ? (
+            <div className="cmdk-empty">{t("palette.empty")}</div>
+          ) : null}
+          {grouped.map((section) => (
+            <div className="cmdk-group" key={section.group}>
+              <div className="cmdk-gh">{groupLabel(section.group)}</div>
+              {section.items.map((c) => {
+                const i = filtered.indexOf(c);
+                return (
+                  <div
+                    key={c.id}
+                    data-idx={i}
+                    className="cmdk-row"
+                    data-active={i === active}
+                    onMouseEnter={() => setActive(i)}
+                    onClick={() => run(c)}
+                  >
+                    <span className="ic">{c.icon}</span>
+                    <span className="l">{c.label}</span>
+                    <span className="g">{groupLabel(c.group)}</span>
+                    {c.shortcut ? (
+                      <span className="kb">
+                        <Shortcut keys={c.shortcut} />
+                      </span>
+                    ) : (
+                      <span className="kb-empty" />
+                    )}
+                  </div>
+                );
+              })}
+            </div>
+          ))}
+        </div>
+        <div className="cmdk-foot">
+          <span>
+            <Shortcut keys={["updown"]} />
+            {t("palette.footMove")}
+          </span>
+          <span>
+            <Shortcut keys={["enter"]} />
+            {t("palette.footRun")}
+          </span>
+          <span>
+            <Shortcut keys={["esc"]} />
+            {t("palette.footClose")}
+          </span>
+          <span style={{ marginLeft: "auto", color: "var(--muted)" }}>
+            {filtered.length} {t("palette.countSuffix")}
+          </span>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export function Toast({ message }: { message: { msg: string; yolo?: boolean } | null }) {
+  if (!message) return null;
+  if (message.yolo) {
+    return (
+      <div className="toast toast-yolo">
+        <span className="toast-yolo-badge">YOLO</span>
+        {message.msg}
+      </div>
+    );
+  }
+  return <div className="toast">{message.msg}</div>;
+}

dashboard/src/Markdown.tsx

@@ -0,0 +1,271 @@
+import { invoke } from "@tauri-apps/api/core";
+import { openPath, openUrl } from "@tauri-apps/plugin-opener";
+import { Check, Copy, ExternalLink, FileText } from "lucide-react";
+import {
+  Children,
+  cloneElement,
+  createContext,
+  isValidElement,
+  memo,
+  type ReactNode,
+  useContext,
+  useState,
+} from "react";
+import ReactMarkdown from "react-markdown";
+import rehypeKatex from "rehype-katex";
+import remarkBreaks from "remark-breaks";
+import remarkGfm from "remark-gfm";
+import remarkMath from "remark-math";
+import { CodeView } from "./CodeView";
+import { t, useLang } from "./i18n";
+
+async function openWithEditor(
+  editor: string | undefined,
+  abs: string,
+  line?: number,
+): Promise<void> {
+  if (editor && editor.trim()) {
+    await invoke("open_in_editor", { command: editor, path: abs, line: line ?? null });
+    return;
+  }
+  await openPath(abs);
+}
+
+type WorkspaceCtx = { dir?: string; editor?: string };
+const WorkspaceContext = createContext<WorkspaceCtx>({});
+export const WorkspaceProvider = WorkspaceContext.Provider;
+
+function resolveAgainstWorkspace(rel: string, ws: string | undefined): string {
+  if (!ws) return rel;
+  if (/^[a-zA-Z]:[\\/]/.test(rel) || rel.startsWith("/")) return rel;
+  const sep = ws.includes("\\") ? "\\" : "/";
+  const trimmed = ws.replace(/[\\/]$/, "");
+  return `${trimmed}${sep}${rel.replace(/^\.[\\/]/, "")}`;
+}
+
+const KNOWN_EXTS =
+  "ts|tsx|mts|cts|js|jsx|mjs|cjs|py|pyi|rs|go|json|jsonc|md|mdx|css|scss|less|html|htm|xml|svg|yaml|yml|toml|sh|bash|zsh|fish|sql|rb|java|kt|swift|c|cpp|cc|cxx|h|hpp|hxx|cs|php|lua|dart|ex|exs|erl|hs|clj|cljs|zig|vue|svelte|graphql|gql|proto";
+// No lookbehind here — Tauri's WKWebView on macOS Monterey (Safari < 16.4)
+// can't parse `(?<=...)` and the whole bundle fails to load with an
+// "invalid group specifier name" error. Capture the leading char as
+// group 1 instead and let splitFilePaths skip past it. Issue #1209.
+const FILE_PATH_RE = new RegExp(
+  `(^|[\\s\`'"(\\[])((?:[\\w.-]+\\/)+[\\w.-]+\\.(?:${KNOWN_EXTS}))(?::(\\d+(?:-\\d+)?))?(?=[\\s.,;!?\\]\\)'"\`]|$)`,
+  "g",
+);
+
+function FilePill({ path, line }: { path: string; line?: string }) {
+  useLang();
+  const ctx = useContext(WorkspaceContext);
+  const [done, setDone] = useState<"open" | "copy" | null>(null);
+  const display = line ? `${path}:${line}` : path;
+  const openInEditor = async () => {
+    try {
+      const abs = resolveAgainstWorkspace(path, ctx.dir);
+      const lineNum = line ? Number.parseInt(line.split("-")[0] ?? line, 10) : undefined;
+      await openWithEditor(ctx.editor, abs, Number.isFinite(lineNum) ? lineNum : undefined);
+      setDone("open");
+      setTimeout(() => setDone(null), 1200);
+    } catch {
+      try {
+        await navigator.clipboard.writeText(display);
+        setDone("copy");
+        setTimeout(() => setDone(null), 1200);
+      } catch {
+        /* ignore */
+      }
+    }
+  };
+  const copyOnly = async (e: React.MouseEvent) => {
+    e.stopPropagation();
+    try {
+      await navigator.clipboard.writeText(display);
+      setDone("copy");
+      setTimeout(() => setDone(null), 1200);
+    } catch {
+      /* ignore */
+    }
+  };
+  return (
+    <span
+      className={`file-pill ${done ? "done" : ""}`}
+      role="button"
+      tabIndex={0}
+      onClick={openInEditor}
+      onContextMenu={(e) => {
+        e.preventDefault();
+        void copyOnly(e);
+      }}
+      onKeyDown={(e) => {
+        if (e.key === "Enter" || e.key === " ") {
+          e.preventDefault();
+          void openInEditor();
+        }
+      }}
+      title={t("markdown.filePillTitle")}
+    >
+      <FileText size={10} className="file-pill-icon" />
+      <span className="file-pill-path">{path}</span>
+      {line && <span className="file-pill-line">:{line}</span>}
+      {done && <Check size={10} className="file-pill-check" />}
+    </span>
+  );
+}
+
+function splitFilePaths(text: string): ReactNode[] | string {
+  FILE_PATH_RE.lastIndex = 0;
+  const out: ReactNode[] = [];
+  let last = 0;
+  let m: RegExpExecArray | null = FILE_PATH_RE.exec(text);
+  while (m !== null) {
+    const prefix = m[1] ?? "";
+    const path = m[2]!;
+    const line = m[3];
+    const pillStart = m.index + prefix.length;
+    if (pillStart > last) out.push(text.slice(last, pillStart));
+    out.push(<FilePill key={`fp-${pillStart}`} path={path} line={line} />);
+    last = pillStart + path.length + (line ? line.length + 1 : 0);
+    m = FILE_PATH_RE.exec(text);
+  }
+  if (out.length === 0) return text;
+  if (last < text.length) out.push(text.slice(last));
+  return out;
+}
+
+type AnyProps = { children?: ReactNode } & Record<string, unknown>;
+
+function withFilePills(children: ReactNode): ReactNode {
+  return Children.map(children, (child) => {
+    if (typeof child === "string") return splitFilePaths(child);
+    if (isValidElement(child)) {
+      const props = child.props as AnyProps;
+      if (props.children !== undefined) {
+        return cloneElement(child, undefined, withFilePills(props.children));
+      }
+    }
+    return child;
+  });
+}
+
+export const Markdown = memo(function Markdown({ source }: { source: string }) {
+  return (
+    <div className="markdown">
+      <ReactMarkdown
+        remarkPlugins={[remarkGfm, remarkBreaks, remarkMath]}
+        rehypePlugins={[[rehypeKatex, { throwOnError: false }]]}
+        components={{
+          pre: ({ children }) => {
+            // react-markdown v9 nests children unpredictably — flatten all text.
+            const rawText = flattenChildText(children).trimEnd();
+            return <CodeBlock lang={extractFencedLang(children)} text={rawText} />;
+          },
+          code: ({ className, children }) => <code className={className}>{children}</code>,
+          a: ({ href, children }) => <SafeLink href={href}>{children}</SafeLink>,
+          p: ({ children }) => <p>{withFilePills(children)}</p>,
+          li: ({ children }) => <li>{withFilePills(children)}</li>,
+          td: ({ children }) => <td>{withFilePills(children)}</td>,
+        }}
+      >
+        {source}
+      </ReactMarkdown>
+    </div>
+  );
+});
+
+function SafeLink({ href, children }: { href?: string; children: ReactNode }) {
+  useLang();
+  const ctx = useContext(WorkspaceContext);
+  const [done, setDone] = useState(false);
+  const isExternal = !!href && /^https?:\/\//i.test(href);
+  const onClick = async (e: React.MouseEvent) => {
+    e.preventDefault();
+    if (!href) return;
+    if (isExternal) {
+      try {
+        await openUrl(href);
+      } catch {
+        window.open(href, "_blank", "noopener,noreferrer");
+      }
+      return;
+    }
+    try {
+      const stripped = href.replace(/^file:\/\//, "");
+      const abs = resolveAgainstWorkspace(stripped, ctx.dir);
+      await openWithEditor(ctx.editor, abs);
+    } catch {
+      try {
+        await navigator.clipboard.writeText(href);
+        setDone(true);
+        setTimeout(() => setDone(false), 1200);
+      } catch {
+        /* ignore */
+      }
+    }
+  };
+  return (
+    <a
+      href={href ?? "#"}
+      onClick={onClick}
+      className={`md-link ${isExternal ? "external" : "local"} ${done ? "done" : ""}`}
+      title={
+        isExternal
+          ? t("markdown.externalLinkTitle", { href: href ?? "" })
+          : t("markdown.localLinkTitle", { href: href ?? "" })
+      }
+    >
+      {children}
+      {isExternal ? (
+        <ExternalLink size={10} className="md-link-icon" />
+      ) : done ? (
+        <Check size={10} className="md-link-icon" />
+      ) : null}
+    </a>
+  );
+}
+
+export function extractFencedLang(children: ReactNode): string {
+  for (const kid of Children.toArray(children)) {
+    if (isValidElement(kid)) {
+      const cls = (kid.props as Record<string, unknown>).className;
+      if (typeof cls === "string") {
+        const m = cls.match(/language-([\w-]+)/);
+        if (m) return m[1]!;
+      }
+    }
+  }
+  return "text";
+}
+
+function flattenChildText(node: ReactNode): string {
+  if (typeof node === "string" || typeof node === "number") return String(node);
+  if (Array.isArray(node)) return node.map(flattenChildText).join("");
+  if (isValidElement(node))
+    return flattenChildText((node.props as { children?: ReactNode }).children);
+  return "";
+}
+
+function CodeBlock({ lang, text }: { lang: string; text: string }): ReactNode {
+  useLang();
+  const [copied, setCopied] = useState(false);
+  const onCopy = async () => {
+    try {
+      await navigator.clipboard.writeText(text);
+      setCopied(true);
+      setTimeout(() => setCopied(false), 1400);
+    } catch {
+      /* ignore */
+    }
+  };
+  return (
+    <div className="codeblock">
+      <div className="codeblock-head">
+        <span className="codeblock-lang">{lang}</span>
+        <button type="button" className={`copy-btn ${copied ? "done" : ""}`} onClick={onCopy}>
+          {copied ? <Check size={11} /> : <Copy size={11} />}
+          {copied ? t("markdown.copied") : t("markdown.copy")}
+        </button>
+      </div>
+      <CodeView text={text} lang={lang} />
+    </div>
+  );
+}

dashboard/src/components/chat-internals.ts

@@ -1,912 +0,0 @@
-import { marked } from "marked";
-import { memo } from "preact/compat";
-import { useState } from "preact/hooks";
-import { html } from "../lib/html.js";
-import { t, useLang } from "../i18n/index.js";
-import {
-  escapeHtml,
-  hlLine,
-  langFromPath,
-  renderHighlightedBlock,
-  renderMarkdownToString,
-  renderSearchReplace,
-} from "../lib/markdown.js";
-
-export type ChatRole = "user" | "assistant" | "tool" | "info" | "warning" | "error";
-
-export interface ChatMsg {
-  id: string;
-  role: ChatRole;
-  text?: string;
-  reasoning?: string;
-  toolName?: string;
-  toolArgs?: string;
-}
-
-const ROLE_GLYPH: Record<ChatRole, string> = {
-  user: "◇",
-  assistant: "◆",
-  tool: "▣",
-  info: "·",
-  warning: "▲",
-  error: "✦",
-};
-
-export type OnResolve = (kind: string, ...args: unknown[]) => void;
-
-interface ToolCardProps {
-  msg: ChatMsg;
-}
-
-interface ChatMessageProps {
-  msg: ChatMsg;
-  streaming?: boolean;
-}
-
-interface ModalCardProps {
-  accent: string;
-  icon: string;
-  title: string;
-  subtitle?: string;
-  children?: unknown;
-}
-
-interface ShellModalSpec {
-  command: string;
-  allowPrefix?: string;
-  shellKind?: string;
-}
-
-interface ChoiceOption {
-  id: string;
-  title: string;
-  summary?: string;
-}
-
-interface ChoiceModalSpec {
-  question: string;
-  options: ChoiceOption[];
-  allowCustom?: boolean;
-}
-
-interface PlanModalSpec {
-  body?: string;
-}
-
-interface EditReviewSpec {
-  search?: string;
-  replace?: string;
-  path?: string;
-  remaining: number;
-  total: number;
-}
-
-interface WorkspaceSpec {
-  path: string;
-}
-
-interface CheckpointSpec {
-  stepId: string;
-  title?: string;
-  completed?: number;
-  total?: number;
-}
-
-interface RevisionStep {
-  id: string;
-  title: string;
-  action: string;
-  risk?: "low" | "med" | "high";
-}
-
-interface RevisionSpec {
-  summary?: string;
-  reason: string;
-  remainingSteps: RevisionStep[];
-}
-
-export type PickerActionName =
-  | "pick"
-  | "delete"
-  | "rename"
-  | "new"
-  | "install"
-  | "uninstall"
-  | "load-more"
-  | "refine"
-  | "cancel";
-
-export interface PickerItemSpec {
-  id: string;
-  title: string;
-  subtitle?: string;
-  badge?: string;
-  meta?: string;
-}
-
-export interface PickerModalSpec {
-  pickerKind: string;
-  title: string;
-  query?: string;
-  items: PickerItemSpec[];
-  actions: PickerActionName[];
-  hasMore?: boolean;
-  hint?: string;
-}
-
-export interface ViewerStep {
-  id: string;
-  title: string;
-  status: "done" | "queued";
-}
-
-export interface ViewerModalSpec {
-  viewerKind: string;
-  title: string;
-  body?: string;
-  steps?: ViewerStep[];
-  meta?: string;
-}
-
-interface DiffEntry {
-  kind: "context" | "ins" | "del";
-  text: string;
-}
-
-interface DiffPair {
-  left: string | null;
-  right: string | null;
-  kind: "context" | "change" | "ins" | "del";
-}
-
-export function renderMessageBody(text: string | null | undefined) {
-  if (!text) return null;
-  return html`<div class="md" dangerouslySetInnerHTML=${{ __html: renderMarkdownToString(text) }}></div>`;
-}
-
-export function parseToolArgs(raw: string | null | undefined): Record<string, unknown> | null {
-  if (!raw) return null;
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-
-export function ToolCard({ msg }: ToolCardProps) {
-  useLang();
-  const args = parseToolArgs(msg.toolArgs);
-  const name = msg.toolName ?? "tool";
-  // Reasonix's filesystem tools emit the path in args.path; MCP-bridged
-  // ones may differ but most expose a `path` field too. Normalize.
-  const path = (args?.path ?? args?.file_path ?? args?.filename) as string | undefined;
-
-  // edit_file (Reasonix) — search/replace pair → diff view.
-  if (
-    (name === "edit_file" || name.endsWith("_edit_file")) &&
-    args &&
-    typeof args.search === "string" &&
-    typeof args.replace === "string"
-  ) {
-    const diffHtml = renderSearchReplace(
-      args.search as string,
-      args.replace as string,
-      path ?? "",
-    );
-    return html`
-      <div class="tool-card">
-        <div class="tool-card-head">
-          <span class="tool-card-icon">✎</span>
-          <span class="tool-card-name">edit_file</span>
-          ${path ? html`<code class="tool-card-path">${path}</code>` : null}
-        </div>
-        <div dangerouslySetInnerHTML=${{ __html: diffHtml }}></div>
-        ${msg.text ? html`<div class="tool-card-result">${msg.text}</div>` : null}
-      </div>
-    `;
-  }
-
-  // write_file — show new content as a code block with path-derived lang.
-  if (
-    (name === "write_file" || name.endsWith("_write_file")) &&
-    args &&
-    typeof args.content === "string"
-  ) {
-    const lang = langFromPath(path);
-    return html`
-      <div class="tool-card">
-        <div class="tool-card-head">
-          <span class="tool-card-icon">+</span>
-          <span class="tool-card-name">write_file</span>
-          ${path ? html`<code class="tool-card-path">${path}</code>` : null}
-          ${lang ? html`<span class="pill">${lang}</span>` : null}
-        </div>
-        <div dangerouslySetInnerHTML=${{ __html: renderHighlightedBlock(args.content as string, lang) }}></div>
-        ${msg.text ? html`<div class="tool-card-result">${msg.text}</div>` : null}
-      </div>
-    `;
-  }
-
-  // read_file / list_files — content lands in msg.text.
-  if (name === "read_file" || name.endsWith("_read_file") || name === "filesystem_read_file") {
-    const lang = langFromPath(path);
-    return html`
-      <div class="tool-card">
-        <div class="tool-card-head">
-          <span class="tool-card-icon">▤</span>
-          <span class="tool-card-name">read_file</span>
-          ${path ? html`<code class="tool-card-path">${path}</code>` : null}
-          ${lang ? html`<span class="pill">${lang}</span>` : null}
-        </div>
-        <div dangerouslySetInnerHTML=${{ __html: renderHighlightedBlock(msg.text ?? "", lang) }}></div>
-      </div>
-    `;
-  }
-
-  // run_command / run_background — terminal-style.
-  if (name === "run_command" || name === "run_background") {
-    const cmd = args?.command;
-    return html`
-      <div class="tool-card">
-        <div class="tool-card-head">
-          <span class="tool-card-icon">⚡</span>
-          <span class="tool-card-name">${name === "run_background" ? "run_background" : "run_command"}</span>
-        </div>
-        ${
-          cmd
-            ? html`<pre class="tool-card-cmd"><span class="tool-card-prompt">$</span> <code>${cmd}</code></pre>`
-            : null
-        }
-        ${msg.text ? html`<pre class="tool-card-output">${msg.text}</pre>` : null}
-      </div>
-    `;
-  }
-
-  // list_files / file_exists / delete_file — show args + result inline.
-  if (
-    name === "list_files" ||
-    name === "file_exists" ||
-    name === "delete_file" ||
-    name === "create_directory" ||
-    name === "delete_directory" ||
-    name.endsWith("_list_files")
-  ) {
-    return html`
-      <div class="tool-card">
-        <div class="tool-card-head">
-          <span class="tool-card-icon">▣</span>
-          <span class="tool-card-name">${name}</span>
-          ${path ? html`<code class="tool-card-path">${path}</code>` : null}
-        </div>
-        <pre class="tool-card-output">${msg.text}</pre>
-      </div>
-    `;
-  }
-
-  // Default — keep the legacy compact box but add an args preview when
-  // present so MCP-bridged tools still surface something readable.
-  return html`
-    <div class="tool-card">
-      <div class="tool-card-head">
-        <span class="tool-card-icon">▣</span>
-        <span class="tool-card-name">${name}</span>
-      </div>
-      ${
-        args
-          ? html`<details class="tool-card-args"><summary>${t("modal.arguments")}</summary><pre>${escapeHtml(JSON.stringify(args, null, 2))}</pre></details>`
-          : null
-      }
-      <pre class="tool-card-output">${msg.text}</pre>
-    </div>
-  `;
-}
-
-// memo() short-circuits re-renders when shallow props are unchanged.
-// Historical messages keep stable msg references across deltas, so the
-// O(N) marked.parse + hljs work that used to fire per assistant_delta
-// now only runs on truly new messages and the live streaming bubble.
-export const ChatMessage = memo(function ChatMessage({ msg, streaming }: ChatMessageProps) {
-  const role = msg.role;
-  const glyph = ROLE_GLYPH[role as ChatRole] ?? "·";
-  if (role === "tool") {
-    return html`
-      <div class="chat-msg tool">
-        <div class="glyph">${glyph}</div>
-        <${ToolCard} msg=${msg} />
-      </div>
-    `;
-  }
-  return html`
-    <div class="chat-msg ${role}">
-      <div class="glyph">${glyph}</div>
-      <div class="body">
-        ${msg.reasoning ? html`<div class="reasoning">${msg.reasoning}</div>` : null}
-        ${renderMessageBody(msg.text)}
-        ${streaming ? html`<span class="chat-streaming-cursor"></span>` : null}
-      </div>
-    </div>
-  `;
-});
-
-//
-// Each component renders a card matching the TUI's ModalCard accent
-// palette: red for shell (run-now), magenta for choice (branching),
-// cyan for plan (decision), green for edits. onResolve pushes to the
-// server; the SSE channel will echo back a modal-down that clears the
-// local state — both surfaces stay in lockstep without polling.
-
-export function ModalCard({ accent, icon, title, subtitle, children }: ModalCardProps) {
-  return html`
-    <div class="modal-card" style=${`border-left-color: ${accent};`}>
-      <div class="modal-card-head">
-        <span class="modal-card-icon" style=${`color: ${accent};`}>${icon}</span>
-        <div>
-          <div class="modal-card-title">${title}</div>
-          ${subtitle ? html`<div class="modal-card-subtitle">${subtitle}</div>` : null}
-        </div>
-      </div>
-      ${children}
-    </div>
-  `;
-}
-
-export function ShellModal({ modal, onResolve }: { modal: ShellModalSpec; onResolve: OnResolve }) {
-  useLang();
-  const isBg = modal.shellKind === "run_background";
-  return html`
-    <${ModalCard}
-      accent="#f87171"
-      icon=${isBg ? "⏱" : "⚡"}
-      title=${isBg ? t("modal.shellBgTitle") : t("modal.shellTitle")}
-      subtitle=${
-        isBg ? t("modal.shellBgSubtitle") : t("modal.shellSubtitle")
-      }
-    >
-      <div class="modal-cmd"><span class="modal-cmd-prompt">$</span> <code>${modal.command}</code></div>
-      <div class="modal-actions">
-        <button class="primary" onClick=${() => onResolve("shell", "run_once")}>${t("modal.runOnce")}</button>
-        <button onClick=${() => onResolve("shell", "always_allow")}>${t("modal.alwaysAllow", { prefix: modal.allowPrefix ?? "" })}</button>
-        <button class="danger" onClick=${() => onResolve("shell", "deny")}>${t("modal.deny")}</button>
-      </div>
-    <//>
-  `;
-}
-
-export function ChoiceModal({ modal, onResolve }: { modal: ChoiceModalSpec; onResolve: OnResolve }) {
-  useLang();
-  const [custom, setCustom] = useState("");
-  const [showCustom, setShowCustom] = useState(false);
-  return html`
-    <${ModalCard} accent="#f0abfc" icon="🔀" title=${t("modal.choiceTitle")} subtitle=${modal.question}>
-      ${modal.options.map(
-        (opt: ChoiceOption) => html`
-        <button
-          key=${opt.id}
-          class="modal-choice-row"
-          onClick=${() => onResolve("choice", { kind: "pick", optionId: opt.id })}
-        >
-          <span class="modal-choice-id">${opt.id}</span>
-          <span class="modal-choice-title">${opt.title}</span>
-          ${opt.summary ? html`<span class="modal-choice-summary">${opt.summary}</span>` : null}
-        </button>
-      `,
-      )}
-      ${
-        modal.allowCustom
-          ? showCustom
-            ? html`
-            <div class="modal-custom">
-              <textarea
-                placeholder=${t("modal.typePlaceholder")}
-                rows="2"
-                value=${custom}
-                onInput=${(e: Event) => setCustom((e.target as HTMLTextAreaElement).value)}
-              ></textarea>
-              <div class="modal-actions">
-                <button class="primary" onClick=${() => onResolve("choice", { kind: "custom", text: custom })} disabled=${!custom.trim()}>${t("modal.send")}</button>
-                <button onClick=${() => {
-                  setShowCustom(false);
-                  setCustom("");
-                }}>${t("common.back")}</button>
-              </div>
-            </div>
-          `
-            : html`
-            <button class="modal-choice-row" onClick=${() => setShowCustom(true)}>
-              <span class="modal-choice-id">·</span>
-              <span class="modal-choice-title">${t("modal.typeOwn")}</span>
-              <span class="modal-choice-summary">${t("modal.typeOwnSummary")}</span>
-            </button>
-          `
-          : null
-      }
-      <button class="modal-choice-row modal-choice-cancel" onClick=${() => onResolve("choice", { kind: "cancel" })}>
-        <span class="modal-choice-id">×</span>
-        <span class="modal-choice-title">${t("modal.cancel")}</span>
-        <span class="modal-choice-summary">${t("modal.cancelSummary")}</span>
-      </button>
-    <//>
-  `;
-}
-
-export function PlanModal({ modal, onResolve }: { modal: PlanModalSpec; onResolve: OnResolve }) {
-  useLang();
-  const [feedback, setFeedback] = useState("");
-  const [stage, setStage] = useState<"approve" | "refine" | null>(null);
-  const send = () => onResolve("plan", stage, feedback);
-  return html`
-    <${ModalCard} accent="#67e8f9" icon="◆" title=${t("modal.planTitle")} subtitle=${t("modal.planSubtitle")}>
-      <div class="md modal-plan-body" dangerouslySetInnerHTML=${{ __html: marked.parse(modal.body || "") }}></div>
-      ${
-        stage
-          ? html`
-          <textarea
-            placeholder=${
-              stage === "approve"
-                ? t("modal.approveInstructions")
-                : t("modal.refinePlaceholder")
-            }
-            rows="3"
-            value=${feedback}
-            onInput=${(e: Event) => setFeedback((e.target as HTMLTextAreaElement).value)}
-          ></textarea>
-          <div class="modal-actions">
-            <button class="primary" onClick=${send}>${stage === "approve" ? t("modal.approve") : t("modal.sendRefinement")}</button>
-            <button onClick=${() => {
-              setStage(null);
-              setFeedback("");
-            }}>${t("common.back")}</button>
-          </div>
-        `
-          : html`
-          <div class="modal-actions">
-            <button class="primary" onClick=${() => setStage("approve")}>${t("modal.approve")}</button>
-            <button onClick=${() => setStage("refine")}>${t("modal.refine")}</button>
-            <button class="danger" onClick=${() => onResolve("plan", "cancel")}>${t("modal.cancel")}</button>
-          </div>
-        `
-      }
-    <//>
-  `;
-}
-
-// Line-level LCS diff. Returns an ordered list of rows; "context" rows
-// appear on both sides, "del" only on the left (red), "ins" only on the
-// right (green). Adjacent del/ins are paired into one row downstream so
-// the change reads "old → new" left-to-right like a git side-by-side.
-function lineDiff(aLines: string[], bLines: string[]): DiffEntry[] {
-  const m = aLines.length;
-  const n = bLines.length;
-  const dp: number[][] = Array.from({ length: m + 1 }, () => new Array<number>(n + 1).fill(0));
-  for (let i = 1; i <= m; i++) {
-    for (let j = 1; j <= n; j++) {
-      if (aLines[i - 1] === bLines[j - 1]) dp[i]![j] = dp[i - 1]![j - 1]! + 1;
-      else dp[i]![j] = Math.max(dp[i - 1]![j]!, dp[i]![j - 1]!);
-    }
-  }
-  const out: DiffEntry[] = [];
-  let i = m;
-  let j = n;
-  while (i > 0 || j > 0) {
-    if (i > 0 && j > 0 && aLines[i - 1] === bLines[j - 1]) {
-      out.push({ kind: "context", text: aLines[i - 1]! });
-      i--;
-      j--;
-    } else if (j > 0 && (i === 0 || dp[i]![j - 1]! >= dp[i - 1]![j]!)) {
-      out.push({ kind: "ins", text: bLines[j - 1]! });
-      j--;
-    } else {
-      out.push({ kind: "del", text: aLines[i - 1]! });
-      i--;
-    }
-  }
-  return out.reverse();
-}
-
-// Pair del/ins runs into side-by-side rows. A run of consecutive dels
-// followed by a run of inss collapses into rows of (del[k], ins[k]) so
-// the modified line lines up across the gutter; surplus on either side
-// produces rows with the opposite cell empty.
-function pairDiffRows(diff: DiffEntry[]): DiffPair[] {
-  const rows: DiffPair[] = [];
-  let k = 0;
-  while (k < diff.length) {
-    const entry = diff[k]!;
-    if (entry.kind === "context") {
-      rows.push({ left: entry.text, right: entry.text, kind: "context" });
-      k++;
-      continue;
-    }
-    const dels: string[] = [];
-    const inss: string[] = [];
-    while (k < diff.length && diff[k]!.kind === "del") {
-      dels.push(diff[k]!.text);
-      k++;
-    }
-    while (k < diff.length && diff[k]!.kind === "ins") {
-      inss.push(diff[k]!.text);
-      k++;
-    }
-    const pairs = Math.max(dels.length, inss.length);
-    for (let p = 0; p < pairs; p++) {
-      const dp = dels[p];
-      const ip = inss[p];
-      rows.push({
-        left: dp ?? null,
-        right: ip ?? null,
-        kind: dp != null && ip != null ? "change" : dp != null ? "del" : "ins",
-      });
-    }
-  }
-  return rows;
-}
-
-export function EditReviewModal({ modal, onResolve }: { modal: EditReviewSpec; onResolve: OnResolve }) {
-  useLang();
-  const search = modal.search ?? "";
-  const replace = modal.replace ?? "";
-  const lang = langFromPath(modal.path);
-  const aLines = search.split("\n");
-  const bLines = replace.split("\n");
-  const rows = pairDiffRows(lineDiff(aLines, bLines));
-
-  return html`
-    <${ModalCard}
-      accent="#86efac"
-      icon="◆"
-      title=${t("modal.editTitle")}
-      subtitle=${t("modal.editSubtitle", { path: modal.path ?? "", remaining: modal.remaining, total: modal.total })}
-    >
-      <div class="edit-diff-wrap">
-        <div class="edit-diff-head">
-          <div class="edit-diff-side edit-diff-side-old">
-            <span class="edit-diff-marker">−</span> ${t("modal.before")}
-          </div>
-          <div class="edit-diff-side edit-diff-side-new">
-            <span class="edit-diff-marker">+</span> ${t("modal.after")}
-          </div>
-        </div>
-        <div class="edit-diff-body">
-          ${rows.map(
-            (row, i) => html`
-            <div key=${i} class=${`edit-diff-row edit-diff-row-${row.kind}`}>
-              <div class="edit-diff-cell edit-diff-cell-old">
-                ${
-                  row.left != null
-                    ? html`<span
-                        class="edit-diff-line"
-                        dangerouslySetInnerHTML=${{ __html: hlLine(row.left, lang) || "&nbsp;" }}
-                      ></span>`
-                    : html`<span class="edit-diff-empty">&nbsp;</span>`
-                }
-              </div>
-              <div class="edit-diff-cell edit-diff-cell-new">
-                ${
-                  row.right != null
-                    ? html`<span
-                        class="edit-diff-line"
-                        dangerouslySetInnerHTML=${{ __html: hlLine(row.right, lang) || "&nbsp;" }}
-                      ></span>`
-                    : html`<span class="edit-diff-empty">&nbsp;</span>`
-                }
-              </div>
-            </div>
-          `,
-          )}
-        </div>
-      </div>
-      <div class="modal-actions">
-        <button class="primary" onClick=${() => onResolve("edit-review", "apply")}>${t("chat.confirmBtn")}</button>
-        <button onClick=${() => onResolve("edit-review", "reject")}>${t("chat.rejectBtn")}</button>
-        <button onClick=${() => onResolve("edit-review", "apply-rest-of-turn")}>${t("chat.applyRestBtn")}</button>
-        <button onClick=${() => onResolve("edit-review", "flip-to-auto")}>${t("chat.flipAutoBtn")}</button>
-      </div>
-    <//>
-  `;
-}
-
-export function WorkspaceModal({ modal, onResolve }: { modal: WorkspaceSpec; onResolve: OnResolve }) {
-  useLang();
-  return html`
-    <${ModalCard}
-      accent="#fbbf24"
-      icon="◇"
-      title=${t("modal.workspaceTitle")}
-      subtitle=${t("modal.workspaceSubtitle")}
-    >
-      <div class="modal-cmd"><span class="modal-cmd-prompt">→</span> <code>${modal.path}</code></div>
-      <div class="modal-actions">
-        <button class="primary" onClick=${() => onResolve("workspace", "switch")}>${t("modal.switchBtn")}</button>
-        <button class="danger" onClick=${() => onResolve("workspace", "deny")}>${t("modal.denyBtn")}</button>
-      </div>
-    <//>
-  `;
-}
-
-export function CheckpointModal({ modal, onResolve }: { modal: CheckpointSpec; onResolve: OnResolve }) {
-  useLang();
-  const [reviseText, setReviseText] = useState("");
-  const [staged, setStaged] = useState(false);
-  const label = modal.title ? `${modal.stepId} · ${modal.title}` : modal.stepId;
-  const counter = (modal.total ?? 0) > 0 ? ` (${modal.completed}/${modal.total})` : "";
-  return html`
-    <${ModalCard}
-      accent="#a5f3fc"
-      icon="✓"
-      title=${t("modal.stepComplete", { counter })}
-      subtitle=${label}
-    >
-      ${
-        staged
-          ? html`
-          <textarea
-            placeholder=${t("modal.revisePlaceholder")}
-            rows="3"
-            value=${reviseText}
-            onInput=${(e: Event) => setReviseText((e.target as HTMLTextAreaElement).value)}
-          ></textarea>
-          <div class="modal-actions">
-            <button class="primary" onClick=${() => onResolve("checkpoint", "revise", reviseText)}>${t("modal.sendRevision")}</button>
-            <button onClick=${() => {
-              setStaged(false);
-              setReviseText("");
-            }}>${t("common.back")}</button>
-          </div>
-        `
-          : html`
-          <div class="modal-actions">
-            <button class="primary" onClick=${() => onResolve("checkpoint", "continue")}>${t("modal.continueBtn")}</button>
-            <button onClick=${() => setStaged(true)}>${t("modal.reviseBtn")}</button>
-            <button class="danger" onClick=${() => onResolve("checkpoint", "stop")}>${t("modal.stopBtn")}</button>
-          </div>
-        `
-      }
-    <//>
-  `;
-}
-
-export function PickerModal({
-  modal,
-  onResolve,
-}: {
-  modal: PickerModalSpec;
-  onResolve: OnResolve;
-}) {
-  useLang();
-  const [selectedId, setSelectedId] = useState<string | null>(modal.items[0]?.id ?? null);
-  const [query, setQuery] = useState(modal.query ?? "");
-  const [renameTarget, setRenameTarget] = useState<string | null>(null);
-  const [renameText, setRenameText] = useState("");
-  const [showNew, setShowNew] = useState(false);
-  const [newText, setNewText] = useState("");
-
-  const has = (a: PickerActionName) => modal.actions.includes(a);
-  const selected = modal.items.find((i) => i.id === selectedId) ?? null;
-
-  const submitRefine = (next: string) => {
-    setQuery(next);
-    if (has("refine")) onResolve("picker", { action: "refine", query: next });
-  };
-
-  const startRename = (id: string) => {
-    const item = modal.items.find((i) => i.id === id);
-    if (!item) return;
-    setRenameTarget(id);
-    setRenameText(item.title);
-  };
-
-  const sendRename = () => {
-    if (!renameTarget || !renameText.trim()) return;
-    onResolve("picker", { action: "rename", id: renameTarget, text: renameText });
-    setRenameTarget(null);
-    setRenameText("");
-  };
-
-  const sendNew = () => {
-    onResolve("picker", newText.trim() ? { action: "new", text: newText } : { action: "new" });
-    setShowNew(false);
-    setNewText("");
-  };
-
-  return html`
-    <${ModalCard}
-      accent="#fcd34d"
-      icon="≡"
-      title=${modal.title}
-      subtitle=${modal.hint}
-    >
-      ${
-        has("refine")
-          ? html`<input
-              class="modal-picker-search"
-              type="search"
-              placeholder=${t("modal.pickerFilter")}
-              value=${query}
-              onInput=${(e: Event) => submitRefine((e.target as HTMLInputElement).value)}
-            />`
-          : null
-      }
-      <div class="modal-picker-list">
-        ${
-          modal.items.length === 0
-            ? html`<div class="modal-picker-empty">${t("modal.pickerEmpty")}</div>`
-            : modal.items.map(
-                (it) => html`
-                  <button
-                    key=${it.id}
-                    class=${`modal-picker-row${it.id === selectedId ? " selected" : ""}`}
-                    onClick=${() => setSelectedId(it.id)}
-                    onDblClick=${() => has("pick") && onResolve("picker", { action: "pick", id: it.id })}
-                  >
-                    <span class="modal-picker-title">${it.title}</span>
-                    ${it.badge ? html`<span class="modal-picker-badge">${it.badge}</span>` : null}
-                    ${it.subtitle ? html`<span class="modal-picker-subtitle">${it.subtitle}</span>` : null}
-                    ${it.meta ? html`<span class="modal-picker-meta">${it.meta}</span>` : null}
-                  </button>
-                `,
-              )
-        }
-      </div>
-      ${
-        modal.hasMore && has("load-more")
-          ? html`<button
-              class="modal-picker-more"
-              onClick=${() => onResolve("picker", { action: "load-more" })}
-            >${t("modal.pickerLoadMore")}</button>`
-          : null
-      }
-      ${
-        renameTarget
-          ? html`
-            <div class="modal-picker-form">
-              <input
-                type="text"
-                value=${renameText}
-                onInput=${(e: Event) => setRenameText((e.target as HTMLInputElement).value)}
-              />
-              <div class="modal-actions">
-                <button class="primary" onClick=${sendRename} disabled=${!renameText.trim()}>${t("common.save")}</button>
-                <button onClick=${() => setRenameTarget(null)}>${t("common.back")}</button>
-              </div>
-            </div>
-          `
-          : showNew
-            ? html`
-              <div class="modal-picker-form">
-                <input
-                  type="text"
-                  placeholder=${t("modal.pickerNewPlaceholder")}
-                  value=${newText}
-                  onInput=${(e: Event) => setNewText((e.target as HTMLInputElement).value)}
-                />
-                <div class="modal-actions">
-                  <button class="primary" onClick=${sendNew}>${t("common.add")}</button>
-                  <button onClick=${() => setShowNew(false)}>${t("common.back")}</button>
-                </div>
-              </div>
-            `
-            : html`
-              <div class="modal-actions">
-                ${
-                  has("pick") && selected
-                    ? html`<button
-                        class="primary"
-                        onClick=${() => onResolve("picker", { action: "pick", id: selected.id })}
-                      >${t("modal.pickerPick")}</button>`
-                    : null
-                }
-                ${
-                  has("install") && selected
-                    ? html`<button
-                        class="primary"
-                        onClick=${() => onResolve("picker", { action: "install", id: selected.id })}
-                      >${t("modal.pickerInstall")}</button>`
-                    : null
-                }
-                ${
-                  has("uninstall") && selected
-                    ? html`<button
-                        onClick=${() => onResolve("picker", { action: "uninstall", id: selected.id })}
-                      >${t("modal.pickerUninstall")}</button>`
-                    : null
-                }
-                ${
-                  has("rename") && selected
-                    ? html`<button onClick=${() => startRename(selected.id)}>${t("modal.pickerRename")}</button>`
-                    : null
-                }
-                ${
-                  has("delete") && selected
-                    ? html`<button
-                        class="danger"
-                        onClick=${() => onResolve("picker", { action: "delete", id: selected.id })}
-                      >${t("common.delete")}</button>`
-                    : null
-                }
-                ${
-                  has("new")
-                    ? html`<button onClick=${() => setShowNew(true)}>${t("modal.pickerNew")}</button>`
-                    : null
-                }
-                <button onClick=${() => onResolve("picker", { action: "cancel" })}>${t("modal.cancel")}</button>
-              </div>
-            `
-      }
-    <//>
-  `;
-}
-
-export function ViewerModal({
-  modal,
-  onResolve,
-}: {
-  modal: ViewerModalSpec;
-  onResolve: OnResolve;
-}) {
-  useLang();
-  return html`
-    <${ModalCard}
-      accent="#67e8f9"
-      icon="◇"
-      title=${modal.title}
-      subtitle=${modal.meta}
-    >
-      ${
-        modal.steps && modal.steps.length > 0
-          ? html`
-            <ol class="modal-viewer-steps">
-              ${modal.steps.map(
-                (s: ViewerStep) => html`
-                  <li key=${s.id} class=${`modal-viewer-step modal-viewer-step-${s.status}`}>
-                    <span class="modal-viewer-step-mark">${s.status === "done" ? "✓" : "·"}</span>
-                    <span class="modal-viewer-step-title">${s.title}</span>
-                  </li>
-                `,
-              )}
-            </ol>
-          `
-          : null
-      }
-      ${
-        modal.body
-          ? html`<div class="md modal-viewer-body" dangerouslySetInnerHTML=${{ __html: marked.parse(modal.body) }}></div>`
-          : null
-      }
-      <div class="modal-actions">
-        <button onClick=${() => onResolve("viewer", { action: "close" })}>${t("modal.viewerClose")}</button>
-      </div>
-    <//>
-  `;
-}
-
-export function RevisionModal({ modal, onResolve }: { modal: RevisionSpec; onResolve: OnResolve }) {
-  useLang();
-  const riskColor = (r: string | undefined) =>
-    r === "high" ? "#f87171" : r === "med" ? "#fbbf24" : r === "low" ? "#86efac" : "#9ca3af";
-  return html`
-    <${ModalCard}
-      accent="#c4b5fd"
-      icon="✎"
-      title=${t("modal.revisionTitle")}
-      subtitle=${modal.summary || modal.reason}
-    >
-      <div class="modal-revise-reason">${modal.reason}</div>
-      <ol class="modal-revise-steps">
-        ${modal.remainingSteps.map(
-          (s: RevisionStep) => html`
-            <li key=${s.id}>
-              <span class="modal-revise-dot" style=${`background:${riskColor(s.risk)}`}></span>
-              <span class="modal-revise-id">${s.id}</span>
-              <span class="modal-revise-title">${s.title}</span>
-              <span class="modal-revise-action">${s.action}</span>
-            </li>
-          `,
-        )}
-      </ol>
-      <div class="modal-actions">
-        <button class="primary" onClick=${() => onResolve("revision", "accept")}>${t("modal.accept")}</button>
-        <button class="danger" onClick=${() => onResolve("revision", "reject")}>${t("modal.reject")}</button>
-      </div>
-    <//>
-  `;
-}

dashboard/src/i18n/en.ts

@@ -23,6 +23,111 @@ export const en = {
     themeToggle: "Toggle theme",
     themeLight: "Light",
     themeDark: "Dark",
+    skill: {
+      scope: {
+        builtin: "Built-in",
+        global: "Global",
+        project: "Project",
+      },
+      runAs: {
+        subagent: "Subagent",
+        inline: "Inline",
+      },
+      generic: "Skill",
+    },
+    exportReasoningSummary: "Reasoning Summary",
+    exportToolLabel: "Tool Calls",
+    exportUserLabel: "User Messages",
+    empty: {
+      currentWorkspace: "Current workspace",
+      selectWorkspace: "Select a workspace to get started",
+      suggestion0: "Start a new conversation",
+      suggestion1: "Open settings",
+      suggestion2: "View overview",
+      suggestion3: "Browse sessions",
+      welcome: "Welcome to Reasonix",
+    },
+    errorLabel: "Error",
+    connecting: "Connecting…",
+    session: {
+      format: "Session",
+      new: "New Session",
+    },
+    setup: {
+      choose: "Choose a workspace",
+      description: "Select a workspace to start working",
+      notSelected: "No workspace selected",
+      saveAndStart: "Save & Start",
+      welcome: "Welcome",
+      workspace: "Workspace",
+    },
+    tab: {
+      newTab: "+ New Tab",
+      newTabTitle: "Open a new tab",
+    },
+    titlebar: {
+      clearChat: "Clear Chat",
+      close: "Close",
+      commandPalette: "Command Palette",
+      contextPanel: "Context Panel",
+      copyMd: "Copy as Markdown",
+      exportMd: "Export as Markdown",
+      maximize: "Maximize",
+      minimize: "Minimize",
+      more: "More",
+      restore: "Restore",
+      settings: "Settings",
+      sidebar: "Sidebar",
+      windowControls: "Window Controls",
+    },
+    toast: {
+      cleared: "Chat cleared",
+      copied: "Copied to clipboard",
+      copiedMd: "Copied as Markdown",
+      emptySession: "No messages to export",
+      exportDialogTitle: "Export Chat",
+      exportedMd: "Exported as Markdown",
+      exportFailed: "Export failed",
+      langSwitched: "Language switched",
+      modelSwitched: "Model → {model}",
+      effortSwitched: "Effort → {effort}",
+      modeSwitched: "Mode switched",
+      newSession: "New session created",
+    },
+    yolo: {
+      toast: "YOLO mode enabled",
+    },
+    cmd: {
+      abort: "Abort",
+      btw: "BTW",
+      clearChat: "Clear Chat",
+      compact: "Compact",
+      copyLast: "Copy Last",
+      exportMd: "Export as Markdown",
+      feedback: "Feedback",
+      help: "Help",
+      newSession: "New Session",
+      retry: "Retry",
+      switchModel: "Switch Model",
+      toggleCurrency: "Toggle Currency",
+      toggleLang: "Toggle Language",
+      toggleTheme: "Toggle Theme",
+    },
+    header: {
+      abort: "Abort",
+      clickToSelect: "Click to select",
+      copy: "Copy",
+      copyMd: "Copy as Markdown",
+      export: "Export",
+      exportMd: "Export as Markdown",
+      newChat: "New Chat",
+      noWorkspace: "No workspace",
+      running: "Running…",
+    },
+    jumpToBottom: "Jump to bottom",
+    langEN: "English",
+    langZH: "中文",
+    splashSubtitle: "AI-powered coding assistant",
   },
   changes: {
     chatPlaceholder: "Ask about your code...",
@@ -101,29 +206,51 @@ export const en = {
     saved: "saved: {fields}",
     sectionApi: "DeepSeek API",
     apiKey: "API key",
+    apiKeyNotSet: "Not set",
+    apiKeySave: "Save key",
+    apiKeySet: "Set",
+    apiSection: "API Configuration",
     notSet: "(not set)",
     replace: "replace",
     pasteKey: "paste a fresh sk-… token",
     saveKey: "Save key",
     baseUrl: "base url",
     baseUrlPlaceholder: "https://api.deepseek.com (default)",
+    baseUrlHint: "Base URL for API requests",
     sectionDefaults: "Defaults",
-    preset: "preset",
-    presetAuto: "auto — flash → pro on hard turns",
-    presetFlash: "flash — always flash, no auto-escalate",
-    presetPro: "pro — always pro",
+    effortSection: "Reasoning effort",
+    modelCustom: "Custom model id",
+    modelCustomHint: "Any OpenAI-compatible id your endpoint serves (vLLM, Ollama, Together, …).",
+    modelCustomActive: "Currently running on a custom id: {model}",
     appliesNextTurn: "applies next turn",
     effort: "effort",
-    effortMax: "max (default — best)",
-    effortHigh: "high (cheaper / faster)",
+    effortMax: "max (DeepSeek extension — rejected by stock OpenAI / vLLM)",
+    effortHigh: "high (safe default — vLLM / Azure compatible)",
+    effortMedium: "medium",
+    effortLow: "low (fastest)",
     webSearch: "web search",
     webSearchNote: "web_fetch + web_search tools",
-    sectionCompute: "Compute",
-    proNext: "/pro one-shot",
-    proArm: "Arm for next turn",
-    proArmed: "Armed — disarms after next turn",
-    proNextNote: "next turn runs on deepseek-v4-pro, then auto-disarms",
+    webSearchEngine: "search engine",
+    webSearchEngineBing: "bing — default, works from CN without proxy",
+    webSearchEngineBingIntl: "bing-intl — international index via www.bing.com",
+    webSearchEngineSearxng: "searxng — self-hosted (set endpoint via /se searxng <url>)",
+    webSearchEngineMetaso: "metaso — 100/day free (CN-friendly, free key at metaso.cn)",
+    webSearchEngineBaidu: "baidu — Baidu AI Search (set BAIDU_API_KEY or QIANFAN_API_KEY)",
+    webSearchEngineTavily: "tavily — 1000/mo free (set TAVILY_API_KEY)",
+    webSearchEnginePerplexity: "perplexity — AI-native (set PERPLEXITY_API_KEY)",
+    webSearchEngineExa: "exa — AI-native 1000/mo free (set EXA_API_KEY)",
+    webSearchEngineBrave: "brave — independent index, 2000/mo free (set BRAVE_SEARCH_API_KEY)",
+    webSearchEngineOllama: "ollama — Ollama cloud web search (set OLLAMA_API_KEY)",
+    webSearchEngineNote: "applies to the next web_search call",
+    webSearchApiKeySignup: "(get key)",
+    webSearchApiKeyClear: "Clear",
+    webSearchApiKey: {
+      baidu: "Baidu API key",
+    },
     sectionBudget: "Budget",
+    budget: "Budget",
+    budgetHint: "Set spending limits",
+    budgetPlaceholder: "Enter budget amount",
     budgetOf: "of",
     budgetSetCap: "set a cap",
     budgetCustom: "custom",
@@ -149,21 +276,153 @@ export const en = {
     skillPaths: "skill paths",
     skillPathsPlaceholder: "/path/to/skills-a, /path/to/skills-b",
     skillPathsNote: "comma-separated · next /new or new session",
+    skillsEmpty: "No skills loaded",
+    skillsLoaded: "Skills loaded",
+    subagentModelFlash: "flash",
+    subagentModelPro: "pro",
+    subagentModelHint: "Model used when this skill spawns its isolated subagent",
     sectionRuntime: "Runtime",
     activeModel: "active model",
+    model: "Model",
+    modelFlashDesc: "Flash — always flash",
+    modelProDesc: "Pro — always pro",
     modelPricingLine: "${hit} hit · ${miss} miss · ${out} out  per 1M tok",
     editMode: "edit mode",
     editModeNote: "switch from the Chat tab header",
+    editModeHint: "Configure edit mode",
+    showSystemEvents: "system events",
+    showSystemEventsHint: "Show quiet inline notices for context compaction, abort, rate-limit.",
+    shown: "shown",
+    hidden: "hidden",
     sectionLanguage: "Language",
     language: "language",
+    languageHint: "Switch language",
     langEn: "English",
     langZhCn: "简体中文",
+    appMode: "App mode",
+    appearanceSection: "Appearance",
+    behaviorSection: "Behavior",
+    ruleAutoApprovalHint: "Configure auto-approval rules",
+    ruleAutoApprovalSection: "Auto-approval Rules",
+    theme: "Theme",
+    themeDark: "Dark",
+    themeHint: "Switch between light and dark themes",
+    themeLight: "Light",
+    themeStyle: "Theme style",
+    themeStyleHint: "Choose theme style",
+    themeStyleGraphite: "Graphite",
+    themeStyleGraphiteDesc: "Cool dark neutrals — best for long sessions.",
+    themeStyleEmber: "Ember",
+    themeStyleEmberDesc: "Warm dark with a stronger Reasonix orange accent.",
+    themeStyleAurora: "Aurora",
+    themeStyleAuroraDesc: "Teal-green dark for a softer low-light workspace.",
+    themeStyleSandstone: "Sandstone",
+    themeStyleSandstoneDesc: "Warm light tones — easy on bright rooms.",
+    themeStylePorcelain: "Porcelain",
+    themeStylePorcelainDesc: "Clean light with extra contrast.",
+    themeStyleLinen: "Linen",
+    themeStyleLinenDesc: "Editorial warm light with paper-like surfaces.",
+    themeStyleGlacier: "Glacier",
+    themeStyleGlacierDesc: "Cool light with crisp blue accents.",
+    themeStyleMidnight: "Midnight",
+    themeStyleMidnightDesc: "Deep dark with cooler highlights.",
+    pageGeneralLabel: "General",
+    pageGeneralDesc: "Theme, fonts, language and workspace.",
+    pageModelsLabel: "Models",
+    pageModelsDesc: "Default model and reasoning effort.",
+    pageMcpLabel: "MCP servers",
+    pageMcpDesc: "Connect external tool servers.",
+    pageSkillsLabel: "Skills",
+    pageSkillsDesc: "User-defined skills you can run with /skill.",
+    pageMemoryLabel: "Memory",
+    pageMemoryDesc: "Long-lived notes carried across sessions.",
+    pageRulesLabel: "Rules",
+    pageRulesDesc: "Auto-approval rules for shell + path access.",
+    pageBillingLabel: "Billing",
+    pageBillingDesc: "API key, balance and per-session budget.",
+    pageShortcutsLabel: "Shortcuts",
+    pageShortcutsDesc: "Keyboard shortcuts reference.",
+    fontFamily: "Font family",
+    fontFamilyHint: "Choose font family",
+    fontFamilySans: "Sans-serif",
+    fontFamilySerif: "Serif",
+    fontFamilySystem: "System",
+    fontScale: "Font scale",
+    fontScaleHint: "Adjust font size",
+    fontScaleLarge: "Large",
+    fontScaleMedium: "Medium",
+    fontScaleSmall: "Small",
+    currentWorkspace: "Current workspace",
+    defaultModelCurrent: "Current model",
+    editor: "Editor",
+    editorHint: "Configure editor preferences",
+    maxOutput: "Max output",
+    reasoningEffort: "Reasoning effort",
+    reasoningEffortHint: "Adjust reasoning depth",
+    sessionCost: "Session cost",
+    balanceAvailable: "Available",
+    balanceLabel: "Balance",
+    balanceLow: "Low balance",
+    cacheHitRate: "Cache hit rate",
+    ctxWindow: "Context window",
+    notSelected: "Not selected",
+    parseError: "Parse error",
+    workspaceChange: "Change",
+    workspaceSection: "Workspace",
+    mcpAdd: "Add",
+    mcpAddSection: "Add MCP Server",
+    mcpBridged: "Bridged",
+    mcpConfigured: "Configured",
+    mcpEmpty: "No MCP servers",
+    mcpNotBridged: "Not bridged",
+    mcpRemove: "Remove",
+    mcpSpecFormat: "JSON format",
+    mcpSpecLabel: "Server spec",
+    memoryDesc: "Configure memory settings",
+    memorySection: "Memory",
+    shortcutAbort: "Abort",
+    shortcutCloseTab: "Close Tab",
+    shortcutCommandPalette: "Command Palette",
+    shortcutFocusComposer: "Focus Composer",
+    shortcutNewChat: "New Chat",
+    shortcutNewTab: "New Tab",
+    shortcutSettings: "Settings",
+    shortcutSwitchTab: "Switch Tab",
+    qqAccessAllowlist: "Allowlist",
+    qqAccessOpen: "Open",
+    qqAccessOwner: "Owner",
+    qqAccessOwnerWithAllowlist: "Owner + Allowlist",
+    qqAccessRuntime: "Runtime",
+    qqAppId: "App ID",
+    qqApplyAction: "Apply",
+    qqApplyLabel: "Apply",
+    qqAppSecret: "App Secret",
+    qqBack: "Back",
+    qqConfigure: "Configure",
+    qqConfigureHint: "Set up QQ integration",
+    qqConfigureTitle: "QQ Configuration",
+    qqConnected: "Connected",
+    qqConnecting: "Connecting…",
+    qqDisconnected: "Disconnected",
+    qqEnvironment: "Environment",
+    qqFailed: "Failed",
+    qqProduction: "Production",
+    qqSandbox: "Sandbox",
+    qqSave: "Save",
+    qqSaveAndConnect: "Save & Connect",
+    qqSection: "QQ Integration",
+    qqSummaryAppId: "App ID",
+    qqSummaryDetail: "Details",
+    qqSummaryMissing: "Not configured",
+    qqTitle: "QQ Bot",
   },
   chat: {
     modeMirror: "TUI mirror",
     modeView: "session view",
     placeholder: "Type a prompt — Enter sends, Shift+Enter for a newline · / @ for pickers",
     placeholderBusy: "wait for the current turn to finish…",
+    placeholderSteerBusy: "type to steer — commands and pickers are disabled while busy",
+    steerHint: "message steers the current turn (added as instruction)",
     send: "Send",
     new: "New",
     clear: "Clear",
@@ -185,15 +444,10 @@ export const en = {
     slashCommands: "slash commands",
     projectFiles: "project files",
     effortTitle: "reasoning_effort — applies next turn",
-    effortMaxTitle: "max (default — best quality)",
-    effortHighTitle: "high (cheaper / faster)",
-    presetTitle: "preset — model commitment",
-    presetAutoTitle:
-      "auto — flash baseline; auto-escalates to pro on hard turns (NEEDS_PRO / failure threshold)",
-    presetFlashTitle:
-      "flash — always flash; no auto-escalate. /pro still works for one-shot manual",
-    presetProTitle:
-      "pro — always pro; ~3× flash cost (5/31 discount). Locks in on hard architecture work.",
+    effortMaxTitle: "max (DeepSeek extension)",
+    effortHighTitle: "high (safe default — vLLM / Azure compatible)",
+    effortMediumTitle: "medium",
+    effortLowTitle: "low (fastest)",
     editGateTitle: "edit gate — Shift+Tab cycles in TUI",
     editReviewTitle: "review — both edits and non-allowlisted shell ask first",
     editAutoTitle: "auto — edits auto-apply, shell still asks",
@@ -304,6 +558,16 @@ export const en = {
     loadingTranscript: "loading transcript…",
     emptyTranscript: "empty transcript.",
     messages: "{count} message{s}",
+    newBtn: "New session",
+    newHint: "Archive the current conversation and start a fresh one",
+    switchBtn: "Switch to this session",
+    deleteBtn: "Delete",
+    deleteConfirm: "Delete session \"{name}\"? This removes the transcript file and cannot be undone.",
+    cantDeleteActive: "Switch to a different session before deleting this one.",
+    attachRequired:
+      "Live session operations need an attached CLI session. Launch via reasonix chat or open the dashboard from inside a TUI session.",
+    activeChip: "active",
+    activePill: "active",
   },
   tools: {
     loading: "loading tools…",
@@ -431,6 +695,10 @@ export const en = {
     whyUnbridgedDesc:
       "This spec lives in your config.json but isn't bridged into the live session. MCP servers attach when reasonix code starts; the dashboard alone can't spawn the child process.",
     whyUnbridgedHint: "To activate: restart reasonix code, then refresh this dashboard.",
+    bridgeFailed: "Bridge failed",
+    bridgeFailedTitle: "bridge failed · in config",
+    bridgeFailedHint:
+      "Reasonix tried to bridge this server and the attempt errored. Common causes: wrong URL, missing auth header, upstream 404/5xx, missing local command. Fix and restart reasonix code to retry.",
     pickHint: "Pick an MCP server on the left to inspect tools / resources / prompts.",
     toolsTitle: "Tools · {count}",
     resourcesTitle: "Resources · {count}",
@@ -614,6 +882,7 @@ export const en = {
     customRequestBodyMustBeObject: "Custom request body must be a JSON object.",
     saveBeforeIndex: "Save semantic settings before starting an index.",
     extraBody: "extra body",
+    batchSize: "batch size",
     keepExistingKey: "leave blank to keep existing key",
     remoteProvider: "Remote embedding provider",
     remoteProviderDesc:
@@ -679,6 +948,12 @@ export const en = {
     shellBgTitle: "background process",
     shellSubtitle: "model wants to run a shell command",
     shellBgSubtitle: "long-running — keeps running after approval",
+    pathTitle: "file outside sandbox",
+    pathSubtitle: "{intent} via {tool}",
+    pathRead: "read",
+    pathWrite: "write",
+    pathSandboxLabel: "sandbox",
+    pathAllowPrefixLabel: "allow prefix",
     runOnce: "Run once",
     alwaysAllow: 'Always allow "{prefix}"',
     deny: "Deny",
@@ -743,4 +1018,326 @@ export const en = {
     hoursAgo: "{n}h ago",
     daysAgo: "{n}d ago",
   },
+  cards: {
+    applied: "Applied",
+    cacheHit: "Cache hit",
+    checkpointRewind: "Checkpoint Rewind",
+    cost: "Cost",
+    diffApply: "Apply",
+    diffApplyChanges: "Apply Changes",
+    diffAwaiting: "Awaiting review",
+    diffDiscard: "Discard",
+    done: "Done",
+    elapsed: "Elapsed",
+    error: "Error",
+    errorName: "Error",
+    failed: "Failed",
+    hits: "Hits",
+    memoryCountSuffix: "memories",
+    memoryName: "Memory",
+    output: "Output",
+    planDefaultTitle: "Plan",
+    prompt: "Prompt",
+    compactionMeta: "{chars} chars",
+    compactionName: "Compacted history",
+    reasoningComplete: "Reasoning complete",
+    reasoningName: "Reasoning",
+    result: "Result",
+    running: "Running",
+    searchName: "Search",
+    shellAlwaysAllow: "Always Allow",
+    shellAwaiting: "Awaiting approval",
+    shellExecuteHint: "Execute this command?",
+    shellReject: "Reject",
+    shellRun: "Run",
+    shellRunning: "Running",
+    streaming: "Streaming",
+    subagentDone: "Subagent done",
+    subagentDoneProgress: "Subagent done ({pct}%)",
+    subagentFailed: "Subagent failed",
+    subagentRunning: "Subagent running",
+  },
+  planBadge: {
+    blocked: "Blocked",
+    done: "Done",
+    failed: "Failed",
+    pending: "Pending",
+    running: "Running",
+  },
+  composer: {
+    atHeader: "Mention files",
+    close: "Close",
+    commandPalette: "Command Palette",
+    commands: "Commands",
+    commandsLabel: "Commands",
+    confirm: "Confirm",
+    imageFilterName: "Images",
+    insertFile: "Insert File",
+    insertImage: "Insert Image",
+    interrupt: "Interrupt",
+    mentionFiles: "Mention Files",
+    mentionLabel: "Mention",
+    newline: "New Line",
+    noMatches: "No matches",
+    placeholder: "Type a prompt…",
+    queue: "Queue",
+    queueCount: "{count} queued",
+    select: "Select",
+    send: "Send",
+    slashHeader: "Slash Commands",
+    switchModel: "Switch Model",
+    switchEffort: "Switch Reasoning Effort",
+    workspaceRoot: "Workspace Root",
+  },
+  contextPanel: {
+    allow: "Allow",
+    ask: "Ask",
+    autoApproveTitle: "Auto-approve",
+    cacheKey: "Cache",
+    contextTokens: "Context tokens",
+    fileInContext: "In context",
+    fileModified: "Modified",
+    filesCount: "{count} files",
+    filesTab: "Files",
+    filesTitle: "Files",
+    freeKey: "Free",
+    itemCount: "{count} items",
+    mcpConfigured: "Configured",
+    mcpConnecting: "Connecting…",
+    mcpDisabled: "Disabled",
+    mcpEmpty: "No MCP servers",
+    mcpFailed: "Failed",
+    mcpReady: "Ready",
+    mcpReadyAll: "All ready",
+    mcpReadySome: "Some ready",
+    mcpTitle: "MCP",
+    mcpTools: "Tools",
+    memoryTab: "Memory",
+    memoryTitle: "Memory",
+    noFilesMsg: "No files in context",
+    noMemoriesMsg: "No memories",
+    reservedKey: "Reserved",
+    ruleReadOnly: "Read-only",
+    ruleReview: "Review",
+    ruleShellAllowlist: "Shell allowlist",
+    rulesTab: "Rules",
+    ruleWritesAsk: "Writes ask",
+    ruleYolo: "YOLO",
+    scopeGlobal: "Global",
+    scopeProject: "Project",
+    toolsTab: "Tools",
+    usedKey: "Used",
+  },
+  dragDrop: {
+    overlay: "Drop files here",
+  },
+  extraCards: {
+    approve: "Approve",
+    balance: "Balance",
+    cache: "Cache",
+    cacheHit: "Cache hit",
+    contextWindow: "Context window",
+    doctorTitle: "Diagnostics",
+    output: "Output",
+    prompt: "Prompt",
+    reasoning: "Reasoning",
+    reject: "Reject",
+    sessionCost: "Session cost",
+    sessionUsage: "Session usage",
+    topToolsUsage: "Top tools",
+    unknownKind: "Unknown",
+    memoryUser: "User",
+    memoryFeedback: "Feedback",
+    memoryProject: "Project",
+    memoryReference: "Reference",
+  },
+  jobs: {
+    empty: "No background jobs",
+    exited: "Exited",
+    kbClose: "Close",
+    kbToggle: "Toggle",
+    running: "Running",
+    stop: "Stop",
+    stopAll: "Stop All",
+    stopAllTip: "Stop all jobs",
+    stopOne: "Stop",
+    title: "Background Jobs",
+  },
+  live: {
+    deliveredWaiting: "Waiting for next message",
+    reasoning: "Reasoning",
+    running: "Running",
+    secondsAgo: "{n}s ago",
+    you: "You",
+  },
+  markdown: {
+    copied: "Copied!",
+    copy: "Copy",
+    externalLinkTitle: "Open in new tab",
+    filePillTitle: "Open file",
+    localLinkTitle: "Open link",
+  },
+  palette: {
+    abort: "Abort",
+    abortHint: "Abort current request",
+    about: "About",
+    clearChat: "Clear Chat",
+    clearChatHint: "Clear conversation",
+    closeTab: "Close Tab",
+    closeTabHint: "Close current tab",
+    copyConv: "Copy Conversation",
+    copyConvHint: "Copy conversation as Markdown",
+    copyLast: "Copy Last Response",
+    copyLastHint: "Copy last assistant message",
+    countSuffix: "items",
+    empty: "No matching commands",
+    exportMd: "Export as Markdown",
+    exportMdHint: "Export chat as Markdown file",
+    focusComposer: "Focus Composer",
+    footClose: "Close",
+    footMove: "Move",
+    footRun: "Run",
+    groupAction: "Actions",
+    groupNav: "Navigation",
+    groupSettings: "Settings",
+    groupWorkspace: "Workspace",
+    newChat: "New Chat",
+    newChatHint: "Start a new conversation",
+    newTab: "New Tab",
+    newTabHint: "Open a new tab",
+    pickWorkspace: "Switch Workspace",
+    pickWorkspaceHint: "Change workspace",
+    searchPlaceholder: "Search commands…",
+    settings: "Settings",
+    settingsHint: "Open settings",
+  },
+  panel: {
+    renderError: "Panel crashed",
+  },
+  sidebarPanel: {
+    approvalRules: "Approval Rules",
+    cancel: "Cancel",
+    commandPalette: "Command Palette",
+    daysAgo: "{n}d ago",
+    delete: "Delete",
+    deleteSession: "Delete Session",
+    hoursAgo: "{n}h ago",
+    justNow: "Just now",
+    loading: "Loading…",
+    messageCount: "{count} messages",
+    minutesAgo: "{n}m ago",
+    newChat: "New Chat",
+    noMatches: "No matches",
+    noSessions: "No sessions",
+    recent: "Recent",
+    searchSessions: "Search sessions…",
+    sessionTitle: "Sessions",
+    settings: "Settings",
+    weeksAgo: "{n}w ago",
+  },
+  statusbar: {
+    balance: "Balance",
+    busy: "Busy",
+    cache: "Cache",
+    cacheHit: "Cache hit",
+    jobs: "Jobs",
+    jobsTip: "Background jobs",
+    offline: "Offline",
+    online: "Online",
+    switchCurrency: "Switch currency",
+    switchTheme: "Switch theme",
+    switchWorkspace: "Switch workspace",
+    themeDark: "Dark",
+    themeLight: "Light",
+    themeStyleGraphite: "Graphite",
+    themeStyleEmber: "Ember",
+    themeStyleAurora: "Aurora",
+    themeStyleSandstone: "Sandstone",
+    themeStylePorcelain: "Porcelain",
+    themeStyleLinen: "Linen",
+    themeStyleGlacier: "Glacier",
+    themeStyleMidnight: "Midnight",
+    thisTurn: "This turn",
+    tokens: "Tokens",
+  },
+  thread: {
+    activePlan: "Active plan",
+    allowRead: "Allow read",
+    allowWrite: "Allow write",
+    alwaysAllow: "Always allow",
+    alwaysAllowPrefix: "Always allow {prefix}",
+    approve: "Approve",
+    approveRewrite: "Approve rewrite",
+    cancel: "Cancel",
+    checkpointKind: "Checkpoint",
+    checkpointSub: "Save current state",
+    checkpointTitle: "Create checkpoint",
+    collapse: "Collapse",
+    continue: "Continue",
+    copyMessage: "Copy message",
+    copyResponse: "Copy response",
+    execute: "Execute",
+    keepOriginal: "Keep original",
+    keepSteps: "Keep steps",
+    optionCount: "{count} options",
+    pathAccessKind: "Path access",
+    planConfirmationKind: "Plan approval",
+    planRevisionKind: "Plan revision",
+    planRunning: "Plan in progress",
+    planStepCount: "Step {done}/{total}",
+    readPathOutsideSandbox: "Read path outside sandbox",
+    refine: "Refine",
+    reject: "Reject",
+    revise: "Revise",
+    revisionMeta: "Revision",
+    rewritePlan: "Rewrite plan",
+    risk: "Risk assessment",
+    riskMedium: "Medium risk",
+    runBackgroundCommand: "Run in background",
+    runCommand: "Run command",
+    shellConfirmationKind: "Shell confirmation",
+    startPlan: "Start plan",
+    stop: "Stop",
+    subagent: "Subagent",
+    userChoiceKind: "User choice",
+    writePathOutsideSandbox: "Write path outside sandbox",
+    you: "You",
+  },
+  workdir: {
+    browse: "Browse…",
+    cancel: "Cancel",
+    empty: "No workspaces",
+    emptyDir: "No subdirectories.",
+    go: "Go",
+    goTip: "Navigate to this path",
+    loading: "Loading…",
+    openHere: "Open this folder",
+    pathPlaceholder: "Absolute path…",
+    promptWeb: "Enter the absolute path of the workspace to open:",
+    searchPlaceholder: "Search workspaces…",
+    title: "Workspace",
+  },
+  about: {
+    close: "Close",
+    repo: "Repository",
+    sidebarLabel: "About",
+    tagline: "AI-powered coding assistant",
+    version: "Version",
+  },
+  effort: {
+    lowDesc: "fastest — minimal reasoning",
+    mediumDesc: "balanced",
+    highDesc: "default — safe for vLLM / Azure",
+    maxDesc: "DeepSeek extension; rejected by stock OpenAI / vLLM",
+  },
+  editMode: {
+    plan: "Plan",
+    planHint: "read-only · all write tools refuse to dispatch",
+    review: "Review",
+    reviewHint: "both edits and non-allowlisted shell ask first",
+    auto: "Auto",
+    autoHint: "edits auto-apply, shell still asks",
+    yolo: "YOLO",
+    yoloHint: "edits AND shell auto-run, allowlist bypassed",
+  },
 };

dashboard/src/i18n/index.ts

@@ -1,8 +1,117 @@
-import { createT } from "../lib/i18n.js";
-import { en } from "./en.js";
-import { zhCN } from "./zh-CN.js";
+import { useEffect, useState } from "react";
+import { de } from "./de";
+import { en } from "./en";
+import { ja } from "./ja";
+import { ru } from "./ru";
+import { zhCN } from "./zh-CN";
 
-export { getLang, initLangFromServer, setLang, useLang, onLangChange } from "../lib/i18n.js";
-export type { DashboardLang } from "../lib/i18n.js";
+export type Lang = "en" | "zh-CN" | "de" | "ja" | "ru";
 
-export const t = createT({ en, "zh-CN": zhCN });
+const SUPPORTED_LANGS: readonly Lang[] = ["en", "zh-CN", "de", "ja", "ru"];
+const SUPPORTED: ReadonlySet<Lang> = new Set<Lang>(SUPPORTED_LANGS);
+const LANG_LABELS: Record<Lang, string> = {
+  en: "English",
+  "zh-CN": "简体中文",
+  de: "Deutsch",
+  ja: "日本語",
+  ru: "Русский",
+};
+const STORAGE_KEY = "reasonix.lang";
+
+type Listener = () => void;
+const listeners: Listener[] = [];
+
+function detectDefault(): Lang {
+  try {
+    const stored = localStorage.getItem(STORAGE_KEY);
+    if (stored && SUPPORTED.has(stored as Lang)) return stored as Lang;
+  } catch {
+    /* private mode */
+  }
+  const nav = typeof navigator !== "undefined" ? navigator.language : "";
+  const lower = nav.toLowerCase();
+  if (lower.startsWith("zh")) return "zh-CN";
+  if (lower.startsWith("de")) return "de";
+  if (lower.startsWith("ja")) return "ja";
+  if (lower.startsWith("ru")) return "ru";
+  return "en";
+}
+
+let currentLang: Lang = detectDefault();
+
+function syncHtmlLang(lang: Lang): void {
+  if (typeof document === "undefined") return;
+  try {
+    document.documentElement.lang = lang;
+  } catch {
+    /* document not ready */
+  }
+}
+
+syncHtmlLang(currentLang);
+
+export function getLang(): Lang {
+  return currentLang;
+}
+
+export function getSupportedLangs(): readonly Lang[] {
+  return SUPPORTED_LANGS;
+}
+
+export function getLangLabel(lang: Lang): string {
+  return LANG_LABELS[lang];
+}
+
+export function setLang(lang: Lang): void {
+  if (!SUPPORTED.has(lang) || lang === currentLang) return;
+  currentLang = lang;
+  try {
+    localStorage.setItem(STORAGE_KEY, lang);
+  } catch {
+    /* ignore */
+  }
+  syncHtmlLang(lang);
+  for (const cb of listeners) cb();
+}
+
+export function useLang(): Lang {
+  const [, setTick] = useState(0);
+  useEffect(() => {
+    const cb = () => setTick((n) => n + 1);
+    listeners.push(cb);
+    return () => {
+      const idx = listeners.indexOf(cb);
+      if (idx >= 0) listeners.splice(idx, 1);
+    };
+  }, []);
+  return currentLang;
+}
+
+const dicts = { en, "zh-CN": zhCN, de, ja, ru } as const;
+
+type Dict = typeof en;
+type Path<T, K extends keyof T = keyof T> = K extends string
+  ? T[K] extends Record<string, unknown>
+    ? `${K}.${Path<T[K]>}`
+    : K
+  : never;
+export type TKey = Path<Dict>;
+
+function resolve(dict: Dict, key: string): string {
+  const parts = key.split(".");
+  let cursor: unknown = dict;
+  for (const p of parts) {
+    if (cursor && typeof cursor === "object" && p in (cursor as Record<string, unknown>)) {
+      cursor = (cursor as Record<string, unknown>)[p];
+    } else {
+      return key;
+    }
+  }
+  return typeof cursor === "string" ? cursor : key;
+}
+
+export function t(key: TKey, params?: Record<string, string | number>): string {
+  const raw = resolve(dicts[currentLang], key);
+  if (!params) return raw;
+  return raw.replace(/\{(\w+)\}/g, (_, k) => (k in params ? String(params[k]) : `{${k}}`));
+}

dashboard/src/i18n/ja.ts

@@ -0,0 +1,507 @@
+import { en } from "./en";
+
+export const ja: typeof en = {
+  ...en,
+  app: {
+    ...en.app,
+    sectionWorkspace: "ワークスペース",
+    sectionObserve: "監視",
+    sectionConfigure: "設定",
+    tabChat: "チャット",
+    tabPlans: "プラン",
+    tabSessions: "セッション",
+    tabOverview: "概要",
+    tabUsage: "使用量",
+    tabSystem: "システム",
+    tabSemantic: "セマンティック",
+    tabTools: "ツール",
+    tabPermissions: "権限",
+    tabMcp: "MCP",
+    tabSkills: "スキル",
+    tabMemory: "メモリ",
+    tabHooks: "フック",
+    tabSettings: "設定",
+    sectionChanges: "変更",
+    tabChanges: "変更",
+    footer: "127.0.0.1 のみ · トークン認証",
+    themeToggle: "テーマ切替",
+    themeLight: "ライト",
+    themeDark: "ダーク",
+    skill: {
+      ...en.app.skill,
+      scope: {
+        ...en.app.skill.scope,
+        builtin: "ビルトイン",
+        global: "グローバル",
+        project: "プロジェクト",
+      },
+      runAs: {
+        ...en.app.skill.runAs,
+        subagent: "サブエージェント",
+        inline: "インライン",
+      },
+      generic: "スキル",
+    },
+    exportReasoningSummary: "推論サマリー",
+    exportToolLabel: "ツール呼び出し",
+    exportUserLabel: "ユーザーメッセージ",
+    empty: {
+      ...en.app.empty,
+      currentWorkspace: "現在のワークスペース",
+      selectWorkspace: "ワークスペースを選択して開始",
+      suggestion0: "新しい会話を始める",
+      suggestion1: "設定を開く",
+      suggestion2: "概要を表示",
+      suggestion3: "セッションを閲覧",
+      welcome: "Reasonix へようこそ",
+    },
+    errorLabel: "エラー",
+    connecting: "接続中…",
+    session: {
+      ...en.app.session,
+      format: "セッション",
+      new: "新しいセッション",
+    },
+    setup: {
+      ...en.app.setup,
+      choose: "ワークスペースを選択",
+      description: "作業を開始するワークスペースを選択",
+      notSelected: "ワークスペース未選択",
+      saveAndStart: "保存して開始",
+      welcome: "ようこそ",
+      workspace: "ワークスペース",
+    },
+    tab: {
+      ...en.app.tab,
+      newTab: "+ 新しいタブ",
+      newTabTitle: "新しいタブを開く",
+    },
+    titlebar: {
+      ...en.app.titlebar,
+      clearChat: "チャットクリア",
+      close: "閉じる",
+      commandPalette: "コマンドパレット",
+      contextPanel: "コンテキストパネル",
+      copyMd: "Markdownでコピー",
+      exportMd: "Markdownでエクスポート",
+      maximize: "最大化",
+      minimize: "最小化",
+      more: "その他",
+      restore: "元に戻す",
+      settings: "設定",
+      sidebar: "サイドバー",
+      windowControls: "ウィンドウ操作",
+    },
+    toast: {
+      ...en.app.toast,
+      cleared: "チャットをクリアしました",
+      copied: "クリップボードにコピーしました",
+      copiedMd: "Markdownでコピーしました",
+      emptySession: "エクスポートするメッセージがありません",
+      exportDialogTitle: "チャットをエクスポート",
+      exportedMd: "Markdownでエクスポートしました",
+      exportFailed: "エクスポートに失敗しました",
+      langSwitched: "言語を切り替えました",
+      modelSwitched: "モデル → {model}",
+      effortSwitched: "努力 → {effort}",
+      modeSwitched: "モードを切り替えました",
+      newSession: "新しいセッションを作成しました",
+    },
+    yolo: {
+      ...en.app.yolo,
+      toast: "YOLOモードが有効です",
+    },
+    cmd: {
+      ...en.app.cmd,
+      abort: "中断",
+      btw: "BTW",
+      clearChat: "チャットクリア",
+      compact: "圧縮",
+      copyLast: "最後をコピー",
+      exportMd: "Markdownでエクスポート",
+      feedback: "フィードバック",
+      help: "ヘルプ",
+      newSession: "新しいセッション",
+      retry: "再試行",
+      switchModel: "モデル切替",
+      toggleCurrency: "通貨切替",
+      toggleLang: "言語切替",
+      toggleTheme: "テーマ切替",
+    },
+    header: {
+      ...en.app.header,
+      abort: "中断",
+      clickToSelect: "クリックで選択",
+      copy: "コピー",
+      copyMd: "Markdownでコピー",
+      export: "エクスポート",
+      exportMd: "Markdownでエクスポート",
+      newChat: "新しいチャット",
+      noWorkspace: "ワークスペースなし",
+      running: "実行中…",
+    },
+    jumpToBottom: "最下部にジャンプ",
+    langEN: "English",
+    langZH: "中文",
+    splashSubtitle: "AI搭載コーディングアシスタント",
+  },
+  changes: {
+    ...en.changes,
+    chatPlaceholder: "コードについて質問…",
+    chatWelcome: "変更 — プロジェクトファイルについて質問してください。",
+    chatSend: "送信",
+    viewerPlaceholder: "表示するファイルを選択",
+    treeEmpty: "(空)",
+    tabClose: "タブを閉じる",
+    newConversation: "新規",
+    clearConversation: "クリア",
+    newTitle: "/new — 会話コンテキストを消去",
+    clearTitle: "/clear — 表示スクロールバックを消去",
+    newConfirmBusy: "ターンが実行中です。中断して新しい会話を始めますか？",
+    newConfirm: "現在の会話をクリアして新しく始めますか？",
+    newToast: "新しい会話",
+    clearToast: "スクロールバックをクリアしました",
+    newFailed: "/new 失敗: {error}",
+    clearFailed: "/clear 失敗: {error}",
+    chatSendBtn: "送信",
+    fileTreeTitle: "ファイル",
+    codeViewerTitle: "コードビューア",
+    chatPanelTitle: "チャット",
+    loadingFiles: "プロジェクトファイルを読み込み中…",
+    review: "レビュー",
+    allFiles: "すべてのファイル",
+    changes: "変更",
+    commentLabel: "行にコメント",
+    commentPlaceholder: "コメントを追加…",
+    commentCancel: "キャンセル",
+    commentSubmit: "コメント",
+    commentLine: "行",
+    commentEdit: "編集",
+    commentDelete: "削除",
+    diffSourceGit: "Gitの変更",
+    diffSourceSession: "前回のセッション",
+    diffSourceCheckpoint: "チェックポイント",
+    checkpointEmpty: "このワークスペースにチェックポイントはまだありません。",
+    restoreBtn: "復元",
+    restoreConfirm: '"{name}" を復元しますか？現在のファイルが上書きされます。',
+    deleteBtn: "削除",
+    deleteConfirm:
+      'チェックポイント "{name}" を削除しますか？スナップショットは削除され、ファイルはそのままです。',
+    createBtn: "スナップショット",
+    createPlaceholder: "スナップショット名…",
+    backToList: "リストに戻る",
+    reviewEmpty: "保留中のレビューはありません。",
+    diffStyleUnified: "統合",
+    diffStyleSplit: "分割",
+    expandAll: "すべて展開",
+    collapseAll: "すべて折りたたみ",
+    createFailed: "作成に失敗しました",
+    restoreFailed: "復元に失敗しました",
+    deleteFailed: "削除に失敗しました",
+  },
+  common: {
+    ...en.common,
+    loading: "読み込み中…",
+    loadingFailed: "{name} 失敗: {error}",
+    back: "← 戻る",
+    save: "保存",
+    remove: "削除",
+    cancel: "キャンセル",
+    delete: "削除",
+    add: "追加",
+    confirm: "確認",
+    noData: "まだ {name} がありません。",
+    all: "すべて",
+    yes: "はい",
+    no: "いいえ",
+    on: "オン",
+    off: "オフ",
+    enabled: "有効",
+    disabled: "無効",
+  },
+  settings: {
+    ...en.settings,
+    title: "設定",
+    loading: "設定を読み込み中…",
+    saved: "保存: {fields}",
+    sectionApi: "DeepSeek API",
+    apiKey: "APIキー",
+    apiKeyNotSet: "未設定",
+    apiKeySave: "キーを保存",
+    apiKeySet: "設定済み",
+    apiSection: "API設定",
+    notSet: "(未設定)",
+    replace: "置換",
+    pasteKey: "新しい sk-… トークンを貼り付け",
+    saveKey: "キーを保存",
+    baseUrl: "ベースURL",
+    baseUrlPlaceholder: "https://api.deepseek.com (デフォルト)",
+    baseUrlHint: "APIリクエストのベースURL",
+    sectionDefaults: "デフォルト",
+    effortSection: "推論努力",
+    modelCustom: "カスタムモデルID",
+    modelCustomHint: "エンドポイントが提供するOpenAI互換ID (vLLM, Ollama, Together, …)。",
+    modelCustomActive: "現在カスタムIDで実行中: {model}",
+    appliesNextTurn: "次のターンから適用",
+    effort: "努力",
+    effortMax: "max (DeepSeek拡張 — 標準OpenAI / vLLMでは拒否)",
+    effortHigh: "high (安全なデフォルト — vLLM / Azure互換)",
+    effortMedium: "medium",
+    effortLow: "low (最速)",
+    webSearch: "Web検索",
+    webSearchNote: "web_fetch + web_search ツール",
+    webSearchEngine: "検索エンジン",
+    webSearchEngineBing: "bing — デフォルト、プロキシなしで中国から利用可",
+    webSearchEngineBingIntl: "bing-intl — www.bing.com 経由の国際版インデックス",
+    webSearchEngineSearxng: "searxng — セルフホスト (/se searxng <url> でエンドポイント設定)",
+    webSearchEngineMetaso: "metaso — 100回/日無料 (中国対応、metaso.cnで無料キー取得)",
+    webSearchEngineBaidu: "baidu — Baidu AI Search (BAIDU_API_KEY または QIANFAN_API_KEY を設定)",
+    webSearchEngineTavily: "tavily — 1000回/月無料 (TAVILY_API_KEY を設定)",
+    webSearchEnginePerplexity: "perplexity — AIネイティブ (PERPLEXITY_API_KEY を設定)",
+    webSearchEngineExa: "exa — AIネイティブ 1000回/月無料 (EXA_API_KEY を設定)",
+    webSearchEngineBrave: "brave — 独立インデックス、2000回/月無料 (BRAVE_SEARCH_API_KEY を設定)",
+    webSearchEngineOllama: "ollama — Ollama クラウド Web 検索 (OLLAMA_API_KEY を設定)",
+    webSearchEngineNote: "次の web_search 呼び出しに適用",
+    webSearchApiKeySignup: "(キーを取得)",
+    webSearchApiKeyClear: "クリア",
+    webSearchApiKey: {
+      ...en.settings.webSearchApiKey,
+      baidu: "Baidu APIキー",
+    },
+    sectionBudget: "予算",
+    budget: "予算",
+    budgetHint: "支出制限を設定",
+    budgetPlaceholder: "予算額を入力",
+    budgetOf: "/",
+    budgetSetCap: "上限を設定",
+    budgetCustom: "カスタム",
+    budgetBumpHint: "上限を引き上げて続行",
+    budgetClear: "上限をクリア",
+    budgetIdleLine: "80%で警告 · 100%超過で拒否",
+    budgetWarnLine: "上限接近 — ループは100%超過で拒否",
+    budgetRefusing: "上限到達 — 引き上げまたはクリアまで次のターンは拒否",
+    sectionLoop: "ループ",
+    loopIdleHint: "固定間隔でプロンプトを自動再送信。",
+    loopCostHint: "各イテレーションのコスト ~{cost} (前回ターン)。",
+    loopInterval: "間隔",
+    loopCustom: "カスタム",
+    loopRangeError: "間隔は5秒〜6時間の範囲である必要があります",
+    loopPrompt: "プロンプト",
+    loopPromptPlaceholder: "例: デプロイ状態を確認してエラーを報告",
+    loopStart: "ループ開始",
+    loopStop: "停止",
+    loopRunning: "実行中",
+    loopIter: "反復 {iter}",
+    loopFiresIn: "{remaining} 後に実行",
+    sectionSkills: "スキル",
+    skillPaths: "スキルパス",
+    skillPathsPlaceholder: "/path/to/skills-a, /path/to/skills-b",
+    skillPathsNote: "カンマ区切り · 次の /new または新規セッション",
+    skillsEmpty: "スキルが読み込まれていません",
+    skillsLoaded: "スキル読み込み済み",
+    subagentModelFlash: "flash",
+    subagentModelPro: "pro",
+    subagentModelHint: "このスキルが分離サブエージェントを生成するときに使用するモデル",
+    sectionRuntime: "ランタイム",
+    activeModel: "アクティブモデル",
+    model: "モデル",
+    modelFlashDesc: "Flash — 常にflash",
+    modelProDesc: "Pro — 常にpro",
+    modelPricingLine: "${hit} ヒット · ${miss} ミス · ${out} 出力 / 1M tok",
+    editMode: "編集モード",
+    editModeNote: "チャットタブヘッダーから切り替え",
+    editModeHint: "編集モードを設定",
+    showSystemEvents: "システムイベント",
+    showSystemEventsHint: "コンテキスト圧縮、中断、レート制限の通知を表示。",
+    shown: "表示",
+    hidden: "非表示",
+    sectionLanguage: "言語",
+    language: "言語",
+    languageHint: "言語を切り替え",
+    langEn: "English",
+    langZhCn: "简体中文",
+    appMode: "アプリモード",
+    appearanceSection: "外観",
+    behaviorSection: "動作",
+    ruleAutoApprovalHint: "自動承認ルールを設定",
+    ruleAutoApprovalSection: "自動承認ルール",
+    theme: "テーマ",
+    themeDark: "ダーク",
+    themeHint: "ライト/ダークテーマを切り替え",
+    themeLight: "ライト",
+    themeStyle: "テーマスタイル",
+    themeStyleHint: "テーマスタイルを選択",
+    themeStyleGraphite: "グラファイト",
+    themeStyleGraphiteDesc: "クールなダークニュートラル — 長時間のセッションに最適。",
+    themeStyleEmber: "エンバー",
+    themeStyleEmberDesc: "Reasonixのオレンジを強めた暖かいダーク。",
+    themeStyleAurora: "オーロラ",
+    themeStyleAuroraDesc: "低照度でも柔らかいティールグリーンのダーク。",
+    themeStyleSandstone: "サンドストーン",
+    themeStyleSandstoneDesc: "温かみのあるライトトーン — 明るい部屋に最適。",
+    themeStylePorcelain: "ポーセリン",
+    themeStylePorcelainDesc: "クリーンなライト、高コントラスト。",
+    themeStyleLinen: "リネン",
+    themeStyleLinenDesc: "紙のような表面を持つ編集調の暖かいライト。",
+    themeStyleGlacier: "グレイシャー",
+    themeStyleGlacierDesc: "くっきりしたブルーアクセントのクールなライト。",
+    themeStyleMidnight: "ミッドナイト",
+    themeStyleMidnightDesc: "深いダーク、クールなハイライト。",
+    pageGeneralLabel: "一般",
+    pageGeneralDesc: "テーマ、フォント、言語、ワークスペース。",
+    pageModelsLabel: "モデル",
+    pageModelsDesc: "デフォルトモデルと推論努力。",
+    pageMcpLabel: "MCPサーバー",
+    pageMcpDesc: "外部ツールサーバーに接続。",
+    pageSkillsLabel: "スキル",
+    pageSkillsDesc: "/skill で実行できるユーザー定義スキル。",
+    pageMemoryLabel: "メモリ",
+    pageMemoryDesc: "セッションをまたいで保持される長期メモ。",
+    pageRulesLabel: "ルール",
+    pageRulesDesc: "シェル+パスアクセスの自動承認ルール。",
+    pageBillingLabel: "請求",
+    pageBillingDesc: "APIキー、残高、セッションごとの予算。",
+    pageShortcutsLabel: "ショートカット",
+    pageShortcutsDesc: "キーボードショートカットリファレンス。",
+    fontFamily: "フォントファミリー",
+    fontFamilyHint: "フォントファミリーを選択",
+    fontFamilySans: "サンセリフ",
+    fontFamilySerif: "セリフ",
+    fontFamilySystem: "システム",
+    fontScale: "フォントスケール",
+    fontScaleHint: "フォントサイズを調整",
+    fontScaleLarge: "大",
+    fontScaleMedium: "中",
+    fontScaleSmall: "小",
+    currentWorkspace: "現在のワークスペース",
+    defaultModelCurrent: "現在のモデル",
+    editor: "エディタ",
+    editorHint: "エディタ設定を構成",
+    maxOutput: "最大出力",
+    reasoningEffort: "推論努力",
+    reasoningEffortHint: "推論の深さを調整",
+    sessionCost: "セッションコスト",
+    balanceAvailable: "利用可能",
+    balanceLabel: "残高",
+    balanceLow: "残高不足",
+    cacheHitRate: "キャッシュヒット率",
+    ctxWindow: "コンテキストウィンドウ",
+    notSelected: "未選択",
+    parseError: "パースエラー",
+    workspaceChange: "変更",
+    workspaceSection: "ワークスペース",
+    mcpAdd: "追加",
+    mcpAddSection: "MCPサーバーを追加",
+    mcpBridged: "ブリッジ済み",
+    mcpConfigured: "設定済み",
+    mcpEmpty: "MCPサーバーなし",
+    mcpNotBridged: "ブリッジ未接続",
+    mcpRemove: "削除",
+    mcpSpecFormat: "JSON形式",
+    mcpSpecLabel: "サーバー仕様",
+    memoryDesc: "メモリ設定を構成",
+    memorySection: "メモリ",
+    shortcutAbort: "中断",
+    shortcutCloseTab: "タブを閉じる",
+    shortcutCommandPalette: "コマンドパレット",
+    shortcutFocusComposer: "入力欄にフォーカス",
+    shortcutNewChat: "新しいチャット",
+    shortcutNewTab: "新しいタブ",
+    shortcutSettings: "設定",
+    shortcutSwitchTab: "タブ切替",
+    qqAccessAllowlist: "許可リスト",
+    qqAccessOpen: "オープン",
+    qqAccessOwner: "所有者",
+    qqAccessOwnerWithAllowlist: "所有者 + 許可リスト",
+    qqAccessRuntime: "ランタイム",
+    qqAppId: "App ID",
+    qqApplyAction: "申請",
+    qqApplyLabel: "申請",
+    qqAppSecret: "App Secret",
+    qqBack: "戻る",
+    qqConfigure: "設定",
+    qqConfigureHint: "QQ統合を設定",
+    qqConfigureTitle: "QQ設定",
+    qqConnected: "接続済み",
+    qqConnecting: "接続中…",
+    qqDisconnected: "切断済み",
+    qqEnvironment: "環境",
+    qqFailed: "失敗",
+    qqProduction: "本番",
+    qqSandbox: "サンドボックス",
+    qqSave: "保存",
+    qqSaveAndConnect: "保存して接続",
+    qqSection: "QQ統合",
+    qqSummaryAppId: "App ID",
+    qqSummaryDetail: "詳細",
+    qqSummaryMissing: "未設定",
+    qqTitle: "QQボット",
+  },
+  chat: {
+    ...en.chat,
+    modeMirror: "TUIミラー",
+    modeView: "セッションビュー",
+    placeholder: "プロンプトを入力 — Enterで送信、Shift+Enterで改行 · / @ でピッカー",
+    placeholderBusy: "現在のターンの完了を待っています…",
+    placeholderSteerBusy: "入力で操作 — ビジー中はコマンドとピッカーが無効です",
+    steerHint: "メッセージが現在のターンを操作します（指示として追加）",
+    send: "送信",
+    new: "新規",
+    clear: "クリア",
+    newTitle: "/new — 会話コンテキストを消去（ループログ + スクロールバック）",
+    clearTitle: "/clear — 表示スクロールバックのみ消去（コンテキストは保持）",
+    noConversation: "まだ会話がありません。下のプロンプトを送信して開始してください。",
+    newConfirmBusy: "ターンが実行中です。中断して新しい会話を始めますか？",
+    newConfirm: "現在の会話をクリアして新しく始めますか？",
+    newToast: "新しい会話",
+    clearToast: "スクロールバックをクリアしました",
+    newFailed: "/new 失敗: {error}",
+    clearFailed: "/clear 失敗: {error}",
+    eventStreamError: "イベントストリームが中断されました — 再接続中…",
+    semanticBanner: "このプロジェクトではセマンティック検索が有効になっていません。",
+    semanticBannerDesc:
+      "インデックスを一度構築すると、モデルは正確な文字列のgrepではなく意味でコードを見つけられるようになります（「認証失敗をどのように処理しているか？」など）。",
+    semanticBannerBtn: "構築する →",
+    semanticBannerDismiss: "閉じる（再表示しない）",
+    slashCommands: "スラッシュコマンド",
+    projectFiles: "プロジェクトファイル",
+    effortTitle: "reasoning_effort — 次のターンから適用",
+    effortMaxTitle: "max (DeepSeek拡張)",
+    effortHighTitle: "high (安全なデフォルト — vLLM / Azure互換)",
+    effortMediumTitle: "medium",
+    effortLowTitle: "low (最速)",
+    editGateTitle: "編集ゲート — TUIではShift+Tabで切替",
+    editReviewTitle: "review — 編集と未許可シェルの両方が最初に確認",
+    editAutoTitle: "auto — 編集は自動適用、シェルは確認あり",
+    editYoloTitle: "yolo — 編集とシェルの両方が自動実行、許可リストバイパス",
+    railSession: "セッション",
+    railTurns: "ターン",
+    railPromptTok: "プロンプトtok",
+    railCost: "コスト",
+    railCacheHit: "キャッシュヒット",
+    railToolBudget: "ツール予算",
+    railSpend: "消費",
+    railActivePlan: "アクティブプラン",
+    railProgress: "進捗",
+    statusModel: "モデル",
+    statusCtx: "ctx",
+    statusCache: "キャッシュ",
+    statusTurn: "ターン",
+    statusSession: "セッション",
+    statusBalance: "残高",
+    statusTurns: "{count} ターン",
+    waitingStats: "· · ·  ライブ統計待ち",
+    inflightPhase: "{phase}",
+    inflightRunning: "実行中",
+    inflightThinking: "思考中",
+    inflightStreaming: "ストリーミング中",
+    inflightWaiting: "待機中",
+    inflightReasoning: "推論 {count} ch",
+    inflightOut: "出力 {count} ch",
+    abortBtn: "中断 (Esc)",
+    confirmBtn: "適用 (y)",
+    rejectBtn: "拒否 (n)",
+    applyRestBtn: "残りを適用 (a)",
+    flipAutoBtn: "AUTOに切替 (A)",
+  },
+};

dashboard/src/i18n/ru.ts

@@ -0,0 +1,5 @@
+import { en } from "./en";
+
+export const ru: typeof en = {
+  ...en,
+};

dashboard/src/i18n/zh-CN.ts

@@ -23,6 +23,111 @@ export const zhCN = {
     themeToggle: "切换主题",
     themeLight: "浅色",
     themeDark: "深色",
+    skill: {
+      scope: {
+        builtin: "内置",
+        global: "全局",
+        project: "项目",
+      },
+      runAs: {
+        subagent: "子代理",
+        inline: "内联",
+      },
+      generic: "技能",
+    },
+    exportReasoningSummary: "推理摘要",
+    exportToolLabel: "工具调用",
+    exportUserLabel: "用户消息",
+    empty: {
+      currentWorkspace: "当前工作区",
+      selectWorkspace: "选择一个工作区开始",
+      suggestion0: "开始新对话",
+      suggestion1: "打开设置",
+      suggestion2: "查看概览",
+      suggestion3: "浏览会话",
+      welcome: "欢迎使用 Reasonix",
+    },
+    errorLabel: "错误",
+    connecting: "连接中…",
+    session: {
+      format: "会话",
+      new: "新建会话",
+    },
+    setup: {
+      choose: "选择工作区",
+      description: "选择一个工作区开始工作",
+      notSelected: "未选择工作区",
+      saveAndStart: "保存并开始",
+      welcome: "欢迎",
+      workspace: "工作区",
+    },
+    tab: {
+      newTab: "+ 新建标签",
+      newTabTitle: "打开新标签",
+    },
+    titlebar: {
+      clearChat: "清除对话",
+      close: "关闭",
+      commandPalette: "命令面板",
+      contextPanel: "上下文面板",
+      copyMd: "复制为 Markdown",
+      exportMd: "导出为 Markdown",
+      maximize: "最大化",
+      minimize: "最小化",
+      more: "更多",
+      restore: "还原",
+      settings: "设置",
+      sidebar: "侧边栏",
+      windowControls: "窗口控制",
+    },
+    toast: {
+      cleared: "对话已清除",
+      copied: "已复制到剪贴板",
+      copiedMd: "已复制为 Markdown",
+      emptySession: "无消息可导出",
+      exportDialogTitle: "导出对话",
+      exportedMd: "已导出为 Markdown",
+      exportFailed: "导出失败",
+      langSwitched: "语言已切换",
+      modelSwitched: "模型 → {model}",
+      effortSwitched: "强度 → {effort}",
+      modeSwitched: "模式已切换",
+      newSession: "新会话已创建",
+    },
+    yolo: {
+      toast: "YOLO 模式已启用",
+    },
+    cmd: {
+      abort: "中止",
+      btw: "顺便说一下",
+      clearChat: "清除对话",
+      compact: "紧凑",
+      copyLast: "复制上条",
+      exportMd: "导出为 Markdown",
+      feedback: "反馈",
+      help: "帮助",
+      newSession: "新建会话",
+      retry: "重试",
+      switchModel: "切换模型",
+      toggleCurrency: "切换货币",
+      toggleLang: "切换语言",
+      toggleTheme: "切换主题",
+    },
+    header: {
+      abort: "中止",
+      clickToSelect: "点击选择",
+      copy: "复制",
+      copyMd: "复制为 Markdown",
+      export: "导出",
+      exportMd: "导出为 Markdown",
+      newChat: "新建对话",
+      noWorkspace: "无工作区",
+      running: "运行中…",
+    },
+    jumpToBottom: "跳到底部",
+    langEN: "English",
+    langZH: "中文",
+    splashSubtitle: "AI 驱动的编程助手",
   },
   changes: {
     chatPlaceholder: "询问代码问题…",
@@ -56,6 +161,8 @@ export const zhCN = {
     commentLine: "第",
     commentEdit: "编辑",
     commentDelete: "删除",
+    diffSourceGit: "Git 变更",
+    diffSourceSession: "上一轮变更",
     diffSourceCheckpoint: "检查点",
     checkpointEmpty: "暂无检查点",
     restoreBtn: "恢复",
@@ -66,8 +173,6 @@ export const zhCN = {
     createPlaceholder: "检查点名称…",
     backToList: "返回列表",
     reviewEmpty: "暂无可审查的更改",
-    diffSourceGit: "Git 变更",
-    diffSourceSession: "上一轮变更",
     diffStyleUnified: "统一视图",
     diffStyleSplit: "分栏视图",
     expandAll: "全部展开",
@@ -101,29 +206,51 @@ export const zhCN = {
     saved: "已保存：{fields}",
     sectionApi: "DeepSeek API",
     apiKey: "API 密钥",
+    apiKeyNotSet: "未设置",
+    apiKeySave: "保存密钥",
+    apiKeySet: "已设置",
+    apiSection: "API 配置",
     notSet: "（未设置）",
     replace: "替换",
     pasteKey: "粘贴新的 sk-… 令牌",
     saveKey: "保存密钥",
     baseUrl: "基础 URL",
     baseUrlPlaceholder: "https://api.deepseek.com（默认）",
+    baseUrlHint: "API 请求的基础 URL",
     sectionDefaults: "默认设置",
-    preset: "预设",
-    presetAuto: "auto — flash 基线，困难时自动升级为 pro",
-    presetFlash: "flash — 始终使用 flash，不自动升级",
-    presetPro: "pro — 始终使用 pro",
+    effortSection: "推理强度",
+    modelCustom: "自定义模型 ID",
+    modelCustomHint: "任何 OpenAI 兼容的 ID（vLLM、Ollama、Together …）。",
+    modelCustomActive: "当前运行自定义 ID：{model}",
     appliesNextTurn: "下一轮生效",
     effort: "推理强度",
-    effortMax: "max（默认 — 最佳质量）",
-    effortHigh: "high（更便宜 / 更快）",
+    effortMax: "max（DeepSeek 扩展 — 标准 OpenAI / vLLM 会拒绝）",
+    effortHigh: "high（安全默认 — vLLM / Azure 兼容）",
+    effortMedium: "medium",
+    effortLow: "low（最快）",
     webSearch: "网页搜索",
     webSearchNote: "web_fetch + web_search 工具",
-    sectionCompute: "计算",
-    proNext: "/pro 单轮",
-    proArm: "为下一轮装备",
-    proArmed: "已装备 — 下一轮后自动解除",
-    proNextNote: "下一轮使用 deepseek-v4-pro，之后自动解除",
+    webSearchEngine: "搜索引擎",
+    webSearchEngineBing: "bing — 默认，国内裸 IP 直连，无需代理",
+    webSearchEngineBingIntl: "bing-intl — 国际版索引，走 www.bing.com",
+    webSearchEngineSearxng: "searxng — 自托管（端点用 /se searxng <url> 配置）",
+    webSearchEngineMetaso: "metaso — 每日 100 次免费（国内友好，metaso.cn 可领免费 key）",
+    webSearchEngineBaidu: "baidu — 百度 AI Search（设置 BAIDU_API_KEY 或 QIANFAN_API_KEY）",
+    webSearchEngineTavily: "tavily — 每月 1000 次免费（设置 TAVILY_API_KEY）",
+    webSearchEnginePerplexity: "perplexity — AI 直接回答（设置 PERPLEXITY_API_KEY）",
+    webSearchEngineExa: "exa — AI 直接回答，每月 1000 次免费（设置 EXA_API_KEY）",
+    webSearchEngineBrave: "brave — 独立索引，每月 2000 次免费（设置 BRAVE_SEARCH_API_KEY）",
+    webSearchEngineOllama: "ollama — Ollama 云端网页搜索（设置 OLLAMA_API_KEY）",
+    webSearchEngineNote: "下一次 web_search 调用生效",
+    webSearchApiKeySignup: "（获取 key）",
+    webSearchApiKeyClear: "清除",
+    webSearchApiKey: {
+      baidu: "百度 API key",
+    },
     sectionBudget: "预算",
+    budget: "预算",
+    budgetHint: "设置支出限额",
+    budgetPlaceholder: "输入预算金额",
     budgetOf: "/",
     budgetSetCap: "设置上限",
     budgetCustom: "自定义",
@@ -149,21 +276,153 @@ export const zhCN = {
     skillPaths: "技能路径",
     skillPathsPlaceholder: "/path/to/skills-a, /path/to/skills-b",
     skillPathsNote: "英文逗号分隔 · 下次 /new 或新会话生效",
+    skillsEmpty: "无已加载技能",
+    skillsLoaded: "技能已加载",
+    subagentModelFlash: "flash",
+    subagentModelPro: "pro",
+    subagentModelHint: "技能派生独立 subagent 时使用的模型",
     sectionRuntime: "运行时",
     activeModel: "当前模型",
+    model: "模型",
+    modelFlashDesc: "Flash — 始终 flash",
+    modelProDesc: "Pro — 始终 pro",
     modelPricingLine: "${hit} 命中 · ${miss} 未命中 · ${out} 输出  / 100 万 tok",
     editMode: "编辑模式",
     editModeNote: "在对话标签页头部切换",
+    editModeHint: "配置编辑模式",
+    showSystemEvents: "系统事件",
+    showSystemEventsHint: "在对话流中以细线显示压缩 / 中断 / 限速等系统事件",
+    shown: "显示",
+    hidden: "隐藏",
+    appMode: "应用模式",
     sectionLanguage: "语言",
     language: "语言",
+    languageHint: "切换语言",
     langEn: "English",
     langZhCn: "简体中文",
+    appearanceSection: "外观",
+    behaviorSection: "行为",
+    ruleAutoApprovalHint: "配置自动审批规则",
+    ruleAutoApprovalSection: "自动审批规则",
+    theme: "主题",
+    themeDark: "深色",
+    themeHint: "在浅色和深色主题之间切换",
+    themeLight: "浅色",
+    themeStyle: "主题风格",
+    themeStyleHint: "选择主题风格",
+    themeStyleGraphite: "石墨",
+    themeStyleGraphiteDesc: "冷色深色调，适合长时间使用。",
+    themeStyleEmber: "余烬",
+    themeStyleEmberDesc: "暖黑深色调，强化 Reasonix 橙色品牌感。",
+    themeStyleAurora: "极光",
+    themeStyleAuroraDesc: "青绿色深色调，低光环境更柔和。",
+    themeStyleSandstone: "砂岩",
+    themeStyleSandstoneDesc: "暖色浅色调，明亮环境更舒适。",
+    themeStylePorcelain: "瓷白",
+    themeStylePorcelainDesc: "高对比度浅色，简洁清爽。",
+    themeStyleLinen: "亚麻",
+    themeStyleLinenDesc: "偏纸张质感的温暖浅色调。",
+    themeStyleGlacier: "冰川",
+    themeStyleGlacierDesc: "冷白浅色调，蓝色强调更清爽。",
+    themeStyleMidnight: "午夜",
+    themeStyleMidnightDesc: "深色配冷色高光，更深邃。",
+    pageGeneralLabel: "通用",
+    pageGeneralDesc: "主题、字体、语言与工作目录。",
+    pageModelsLabel: "模型",
+    pageModelsDesc: "默认模型与推理强度。",
+    pageMcpLabel: "MCP 服务器",
+    pageMcpDesc: "接入外部工具服务器。",
+    pageSkillsLabel: "技能",
+    pageSkillsDesc: "可通过 /skill 调用的自定义技能。",
+    pageMemoryLabel: "记忆",
+    pageMemoryDesc: "跨会话保留的长期笔记。",
+    pageRulesLabel: "规则",
+    pageRulesDesc: "Shell 与路径访问的自动审批规则。",
+    pageBillingLabel: "账单",
+    pageBillingDesc: "API key、余额与会话预算。",
+    pageShortcutsLabel: "快捷键",
+    pageShortcutsDesc: "键盘快捷键参考。",
+    fontFamily: "字体",
+    fontFamilyHint: "选择字体",
+    fontFamilySans: "无衬线",
+    fontFamilySerif: "衬线",
+    fontFamilySystem: "系统",
+    fontScale: "字体大小",
+    fontScaleHint: "调整字体大小",
+    fontScaleLarge: "大",
+    fontScaleMedium: "中",
+    fontScaleSmall: "小",
+    currentWorkspace: "当前工作区",
+    defaultModelCurrent: "当前模型",
+    editor: "编辑器",
+    editorHint: "配置编辑器偏好",
+    maxOutput: "最大输出",
+    reasoningEffort: "推理强度",
+    reasoningEffortHint: "调整推理深度",
+    sessionCost: "会话成本",
+    balanceAvailable: "可用",
+    balanceLabel: "余额",
+    balanceLow: "余额不足",
+    cacheHitRate: "缓存命中率",
+    ctxWindow: "上下文窗口",
+    notSelected: "未选择",
+    parseError: "解析错误",
+    workspaceChange: "更改",
+    workspaceSection: "工作区",
+    mcpAdd: "添加",
+    mcpAddSection: "添加 MCP 服务器",
+    mcpBridged: "已桥接",
+    mcpConfigured: "已配置",
+    mcpEmpty: "无 MCP 服务器",
+    mcpNotBridged: "未桥接",
+    mcpRemove: "移除",
+    mcpSpecFormat: "JSON 格式",
+    mcpSpecLabel: "服务器规格",
+    memoryDesc: "配置记忆设置",
+    memorySection: "记忆",
+    shortcutAbort: "中止",
+    shortcutCloseTab: "关闭标签",
+    shortcutCommandPalette: "命令面板",
+    shortcutFocusComposer: "聚焦编辑器",
+    shortcutNewChat: "新建对话",
+    shortcutNewTab: "新建标签",
+    shortcutSettings: "设置",
+    shortcutSwitchTab: "切换标签",
+    qqAccessAllowlist: "允许列表",
+    qqAccessOpen: "开放",
+    qqAccessOwner: "所有者",
+    qqAccessOwnerWithAllowlist: "所有者 + 允许列表",
+    qqAccessRuntime: "运行时",
+    qqAppId: "App ID",
+    qqApplyAction: "应用",
+    qqApplyLabel: "应用",
+    qqAppSecret: "App Secret",
+    qqBack: "返回",
+    qqConfigure: "配置",
+    qqConfigureHint: "设置 QQ 集成",
+    qqConfigureTitle: "QQ 配置",
+    qqConnected: "已连接",
+    qqConnecting: "连接中…",
+    qqDisconnected: "已断开",
+    qqEnvironment: "环境",
+    qqFailed: "失败",
+    qqProduction: "生产环境",
+    qqSandbox: "沙箱环境",
+    qqSave: "保存",
+    qqSaveAndConnect: "保存并连接",
+    qqSection: "QQ 集成",
+    qqSummaryAppId: "App ID",
+    qqSummaryDetail: "详情",
+    qqSummaryMissing: "未配置",
+    qqTitle: "QQ 机器人",
   },
   chat: {
     modeMirror: "TUI 镜像",
     modeView: "会话视图",
     placeholder: "输入提示词 — Enter 发送，Shift+Enter 换行 · / @ 打开选择器",
     placeholderBusy: "请等待当前轮次完成…",
+    placeholderSteerBusy: "输入消息以引导当前任务 — 忙碌时不支持命令和选择器",
+    steerHint: "消息将作为附加指示引导当前轮次",
     send: "发送",
     new: "新建",
     clear: "清除",
@@ -179,18 +438,16 @@ export const zhCN = {
     eventStreamError: "事件流中断 — 正在重连…",
     semanticBanner: "此项目未启用语义搜索。",
     semanticBannerDesc:
-      "构建一次索引，模型即可按含义查找代码（“哪里处理认证失败？”），而不仅依赖精确字符串的 grep。",
+      "构建一次索引，模型即可按含义查找代码（\u201C哪里处理认证失败？\u201D），而不仅依赖精确字符串的 grep。",
     semanticBannerBtn: "构建 →",
     semanticBannerDismiss: "关闭（不再显示）",
     slashCommands: "斜杠命令",
     projectFiles: "项目文件",
     effortTitle: "reasoning_effort — 下一轮生效",
-    effortMaxTitle: "max（默认 — 最佳质量）",
-    effortHighTitle: "high（更便宜 / 更快）",
-    presetTitle: "预设 — 模型承诺",
-    presetAutoTitle: "auto — flash 基线；困难轮次自动升级为 pro（NEEDS_PRO / 失败阈值）",
-    presetFlashTitle: "flash — 始终 flash；不自动升级。/pro 仍可用于一次性手动提升",
-    presetProTitle: "pro — 始终 pro；约 3 倍 flash 成本（5/31 折扣）。锁定困难的架构工作。",
+    effortMaxTitle: "max（DeepSeek 扩展）",
+    effortHighTitle: "high（安全默认 — vLLM / Azure 兼容）",
+    effortMediumTitle: "medium",
+    effortLowTitle: "low（最快）",
     editGateTitle: "编辑门控 — Shift+Tab 在 TUI 中循环",
     editReviewTitle: "review — 编辑和非允许列表的 shell 命令都会先询问",
     editAutoTitle: "auto — 编辑自动应用，shell 仍会询问",
@@ -300,6 +557,16 @@ export const zhCN = {
     loadingTranscript: "加载转录稿…",
     emptyTranscript: "空的转录稿。",
     messages: "{count} 条消息",
+    newBtn: "新建会话",
+    newHint: "归档当前会话并开启新会话",
+    switchBtn: "切换到此会话",
+    deleteBtn: "删除",
+    deleteConfirm: "确定删除会话「{name}」？转录文件将被移除，无法撤销。",
+    cantDeleteActive: "请先切换到其他会话，再删除当前会话。",
+    attachRequired:
+      "实时会话操作需要已连接的 CLI 会话。请通过 reasonix chat 启动，或在 TUI 会话中打开仪表盘。",
+    activeChip: "当前",
+    activePill: "当前",
   },
   tools: {
     loading: "加载工具…",
@@ -407,6 +674,10 @@ export const zhCN = {
     whyUnbridgedDesc:
       "此规格存在于您的 config.json 中，但未桥接到实时会话。MCP 服务器在 reasonix code 启动时连接；仪表盘本身无法生成子进程。",
     whyUnbridgedHint: "激活方法：重启 reasonix code，然后刷新此仪表盘。",
+    bridgeFailed: "桥接失败",
+    bridgeFailedTitle: "桥接失败 · 在配置中",
+    bridgeFailedHint:
+      "已尝试桥接但失败。常见原因：URL 错误、需要鉴权、上游 404 / 5xx、本地命令缺失。修复后重启 reasonix code 重试。",
     pickHint: "选择左侧的 MCP 服务器以检查工具 / 资源 / 提示。",
     toolsTitle: "工具 · {count}",
     resourcesTitle: "资源 · {count}",
@@ -570,7 +841,7 @@ export const zhCN = {
     builtWith: "构建来源",
     currentTarget: "当前目标",
     incompatibleHint:
-      "磁盘上的这个索引是为不同的 provider 或 model 构建的。运行“完全重建”即可替换。",
+      "磁盘上的这个索引是为不同的 provider 或 model 构建的。运行\u201C完全重建\u201D即可替换。",
     runIndexHint: "运行索引以启用 semantic_search。",
     reIndex: "重建索引",
     build: "构建",
@@ -587,6 +858,7 @@ export const zhCN = {
     customRequestBodyMustBeObject: "自定义请求体必须是 JSON 对象。",
     saveBeforeIndex: "请先保存语义设置，再启动索引。",
     extraBody: "扩展请求体",
+    batchSize: "批次大小",
     keepExistingKey: "留空则保留现有 Key",
     remoteProvider: "远程向量服务",
     remoteProviderDesc:
@@ -652,6 +924,12 @@ export const zhCN = {
     shellBgTitle: "后台进程",
     shellSubtitle: "模型想要运行一条 Shell 命令",
     shellBgSubtitle: "长时间运行 — 批准后继续运行",
+    pathTitle: "沙箱外文件访问",
+    pathSubtitle: "{intent} · 通过 {tool}",
+    pathRead: "读取",
+    pathWrite: "写入",
+    pathSandboxLabel: "沙箱",
+    pathAllowPrefixLabel: "允许前缀",
     runOnce: "运行一次",
     alwaysAllow: '始终允许 "{prefix}"',
     deny: "拒绝",
@@ -715,4 +993,326 @@ export const zhCN = {
     hoursAgo: "{n} 小时前",
     daysAgo: "{n} 天前",
   },
+  cards: {
+    applied: "已应用",
+    cacheHit: "缓存命中",
+    checkpointRewind: "检查点回退",
+    cost: "费用",
+    diffApply: "应用",
+    diffApplyChanges: "应用更改",
+    diffAwaiting: "待审阅",
+    diffDiscard: "丢弃",
+    done: "完成",
+    elapsed: "耗时",
+    error: "错误",
+    errorName: "错误",
+    failed: "失败",
+    hits: "命中",
+    memoryCountSuffix: "条记忆",
+    memoryName: "记忆",
+    output: "输出",
+    planDefaultTitle: "计划",
+    prompt: "提示词",
+    compactionMeta: "{chars} 字符",
+    compactionName: "已压缩历史",
+    reasoningComplete: "推理完成",
+    reasoningName: "推理",
+    result: "结果",
+    running: "运行中",
+    searchName: "搜索",
+    shellAlwaysAllow: "始终允许",
+    shellAwaiting: "待审批",
+    shellExecuteHint: "执行此命令？",
+    shellReject: "拒绝",
+    shellRun: "运行",
+    shellRunning: "运行中",
+    streaming: "输出中",
+    subagentDone: "子代理完成",
+    subagentDoneProgress: "子代理完成 ({pct}%)",
+    subagentFailed: "子代理失败",
+    subagentRunning: "子代理运行中",
+  },
+  planBadge: {
+    blocked: "已阻塞",
+    done: "完成",
+    failed: "失败",
+    pending: "待处理",
+    running: "运行中",
+  },
+  composer: {
+    atHeader: "提及文件",
+    close: "关闭",
+    commandPalette: "命令面板",
+    commands: "命令",
+    commandsLabel: "命令",
+    confirm: "确认",
+    imageFilterName: "图片",
+    insertFile: "插入文件",
+    insertImage: "插入图片",
+    interrupt: "中断",
+    mentionFiles: "提及文件",
+    mentionLabel: "提及",
+    newline: "换行",
+    noMatches: "无匹配",
+    placeholder: "输入提示词…",
+    queue: "队列",
+    queueCount: "{count} 个排队",
+    select: "选择",
+    send: "发送",
+    slashHeader: "斜杠命令",
+    switchModel: "切换模型",
+    switchEffort: "切换推理强度",
+    workspaceRoot: "工作区根目录",
+  },
+  contextPanel: {
+    allow: "允许",
+    ask: "询问",
+    autoApproveTitle: "自动审批",
+    cacheKey: "缓存",
+    contextTokens: "上下文 tokens",
+    fileInContext: "在上下文中",
+    fileModified: "已修改",
+    filesCount: "{count} 个文件",
+    filesTab: "文件",
+    filesTitle: "文件",
+    freeKey: "空闲",
+    itemCount: "{count} 个项目",
+    mcpConfigured: "已配置",
+    mcpConnecting: "连接中…",
+    mcpDisabled: "已禁用",
+    mcpEmpty: "无 MCP 服务器",
+    mcpFailed: "失败",
+    mcpReady: "就绪",
+    mcpReadyAll: "全部就绪",
+    mcpReadySome: "部分就绪",
+    mcpTitle: "MCP",
+    mcpTools: "工具",
+    memoryTab: "记忆",
+    memoryTitle: "记忆",
+    noFilesMsg: "上下文中无文件",
+    noMemoriesMsg: "无记忆",
+    reservedKey: "保留",
+    ruleReadOnly: "只读",
+    ruleReview: "审阅",
+    ruleShellAllowlist: "Shell 允许列表",
+    rulesTab: "规则",
+    ruleWritesAsk: "写入需询问",
+    ruleYolo: "YOLO",
+    scopeGlobal: "全局",
+    scopeProject: "项目",
+    toolsTab: "工具",
+    usedKey: "已用",
+  },
+  dragDrop: {
+    overlay: "拖放文件到此处",
+  },
+  extraCards: {
+    approve: "批准",
+    balance: "余额",
+    cache: "缓存",
+    cacheHit: "缓存命中",
+    contextWindow: "上下文窗口",
+    doctorTitle: "诊断",
+    output: "输出",
+    prompt: "提示词",
+    reasoning: "推理",
+    reject: "拒绝",
+    sessionCost: "会话成本",
+    sessionUsage: "会话用量",
+    topToolsUsage: "热门工具",
+    unknownKind: "未知",
+    memoryUser: "用户",
+    memoryFeedback: "反馈",
+    memoryProject: "项目",
+    memoryReference: "参考",
+  },
+  jobs: {
+    empty: "无后台任务",
+    exited: "已退出",
+    kbClose: "关闭",
+    kbToggle: "切换",
+    running: "运行中",
+    stop: "停止",
+    stopAll: "全部停止",
+    stopAllTip: "停止所有任务",
+    stopOne: "停止",
+    title: "后台任务",
+  },
+  live: {
+    deliveredWaiting: "等待下一条消息",
+    reasoning: "推理",
+    running: "运行中",
+    secondsAgo: "{n} 秒前",
+    you: "你",
+  },
+  markdown: {
+    copied: "已复制！",
+    copy: "复制",
+    externalLinkTitle: "在新标签中打开",
+    filePillTitle: "打开文件",
+    localLinkTitle: "打开链接",
+  },
+  palette: {
+    abort: "中止",
+    abortHint: "中止当前请求",
+    about: "关于",
+    clearChat: "清除对话",
+    clearChatHint: "清除对话",
+    closeTab: "关闭标签",
+    closeTabHint: "关闭当前标签",
+    copyConv: "复制对话",
+    copyConvHint: "复制对话为 Markdown",
+    copyLast: "复制上条回复",
+    copyLastHint: "复制上条助手消息",
+    countSuffix: "个项目",
+    empty: "无匹配命令",
+    exportMd: "导出为 Markdown",
+    exportMdHint: "导出对话为 Markdown 文件",
+    focusComposer: "聚焦编辑器",
+    footClose: "关闭",
+    footMove: "移动",
+    footRun: "运行",
+    groupAction: "操作",
+    groupNav: "导航",
+    groupSettings: "设置",
+    groupWorkspace: "工作区",
+    newChat: "新建对话",
+    newChatHint: "开始新对话",
+    newTab: "新建标签",
+    newTabHint: "打开新标签",
+    pickWorkspace: "切换工作区",
+    pickWorkspaceHint: "更改工作区",
+    searchPlaceholder: "搜索命令…",
+    settings: "设置",
+    settingsHint: "打开设置",
+  },
+  panel: {
+    renderError: "面板崩溃",
+  },
+  sidebarPanel: {
+    approvalRules: "审批规则",
+    cancel: "取消",
+    commandPalette: "命令面板",
+    daysAgo: "{n} 天前",
+    delete: "删除",
+    deleteSession: "删除会话",
+    hoursAgo: "{n} 小时前",
+    justNow: "刚刚",
+    loading: "加载中…",
+    messageCount: "{count} 条消息",
+    minutesAgo: "{n} 分钟前",
+    newChat: "新建对话",
+    noMatches: "无匹配",
+    noSessions: "无会话",
+    recent: "最近",
+    searchSessions: "搜索会话…",
+    sessionTitle: "会话",
+    settings: "设置",
+    weeksAgo: "{n} 周前",
+  },
+  statusbar: {
+    balance: "余额",
+    busy: "忙碌",
+    cache: "缓存",
+    cacheHit: "缓存命中",
+    jobs: "任务",
+    jobsTip: "后台任务",
+    offline: "离线",
+    online: "在线",
+    switchCurrency: "切换货币",
+    switchTheme: "切换主题",
+    switchWorkspace: "切换工作区",
+    themeDark: "深色",
+    themeLight: "浅色",
+    themeStyleGraphite: "石墨",
+    themeStyleEmber: "余烬",
+    themeStyleAurora: "极光",
+    themeStyleSandstone: "砂岩",
+    themeStylePorcelain: "瓷白",
+    themeStyleLinen: "亚麻",
+    themeStyleGlacier: "冰川",
+    themeStyleMidnight: "午夜",
+    thisTurn: "本轮",
+    tokens: "Tokens",
+  },
+  thread: {
+    activePlan: "活跃计划",
+    allowRead: "允许读取",
+    allowWrite: "允许写入",
+    alwaysAllow: "始终允许",
+    alwaysAllowPrefix: "始终允许 {prefix}",
+    approve: "批准",
+    approveRewrite: "批准重写",
+    cancel: "取消",
+    checkpointKind: "检查点",
+    checkpointSub: "保存当前状态",
+    checkpointTitle: "创建检查点",
+    collapse: "折叠",
+    continue: "继续",
+    copyMessage: "复制消息",
+    copyResponse: "复制回复",
+    execute: "执行",
+    keepOriginal: "保留原始",
+    keepSteps: "保留步骤",
+    optionCount: "{count} 个选项",
+    pathAccessKind: "路径访问",
+    planConfirmationKind: "计划审批",
+    planRevisionKind: "计划修订",
+    planRunning: "计划进行中",
+    planStepCount: "步骤 {done}/{total}",
+    readPathOutsideSandbox: "沙箱外读取路径",
+    refine: "优化",
+    reject: "拒绝",
+    revise: "修订",
+    revisionMeta: "修订",
+    rewritePlan: "重写计划",
+    risk: "风险评估",
+    riskMedium: "中等风险",
+    runBackgroundCommand: "后台运行",
+    runCommand: "运行命令",
+    shellConfirmationKind: "Shell 确认",
+    startPlan: "启动计划",
+    stop: "停止",
+    subagent: "子代理",
+    userChoiceKind: "用户选择",
+    writePathOutsideSandbox: "沙箱外写入路径",
+    you: "你",
+  },
+  workdir: {
+    browse: "浏览…",
+    cancel: "取消",
+    empty: "无工作区",
+    emptyDir: "无子目录。",
+    go: "前往",
+    goTip: "跳转到该路径",
+    loading: "加载中…",
+    openHere: "打开此目录",
+    pathPlaceholder: "绝对路径…",
+    promptWeb: "输入要打开的工作区绝对路径：",
+    searchPlaceholder: "搜索工作区…",
+    title: "工作区",
+  },
+  about: {
+    close: "关闭",
+    repo: "仓库",
+    sidebarLabel: "关于",
+    tagline: "AI 驱动的编程助手",
+    version: "版本",
+  },
+  effort: {
+    lowDesc: "最快 — 极少推理",
+    mediumDesc: "平衡",
+    highDesc: "默认 — vLLM / Azure 安全",
+    maxDesc: "DeepSeek 扩展；标准 OpenAI / vLLM 会拒绝",
+  },
+  editMode: {
+    plan: "计划",
+    planHint: "只读模式 · 所有写工具都不会派发",
+    review: "审阅",
+    reviewHint: "编辑和非允许列表的 shell 命令都会先询问",
+    auto: "自动",
+    autoHint: "编辑自动应用，shell 仍会询问",
+    yolo: "YOLO",
+    yoloHint: "编辑和 shell 都自动运行，绕过允许列表",
+  },
 };

dashboard/src/icons.tsx

@@ -0,0 +1,81 @@
+import type { SVGProps } from "react";
+
+type IconProps = SVGProps<SVGSVGElement> & { size?: number };
+
+function Ic({ size = 14, children, ...rest }: IconProps & { children: React.ReactNode }) {
+  return (
+    <svg
+      xmlns="http://www.w3.org/2000/svg"
+      width={size}
+      height={size}
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth="1.8"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+      {...rest}
+    >
+      {children}
+    </svg>
+  );
+}
+
+export const I = {
+  plus: (p: IconProps) => (<Ic {...p}><path d="M12 5v14M5 12h14" /></Ic>),
+  search: (p: IconProps) => (<Ic {...p}><circle cx="11" cy="11" r="7" /><path d="m20 20-3.5-3.5" /></Ic>),
+  send: (p: IconProps) => (<Ic {...p}><path d="M4 12 20 4l-6 16-3-7-7-1Z" /></Ic>),
+  chev: (p: IconProps) => (<Ic {...p}><path d="m6 9 6 6 6-6" /></Ic>),
+  chevR: (p: IconProps) => (<Ic {...p}><path d="m9 6 6 6-6 6" /></Ic>),
+  check: (p: IconProps) => (<Ic {...p}><path d="m5 12 5 5L20 7" /></Ic>),
+  x: (p: IconProps) => (<Ic {...p}><path d="M6 6l12 12M18 6 6 18" /></Ic>),
+  terminal: (p: IconProps) => (<Ic {...p}><rect x="3" y="4" width="18" height="16" rx="2" /><path d="m7 9 3 3-3 3M13 15h4" /></Ic>),
+  brain: (p: IconProps) => (
+    <Ic {...p}>
+      <path d="M9 4a3 3 0 0 0-3 3v0a3 3 0 0 0-2 5 3 3 0 0 0 2 5 3 3 0 0 0 3 3h0a3 3 0 0 0 3-3V4" />
+      <path d="M15 4a3 3 0 0 1 3 3 3 3 0 0 1 2 5 3 3 0 0 1-2 5 3 3 0 0 1-3 3" />
+    </Ic>
+  ),
+  list: (p: IconProps) => (<Ic {...p}><path d="M4 6h2M4 12h2M4 18h2M9 6h11M9 12h11M9 18h11" /></Ic>),
+  diff: (p: IconProps) => (<Ic {...p}><path d="M7 4v11a3 3 0 0 0 3 3h2M17 20V9a3 3 0 0 0-3-3h-2" /><circle cx="7" cy="20" r="2" /><circle cx="17" cy="4" r="2" /></Ic>),
+  globe: (p: IconProps) => (<Ic {...p}><circle cx="12" cy="12" r="9" /><path d="M3 12h18M12 3a14 14 0 0 1 0 18M12 3a14 14 0 0 0 0 18" /></Ic>),
+  link: (p: IconProps) => (<Ic {...p}><path d="M10 14a4 4 0 0 1 0-6l3-3a4 4 0 0 1 6 6l-2 2" /><path d="M14 10a4 4 0 0 1 0 6l-3 3a4 4 0 0 1-6-6l2-2" /></Ic>),
+  wrench: (p: IconProps) => (<Ic {...p}><path d="M14 7a4 4 0 1 0 4 4l3 3-3 3-3-3a4 4 0 0 1-4-4l-3-3-3 3 3 3a4 4 0 0 0 6 0" /></Ic>),
+  bot: (p: IconProps) => (<Ic {...p}><rect x="4" y="7" width="16" height="12" rx="3" /><path d="M12 3v4M8 12h.01M16 12h.01M9 16h6" /></Ic>),
+  archive: (p: IconProps) => (<Ic {...p}><rect x="3" y="3" width="18" height="5" rx="1" /><path d="M5 8v11a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1V8M10 12h4" /></Ic>),
+  bookmark: (p: IconProps) => (<Ic {...p}><path d="M6 3h12v18l-6-4-6 4Z" /></Ic>),
+  warning: (p: IconProps) => (<Ic {...p}><path d="M12 3 2 21h20Z" /><path d="M12 10v5M12 18h.01" /></Ic>),
+  zap: (p: IconProps) => (<Ic {...p}><path d="M13 3 4 14h7l-1 7 9-11h-7Z" /></Ic>),
+  database: (p: IconProps) => (<Ic {...p}><ellipse cx="12" cy="5" rx="8" ry="3" /><path d="M4 5v6c0 1.7 3.6 3 8 3s8-1.3 8-3V5M4 11v6c0 1.7 3.6 3 8 3s8-1.3 8-3v-6" /></Ic>),
+  cpu: (p: IconProps) => (<Ic {...p}><rect x="5" y="5" width="14" height="14" rx="2" /><rect x="9" y="9" width="6" height="6" /><path d="M9 2v3M15 2v3M9 19v3M15 19v3M2 9h3M2 15h3M19 9h3M19 15h3" /></Ic>),
+  coin: (p: IconProps) => (<Ic {...p}><circle cx="12" cy="12" r="9" /><path d="M12 7v10M9 10h4a2 2 0 0 1 0 4H9" /></Ic>),
+  file: (p: IconProps) => (<Ic {...p}><path d="M14 3H6a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V9Z" /><path d="M14 3v6h6" /></Ic>),
+  folder: (p: IconProps) => (<Ic {...p}><path d="M3 7a2 2 0 0 1 2-2h4l2 2h8a2 2 0 0 1 2 2v9a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2Z" /></Ic>),
+  image: (p: IconProps) => (<Ic {...p}><rect x="3" y="4" width="18" height="16" rx="2" /><circle cx="9" cy="10" r="2" /><path d="m3 18 5-5 4 4 3-3 6 6" /></Ic>),
+  paperclip: (p: IconProps) => (<Ic {...p}><path d="M21 12 12 21a5 5 0 0 1-7-7L14 5a3 3 0 0 1 4 4l-9 9a1 1 0 0 1-2-2l8-8" /></Ic>),
+  mic: (p: IconProps) => (<Ic {...p}><rect x="9" y="3" width="6" height="12" rx="3" /><path d="M5 11a7 7 0 0 0 14 0M12 18v3M9 21h6" /></Ic>),
+  sun: (p: IconProps) => (<Ic {...p}><circle cx="12" cy="12" r="4" /><path d="M12 2v2M12 20v2M2 12h2M20 12h2M5 5l1.5 1.5M17.5 17.5 19 19M5 19l1.5-1.5M17.5 6.5 19 5" /></Ic>),
+  moon: (p: IconProps) => (<Ic {...p}><path d="M21 12.8A9 9 0 1 1 11.2 3a7 7 0 0 0 9.8 9.8Z" /></Ic>),
+  panel_l: (p: IconProps) => (<Ic {...p}><rect x="3" y="4" width="18" height="16" rx="2" /><path d="M9 4v16" /></Ic>),
+  panel_r: (p: IconProps) => (<Ic {...p}><rect x="3" y="4" width="18" height="16" rx="2" /><path d="M15 4v16" /></Ic>),
+  cog: (p: IconProps) => (<Ic {...p}><path d="M12 3.6 19.2 7.8v8.4L12 20.4 4.8 16.2V7.8Z" /><circle cx="12" cy="12" r="3.7" /></Ic>),
+  stop: (p: IconProps) => (<Ic {...p}><rect x="6" y="6" width="12" height="12" rx="2" /></Ic>),
+  play: (p: IconProps) => (<Ic {...p}><path d="M7 5v14l12-7Z" /></Ic>),
+  more: (p: IconProps) => (<Ic {...p}><circle cx="6" cy="12" r="1.6" fill="currentColor" /><circle cx="12" cy="12" r="1.6" fill="currentColor" /><circle cx="18" cy="12" r="1.6" fill="currentColor" /></Ic>),
+  pin: (p: IconProps) => (<Ic {...p}><path d="M15 3 9 9l-4 1 9 9 1-4 6-6ZM4 20l5-5" /></Ic>),
+  rotate: (p: IconProps) => (<Ic {...p}><path d="M3 12a9 9 0 1 0 3-6.7L3 8" /><path d="M3 3v5h5" /></Ic>),
+  branch: (p: IconProps) => (<Ic {...p}><circle cx="6" cy="4" r="2" /><circle cx="6" cy="20" r="2" /><circle cx="18" cy="8" r="2" /><path d="M6 6v12M6 14a6 6 0 0 0 6-6h4" /></Ic>),
+  at: (p: IconProps) => (<Ic {...p}><circle cx="12" cy="12" r="4" /><path d="M16 8v6a3 3 0 0 0 5-2 9 9 0 1 0-4 7" /></Ic>),
+  slash: (p: IconProps) => (<Ic {...p}><path d="M16 4 8 20" /></Ic>),
+  layers: (p: IconProps) => (<Ic {...p}><path d="m12 3 9 5-9 5-9-5Z" /><path d="m3 13 9 5 9-5M3 18l9 5 9-5" /></Ic>),
+  download: (p: IconProps) => (<Ic {...p}><path d="M12 4v12M6 12l6 6 6-6M4 20h16" /></Ic>),
+  upload: (p: IconProps) => (<Ic {...p}><path d="M12 20V8M6 12l6-6 6 6M4 4h16" /></Ic>),
+  history: (p: IconProps) => (<Ic {...p}><path d="M3 12a9 9 0 1 0 3-6.7L3 8M12 7v5l3 2" /></Ic>),
+  shield: (p: IconProps) => (<Ic {...p}><path d="M12 3 4 6v6c0 5 3.5 8 8 9 4.5-1 8-4 8-9V6Z" /><path d="m9 12 2 2 4-4" /></Ic>),
+  warn: (p: IconProps) => (<Ic {...p}><path d="M12 3 2 21h20Z" /><path d="M12 10v5M12 18h.01" /></Ic>),
+  help: (p: IconProps) => (<Ic {...p}><circle cx="12" cy="12" r="9" /><path d="M9.5 9a2.5 2.5 0 0 1 5 0c0 1.5-2.5 2-2.5 4M12 17h.01" /></Ic>),
+  refresh: (p: IconProps) => (<Ic {...p}><path d="M3 12a9 9 0 0 1 15-6.7L21 8M21 4v4h-4M21 12a9 9 0 0 1-15 6.7L3 16M3 20v-4h4" /></Ic>),
+  copy: (p: IconProps) => (<Ic {...p}><rect x="8" y="8" width="12" height="12" rx="2" /><path d="M4 16V6a2 2 0 0 1 2-2h10" /></Ic>),
+};
+
+export type IconKey = keyof typeof I;

dashboard/src/lib/api.ts

@@ -1,48 +0,0 @@
-export const TOKEN: string =
-  document.querySelector('meta[name="reasonix-token"]')?.getAttribute("content") ?? "";
-
-export const MODE: "standalone" | "attached" =
-  (document.querySelector('meta[name="reasonix-mode"]')?.getAttribute("content") as
-    | "standalone"
-    | "attached"
-    | null) ?? "standalone";
-
-export interface ApiOptions {
-  method?: string;
-  headers?: Record<string, string>;
-  body?: unknown;
-}
-
-export interface ApiError extends Error {
-  status: number;
-  body: unknown;
-}
-
-export async function api<T = unknown>(path: string, opts: ApiOptions = {}): Promise<T> {
-  const method = opts.method ?? "GET";
-  const url = `/api${path}${path.includes("?") ? "&" : "?"}token=${TOKEN}`;
-  const headers: Record<string, string> = { ...(opts.headers ?? {}) };
-  headers["X-Reasonix-Token"] = TOKEN;
-  if (opts.body !== undefined) headers["Content-Type"] = "application/json";
-  const res = await fetch(url, {
-    method,
-    headers,
-    body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
-  });
-  const text = await res.text();
-  let parsed: unknown = null;
-  try {
-    parsed = text ? JSON.parse(text) : null;
-  } catch {
-    parsed = { error: text };
-  }
-  if (!res.ok) {
-    const errMsg =
-      (parsed as { error?: string } | null)?.error ?? `${res.status} ${res.statusText}`;
-    const err = new Error(errMsg) as ApiError;
-    err.status = res.status;
-    err.body = parsed;
-    throw err;
-  }
-  return parsed as T;
-}

dashboard/src/lib/budget.ts

@@ -1,45 +0,0 @@
-export type BudgetState =
-  | { kind: "off"; spent: number }
-  | { kind: "running"; cap: number; spent: number; pct: number }
-  | { kind: "warn"; cap: number; spent: number; pct: number }
-  | { kind: "exhausted"; cap: number; spent: number; pct: number };
-
-export function deriveBudgetState(
-  cap: number | null | undefined,
-  spent: number | null | undefined,
-): BudgetState {
-  const safeSpent = typeof spent === "number" && spent >= 0 ? spent : 0;
-  if (typeof cap !== "number" || cap <= 0) {
-    return { kind: "off", spent: safeSpent };
-  }
-  const pct = (safeSpent / cap) * 100;
-  if (pct >= 100) return { kind: "exhausted", cap, spent: safeSpent, pct };
-  if (pct >= 80) return { kind: "warn", cap, spent: safeSpent, pct };
-  return { kind: "running", cap, spent: safeSpent, pct };
-}
-
-/** Default quick-cap menu — round dollar amounts users actually pick. */
-export const QUICK_CAPS_USD: ReadonlyArray<number> = [1, 5, 10, 25, 50];
-
-/** 1.5× / 2× / 4× the current cap, snapped to a "nice" round number per bucket. */
-export function bumpSuggestions(currentCap: number): number[] {
-  if (currentCap <= 0) return [];
-  return [niceUp(currentCap * 1.5), niceUp(currentCap * 2), niceUp(currentCap * 4)];
-}
-
-function niceUp(n: number): number {
-  // Subtract a tiny epsilon before ceil so FP noise (0.4 * 1.5 = 0.6000…01)
-  // doesn't bump a value to the next bucket.
-  const eps = 1e-9;
-  if (n < 1) return Math.ceil((n - eps) * 10) / 10;
-  if (n < 10) return Math.ceil((n - eps) * 2) / 2;
-  if (n < 100) return Math.ceil(n - eps);
-  return Math.ceil((n - eps) / 5) * 5;
-}
-
-/** Tone class shared between the cockpit tile and the settings gauge. */
-export function budgetTone(state: BudgetState): "" | "warn" | "err" {
-  if (state.kind === "exhausted") return "err";
-  if (state.kind === "warn") return "warn";
-  return "";
-}

dashboard/src/lib/bus-filter.ts

@@ -1,13 +0,0 @@
-/** Browser extensions (userscripts, ad blockers) inject scripts that throw into our window. Their errors land in the global handlers as if they were ours — see #818. Filter them by origin. */
-const THIRD_PARTY_ORIGIN_PREFIXES = [
-  "chrome-extension://",
-  "moz-extension://",
-  "safari-web-extension://",
-  "safari-extension://",
-  "ms-browser-extension://",
-];
-
-export function isThirdPartyError(error: unknown, filename?: string): boolean {
-  const hay = `${filename ?? ""}\n${(error as { stack?: string } | null)?.stack ?? ""}`;
-  return THIRD_PARTY_ORIGIN_PREFIXES.some((prefix) => hay.includes(prefix));
-}

dashboard/src/lib/bus.ts

@@ -1,68 +0,0 @@
-import htm from "htm";
-import { h } from "preact";
-import { useEffect, useState } from "preact/hooks";
-import { isThirdPartyError } from "./bus-filter.js";
-
-const html = htm.bind(h);
-
-export const appBus = new EventTarget();
-export const toastBus = new EventTarget();
-
-export type ToastKind = "info" | "success" | "warn" | "error";
-
-export function showToast(text: string, kind: ToastKind = "info", ttl = 3000): void {
-  toastBus.dispatchEvent(new CustomEvent("toast", { detail: { text, kind, ttl } }));
-}
-
-export interface ErrorReport {
-  error: unknown;
-  source: string;
-  info?: string;
-  ts: number;
-}
-
-export function reportAppError(error: unknown, source: string, info?: string): void {
-  console.error(`[reasonix dashboard] ${source}:`, error, info);
-  appBus.dispatchEvent(
-    new CustomEvent("error", { detail: { error, source, info, ts: Date.now() } }),
-  );
-}
-
-window.addEventListener("error", (ev) => {
-  if (!ev.error) return;
-  if (isThirdPartyError(ev.error, ev.filename)) return;
-  reportAppError(ev.error, "window", ev.message);
-});
-
-window.addEventListener("unhandledrejection", (ev) => {
-  if (isThirdPartyError(ev.reason)) return;
-  reportAppError(ev.reason, "promise");
-});
-
-interface Toast {
-  id: string;
-  text: string;
-  kind: ToastKind;
-  ttl: number;
-}
-
-export function ToastStack() {
-  const [toasts, setToasts] = useState<Toast[]>([]);
-  useEffect(() => {
-    const onToast = (ev: Event) => {
-      const detail = (ev as CustomEvent).detail as Omit<Toast, "id">;
-      const id = `${Date.now()}-${Math.random()}`;
-      const t: Toast = { id, ...detail };
-      setToasts((prev) => [...prev, t]);
-      setTimeout(() => setToasts((prev) => prev.filter((x) => x.id !== id)), t.ttl);
-    };
-    toastBus.addEventListener("toast", onToast);
-    return () => toastBus.removeEventListener("toast", onToast);
-  }, []);
-  if (toasts.length === 0) return null;
-  return html`
-    <div class="toast-stack">
-      ${toasts.map((t) => html`<div key=${t.id} class="toast ${t.kind}">${t.text}</div>`)}
-    </div>
-  `;
-}

dashboard/src/lib/diff-parser.ts

@@ -1,80 +0,0 @@
-export type HunkLineType = "add" | "del" | "ctx";
-
-export interface HunkLine {
-  type: HunkLineType;
-  content: string;
-  oldLineNum?: number;
-  newLineNum?: number;
-}
-
-export interface Hunk {
-  oldStart: number;
-  oldLines: number;
-  newStart: number;
-  newLines: number;
-  lines: HunkLine[];
-}
-
-/** Parse a unified diff patch string into structured hunk arrays. No external deps. */
-export function parseHunks(patch: string): Hunk[] {
-  if (!patch) return [];
-
-  const hunks: Hunk[] = [];
-  const rawLines = patch.split("\n");
-  let cursor = 0;
-
-  // Skip file headers (--- a/..., +++ b/...)
-  while (cursor < rawLines.length) {
-    const line = rawLines[cursor]!;
-
-    // Start of a hunk: @@ -oldStart[,oldLines] +newStart[,newLines] @@
-    const m = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/.exec(line);
-    if (m) {
-      const oldStart = parseInt(m[1]!, 10);
-      const oldLen = m[2] !== undefined ? parseInt(m[2], 10) : 1;
-      const newStart = parseInt(m[3]!, 10);
-      const newLen = m[4] !== undefined ? parseInt(m[4], 10) : 1;
-
-      const lines: HunkLine[] = [];
-      let oldNum = oldStart;
-      let newNum = newStart;
-
-      cursor++;
-      while (
-        cursor < rawLines.length &&
-        !rawLines[cursor]!.startsWith("@@ ") &&
-        !rawLines[cursor]!.startsWith("diff ") &&
-        !rawLines[cursor]!.startsWith("--- ") &&
-        !rawLines[cursor]!.startsWith("index ")
-      ) {
-        const l = rawLines[cursor]!;
-        if (l.startsWith("\\")) {
-          cursor++;
-          continue;
-        }
-
-        const ch = l[0]!;
-        const content = l.slice(1);
-
-        if (ch === "-") {
-          lines.push({ type: "del", content, oldLineNum: oldNum });
-          oldNum++;
-        } else if (ch === "+") {
-          lines.push({ type: "add", content, newLineNum: newNum });
-          newNum++;
-        } else {
-          lines.push({ type: "ctx", content, oldLineNum: oldNum, newLineNum: newNum });
-          oldNum++;
-          newNum++;
-        }
-        cursor++;
-      }
-
-      hunks.push({ oldStart, oldLines: oldLen, newStart, newLines: newLen, lines });
-    } else {
-      cursor++;
-    }
-  }
-
-  return hunks;
-}

dashboard/src/lib/error-boundary.ts

@@ -1,158 +0,0 @@
-import htm from "htm";
-import { Component, type ComponentChildren, h } from "preact";
-import { useEffect, useState } from "preact/hooks";
-import { t } from "../i18n/index.js";
-import { MODE } from "./api.js";
-import { type ErrorReport, appBus, reportAppError } from "./bus.js";
-
-const html = htm.bind(h);
-
-const REPO_URL = "https://github.com/esengine/reasonix";
-
-function buildIssueBody({ error, source, info }: ErrorReport): string {
-  const ua = typeof navigator === "object" ? navigator.userAgent : "(unknown)";
-  const errMsg = (error as Error)?.message ?? String(error);
-  const stack = (error as Error)?.stack ?? "(no stack)";
-  return [
-    "**What happened**",
-    "(describe what you were doing — typing, switching tabs, clicking a tool path, etc.)",
-    "",
-    "**Error**",
-    "```",
-    `${source}: ${errMsg}`,
-    info ? `info: ${info}` : null,
-    "",
-    stack,
-    "```",
-    "",
-    "**Environment**",
-    `- Reasonix: ${MODE}`,
-    `- Browser: ${ua}`,
-    `- URL: ${location.pathname} (token redacted)`,
-    "",
-    "_Reported from the local dashboard's error overlay._",
-  ]
-    .filter((l): l is string => l !== null)
-    .join("\n");
-}
-
-export function ErrorOverlay() {
-  const [err, setErr] = useState<ErrorReport | null>(null);
-  const [copied, setCopied] = useState(false);
-
-  useEffect(() => {
-    const onError = (ev: Event) => {
-      setErr((ev as CustomEvent).detail as ErrorReport);
-      setCopied(false);
-    };
-    appBus.addEventListener("error", onError);
-    return () => appBus.removeEventListener("error", onError);
-  }, []);
-
-  useEffect(() => {
-    if (!err) return;
-    const onKey = (e: KeyboardEvent) => {
-      if (e.key === "Escape") setErr(null);
-    };
-    window.addEventListener("keydown", onKey);
-    return () => window.removeEventListener("keydown", onKey);
-  }, [err]);
-
-  if (!err) return null;
-  const error = err.error as Error | undefined;
-  const errMsg = error?.message ?? String(error);
-  const stack = error?.stack ?? "(no stack)";
-
-  const issueUrl = `${REPO_URL}/issues/new?title=${encodeURIComponent(`[dashboard] ${errMsg.slice(0, 80)}`)}&body=${encodeURIComponent(buildIssueBody(err))}`;
-
-  const copyDetails = async () => {
-    try {
-      await navigator.clipboard.writeText(buildIssueBody(err));
-      setCopied(true);
-      setTimeout(() => setCopied(false), 2000);
-    } catch {
-      /* clipboard blocked — user can still hit "report on GitHub" */
-    }
-  };
-
-  return html`
-    <div class="error-overlay">
-      <div class="error-overlay-card">
-        <div class="error-overlay-head">
-          <span class="error-overlay-icon">✦</span>
-          <div>
-            <div class="error-overlay-title">${t("error.title")}</div>
-            <div class="error-overlay-subtitle">${err.source} error · ${errMsg}</div>
-          </div>
-        </div>
-
-        <pre class="error-overlay-trace">${stack}</pre>
-
-        ${
-          err.info
-            ? html`<div class="error-overlay-info"><strong>info:</strong> ${err.info}</div>`
-            : null
-        }
-
-        <div class="error-overlay-help">
-          ${t("error.body")}
-        </div>
-
-        <div class="error-overlay-actions">
-          <button class="primary" onClick=${copyDetails}>
-            ${copied ? t("error.copied") : t("error.copyDetails")}
-          </button>
-          <a class="button" href=${issueUrl} target="_blank" rel="noopener noreferrer">
-            ${t("error.reportOnGithub")}
-          </a>
-          <button onClick=${() => setErr(null)} style="margin-left: auto;">${t("error.dismiss")}</button>
-        </div>
-      </div>
-    </div>
-  `;
-}
-
-interface ErrorBoundaryProps {
-  children: ComponentChildren;
-}
-
-interface ErrorBoundaryState {
-  caught: boolean;
-  lastErr: Error | null;
-  attempts: number;
-}
-
-export class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
-  constructor(props: ErrorBoundaryProps) {
-    super(props);
-    this.state = { caught: false, lastErr: null, attempts: 0 };
-  }
-  static override getDerivedStateFromError(error: Error): Partial<ErrorBoundaryState> {
-    return { caught: true, lastErr: error };
-  }
-  override componentDidCatch(error: Error, info: { componentStack?: string }) {
-    reportAppError(error, "render", info?.componentStack ?? "");
-    const attempts = (this.state.attempts ?? 0) + 1;
-    if (attempts >= 3) {
-      this.setState({ attempts });
-      return;
-    }
-    setTimeout(() => this.setState({ caught: false, attempts }), 100);
-  }
-  override render() {
-    if (this.state.caught) {
-      if ((this.state.attempts ?? 0) >= 3) {
-        return html`
-          <div class="boot" style="flex-direction: column; gap: 12px;">
-            <div>${t("error.crashing", { name: "the error overlay has the trace" })}</div>
-            <button onClick=${() => this.setState({ caught: false, attempts: 0 })}>
-              ${t("error.retry")}
-            </button>
-          </div>
-        `;
-      }
-      return html`<div class="boot">${t("error.recovering")}</div>`;
-    }
-    return this.props.children;
-  }
-}

dashboard/src/lib/file-tree.ts

@@ -1,232 +0,0 @@
-import { h } from "preact";
-import { useState, useCallback, useEffect } from "preact/hooks";
-import htm from "htm";
-import { api, MODE } from "./api.js";
-
-const html = htm.bind(h);
-
-export interface TreeNode {
-  name: string;
-  path: string;
-  isDir: boolean;
-  children?: TreeNode[];
-}
-
-export interface OpenFile {
-  path: string;
-  name: string;
-  content: string;
-  language: string;
-}
-
-const EXT_ICONS: Record<string, string> = {
-  ts: "TS", tsx: "TS", js: "JS", jsx: "JS",
-  json: "{}", css: "#", scss: "#", html: "<>",
-  md: "MD", py: "PY", rs: "RS", go: "GO",
-  yaml: "Y", yml: "Y", toml: "T", xml: "<>",
-  svg: "<>", png: "[]", jpg: "[]", ico: "[]",
-  sh: "$", bash: "$", ps1: "$", bat: "$",
-  sql: "DB", graphql: "GQ", proto: "PB",
-  dockerfile: "D", makefile: "MK",
-};
-
-const EXT_LANG: Record<string, string> = {
-  ts: "typescript", tsx: "typescript", js: "javascript", jsx: "javascript",
-  json: "json", css: "css", scss: "scss", html: "html",
-  md: "markdown", py: "python", rs: "rust", go: "go",
-  yaml: "yaml", yml: "yaml", toml: "toml", xml: "xml",
-  sh: "bash", bash: "bash", ps1: "powershell", bat: "batch",
-  sql: "sql", graphql: "graphql", proto: "protobuf",
-  dockerfile: "dockerfile", makefile: "makefile",
-};
-
-export function getFileIcon(name: string): { icon: string; cls: string } {
-  const ext = name.split(".").pop()?.toLowerCase() ?? "";
-  const icon = EXT_ICONS[ext] ?? "·";
-  const cls = ext || "file";
-  return { icon, cls };
-}
-
-export function getLanguage(name: string): string {
-  const ext = name.split(".").pop()?.toLowerCase() ?? "";
-  return EXT_LANG[ext] ?? ext;
-}
-
-function isBinaryExt(name: string): boolean {
-  const ext = name.split(".").pop()?.toLowerCase() ?? "";
-  const binary = new Set(["png", "jpg", "jpeg", "gif", "ico", "svg", "woff", "woff2", "ttf", "eot", "mp4", "webm", "mp3", "wav", "zip", "tar", "gz", "7z", "pdf"]);
-  return binary.has(ext);
-}
-
-interface ProjectTreeResult {
-  tree: TreeNode[];
-}
-
-export function useProjectTree() {
-  const [tree, setTree] = useState<TreeNode[]>([]);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState<string | null>(null);
-
-  useEffect(() => {
-    if (MODE === "standalone") {
-      setLoading(false);
-      setTree(createDemoTree());
-      return;
-    }
-    let cancelled = false;
-    api<ProjectTreeResult>("/project-tree")
-      .then((r) => {
-        if (!cancelled) {
-          setTree(r.tree);
-          setLoading(false);
-        }
-      })
-      .catch((err) => {
-        if (!cancelled) {
-          setError((err as Error).message);
-          setLoading(false);
-          setTree(createDemoTree());
-        }
-      });
-    return () => { cancelled = true; };
-  }, []);
-
-  return { tree, loading, error };
-}
-
-interface FileReadResult {
-  content: string;
-  path: string;
-  size: number;
-}
-
-interface FileLoadingState {
-  [path: string]: boolean;
-}
-
-export function useFileTreeState(initialTree: TreeNode[]) {
-  const [expanded, setExpanded] = useState<Set<string>>(new Set());
-  const [openFiles, setOpenFiles] = useState<OpenFile[]>([]);
-  const [activeFilePath, setActiveFilePath] = useState<string | null>(null);
-  const [loadingFiles, setLoadingFiles] = useState<FileLoadingState>({});
-
-  const toggleExpand = useCallback((path: string) => {
-    setExpanded((prev) => {
-      const next = new Set(prev);
-      if (next.has(path)) next.delete(path);
-      else next.add(path);
-      return next;
-    });
-  }, []);
-
-  const openFile = useCallback(async (node: TreeNode) => {
-    if (node.isDir) {
-      toggleExpand(node.path);
-      return;
-    }
-    if (isBinaryExt(node.name)) return;
-
-    const existing = openFiles.find((f) => f.path === node.path);
-    if (existing) {
-      setActiveFilePath(node.path);
-      return;
-    }
-
-    if (loadingFiles[node.path]) return;
-
-    setLoadingFiles((prev) => ({ ...prev, [node.path]: true }));
-
-    const lang = getLanguage(node.name);
-
-    if (MODE === "standalone") {
-      const mockContent = generateMockContent(node.name, lang);
-      setOpenFiles((prev) => [...prev, { path: node.path, name: node.name, content: mockContent, language: lang }]);
-      setActiveFilePath(node.path);
-      setLoadingFiles((prev) => {
-        const next = { ...prev };
-        delete next[node.path];
-        return next;
-      });
-      return;
-    }
-
-    try {
-      const encodedPath = node.path.split("/").map(encodeURIComponent).join("/");
-      const data = await api<FileReadResult>(`/file/${encodedPath}`);
-      setOpenFiles((prev) => [...prev, { path: node.path, name: node.name, content: data.content, language: lang }]);
-      setActiveFilePath(node.path);
-    } catch (err) {
-      console.error(`[file-tree] failed to load ${node.path}:`, err);
-      setOpenFiles((prev) => [...prev, { path: node.path, name: node.name, content: `// Failed to load file: ${(err as Error).message}\n`, language: lang }]);
-      setActiveFilePath(node.path);
-    } finally {
-      setLoadingFiles((prev) => {
-        const next = { ...prev };
-        delete next[node.path];
-        return next;
-      });
-    }
-  }, [openFiles, toggleExpand, loadingFiles]);
-
-  const closeFile = useCallback((path: string) => {
-    setOpenFiles((prev) => {
-      const next = prev.filter((f) => f.path !== path);
-      if (activeFilePath === path) {
-        const lastFile = next[next.length - 1];
-        setActiveFilePath(lastFile ? lastFile.path : null);
-      }
-      return next;
-    });
-  }, [activeFilePath]);
-
-  const activeFile = openFiles.find((f) => f.path === activeFilePath) ?? null;
-
-  return { expanded, openFiles, activeFilePath, activeFile, toggleExpand, openFile, closeFile, setActiveFilePath, loadingFiles };
-}
-
-function generateMockContent(name: string, lang: string): string {
-  const ext = name.split(".").pop()?.toLowerCase() ?? "";
-  if (ext === "json") return JSON.stringify({ name: "example", version: "1.0.0", dependencies: { react: "^18.0.0" } }, null, 2);
-  if (ext === "md") return "# Example Document\n\nThis is a sample markdown file.\n\n## Section\n\n- Item 1\n- Item 2\n\n```js\nconsole.log(\"hello\");\n```";
-  if (ext === "css") return "/* styles */\n.container {\n  display: flex;\n  padding: 16px;\n  color: var(--fg-1);\n}";
-  if (ext === "html") return "<!doctype html>\n<html>\n<head><title>Example</title></head>\n<body>\n  <h1>Hello</h1>\n</body>\n</html>";
-  if (ext === "py") return "def hello():\n    print('Hello, World!')\n\nif __name__ == '__main__':\n    hello()";
-  if (ext === "yaml" || ext === "yml") return "name: example\nversion: '1.0'\nservices:\n  app:\n    image: node:18\n    ports:\n      - '3000:3000'";
-  return `// ${name}\n// Language: ${lang}\n\nexport function example() {\n  return \"Hello from ${name}\";\n}\n`;
-}
-
-export function createDemoTree(): TreeNode[] {
-  return [
-    {
-      name: "src", path: "src", isDir: true, children: [
-        { name: "index.ts", path: "src/index.ts", isDir: false },
-        { name: "app.tsx", path: "src/app.tsx", isDir: false },
-        { name: "config.ts", path: "src/config.ts", isDir: false },
-        {
-          name: "components", path: "src/components", isDir: true, children: [
-            { name: "Header.tsx", path: "src/components/Header.tsx", isDir: false },
-            { name: "Sidebar.tsx", path: "src/components/Sidebar.tsx", isDir: false },
-            { name: "Button.tsx", path: "src/components/Button.tsx", isDir: false },
-          ]
-        },
-        {
-          name: "lib", path: "src/lib", isDir: true, children: [
-            { name: "api.ts", path: "src/lib/api.ts", isDir: false },
-            { name: "format.ts", path: "src/lib/format.ts", isDir: false },
-          ]
-        },
-      ]
-    },
-    {
-      name: "tests", path: "tests", isDir: true, children: [
-        { name: "app.test.ts", path: "tests/app.test.ts", isDir: false },
-        { name: "utils.test.ts", path: "tests/utils.test.ts", isDir: false },
-      ]
-    },
-    { name: "package.json", path: "package.json", isDir: false },
-    { name: "tsconfig.json", path: "tsconfig.json", isDir: false },
-    { name: "README.md", path: "README.md", isDir: false },
-    { name: "styles.css", path: "styles.css", isDir: false },
-    { name: "index.html", path: "index.html", isDir: false },
-  ];
-}

dashboard/src/lib/format.ts

@@ -1,69 +0,0 @@
-import { t } from "../i18n/index.js";
-
-export function fmtUsd(n: number | null | undefined): string {
-  if (n === null || n === undefined) return "—";
-  if (n === 0) return "$0";
-  return `$${n.toFixed(n < 0.01 ? 6 : 4)}`;
-}
-
-/** Keep in sync with src/cli/ui/theme/tokens.ts USD_TO_CNY. */
-const USD_TO_CNY = 7.2;
-
-/** USD-internal cost rendered in the wallet's display currency. Undefined currency → CNY (matches CLI default). */
-export function fmtCost(
-  usd: number | null | undefined,
-  currency: string | null | undefined,
-  fractionDigits?: number,
-): string {
-  if (usd === null || usd === undefined) return "—";
-  const cur = currency ?? "CNY";
-  const amount = cur === "CNY" ? usd * USD_TO_CNY : usd;
-  if (amount === 0) return cur === "CNY" ? "¥0" : "$0";
-  const sym = cur === "CNY" ? "¥" : cur === "USD" ? "$" : `${cur} `;
-  const digits = fractionDigits ?? (Math.abs(amount) < 0.01 ? 6 : 4);
-  return `${sym}${amount.toFixed(digits)}`;
-}
-
-export function fmtPct(n: number | null | undefined): string {
-  if (n === null || n === undefined) return "—";
-  return `${(n * 100).toFixed(1)}%`;
-}
-
-export function fmtNum(n: number | null | undefined): string {
-  if (n === null || n === undefined) return "—";
-  return n.toLocaleString();
-}
-
-export function fmtBytes(n: number | null | undefined): string {
-  if (n === null || n === undefined) return "—";
-  if (n < 1024) return `${n} B`;
-  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
-  if (n < 1024 * 1024 * 1024) return `${(n / (1024 * 1024)).toFixed(1)} MB`;
-  return `${(n / (1024 * 1024 * 1024)).toFixed(2)} GB`;
-}
-
-export function fmtCompactNum(n: number | null | undefined): string {
-  if (n === null || n === undefined) return "—";
-  if (Math.abs(n) < 1000) return String(n);
-  if (Math.abs(n) < 1_000_000) {
-    const v = n / 1000;
-    return `${v % 1 === 0 ? v.toFixed(0) : v.toFixed(1)}K`;
-  }
-  if (Math.abs(n) < 1_000_000_000) {
-    const v = n / 1_000_000;
-    return `${v % 1 === 0 ? v.toFixed(0) : v.toFixed(1)}M`;
-  }
-  return `${(n / 1_000_000_000).toFixed(1)}B`;
-}
-
-export function fmtRelativeTime(iso: string | number | null | undefined): string {
-  if (!iso) return "—";
-  const ms = typeof iso === "number" ? iso : Date.parse(iso);
-  if (!Number.isFinite(ms)) return "—";
-  const dSec = (Date.now() - ms) / 1000;
-  if (dSec < 60) return t("fmt.justNow");
-  if (dSec < 3600) return t("fmt.minutesAgo", { n: Math.floor(dSec / 60) });
-  if (dSec < 86400) return t("fmt.hoursAgo", { n: Math.floor(dSec / 3600) });
-  if (dSec < 30 * 86400) return t("fmt.daysAgo", { n: Math.floor(dSec / 86400) });
-  return new Date(ms).toISOString().slice(0, 10);
-}

dashboard/src/lib/html.ts

@@ -1,4 +0,0 @@
-import htm from "htm";
-import { h } from "preact";
-
-export const html = htm.bind(h);

dashboard/src/lib/i18n.ts

@@ -1,117 +0,0 @@
-import { useEffect, useState } from "preact/hooks";
-import { TOKEN, api } from "./api.js";
-
-type Listener = () => void;
-
-export type DashboardLang = "en" | "zh-CN";
-
-// [dashboardCode, backendCode] — add new languages here.
-const LANG_REGISTRY: [DashboardLang, string][] = [
-  ["en", "EN"],
-  ["zh-CN", "zh-CN"],
-];
-
-const SUPPORTED = new Set(LANG_REGISTRY.map(([d]) => d));
-const TO_BACKEND = new Map(LANG_REGISTRY);
-const FROM_BACKEND = new Map(LANG_REGISTRY.map(([d, b]) => [b, d]));
-
-const STORAGE_KEY = "rx.lang";
-const listeners: Listener[] = [];
-let currentLang: DashboardLang = loadFromStorage() ?? "en";
-
-function loadFromStorage(): DashboardLang | null {
-  try {
-    const v = localStorage.getItem(STORAGE_KEY);
-    if (v !== null && SUPPORTED.has(v as DashboardLang)) return v as DashboardLang;
-  } catch {
-    /* private mode */
-  }
-  return null;
-}
-
-function toBackendLang(lang: DashboardLang): string {
-  return TO_BACKEND.get(lang) ?? lang;
-}
-
-function fromBackendLang(raw: string): DashboardLang {
-  return (FROM_BACKEND.get(raw) as DashboardLang) ?? "en";
-}
-
-/** Adopt server lang on startup; localStorage is render-cache only, never pushed back. */
-export async function initLangFromServer(): Promise<void> {
-  try {
-    const res = await api<{ lang?: string }>("/settings");
-    const serverLang = res.lang ? fromBackendLang(res.lang) : null;
-    if (!serverLang || serverLang === currentLang) return;
-    currentLang = serverLang;
-    try {
-      localStorage.setItem(STORAGE_KEY, serverLang);
-    } catch {
-      /* ignore */
-    }
-    for (const cb of listeners) cb();
-  } catch {
-    /* offline — keep last-known value rendering */
-  }
-}
-
-export function getLang(): DashboardLang {
-  return currentLang;
-}
-
-export function setLang(lang: DashboardLang): void {
-  if (!SUPPORTED.has(lang)) return;
-  currentLang = lang;
-  try {
-    localStorage.setItem(STORAGE_KEY, lang);
-  } catch {
-    /* ignore */
-  }
-  for (const cb of listeners) cb();
-  // keepalive ensures the request completes even during page unload (refresh).
-  fetch(`/api/settings?token=${TOKEN}`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json", "X-Reasonix-Token": TOKEN },
-    body: JSON.stringify({ lang: toBackendLang(lang) }),
-    keepalive: true,
-  }).catch((err) => console.error("[reasonix dashboard] lang persist:", err));
-}
-
-export function onLangChange(cb: Listener): () => void {
-  listeners.push(cb);
-  return () => {
-    const i = listeners.indexOf(cb);
-    if (i >= 0) listeners.splice(i, 1);
-  };
-}
-
-export function useLang(): DashboardLang {
-  const [lang, setLangState] = useState<DashboardLang>(currentLang);
-  useEffect(() => onLangChange(() => setLangState(currentLang)), []);
-  return lang;
-}
-
-type Nested = { [k: string]: string | Nested };
-
-function get(translations: Nested | undefined, path: string): string | undefined {
-  let val: string | Nested | undefined = translations;
-  for (const part of path.split(".")) {
-    if (val === undefined || typeof val === "string") return undefined;
-    val = val[part];
-  }
-  return typeof val === "string" ? val : undefined;
-}
-
-export function createT(translations: Record<string, Nested>) {
-  return function t(path: string, params?: Record<string, string | number>): string {
-    let val = get(translations[currentLang] ?? translations.en, path);
-    if (val === undefined) val = get(translations.en, path);
-    if (val === undefined) return path;
-    if (!params) return val;
-    let result = val;
-    for (const [k, v] of Object.entries(params)) {
-      result = result.replaceAll(`{${k}}`, String(v));
-    }
-    return result;
-  };
-}

dashboard/src/lib/line-comments.ts

@@ -1,90 +0,0 @@
-import { useState, useCallback } from "preact/hooks";
-
-export interface LineComment {
-  id: string;
-  file: string;
-  lineNumber: number;
-  content: string;
-  timestamp: number;
-}
-
-export interface LineCommentDraft {
-  file: string;
-  lineNumber: number;
-  content: string;
-  editingId?: string;
-}
-
-export function useLineComments() {
-  const [comments, setComments] = useState<LineComment[]>([]);
-  const [draft, setDraft] = useState<LineCommentDraft | null>(null);
-
-  const addComment = useCallback((file: string, lineNumber: number, content: string) => {
-    const id = `comment-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    setComments((prev) => [...prev, { id, file, lineNumber, content, timestamp: Date.now() }]);
-    setDraft(null);
-  }, []);
-
-  const updateComment = useCallback((id: string, content: string) => {
-    setComments((prev) => prev.map((c) => (c.id === id ? { ...c, content } : c)));
-  }, []);
-
-  const deleteComment = useCallback((id: string) => {
-    setComments((prev) => prev.filter((c) => c.id !== id));
-  }, []);
-
-  const startDraft = useCallback((file: string, lineNumber: number) => {
-    setDraft({ file, lineNumber, content: "" });
-  }, []);
-
-  const editComment = useCallback((id: string, content: string) => {
-    const comment = comments.find((c) => c.id === id);
-    if (comment) {
-      setDraft({ file: comment.file, lineNumber: comment.lineNumber, content, editingId: id });
-    }
-  }, [comments]);
-
-  const cancelDraft = useCallback(() => {
-    setDraft(null);
-  }, []);
-
-  const setDraftContent = useCallback((content: string) => {
-    setDraft((prev) => (prev ? { ...prev, content } : null));
-  }, []);
-
-  const submitDraft = useCallback(() => {
-    if (draft && draft.content.trim()) {
-      if (draft.editingId) {
-        updateComment(draft.editingId, draft.content.trim());
-      } else {
-        addComment(draft.file, draft.lineNumber, draft.content.trim());
-      }
-      setDraft(null);
-    }
-  }, [draft, addComment, updateComment]);
-
-  const commentsForFile = useCallback(
-    (file: string) => comments.filter((c) => c.file === file),
-    [comments],
-  );
-
-  const commentsForLine = useCallback(
-    (file: string, lineNumber: number) => comments.filter((c) => c.file === file && c.lineNumber === lineNumber),
-    [comments],
-  );
-
-  return {
-    comments,
-    draft,
-    addComment,
-    updateComment,
-    deleteComment,
-    startDraft,
-    editComment,
-    cancelDraft,
-    setDraftContent,
-    submitDraft,
-    commentsForFile,
-    commentsForLine,
-  };
-}

dashboard/src/lib/loop-control.ts

@@ -1,48 +0,0 @@
-export type IntervalUnit = "s" | "m" | "h";
-
-export interface LoopRunStatus {
-  prompt: string;
-  intervalMs: number;
-  iter: number;
-  /** Wall-clock ms until the next fire — server reports a remaining duration, not an absolute. */
-  nextFireMs: number;
-}
-
-/** Quick-pick intervals in ms — covers the 95% of cases users actually run. */
-export const INTERVAL_PRESETS_MS: ReadonlyArray<{ ms: number; label: string }> = [
-  { ms: 30_000, label: "30s" },
-  { ms: 60_000, label: "1m" },
-  { ms: 5 * 60_000, label: "5m" },
-  { ms: 15 * 60_000, label: "15m" },
-  { ms: 60 * 60_000, label: "1h" },
-  { ms: 6 * 60 * 60_000, label: "6h" },
-];
-
-const UNIT_TO_MS: Record<IntervalUnit, number> = {
-  s: 1_000,
-  m: 60_000,
-  h: 60 * 60_000,
-};
-
-const MIN_INTERVAL_MS = 5_000;
-const MAX_INTERVAL_MS = 6 * 60 * 60_000;
-
-/** Convert a "30" + "s" pair to ms, returning null if out of [5s, 6h]. */
-export function parseCustomInterval(value: string, unit: IntervalUnit): number | null {
-  const n = Number.parseFloat(value);
-  if (!Number.isFinite(n) || n <= 0) return null;
-  const ms = Math.round(n * UNIT_TO_MS[unit]);
-  if (ms < MIN_INTERVAL_MS || ms > MAX_INTERVAL_MS) return null;
-  return ms;
-}
-
-/** Human-friendly "5m 12s" / "12s" / "2h 45m" — shows two largest non-zero units. */
-export function formatRemaining(ms: number): string {
-  const safe = Math.max(0, Math.floor(ms / 1000));
-  const h = Math.floor(safe / 3600);
-  const m = Math.floor((safe % 3600) / 60);
-  const s = safe % 60;
-  if (h > 0) return m > 0 ? `${h}h ${m}m` : `${h}h`;
-  if (m > 0) return s > 0 ? `${m}m ${s}s` : `${m}m`;
-  return `${s}s`;
-}

dashboard/src/lib/markdown.ts

@@ -1,169 +0,0 @@
-import hljs from "highlight.js/lib/common";
-import { marked } from "marked";
-
-export function escapeHtml(s: unknown): string {
-  if (s == null) return "";
-  return String(s)
-    .replace(/&/g, "&")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;")
-    .replace(/'/g, "&#39;");
-}
-
-const SEARCH_REPLACE_RE = /<{7}\s*SEARCH\s*\n([\s\S]*?)\n={7}\s*\n([\s\S]*?)\n>{7}\s*REPLACE/;
-
-export function renderSearchReplace(search: string, replace: string, file: string): string {
-  const safeSearch = typeof search === "string" ? search : String(search ?? "");
-  const safeReplace = typeof replace === "string" ? replace : String(replace ?? "");
-  const oldLines = safeSearch
-    .split("\n")
-    .map((l) => `<span class="diff-line del">- ${escapeHtml(l)}</span>`)
-    .join("\n");
-  const newLines = safeReplace
-    .split("\n")
-    .map((l) => `<span class="diff-line ins">+ ${escapeHtml(l)}</span>`)
-    .join("\n");
-  const header = file ? `<span class="diff-line hunk">▸ edit ${escapeHtml(file)}</span>\n` : "";
-  return `<pre class="diff-block">${header}${oldLines}\n${newLines}</pre>`;
-}
-
-export function renderUnifiedDiff(text: string): string {
-  const safe = typeof text === "string" ? text : String(text ?? "");
-  const lines = safe
-    .split("\n")
-    .map((l) => {
-      if (l.startsWith("+++") || l.startsWith("---")) {
-        return `<span class="diff-line meta">${escapeHtml(l)}</span>`;
-      }
-      if (l.startsWith("+")) return `<span class="diff-line ins">${escapeHtml(l)}</span>`;
-      if (l.startsWith("-")) return `<span class="diff-line del">${escapeHtml(l)}</span>`;
-      if (l.startsWith("@@")) return `<span class="diff-line hunk">${escapeHtml(l)}</span>`;
-      return escapeHtml(l);
-    })
-    .join("\n");
-  return `<pre class="diff-block">${lines}</pre>`;
-}
-
-const renderer = new marked.Renderer();
-renderer.code = function reasonixCode(arg1: unknown, arg2?: string): string {
-  let text: unknown;
-  let lang: string | undefined;
-  if (arg1 && typeof arg1 === "object" && !Array.isArray(arg1)) {
-    text = (arg1 as { text?: unknown }).text;
-    lang = (arg1 as { lang?: string }).lang;
-  } else {
-    text = arg1;
-    lang = arg2;
-  }
-  if (text == null) text = "";
-  const codeText: string = typeof text === "string" ? text : String(text);
-  const sr = SEARCH_REPLACE_RE.exec(codeText);
-  if (sr) {
-    const [, search = "", replace = ""] = sr;
-    const file = typeof lang === "string" && lang.startsWith("edit:") ? lang.slice(5) : "";
-    return renderSearchReplace(search, replace, file);
-  }
-  if (lang === "diff") return renderUnifiedDiff(codeText);
-  if (lang && typeof lang === "string" && hljs.getLanguage(lang)) {
-    try {
-      const h = hljs.highlight(codeText, { language: lang, ignoreIllegals: true }).value;
-      return `<pre><code class="hljs language-${lang}">${h}</code></pre>`;
-    } catch {
-      /* fall through to auto */
-    }
-  }
-  try {
-    const auto = hljs.highlightAuto(codeText);
-    return `<pre><code class="hljs">${auto.value}</code></pre>`;
-  } catch {
-    return `<pre><code>${escapeHtml(codeText)}</code></pre>`;
-  }
-};
-
-marked.use({ renderer, gfm: true, breaks: false, pedantic: false });
-
-export function renderMarkdownToString(text: string): string {
-  return marked.parse(text) as string;
-}
-
-const LANG_BY_EXT: Record<string, string> = {
-  ts: "typescript",
-  tsx: "typescript",
-  js: "javascript",
-  jsx: "javascript",
-  mjs: "javascript",
-  cjs: "javascript",
-  py: "python",
-  rs: "rust",
-  go: "go",
-  java: "java",
-  kt: "kotlin",
-  c: "c",
-  h: "c",
-  cpp: "cpp",
-  cc: "cpp",
-  hpp: "cpp",
-  cs: "csharp",
-  swift: "swift",
-  rb: "ruby",
-  php: "php",
-  sh: "bash",
-  bash: "bash",
-  zsh: "bash",
-  fish: "bash",
-  ps1: "powershell",
-  json: "json",
-  yaml: "yaml",
-  yml: "yaml",
-  toml: "ini",
-  xml: "xml",
-  html: "xml",
-  svg: "xml",
-  css: "css",
-  scss: "scss",
-  less: "less",
-  md: "markdown",
-  sql: "sql",
-  vue: "xml",
-  svelte: "xml",
-  tex: "latex",
-  proto: "protobuf",
-  dockerfile: "dockerfile",
-};
-
-export function langFromPath(path: string | null | undefined): string | null {
-  if (!path) return null;
-  const lower = path.toLowerCase();
-  if (lower.endsWith("dockerfile")) return "dockerfile";
-  const dot = lower.lastIndexOf(".");
-  if (dot < 0) return null;
-  const ext = lower.slice(dot + 1);
-  return LANG_BY_EXT[ext] ?? null;
-}
-
-export function renderHighlightedBlock(text: string, lang: string | null | undefined): string {
-  if (!text) return "";
-  const safeLang = lang && hljs.getLanguage(lang) ? lang : null;
-  try {
-    const out = safeLang
-      ? hljs.highlight(text, { language: safeLang, ignoreIllegals: true })
-      : hljs.highlightAuto(text);
-    return `<pre class="md"><code class="hljs ${safeLang ? `language-${safeLang}` : ""}">${out.value}</code></pre>`;
-  } catch {
-    return `<pre><code>${escapeHtml(text)}</code></pre>`;
-  }
-}
-
-export function hlLine(text: string | null | undefined, lang: string | null | undefined): string {
-  if (text == null) return "";
-  if (text === "") return "";
-  try {
-    if (lang && hljs.getLanguage(lang)) {
-      return hljs.highlight(text, { language: lang, ignoreIllegals: true }).value;
-    }
-    return hljs.highlightAuto(text).value;
-  } catch {
-    return escapeHtml(text);
-  }
-}

dashboard/src/lib/mcp-spec.ts

@@ -1,46 +0,0 @@
-type SpecRecord = Record<string, unknown>;
-
-function isRecord(value: unknown): value is SpecRecord {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function stringField(obj: SpecRecord, key: string): string | null {
-  const value = obj[key];
-  return typeof value === "string" && value.trim() ? value.trim() : null;
-}
-
-function stringArgs(obj: SpecRecord): string[] {
-  const args = obj.args;
-  if (!Array.isArray(args)) return [];
-  return args.filter((arg): arg is string => typeof arg === "string" && arg.length > 0);
-}
-
-export function normalizeMcpSpec(spec: unknown): string | null {
-  if (typeof spec === "string") return spec;
-  if (!isRecord(spec)) return null;
-
-  const raw = stringField(spec, "raw") ?? stringField(spec, "spec");
-  if (raw) return raw;
-
-  const name = stringField(spec, "name") ?? stringField(spec, "label");
-  const command = stringField(spec, "command");
-  const url = stringField(spec, "url");
-  const transport = stringField(spec, "transport");
-  if (name && url) return `${name}=${transport === "streamable-http" ? "streamable+" : ""}${url}`;
-  if (name && command) return `${name}=${[command, ...stringArgs(spec)].join(" ")}`;
-  if (command) return [command, ...stringArgs(spec)].join(" ");
-
-  return null;
-}
-
-export function mcpSpecLabel(spec: unknown): string {
-  const text = normalizeMcpSpec(spec) ?? "";
-  const eq = text.indexOf("=");
-  return eq > 0 ? text.slice(0, eq) : text;
-}
-
-export function mcpSpecCommand(spec: unknown): string {
-  const text = normalizeMcpSpec(spec) ?? "";
-  const eq = text.indexOf("=");
-  return eq > 0 ? text.slice(eq + 1) : text;
-}

dashboard/src/lib/review-diffs.ts

@@ -1,32 +0,0 @@
-import { useState, useCallback, useEffect } from "preact/hooks";
-import { api } from "./api.js";
-
-export interface FileDiff {
-  file: string;
-  additions: number;
-  deletions: number;
-  patch?: string;
-  status: "added" | "deleted" | "modified";
-}
-
-export function useReviewDiffs() {
-  const [diffs, setDiffs] = useState<FileDiff[]>([]);
-  const [loading, setLoading] = useState(false);
-
-  const loadDiffs = useCallback(async (ep: string = "/review-diffs") => {
-    setLoading(true);
-    try {
-      const data = await api<FileDiff[]>(ep);
-      setDiffs(Array.isArray(data) ? data : []);
-    } catch {
-      setDiffs([]);
-    } finally {
-      setLoading(false);
-    }
-  }, []);
-
-  const modifiedFiles = useCallback(() => new Set(diffs.map((d) => d.file)), [diffs]);
-  const modifiedCount = useCallback(() => diffs.length, [diffs]);
-
-  return { diffs, loading, modifiedFiles, modifiedCount, reload: loadDiffs };
-}

dashboard/src/lib/session-url.ts

@@ -0,0 +1,21 @@
+const SESSION_PARAM = "session";
+
+export function readSessionFromUrl(): string | null {
+  if (typeof window === "undefined") return null;
+  const raw = new URLSearchParams(window.location.search).get(SESSION_PARAM);
+  if (!raw) return null;
+  const trimmed = raw.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+export function writeSessionToUrl(name: string | null): void {
+  if (typeof window === "undefined") return;
+  const url = new URL(window.location.href);
+  if (name && name.trim().length > 0) {
+    url.searchParams.set(SESSION_PARAM, name);
+  } else {
+    url.searchParams.delete(SESSION_PARAM);
+  }
+  if (url.href === window.location.href) return;
+  window.history.replaceState(null, "", url.href);
+}

dashboard/src/lib/use-poll.ts

@@ -1,45 +0,0 @@
-import { useCallback, useEffect, useState } from "preact/hooks";
-import { type ApiError, api } from "./api.js";
-
-export interface PollResult<T> {
-  data: T | null;
-  error: ApiError | Error | null;
-  loading: boolean;
-  refresh: () => Promise<void>;
-}
-
-export function usePoll<T = unknown>(path: string, intervalMs = 2000): PollResult<T> {
-  const [data, setData] = useState<T | null>(null);
-  const [error, setError] = useState<Error | null>(null);
-  const [loading, setLoading] = useState(true);
-
-  const refresh = useCallback(async () => {
-    try {
-      const next = await api<T>(path);
-      setData(next);
-      setError(null);
-    } catch (err) {
-      setError(err as Error);
-    } finally {
-      setLoading(false);
-    }
-  }, [path]);
-
-  useEffect(() => {
-    let cancelled = false;
-    let timer: ReturnType<typeof setTimeout> | null = null;
-    const tick = async () => {
-      if (cancelled) return;
-      await refresh();
-      if (cancelled) return;
-      timer = setTimeout(tick, intervalMs);
-    };
-    tick();
-    return () => {
-      cancelled = true;
-      if (timer) clearTimeout(timer);
-    };
-  }, [refresh, intervalMs]);
-
-  return { data, error, loading, refresh };
-}

dashboard/src/lib/version.ts

@@ -1,15 +0,0 @@
-/** Pre-release with same core sorts BELOW the bare version — matches npm `latest` dist-tag semantics. */
-export function compareVersions(a: string, b: string): number {
-  const [aCore = "0", aPre = ""] = a.split("-", 2);
-  const [bCore = "0", bPre = ""] = b.split("-", 2);
-  const aParts = aCore.split(".").map((p) => Number.parseInt(p, 10) || 0);
-  const bParts = bCore.split(".").map((p) => Number.parseInt(p, 10) || 0);
-  for (let i = 0; i < 3; i++) {
-    const diff = (aParts[i] ?? 0) - (bParts[i] ?? 0);
-    if (diff !== 0) return diff;
-  }
-  if (!aPre && !bPre) return 0;
-  if (!aPre) return 1;
-  if (!bPre) return -1;
-  return aPre < bPre ? -1 : aPre > bPre ? 1 : 0;
-}