From ad9d3f94e046998bc53ad812dd53ea2c6ab86e43 Mon Sep 17 00:00:00 2001
From: catlog22 <catlog22@github.com>
Date: Tue, 17 Mar 2026 23:03:20 +0800
Subject: [PATCH] feat: add MCP server for semantic code search with FastMCP
 integration

---
 .claude/skills/wf-composer/SKILL.md           |  153 +
 .claude/skills/wf-composer/phases/01-parse.md |   93 +
 .../skills/wf-composer/phases/02-resolve.md   |   89 +
 .../skills/wf-composer/phases/03-enrich.md    |  104 +
 .../skills/wf-composer/phases/04-confirm.md   |   97 +
 .../skills/wf-composer/phases/05-persist.md   |  107 +
 .../skills/wf-composer/specs/node-catalog.md  |   96 +
 .../wf-composer/specs/template-schema.md      |  202 ++
 .claude/skills/wf-player/SKILL.md             |  151 +
 .claude/skills/wf-player/phases/01-load.md    |   92 +
 .../skills/wf-player/phases/02-instantiate.md |  110 +
 .claude/skills/wf-player/phases/03-execute.md |  211 ++
 .../skills/wf-player/phases/04-complete.md    |   93 +
 .../skills/wf-player/specs/node-executor.md   |  187 ++
 .../skills/wf-player/specs/state-schema.md    |  136 +
 .../components/codexlens/AdvancedTab.test.tsx |  154 -
 .../src/components/codexlens/AdvancedTab.tsx  |  704 -----
 .../src/components/codexlens/CcwToolsCard.tsx |  153 -
 .../components/codexlens/FileWatcherCard.tsx  |  135 -
 .../src/components/codexlens/GpuSelector.tsx  |  293 --
 .../components/codexlens/IndexOperations.tsx  |  286 --
 .../codexlens/InstallProgressOverlay.tsx      |  256 --
 .../components/codexlens/LspServerCard.tsx    |  157 -
 .../src/components/codexlens/ModelCard.tsx    |  234 --
 .../components/codexlens/ModelSelectField.tsx |  195 --
 .../components/codexlens/ModelsTab.test.tsx   |  405 ---
 .../src/components/codexlens/ModelsTab.tsx    |  309 --
 .../components/codexlens/OverviewTab.test.tsx |  276 --
 .../src/components/codexlens/OverviewTab.tsx  |  184 --
 .../codexlens/SchemaFormRenderer.tsx          |  286 --
 .../src/components/codexlens/SearchTab.tsx    |  445 ---
 .../codexlens/SemanticInstallDialog.tsx       |  205 --
 .../components/codexlens/SettingsTab.test.tsx |  431 ---
 .../src/components/codexlens/SettingsTab.tsx  |  276 --
 .../src/components/codexlens/envVarSchema.ts  |  389 ---
 ccw/frontend/src/hooks/index.ts               |   83 +-
 ccw/frontend/src/hooks/useCodexLens.test.tsx  |  418 ---
 ccw/frontend/src/hooks/useCodexLens.ts        | 1789 ------------
 ccw/frontend/src/hooks/useV2SearchManager.ts  |  159 +
 ccw/frontend/src/lib/api.ts                   | 1014 +------
 ccw/frontend/src/locales/en/codexlens.json    |  406 +--
 ccw/frontend/src/locales/en/navigation.json   |    2 +-
 ccw/frontend/src/locales/zh/codexlens.json    |  406 +--
 ccw/frontend/src/locales/zh/navigation.json   |    2 +-
 .../src/pages/CodexLensManagerPage.test.tsx   |  481 +--
 .../src/pages/CodexLensManagerPage.tsx        |  410 +--
 ccw/frontend/src/test/i18n.tsx                |  380 +--
 ccw/frontend/src/types/codexlens.ts           |   63 -
 ccw/src/core/memory-embedder-bridge.ts        |  367 +--
 ccw/src/core/routes/codexlens-routes.ts       |   23 -
 ccw/src/core/routes/codexlens/README.md       |   37 -
 .../core/routes/codexlens/config-handlers.ts  | 1448 ---------
 .../core/routes/codexlens/index-handlers.ts   |  459 ---
 .../routes/codexlens/semantic-handlers.ts     | 1289 ---------
 ccw/src/core/routes/codexlens/utils.ts        |   96 -
 .../core/routes/codexlens/watcher-handlers.ts |  322 ---
 ccw/src/core/routes/litellm-api-routes.ts     |  249 +-
 ccw/src/core/routes/status-routes.ts          |   29 +-
 ccw/src/core/server.ts                        |   29 -
 ccw/src/core/unified-vector-index.ts          |  418 +--
 ccw/src/tools/codex-lens-lsp.ts               |  405 ---
 ccw/src/tools/codex-lens.ts                   | 2576 +----------------
 ccw/src/tools/index.ts                        |    4 +-
 ccw/src/tools/litellm-client.ts               |  244 +-
 ccw/src/utils/codexlens-path.ts               |   54 -
 ccw/src/utils/package-discovery.ts            |  327 ---
 ccw/src/utils/python-utils.ts                 |  269 --
 ccw/src/utils/uv-manager.ts                   |  902 ------
 .../codex-lens-bootstrap-pip-missing.test.js  |  120 -
 ccw/tests/codex-lens-uv-install.test.ts       |  372 ---
 ccw/tests/codexlens-path.test.js              |   66 -
 ccw/tests/uv-manager-codexlens-python.test.js |  121 -
 ccw/tests/uv-manager.test.ts                  |  414 ---
 codex-lens-v2/.gitignore                      |   32 +
 codex-lens-v2/README.md                       |  296 +-
 .../codexlens_search-0.2.0-py3-none-any.whl   |  Bin 30402 -> 0 bytes
 .../dist/codexlens_search-0.2.0.tar.gz        |  Bin 31214 -> 0 bytes
 codex-lens-v2/pyproject.toml                  |   34 +-
 codex-lens-v2/src/codexlens_search/bridge.py  |   80 +-
 .../src/codexlens_search/mcp_server.py        |  367 +++
 80 files changed, 3427 insertions(+), 21329 deletions(-)
 create mode 100644 .claude/skills/wf-composer/SKILL.md
 create mode 100644 .claude/skills/wf-composer/phases/01-parse.md
 create mode 100644 .claude/skills/wf-composer/phases/02-resolve.md
 create mode 100644 .claude/skills/wf-composer/phases/03-enrich.md
 create mode 100644 .claude/skills/wf-composer/phases/04-confirm.md
 create mode 100644 .claude/skills/wf-composer/phases/05-persist.md
 create mode 100644 .claude/skills/wf-composer/specs/node-catalog.md
 create mode 100644 .claude/skills/wf-composer/specs/template-schema.md
 create mode 100644 .claude/skills/wf-player/SKILL.md
 create mode 100644 .claude/skills/wf-player/phases/01-load.md
 create mode 100644 .claude/skills/wf-player/phases/02-instantiate.md
 create mode 100644 .claude/skills/wf-player/phases/03-execute.md
 create mode 100644 .claude/skills/wf-player/phases/04-complete.md
 create mode 100644 .claude/skills/wf-player/specs/node-executor.md
 create mode 100644 .claude/skills/wf-player/specs/state-schema.md
 delete mode 100644 ccw/frontend/src/components/codexlens/AdvancedTab.test.tsx
 delete mode 100644 ccw/frontend/src/components/codexlens/AdvancedTab.tsx
 delete mode 100644 ccw/frontend/src/components/codexlens/CcwToolsCard.tsx
 delete mode 100644 ccw/frontend/src/components/codexlens/FileWatcherCard.tsx
 delete mode 100644 ccw/frontend/src/components/codexlens/GpuSelector.tsx
 delete mode 100644 ccw/frontend/src/components/codexlens/IndexOperations.tsx
 delete mode 100644 ccw/frontend/src/components/codexlens/InstallProgressOverlay.tsx
 delete mode 100644 ccw/frontend/src/components/codexlens/LspServerCard.tsx
 delete mode 100644 ccw/frontend/src/components/codexlens/ModelCard.tsx
 delete mode 100644 ccw/frontend/src/components/codexlens/ModelSelectField.tsx
 delete mode 100644 ccw/frontend/src/components/codexlens/ModelsTab.test.tsx
 delete mode 100644 ccw/frontend/src/components/codexlens/ModelsTab.tsx
 delete mode 100644 ccw/frontend/src/components/codexlens/OverviewTab.test.tsx
 delete mode 100644 ccw/frontend/src/components/codexlens/OverviewTab.tsx
 delete mode 100644 ccw/frontend/src/components/codexlens/SchemaFormRenderer.tsx
 delete mode 100644 ccw/frontend/src/components/codexlens/SearchTab.tsx
 delete mode 100644 ccw/frontend/src/components/codexlens/SemanticInstallDialog.tsx
 delete mode 100644 ccw/frontend/src/components/codexlens/SettingsTab.test.tsx
 delete mode 100644 ccw/frontend/src/components/codexlens/SettingsTab.tsx
 delete mode 100644 ccw/frontend/src/components/codexlens/envVarSchema.ts
 delete mode 100644 ccw/frontend/src/hooks/useCodexLens.test.tsx
 delete mode 100644 ccw/frontend/src/hooks/useCodexLens.ts
 create mode 100644 ccw/frontend/src/hooks/useV2SearchManager.ts
 delete mode 100644 ccw/frontend/src/types/codexlens.ts
 delete mode 100644 ccw/src/core/routes/codexlens-routes.ts
 delete mode 100644 ccw/src/core/routes/codexlens/README.md
 delete mode 100644 ccw/src/core/routes/codexlens/config-handlers.ts
 delete mode 100644 ccw/src/core/routes/codexlens/index-handlers.ts
 delete mode 100644 ccw/src/core/routes/codexlens/semantic-handlers.ts
 delete mode 100644 ccw/src/core/routes/codexlens/utils.ts
 delete mode 100644 ccw/src/core/routes/codexlens/watcher-handlers.ts
 delete mode 100644 ccw/src/tools/codex-lens-lsp.ts
 delete mode 100644 ccw/src/utils/package-discovery.ts
 delete mode 100644 ccw/src/utils/python-utils.ts
 delete mode 100644 ccw/src/utils/uv-manager.ts
 delete mode 100644 ccw/tests/codex-lens-bootstrap-pip-missing.test.js
 delete mode 100644 ccw/tests/codex-lens-uv-install.test.ts
 delete mode 100644 ccw/tests/codexlens-path.test.js
 delete mode 100644 ccw/tests/uv-manager-codexlens-python.test.js
 delete mode 100644 ccw/tests/uv-manager.test.ts
 delete mode 100644 codex-lens-v2/dist/codexlens_search-0.2.0-py3-none-any.whl
 delete mode 100644 codex-lens-v2/dist/codexlens_search-0.2.0.tar.gz
 create mode 100644 codex-lens-v2/src/codexlens_search/mcp_server.py

diff --git a/.claude/skills/wf-composer/SKILL.md b/.claude/skills/wf-composer/SKILL.md
new file mode 100644
index 00000000..7a3b9a74
--- /dev/null
+++ b/.claude/skills/wf-composer/SKILL.md
@@ -0,0 +1,153 @@
+---
+name: wf-composer
+description: Semantic workflow composer — parse natural language workflow description into a DAG of skill/CLI/agent nodes, auto-inject checkpoint save nodes, confirm with user, persist as reusable JSON template. Triggers on "wf-composer " or "/wf-composer".
+argument-hint: "[workflow description]"
+allowed-tools: Agent(*), AskUserQuestion(*), Read(*), Write(*), Edit(*), Bash(*), Glob(*), Grep(*)
+---
+
+# Workflow Design
+
+Parse user's semantic workflow description → decompose into nodes → map to executors → auto-inject checkpoints → confirm pipeline → save as reusable `workflow-template.json`.
+
+## Architecture
+
+```
+User describes workflow in natural language
+  -> Phase 1: Parse — extract intent steps + variables
+  -> Phase 2: Resolve — map each step to executor (skill/cli/agent/command)
+  -> Phase 3: Enrich — inject checkpoint nodes, set DAG edges
+  -> Phase 4: Confirm — visualize pipeline, user approval/edit
+  -> Phase 5: Persist — save .workflow/templates/<name>.json
+```
+
+## Shared Constants
+
+| Constant | Value |
+|----------|-------|
+| Session prefix | `WFD` |
+| Template dir | `.workflow/templates/` |
+| Template ID format | `wft-<slug>-<date>` |
+| Node ID format | `N-<seq>` (e.g. N-001), `CP-<seq>` for checkpoints |
+| Max nodes | 20 |
+
+## Entry Router
+
+Parse `$ARGUMENTS`.
+
+| Detection | Condition | Handler |
+|-----------|-----------|---------|
+| Resume design | `--resume` flag or existing WFD session | -> Phase 0: Resume |
+| Edit template | `--edit <template-id>` flag | -> Phase 0: Load + Edit |
+| New design | Default | -> Phase 1: Parse |
+
+## Phase 0: Resume / Edit (optional)
+
+**Resume design session**:
+1. Scan `.workflow/templates/design-drafts/WFD-*.json` for in-progress designs
+2. Multiple found → AskUserQuestion for selection
+3. Load draft → skip to last incomplete phase
+
+**Edit existing template**:
+1. Load template from `--edit` path
+2. Show current pipeline visualization
+3. AskUserQuestion: which nodes to modify/add/remove
+4. Re-enter at Phase 3 (Enrich) with edits applied
+
+---
+
+## Phase 1: Parse
+
+Read `phases/01-parse.md` and execute.
+
+**Objective**: Extract structured semantic steps + context variables from natural language.
+
+**Success**: `design-session/intent.json` written with: steps[], variables[], task_type, complexity.
+
+---
+
+## Phase 2: Resolve
+
+Read `phases/02-resolve.md` and execute.
+
+**Objective**: Map each intent step to a concrete executor node.
+
+**Executor types**:
+- `skill` — invoke via `Skill(skill=..., args=...)`
+- `cli` — invoke via `ccw cli -p "..." --tool ... --mode ...`
+- `command` — invoke via `Skill(skill="<namespace:command>", args=...)`
+- `agent` — invoke via `Agent(subagent_type=..., prompt=...)`
+- `checkpoint` — state save + optional user pause
+
+**Success**: `design-session/nodes.json` written with resolved executor for each step.
+
+---
+
+## Phase 3: Enrich
+
+Read `phases/03-enrich.md` and execute.
+
+**Objective**: Build DAG edges, auto-inject checkpoints at phase boundaries, validate port compatibility.
+
+**Checkpoint injection rules**:
+- After every `skill` → `skill` transition that crosses a semantic phase boundary
+- Before any long-running `agent` spawn
+- After any node that produces a persistent artifact (plan, spec, analysis)
+- At user-defined breakpoints (if any)
+
+**Success**: `design-session/dag.json` with nodes[], edges[], checkpoints[], context_schema{}.
+
+---
+
+## Phase 4: Confirm
+
+Read `phases/04-confirm.md` and execute.
+
+**Objective**: Visualize the pipeline, present to user, incorporate edits.
+
+**Display format**:
+```
+Pipeline: <template-name>
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+N-001 [skill]      workflow-lite-plan       "{goal}"
+  |
+CP-01 [checkpoint] After Plan               auto-continue
+  |
+N-002 [skill]      workflow-test-fix        "--session N-001"
+  |
+CP-02 [checkpoint] After Tests              pause-for-user
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Variables: goal (required)
+Checkpoints: 2 (1 auto, 1 pause)
+```
+
+AskUserQuestion:
+- Confirm & Save
+- Edit node (select node ID)
+- Add node after (select position)
+- Remove node (select node ID)
+- Rename template
+
+**Success**: User confirmed pipeline. Final dag.json ready.
+
+---
+
+## Phase 5: Persist
+
+Read `phases/05-persist.md` and execute.
+
+**Objective**: Assemble final template JSON, write to template library, output summary.
+
+**Output**:
+- `.workflow/templates/<slug>.json` — the reusable template
+- Console summary with template path + usage command
+
+**Success**: Template saved. User shown: `Skill(skill="wf-player", args="<template-path>")`
+
+---
+
+## Specs Reference
+
+| Spec | Purpose |
+|------|---------|
+| [specs/node-catalog.md](specs/node-catalog.md) | Available executors, port definitions, arg templates |
+| [specs/template-schema.md](specs/template-schema.md) | Full JSON template schema |
diff --git a/.claude/skills/wf-composer/phases/01-parse.md b/.claude/skills/wf-composer/phases/01-parse.md
new file mode 100644
index 00000000..c5e09634
--- /dev/null
+++ b/.claude/skills/wf-composer/phases/01-parse.md
@@ -0,0 +1,93 @@
+# Phase 1: Parse — Semantic Intent Extraction
+
+## Objective
+
+Extract structured semantic steps and context variables from the user's natural language workflow description.
+
+## Workflow
+
+### Step 1.1 — Read Input
+
+Parse `$ARGUMENTS` as the workflow description. If empty or ambiguous, AskUserQuestion:
+- "Describe the workflow you want to automate. Include: what steps to run, in what order, and what varies each time (inputs)."
+
+### Step 1.2 — Extract Steps
+
+Scan the description for sequential actions. Each action becomes a candidate node.
+
+**Signal patterns** (not exhaustive — apply NL understanding):
+
+| Signal | Candidate Node Type |
+|--------|---------------------|
+| "analyze", "review", "explore" | analysis step (cli --mode analysis) |
+| "plan", "design", "spec" | planning step (skill: workflow-lite-plan / workflow-plan) |
+| "implement", "build", "code", "fix", "refactor" | execution step (skill: workflow-execute) |
+| "test", "validate", "verify" | testing step (skill: workflow-test-fix) |
+| "brainstorm", "ideate" | brainstorm step (skill: brainstorm / brainstorm-with-file) |
+| "review code", "code review" | review step (skill: review-cycle) |
+| "save", "checkpoint", "pause" | explicit checkpoint node |
+| "spawn agent", "delegate", "subagent" | agent node |
+| "then", "next", "after", "finally" | sequential edge signal |
+| "parallel", "simultaneously", "at the same time" | parallel edge signal |
+
+### Step 1.3 — Extract Variables
+
+Identify inputs that vary per run. These become `context_schema` entries.
+
+**Variable detection**:
+- Direct mentions: "the goal", "the target", "my task", "user-provided X"
+- Parameterized slots: `{goal}`, `[feature]`, `<scope>` patterns in the description
+- Implicit from task type: any "feature/bugfix/topic" is `goal`
+
+For each variable: assign name, type (string|path|boolean), required flag, description.
+
+### Step 1.4 — Detect Task Type
+
+Use ccw-coordinator task detection logic to classify the overall workflow:
+
+```
+bugfix | feature | tdd | review | brainstorm | spec-driven | roadmap |
+refactor | integration-test | greenfield | quick-task | custom
+```
+
+`custom` = user describes a non-standard combination.
+
+### Step 1.5 — Complexity Assessment
+
+Count nodes, detect parallel tracks, identify dependencies:
+- `simple` = 1-3 nodes, linear
+- `medium` = 4-7 nodes, at most 1 parallel track
+- `complex` = 8+ nodes or multiple parallel tracks
+
+### Step 1.6 — Write Output
+
+Create session dir: `.workflow/templates/design-drafts/WFD-<slug>-<date>/`
+
+Write `intent.json`:
+```json
+{
+  "session_id": "WFD-<slug>-<date>",
+  "raw_description": "<original user input>",
+  "task_type": "<detected type>",
+  "complexity": "simple|medium|complex",
+  "steps": [
+    {
+      "seq": 1,
+      "description": "<extracted step description>",
+      "type_hint": "analysis|planning|execution|testing|review|checkpoint|agent|cli",
+      "parallel_with": null,
+      "variables": ["goal"]
+    }
+  ],
+  "variables": {
+    "goal": { "type": "string", "required": true, "description": "<inferred description>" }
+  },
+  "created_at": "<ISO timestamp>"
+}
+```
+
+## Success Criteria
+
+- `intent.json` exists with at least 1 step
+- All referenced variables extracted to `variables` map
+- task_type and complexity assigned
diff --git a/.claude/skills/wf-composer/phases/02-resolve.md b/.claude/skills/wf-composer/phases/02-resolve.md
new file mode 100644
index 00000000..4d3b4dac
--- /dev/null
+++ b/.claude/skills/wf-composer/phases/02-resolve.md
@@ -0,0 +1,89 @@
+# Phase 2: Resolve — Map Steps to Executor Nodes
+
+## Objective
+
+Map each intent step from `intent.json` into a concrete executor node with assigned type, executor, and arg template.
+
+## Workflow
+
+### Step 2.1 — Load Intent
+
+Read `design-session/intent.json`. Load steps[], variables{}.
+
+### Step 2.2 — Map Each Step to Executor
+
+For each step, determine the executor node using the Node Catalog (`specs/node-catalog.md`).
+
+**Resolution algorithm**:
+1. Match `type_hint` to executor candidates in catalog
+2. If multiple candidates, select by semantic fit to step description
+3. If no catalog match, emit `cli` node with inferred `--rule` and `--mode`
+
+**Node type assignment**:
+
+| Step type_hint | Default executor type | Default executor |
+|----------------|----------------------|------------------|
+| `planning` | skill | `workflow-lite-plan` (simple/medium) or `workflow-plan` (complex) |
+| `execution` | skill | `workflow-execute` |
+| `testing` | skill | `workflow-test-fix` |
+| `review` | skill | `review-cycle` |
+| `brainstorm` | skill | `brainstorm` |
+| `analysis` | cli | `ccw cli --tool gemini --mode analysis` |
+| `spec` | skill | `spec-generator` |
+| `tdd` | skill | `workflow-tdd-plan` |
+| `refactor` | command | `workflow:refactor-cycle` |
+| `integration-test` | command | `workflow:integration-test-cycle` |
+| `agent` | agent | (infer subagent_type from description) |
+| `checkpoint` | checkpoint | — |
+
+### Step 2.3 — Build Arg Templates
+
+For each node, build `args_template` by substituting variable references:
+
+```
+skill node:   args_template = `{goal}`  (or `--session {prev_session}`)
+cli node:     args_template = `PURPOSE: {goal}\nTASK: ...\nMODE: analysis\nCONTEXT: @**/*`
+agent node:   args_template = `{goal}\nContext: {prev_output}`
+```
+
+**Context injection rules**:
+- Planning nodes that follow analysis: inject `--context {prev_output_path}`
+- Execution nodes that follow planning: inject `--resume-session {prev_session_id}`
+- Testing nodes that follow execution: inject `--session {prev_session_id}`
+
+Use `{prev_session_id}` and `{prev_output_path}` as runtime-resolved references — the executor will substitute these from node state at run time.
+
+### Step 2.4 — Assign Parallel Groups
+
+For steps with `parallel_with` set:
+- Assign same `parallel_group` string to both nodes
+- Parallel nodes share no data dependency (each gets same input)
+
+### Step 2.5 — Write Output
+
+Write `design-session/nodes.json`:
+```json
+{
+  "session_id": "<WFD-id>",
+  "nodes": [
+    {
+      "id": "N-001",
+      "seq": 1,
+      "name": "<step description shortened>",
+      "type": "skill|cli|command|agent|checkpoint",
+      "executor": "<skill name | cli command | agent subagent_type>",
+      "args_template": "<template string with {variable} placeholders>",
+      "input_ports": ["<port>"],
+      "output_ports": ["<port>"],
+      "parallel_group": null,
+      "on_fail": "abort"
+    }
+  ]
+}
+```
+
+## Success Criteria
+
+- Every intent step has a corresponding node in nodes.json
+- Every node has a non-empty executor and args_template
+- Parallel groups correctly assigned where step.parallel_with is set
diff --git a/.claude/skills/wf-composer/phases/03-enrich.md b/.claude/skills/wf-composer/phases/03-enrich.md
new file mode 100644
index 00000000..758c9714
--- /dev/null
+++ b/.claude/skills/wf-composer/phases/03-enrich.md
@@ -0,0 +1,104 @@
+# Phase 3: Enrich — Inject Checkpoints + Build DAG
+
+## Objective
+
+Build the directed acyclic graph (DAG) with proper edges, auto-inject checkpoint nodes at phase boundaries, and finalize the context_schema.
+
+## Workflow
+
+### Step 3.1 — Load Nodes
+
+Read `design-session/nodes.json`. Get nodes[] list.
+
+### Step 3.2 — Build Sequential Edges
+
+Start with a linear chain: N-001 → N-002 → N-003 → ...
+
+For nodes with the same `parallel_group`:
+- Remove edges between them
+- Add fan-out from the last non-parallel node to all group members
+- Add fan-in from all group members to the next non-parallel node
+
+### Step 3.3 — Auto-Inject Checkpoint Nodes
+
+Scan the edge list and inject a `checkpoint` node between edges that cross a phase boundary.
+
+**Phase boundary detection rules** (inject checkpoint if ANY rule triggers):
+
+| Rule | Condition |
+|------|-----------|
+| **Artifact boundary** | Source node has output_ports containing `plan`, `spec`, `analysis`, `review-findings` |
+| **Execution gate** | Target node type is `skill` with executor containing `execute` |
+| **Agent spawn** | Target node type is `agent` |
+| **Long-running** | Target node executor is `workflow-plan`, `spec-generator`, `collaborative-plan-with-file` |
+| **User-defined** | Intent step had `type_hint: checkpoint` |
+| **Post-testing** | Source node executor contains `test-fix` or `integration-test` |
+
+**Checkpoint node template**:
+```json
+{
+  "id": "CP-<seq>",
+  "name": "Checkpoint: <description>",
+  "type": "checkpoint",
+  "description": "<what was just completed>",
+  "auto_continue": true,
+  "save_fields": ["session_id", "artifacts", "output_path"]
+}
+```
+
+Set `auto_continue: false` for checkpoints that:
+- Precede a user-facing deliverable (spec, plan, review report)
+- Are explicitly requested by the user ("pause and show me")
+
+### Step 3.4 — Insert Checkpoint Edges
+
+For each injected checkpoint CP-X between edge (A → B):
+- Remove edge A → B
+- Add edges: A → CP-X, CP-X → B
+
+### Step 3.5 — Finalize context_schema
+
+Aggregate all `{variable}` references found in nodes' args_template strings.
+
+For each unique variable name found:
+- Look up from `intent.json#variables` if already defined
+- Otherwise infer: type=string, required=true, description="<variable name>"
+
+Produce final `context_schema{}` map.
+
+### Step 3.6 — Validate DAG
+
+Check:
+- No cycles (topological sort must succeed)
+- No orphan nodes (every node reachable from start)
+- Every non-start node has at least one incoming edge
+- Every non-terminal node has at least one outgoing edge
+
+On cycle detection: report error, ask user to resolve.
+
+### Step 3.7 — Write Output
+
+Write `design-session/dag.json`:
+```json
+{
+  "session_id": "<WFD-id>",
+  "nodes": [ /* all nodes including injected checkpoints */ ],
+  "edges": [
+    { "from": "N-001", "to": "CP-01" },
+    { "from": "CP-01", "to": "N-002" }
+  ],
+  "checkpoints": ["CP-01", "CP-02"],
+  "parallel_groups": { "<group-name>": ["N-003", "N-004"] },
+  "context_schema": {
+    "goal": { "type": "string", "required": true, "description": "..." }
+  },
+  "topological_order": ["N-001", "CP-01", "N-002"]
+}
+```
+
+## Success Criteria
+
+- dag.json exists and is valid (no cycles)
+- At least one checkpoint exists (or user explicitly opted out)
+- context_schema contains all variables referenced in args_templates
+- topological_order covers all nodes
diff --git a/.claude/skills/wf-composer/phases/04-confirm.md b/.claude/skills/wf-composer/phases/04-confirm.md
new file mode 100644
index 00000000..671d3426
--- /dev/null
+++ b/.claude/skills/wf-composer/phases/04-confirm.md
@@ -0,0 +1,97 @@
+# Phase 4: Confirm — Visualize + User Approval
+
+## Objective
+
+Render the pipeline as an ASCII diagram, present to user for confirmation and optional edits.
+
+## Workflow
+
+### Step 4.1 — Render Pipeline
+
+Load `design-session/dag.json`. Render in topological order:
+
+```
+Pipeline: <template-name>
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ N-001  [skill]       workflow-lite-plan         "{goal}"
+   |
+ CP-01  [checkpoint]  After Plan                 auto-continue
+   |
+ N-002  [skill]       workflow-execute            --resume {N-001.session_id}
+   |
+ CP-02  [checkpoint]  Before Review              pause-for-user
+   |
+ N-003  [skill]       review-cycle               --session {N-002.session_id}
+   |
+ N-004  [skill]       workflow-test-fix           --session {N-002.session_id}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Variables (required):  goal
+Checkpoints:           2  (1 auto-continue, 1 pause-for-user)
+Nodes:                 4 work + 2 checkpoints
+```
+
+For parallel groups, show fan-out/fan-in:
+```
+ N-003a [skill]  review-cycle    ─┐
+                                   ├─ N-004 [skill] workflow-test-fix
+ N-003b [cli]    gemini analysis  ─┘
+```
+
+### Step 4.2 — Ask User
+
+```
+AskUserQuestion({
+  questions: [{
+    question: "Review the workflow pipeline above.",
+    header: "Confirm Pipeline",
+    options: [
+      { label: "Confirm & Save", description: "Save as reusable template" },
+      { label: "Edit a node", description: "Modify executor or args of a specific node" },
+      { label: "Add a node", description: "Insert a new step at a position" },
+      { label: "Remove a node", description: "Delete a step from the pipeline" },
+      { label: "Rename template", description: "Change the template name" },
+      { label: "Re-run checkpoint injection", description: "Reset and re-inject checkpoints" },
+      { label: "Cancel", description: "Discard and exit" }
+    ]
+  }]
+})
+```
+
+### Step 4.3 — Handle Edit Actions
+
+**Edit a node**:
+- AskUserQuestion: "Which node ID to edit?" → show fields → apply change
+- Re-render pipeline and re-ask
+
+**Add a node**:
+- AskUserQuestion: "Insert after which node ID?" + "Describe the new step"
+- Re-run Phase 2 (resolve) for the new step description
+- Insert new node + update edges
+- Re-run Phase 3 (enrich) for checkpoint injection
+- Re-render and re-ask
+
+**Remove a node**:
+- AskUserQuestion: "Which node ID to remove?"
+- If node is a checkpoint: also remove it, re-wire edges
+- If node is a work node: re-wire edges, re-run checkpoint injection
+- Re-render and re-ask
+
+**Rename template**:
+- AskUserQuestion: "New template name?"
+- Update slug for template_id
+
+### Step 4.4 — Finalize
+
+On "Confirm & Save":
+- Freeze dag.json (mark as confirmed)
+- Proceed to Phase 5
+
+On "Cancel":
+- Save draft to `design-session/dag-draft.json`
+- Output: "Draft saved. Resume with: Skill(skill='wf-composer', args='--resume <session-id>')"
+- Exit
+
+## Success Criteria
+
+- User selected "Confirm & Save"
+- dag.json frozen with all user edits applied
diff --git a/.claude/skills/wf-composer/phases/05-persist.md b/.claude/skills/wf-composer/phases/05-persist.md
new file mode 100644
index 00000000..7e1fd231
--- /dev/null
+++ b/.claude/skills/wf-composer/phases/05-persist.md
@@ -0,0 +1,107 @@
+# Phase 5: Persist — Assemble + Save Template
+
+## Objective
+
+Assemble the final workflow template JSON from design session data, write to template library, output usage instructions.
+
+## Workflow
+
+### Step 5.1 — Load Design Session
+
+Read:
+- `design-session/intent.json` → template metadata
+- `design-session/dag.json` → nodes, edges, checkpoints, context_schema
+
+### Step 5.2 — Determine Template Name + Path
+
+**Name**: Use user's confirmed name from Phase 4. If not set, derive from intent.task_type + first 3 meaningful words of raw_description.
+
+**Slug**: kebab-case from name (e.g. "Feature TDD with Review" → "feature-tdd-with-review")
+
+**Path**: `.workflow/templates/<slug>.json`
+
+**template_id**: `wft-<slug>-<YYYYMMDD>`
+
+Check for existing file:
+- If exists and different content: append `-v2`, `-v3`, etc.
+- If exists and identical: skip write, output "Template already exists"
+
+### Step 5.3 — Assemble Template JSON
+
+See `specs/template-schema.md` for full schema. Assemble:
+
+```json
+{
+  "template_id": "wft-<slug>-<date>",
+  "name": "<human name>",
+  "description": "<raw_description truncated to 120 chars>",
+  "version": "1.0",
+  "created_at": "<ISO timestamp>",
+  "source_session": "<WFD-id>",
+  "tags": ["<task_type>", "<complexity>"],
+  "context_schema": { /* from dag.json */ },
+  "nodes": [ /* from dag.json, full node objects */ ],
+  "edges": [ /* from dag.json */ ],
+  "checkpoints": [ /* checkpoint node IDs */ ],
+  "atomic_groups": [ /* from intent.json parallel groups */ ],
+  "execution_mode": "serial",
+  "metadata": {
+    "node_count": <n>,
+    "checkpoint_count": <n>,
+    "estimated_duration": "<rough estimate based on node types>"
+  }
+}
+```
+
+### Step 5.4 — Write Template
+
+Write assembled JSON to `.workflow/templates/<slug>.json`.
+
+Ensure `.workflow/templates/` directory exists (create if not).
+
+### Step 5.5 — Update Template Index
+
+Read/create `.workflow/templates/index.json`:
+```json
+{
+  "templates": [
+    {
+      "template_id": "wft-<slug>-<date>",
+      "name": "<name>",
+      "path": ".workflow/templates/<slug>.json",
+      "tags": ["<task_type>"],
+      "created_at": "<ISO>",
+      "node_count": <n>
+    }
+  ]
+}
+```
+Append or update entry for this template. Write back.
+
+### Step 5.6 — Output Summary
+
+```
+Template saved: .workflow/templates/<slug>.json
+  ID:          wft-<slug>-<date>
+  Nodes:       <n> work nodes + <n> checkpoints
+  Variables:   <comma-separated required vars>
+
+To execute:
+  Skill(skill="wf-player", args="<slug> --context goal='<your goal>'")
+
+To edit later:
+  Skill(skill="wf-composer", args="--edit .workflow/templates/<slug>.json")
+
+To list all templates:
+  Skill(skill="wf-player", args="--list")
+```
+
+### Step 5.7 — Clean Up Draft
+
+Delete `design-session/` directory (or move to `.workflow/templates/design-drafts/archive/`).
+
+## Success Criteria
+
+- `.workflow/templates/<slug>.json` exists and is valid JSON
+- `index.json` updated with new entry
+- Console shows template path + usage command
diff --git a/.claude/skills/wf-composer/specs/node-catalog.md b/.claude/skills/wf-composer/specs/node-catalog.md
new file mode 100644
index 00000000..294905a9
--- /dev/null
+++ b/.claude/skills/wf-composer/specs/node-catalog.md
@@ -0,0 +1,96 @@
+# Node Catalog — Available Executors
+
+All executors available for node resolution in Phase 2.
+
+## Skill Nodes
+
+| Executor | Type | Input Ports | Output Ports | Typical Args Template |
+|----------|------|-------------|--------------|----------------------|
+| `workflow-lite-plan` | skill | requirement | plan | `"{goal}"` |
+| `workflow-plan` | skill | requirement, specification | detailed-plan | `"{goal}"` |
+| `workflow-execute` | skill | detailed-plan, verified-plan | code | `--resume-session {prev_session_id}` |
+| `workflow-test-fix` | skill | failing-tests, code | test-passed | `--session {prev_session_id}` |
+| `workflow-tdd-plan` | skill | requirement | tdd-tasks | `"{goal}"` |
+| `workflow-multi-cli-plan` | skill | requirement | multi-cli-plan | `"{goal}"` |
+| `review-cycle` | skill | code, session | review-findings | `--session {prev_session_id}` |
+| `brainstorm` | skill | exploration-topic | brainstorm-analysis | `"{goal}"` |
+| `spec-generator` | skill | requirement | specification | `"{goal}"` |
+
+## Command Nodes (namespace skills)
+
+| Executor | Type | Input Ports | Output Ports | Typical Args Template |
+|----------|------|-------------|--------------|----------------------|
+| `workflow:refactor-cycle` | command | codebase | refactored-code | `"{goal}"` |
+| `workflow:integration-test-cycle` | command | requirement | test-passed | `"{goal}"` |
+| `workflow:brainstorm-with-file` | command | exploration-topic | brainstorm-document | `"{goal}"` |
+| `workflow:analyze-with-file` | command | analysis-topic | discussion-document | `"{goal}"` |
+| `workflow:debug-with-file` | command | bug-report | understanding-document | `"{goal}"` |
+| `workflow:collaborative-plan-with-file` | command | requirement | plan-note | `"{goal}"` |
+| `workflow:roadmap-with-file` | command | requirement | execution-plan | `"{goal}"` |
+| `workflow:unified-execute-with-file` | command | plan-note, discussion-document | code | (no args — reads from session) |
+| `issue:discover` | command | codebase | pending-issues | (no args) |
+| `issue:plan` | command | pending-issues | issue-plans | `--all-pending` |
+| `issue:queue` | command | issue-plans | execution-queue | (no args) |
+| `issue:execute` | command | execution-queue | completed-issues | `--queue auto` |
+| `issue:convert-to-plan` | command | plan | converted-plan | `--latest-lite-plan` |
+| `team-planex` | skill | requirement, execution-plan | code | `"{goal}"` |
+
+## CLI Nodes
+
+CLI nodes use `ccw cli` with a tool + mode + rule.
+
+| Use Case | cli_tool | cli_mode | cli_rule |
+|----------|----------|----------|----------|
+| Architecture analysis | gemini | analysis | analysis-review-architecture |
+| Code quality review | gemini | analysis | analysis-review-code-quality |
+| Bug root cause | gemini | analysis | analysis-diagnose-bug-root-cause |
+| Security assessment | gemini | analysis | analysis-assess-security-risks |
+| Performance analysis | gemini | analysis | analysis-analyze-performance |
+| Code patterns | gemini | analysis | analysis-analyze-code-patterns |
+| Task breakdown | gemini | analysis | planning-breakdown-task-steps |
+| Architecture design | gemini | analysis | planning-plan-architecture-design |
+| Feature implementation | gemini | write | development-implement-feature |
+| Refactoring | gemini | write | development-refactor-codebase |
+| Test generation | gemini | write | development-generate-tests |
+
+**CLI node args_template format**:
+```
+PURPOSE: {goal}
+TASK: • [derived from step description]
+MODE: analysis
+CONTEXT: @**/* | Memory: {memory_context}
+EXPECTED: [derived from step output_ports]
+CONSTRAINTS: {scope}
+```
+
+## Agent Nodes
+
+| subagent_type | Use Case | run_in_background |
+|---------------|----------|-------------------|
+| `general-purpose` | Freeform analysis or implementation | false |
+| `team-worker` | Worker in team-coordinate pipeline | true |
+| `code-reviewer` | Focused code review | false |
+
+**Agent node args_template format**:
+```
+Task: {goal}
+
+Context from previous step:
+{prev_output}
+
+Deliver: [specify expected output format]
+```
+
+## Checkpoint Nodes
+
+Checkpoints are auto-generated — not selected from catalog.
+
+| auto_continue | When to Use |
+|---------------|-------------|
+| `true` | Background save, execution continues automatically |
+| `false` | Pause for user review before proceeding |
+
+Set `auto_continue: false` when:
+- The next node is user-facing (plan display, spec review)
+- The user requested an explicit pause in their workflow description
+- The next node spawns a background agent (give user chance to cancel)
diff --git a/.claude/skills/wf-composer/specs/template-schema.md b/.claude/skills/wf-composer/specs/template-schema.md
new file mode 100644
index 00000000..3065911f
--- /dev/null
+++ b/.claude/skills/wf-composer/specs/template-schema.md
@@ -0,0 +1,202 @@
+# Workflow Template Schema
+
+## File Location
+
+`.workflow/templates/<slug>.json`
+
+## Full Schema
+
+```json
+{
+  "template_id": "wft-<slug>-<YYYYMMDD>",
+  "name": "Human readable template name",
+  "description": "Brief description of what this workflow achieves",
+  "version": "1.0",
+  "created_at": "2026-03-17T10:00:00Z",
+  "source_session": "WFD-<slug>-<date>",
+  "tags": ["feature", "medium"],
+
+  "context_schema": {
+    "goal": {
+      "type": "string",
+      "required": true,
+      "description": "Main task goal or feature to implement"
+    },
+    "scope": {
+      "type": "string",
+      "required": false,
+      "description": "Target file or module scope",
+      "default": "src/**/*"
+    }
+  },
+
+  "nodes": [
+    {
+      "id": "N-001",
+      "name": "Plan Feature",
+      "type": "skill",
+      "executor": "workflow-lite-plan",
+      "args_template": "{goal}",
+      "input_ports": ["requirement"],
+      "output_ports": ["plan"],
+      "parallel_group": null,
+      "on_fail": "abort"
+    },
+    {
+      "id": "CP-01",
+      "name": "Checkpoint: After Plan",
+      "type": "checkpoint",
+      "description": "Plan artifact saved before execution proceeds",
+      "auto_continue": true,
+      "save_fields": ["session_id", "artifacts", "output_path"]
+    },
+    {
+      "id": "N-002",
+      "name": "Execute Implementation",
+      "type": "skill",
+      "executor": "workflow-execute",
+      "args_template": "--resume-session {N-001.session_id}",
+      "input_ports": ["plan"],
+      "output_ports": ["code"],
+      "parallel_group": null,
+      "on_fail": "abort"
+    },
+    {
+      "id": "CP-02",
+      "name": "Checkpoint: Before Testing",
+      "type": "checkpoint",
+      "description": "Implementation complete, ready for test validation",
+      "auto_continue": true,
+      "save_fields": ["session_id", "artifacts"]
+    },
+    {
+      "id": "N-003",
+      "name": "Run Tests",
+      "type": "skill",
+      "executor": "workflow-test-fix",
+      "args_template": "--session {N-002.session_id}",
+      "input_ports": ["code"],
+      "output_ports": ["test-passed"],
+      "parallel_group": null,
+      "on_fail": "abort"
+    }
+  ],
+
+  "edges": [
+    { "from": "N-001", "to": "CP-01" },
+    { "from": "CP-01", "to": "N-002" },
+    { "from": "N-002", "to": "CP-02" },
+    { "from": "CP-02", "to": "N-003" }
+  ],
+
+  "checkpoints": ["CP-01", "CP-02"],
+
+  "atomic_groups": [
+    {
+      "name": "planning-execution",
+      "nodes": ["N-001", "CP-01", "N-002"],
+      "description": "Plan must be followed by execution"
+    }
+  ],
+
+  "execution_mode": "serial",
+
+  "metadata": {
+    "node_count": 3,
+    "checkpoint_count": 2,
+    "estimated_duration": "20-40 min"
+  }
+}
+```
+
+## Node Type Definitions
+
+### `skill` node
+```json
+{
+  "id": "N-<seq>",
+  "name": "<descriptive name>",
+  "type": "skill",
+  "executor": "<skill-name>",
+  "args_template": "<string with {variable} and {prev-node-id.field} refs>",
+  "input_ports": ["<port-name>"],
+  "output_ports": ["<port-name>"],
+  "parallel_group": "<group-name> | null",
+  "on_fail": "abort | skip | retry"
+}
+```
+
+### `cli` node
+```json
+{
+  "id": "N-<seq>",
+  "name": "<descriptive name>",
+  "type": "cli",
+  "executor": "ccw cli",
+  "cli_tool": "gemini | qwen | codex",
+  "cli_mode": "analysis | write",
+  "cli_rule": "<rule-template-name>",
+  "args_template": "PURPOSE: {goal}\nTASK: ...\nMODE: analysis\nCONTEXT: @**/*\nEXPECTED: ...\nCONSTRAINTS: ...",
+  "input_ports": ["analysis-topic"],
+  "output_ports": ["analysis"],
+  "parallel_group": null,
+  "on_fail": "abort"
+}
+```
+
+### `command` node
+```json
+{
+  "id": "N-<seq>",
+  "name": "<descriptive name>",
+  "type": "command",
+  "executor": "workflow:refactor-cycle",
+  "args_template": "{goal}",
+  "input_ports": ["codebase"],
+  "output_ports": ["refactored-code"],
+  "parallel_group": null,
+  "on_fail": "abort"
+}
+```
+
+### `agent` node
+```json
+{
+  "id": "N-<seq>",
+  "name": "<descriptive name>",
+  "type": "agent",
+  "executor": "general-purpose",
+  "args_template": "Task: {goal}\n\nContext from previous step:\n{prev_output}",
+  "input_ports": ["requirement"],
+  "output_ports": ["analysis"],
+  "parallel_group": "<group-name> | null",
+  "run_in_background": false,
+  "on_fail": "abort"
+}
+```
+
+### `checkpoint` node
+```json
+{
+  "id": "CP-<seq>",
+  "name": "Checkpoint: <description>",
+  "type": "checkpoint",
+  "description": "<what was just completed, what comes next>",
+  "auto_continue": true,
+  "save_fields": ["session_id", "artifacts", "output_path"]
+}
+```
+
+## Runtime Reference Syntax
+
+In `args_template` strings, these references are resolved at execution time by `wf-player`:
+
+| Reference | Resolves To |
+|-----------|-------------|
+| `{variable}` | Value from context (bound at run start) |
+| `{N-001.session_id}` | `node_states["N-001"].session_id` |
+| `{N-001.output_path}` | `node_states["N-001"].output_path` |
+| `{N-001.artifacts[0]}` | First artifact from N-001 |
+| `{prev_session_id}` | session_id of the immediately preceding work node |
+| `{prev_output}` | Full output text of the immediately preceding node |
+| `{prev_output_path}` | Output file path of the immediately preceding node |
diff --git a/.claude/skills/wf-player/SKILL.md b/.claude/skills/wf-player/SKILL.md
new file mode 100644
index 00000000..3b0057b9
--- /dev/null
+++ b/.claude/skills/wf-player/SKILL.md
@@ -0,0 +1,151 @@
+---
+name: wf-player
+description: Workflow template player — load a JSON template produced by wf-composer, bind context variables, execute nodes in DAG order (serial/parallel), persist state at checkpoints, support resume from any checkpoint. Uses ccw-coordinator serial-blocking for CLI nodes and team-coordinate worker pattern for parallel agent nodes. Triggers on "wf-player " or "/wf-player".
+argument-hint: "<template-slug|path> [--context key=value...] [--resume <session-id>] [--list] [--dry-run]"
+allowed-tools: Agent(*), AskUserQuestion(*), Read(*), Write(*), Edit(*), Bash(*), Glob(*), Grep(*), Skill(*)
+---
+
+# Workflow Run
+
+Load a workflow template → bind variables → execute DAG → persist checkpoints → resume capable.
+
+## Architecture
+
+```
+Skill(skill="wf-player", args="<template> --context goal='...'")
+  |
+  +-- Phase 0: Entry Router
+       |-- --list        -> list available templates, exit
+       |-- --resume      -> load session, skip to Phase 3 (Execute)
+       |-- --dry-run     -> load + show execution plan, no execution
+       |-- default       -> Phase 1 (Load)
+  |
+  +-- Phase 1: Load & Bind
+  |    Load template JSON, bind {variables} from --context, validate required vars
+  |
+  +-- Phase 2: Instantiate
+  |    Init session state, topological sort, write WFR session file
+  |
+  +-- Phase 3: Execute Loop
+  |    For each node in order:
+  |      skill node   -> Skill(skill=...) [synchronous]
+  |      cli node     -> ccw cli [background + stop, hook callback]
+  |      command node -> Skill(skill="namespace:cmd") [synchronous]
+  |      agent node   -> Agent(...) [run_in_background per node config]
+  |      checkpoint   -> save state, optionally pause
+  |
+  +-- Phase 4: Complete
+       Archive session, output summary
+```
+
+## Shared Constants
+
+| Constant | Value |
+|----------|-------|
+| Session prefix | `WFR` |
+| Session dir | `.workflow/sessions/WFR-<slug>-<date>/` |
+| State file | `session-state.json` |
+| Template dir | `.workflow/templates/` |
+| Template index | `.workflow/templates/index.json` |
+
+## Entry Router
+
+Parse `$ARGUMENTS`:
+
+| Detection | Condition | Handler |
+|-----------|-----------|---------|
+| List templates | `--list` in args | -> handleList |
+| Resume session | `--resume <session-id>` in args | -> Phase 2 (resume) |
+| Dry run | `--dry-run` in args | -> Phase 1 + 2, print plan, exit |
+| Normal | Template slug/path provided | -> Phase 1 |
+| No args | Empty args | -> handleList + AskUserQuestion |
+
+### handleList
+
+Scan `.workflow/templates/index.json`. Display:
+```
+Available workflow templates:
+  feature-tdd-review    [feature, complex]   3 work nodes, 2 checkpoints
+  quick-bugfix          [bugfix, simple]     2 work nodes, 1 checkpoint
+  ...
+
+Run: Skill(skill="wf-player", args="<slug> --context goal='...'")
+```
+
+---
+
+## Phase 0 (Resume): Session Reconciliation
+
+**Trigger**: `--resume <session-id>` or active WFR session found in `.workflow/sessions/WFR-*/`
+
+1. Scan `.workflow/sessions/WFR-*/session-state.json` for status = "running" | "paused"
+2. Multiple found → AskUserQuestion for selection
+3. Load session-state.json
+4. Identify `last_checkpoint` and `node_states`
+5. Reset any `running` nodes back to `pending` (they were interrupted)
+6. Determine next executable node from `topological_order` after last checkpoint
+7. Resume at Phase 3 (Execute Loop) from that node
+
+---
+
+## Phase 1: Load & Bind
+
+Read `phases/01-load.md` and execute.
+
+**Objective**: Load template, collect missing variables, bind all {variable} references.
+
+**Success**: Template loaded, all required variables bound, `bound_context{}` ready.
+
+---
+
+## Phase 2: Instantiate
+
+Read `phases/02-instantiate.md` and execute.
+
+**Objective**: Create WFR session directory, init state, compute execution plan.
+
+**Success**: `session-state.json` written, topological_order ready.
+
+---
+
+## Phase 3: Execute Loop
+
+Read `phases/03-execute.md` and execute.
+
+**Objective**: Execute each node in topological_order using appropriate mechanism.
+
+**CRITICAL — CLI node blocking**:
+- CLI nodes launch `ccw cli` in background and immediately STOP
+- Wait for hook callback — DO NOT poll with TaskOutput
+- Hook callback resumes execution at next node
+
+**Success**: All nodes completed, all checkpoints saved.
+
+---
+
+## Phase 4: Complete
+
+Read `phases/04-complete.md` and execute.
+
+**Objective**: Archive session, output execution summary and artifact paths.
+
+---
+
+## Error Handling
+
+| Scenario | Resolution |
+|----------|------------|
+| Required variable missing | AskUserQuestion to collect it |
+| Template not found | Show `--list` and suggest closest match |
+| Node failed (on_fail=abort) | AskUserQuestion: Retry / Skip / Abort |
+| Node failed (on_fail=skip) | Log warning, continue to next node |
+| Node failed (on_fail=retry) | Retry once, then abort |
+| Interrupted mid-execution | State saved at last checkpoint; resume with `--resume <session-id>` |
+| Cycle in DAG | Error immediately, point to template for fix |
+
+## Specs Reference
+
+| Spec | Purpose |
+|------|---------|
+| [specs/node-executor.md](specs/node-executor.md) | Execution mechanism per node type |
+| [specs/state-schema.md](specs/state-schema.md) | session-state.json schema |
diff --git a/.claude/skills/wf-player/phases/01-load.md b/.claude/skills/wf-player/phases/01-load.md
new file mode 100644
index 00000000..27ad677f
--- /dev/null
+++ b/.claude/skills/wf-player/phases/01-load.md
@@ -0,0 +1,92 @@
+# Phase 1: Load & Bind
+
+## Objective
+
+Locate and load the workflow template, collect any missing context variables from the user, bind all `{variable}` references.
+
+## Workflow
+
+### Step 1.1 — Resolve Template Path
+
+Parse `$ARGUMENTS` for template identifier:
+
+**Path resolution order**:
+1. Absolute path: use as-is
+2. Relative path (starts with `.`): resolve from cwd
+3. Slug only (e.g. `feature-tdd-review`): look up in `.workflow/templates/index.json` → get path
+4. Partial slug match: scan index for closest match → confirm with user
+
+If not found:
+- Show available templates from index
+- AskUserQuestion: "Which template to run?"
+
+### Step 1.2 — Parse --context Arguments
+
+Extract `--context key=value` pairs from `$ARGUMENTS`.
+
+Examples:
+```
+--context goal="Implement user auth" --context scope="src/auth"
+--context goal='Fix login bug' scope=src/auth
+```
+
+Build `bound_context = { goal: "...", scope: "..." }`.
+
+### Step 1.3 — Load Template
+
+Read template JSON from resolved path.
+
+Validate:
+- `template_id`, `nodes`, `edges`, `context_schema` all present
+- `nodes` array non-empty
+
+### Step 1.4 — Collect Missing Required Variables
+
+For each variable in `context_schema` where `required: true`:
+- If not in `bound_context`: collect via AskUserQuestion
+- If has `default` value: use default if not provided
+
+```
+AskUserQuestion({
+  questions: [{
+    question: "Provide values for required workflow inputs:",
+    header: "Workflow: <template.name>",
+    // one question per missing required variable
+  }]
+})
+```
+
+For optional variables not provided: use `default` value or leave as empty string.
+
+### Step 1.5 — Bind Variables
+
+Apply substitution throughout all `args_template` strings:
+- Replace `{variable_name}` with `bound_context[variable_name]`
+- Leave `{N-001.session_id}` and `{prev_*}` references unresolved — these are runtime-resolved in Phase 3
+
+Write bound context to memory for Phase 3 use.
+
+### Step 1.6 — Dry Run Output (if --dry-run)
+
+Print execution plan and exit:
+```
+Workflow: <template.name>
+Context:
+  goal = "<value>"
+  scope = "<value>"
+
+Execution Plan:
+  [1] N-001  [skill]       workflow-lite-plan   "<goal>"
+  [2] CP-01  [checkpoint]  After Plan           auto-continue
+  [3] N-002  [skill]       workflow-execute     --resume-session {N-001.session_id}
+  [4] CP-02  [checkpoint]  Before Tests         pause-for-user
+  [5] N-003  [skill]       workflow-test-fix    --session {N-002.session_id}
+
+To execute: Skill(skill="wf-player", args="<slug> --context goal='...'")
+```
+
+## Success Criteria
+
+- Template loaded and validated
+- All required context variables bound
+- bound_context{} available for Phase 2
diff --git a/.claude/skills/wf-player/phases/02-instantiate.md b/.claude/skills/wf-player/phases/02-instantiate.md
new file mode 100644
index 00000000..968e1e07
--- /dev/null
+++ b/.claude/skills/wf-player/phases/02-instantiate.md
@@ -0,0 +1,110 @@
+# Phase 2: Instantiate — Init Session State
+
+## Objective
+
+Create the WFR session directory, initialize `session-state.json` with all nodes marked pending, compute topological execution order.
+
+## Workflow
+
+### Step 2.1 — Generate Session ID
+
+```
+session_id = "WFR-<template-slug>-<YYYYMMDD>-<HHmmss>"
+session_dir = ".workflow/sessions/<session_id>/"
+```
+
+Create session directory.
+
+### Step 2.2 — Topological Sort
+
+Run topological sort on `template.nodes` + `template.edges`:
+
+```
+function topoSort(nodes, edges):
+  build adjacency list from edges
+  Kahn's algorithm (BFS from nodes with no incoming edges)
+  return ordered node IDs
+```
+
+**Parallel group handling**: Nodes in the same `parallel_group` can execute concurrently. In topological order, keep them adjacent and mark them as a parallel batch.
+
+Store `execution_plan`:
+```json
+[
+  { "batch": 1, "nodes": ["N-001"], "parallel": false },
+  { "batch": 2, "nodes": ["CP-01"], "parallel": false },
+  { "batch": 3, "nodes": ["N-002a", "N-002b"], "parallel": true },
+  { "batch": 4, "nodes": ["N-003"], "parallel": false }
+]
+```
+
+### Step 2.3 — Init Node States
+
+For each node in template:
+```json
+{
+  "N-001": {
+    "status": "pending",
+    "started_at": null,
+    "completed_at": null,
+    "session_id": null,
+    "output_path": null,
+    "artifacts": [],
+    "error": null
+  }
+}
+```
+
+Checkpoint nodes:
+```json
+{
+  "CP-01": {
+    "status": "pending",
+    "saved_at": null,
+    "snapshot_path": null
+  }
+}
+```
+
+### Step 2.4 — Write session-state.json
+
+See `specs/state-schema.md` for full schema. Write to `<session_dir>/session-state.json`:
+
+```json
+{
+  "session_id": "<WFR-id>",
+  "template_id": "<template.template_id>",
+  "template_path": "<path to template>",
+  "template_name": "<template.name>",
+  "status": "running",
+  "context": { /* bound_context from Phase 1 */ },
+  "execution_plan": [ /* batches */ ],
+  "current_batch": 1,
+  "current_node": "N-001",
+  "last_checkpoint": null,
+  "node_states": { /* all nodes as pending */ },
+  "created_at": "<ISO>",
+  "updated_at": "<ISO>"
+}
+```
+
+### Step 2.5 — Show Execution Start Banner
+
+```
+[wf-player] ============================================
+[wf-player] Starting: <template.name>
+[wf-player] Session: <session_id>
+[wf-player] Context: goal="<value>"
+[wf-player]
+[wf-player] Plan: <N> nodes, <C> checkpoints
+[wf-player]   N-001 [skill]      workflow-lite-plan
+[wf-player]   CP-01 [checkpoint] After Plan
+[wf-player]   N-002 [skill]      workflow-execute
+[wf-player] ============================================
+```
+
+## Success Criteria
+
+- `<session_dir>/session-state.json` written
+- `execution_plan` has valid topological order
+- Status = "running"
diff --git a/.claude/skills/wf-player/phases/03-execute.md b/.claude/skills/wf-player/phases/03-execute.md
new file mode 100644
index 00000000..d6438f2f
--- /dev/null
+++ b/.claude/skills/wf-player/phases/03-execute.md
@@ -0,0 +1,211 @@
+# Phase 3: Execute Loop
+
+## Objective
+
+Execute each node batch in topological order. Use the correct mechanism per node type. Save state after every checkpoint. Support CLI serial-blocking with hook callback resume.
+
+## Pre-execution: Runtime Reference Resolution
+
+Before executing each node, resolve any `{N-xxx.field}` and `{prev_*}` references in `args_template`:
+
+```
+function resolveArgs(args_template, node_id, session_state):
+  for each {ref} in args_template:
+    if ref matches {variable}:
+      replace with session_state.context[variable]
+    if ref matches {N-001.session_id}:
+      replace with session_state.node_states["N-001"].session_id
+    if ref matches {N-001.output_path}:
+      replace with session_state.node_states["N-001"].output_path
+    if ref matches {prev_session_id}:
+      find previous non-checkpoint node -> replace with its session_id
+    if ref matches {prev_output}:
+      find previous non-checkpoint node -> replace with its output_text
+    if ref matches {prev_output_path}:
+      find previous non-checkpoint node -> replace with its output_path
+  return resolved_args
+```
+
+## Node Execution by Type
+
+Read `specs/node-executor.md` for full details. Summary:
+
+### skill node
+
+```
+resolved_args = resolveArgs(node.args_template, ...)
+mark node status = "running", write session-state.json
+
+result = Skill(skill=node.executor, args=resolved_args)
+
+extract from result: session_id, output_path, artifacts[]
+update node_states[node.id]:
+  status = "completed"
+  session_id = extracted_session_id
+  output_path = extracted_output_path
+  artifacts = extracted_artifacts
+  completed_at = now()
+
+write session-state.json
+advance to next node
+```
+
+### command node
+
+Same as skill node but executor is a namespaced command:
+```
+Skill(skill=node.executor, args=resolved_args)
+```
+
+### cli node — CRITICAL: serial blocking
+
+```
+resolved_args = resolveArgs(node.args_template, ...)
+mark node status = "running", write session-state.json
+
+Bash({
+  command: `ccw cli -p "${resolved_args}" --tool ${node.cli_tool} --mode ${node.cli_mode} --rule ${node.cli_rule}`,
+  run_in_background: true
+})
+
+write session-state.json  // persist "running" state
+STOP — wait for hook callback
+```
+
+**Hook callback resumes here**:
+```
+// Called when ccw cli completes
+load session-state.json
+find node with status "running"
+extract result: exec_id, output_path, cli_output
+update node_states[node.id]:
+  status = "completed"
+  output_path = extracted_output_path
+  completed_at = now()
+write session-state.json
+advance to next node
+```
+
+### agent node
+
+```
+resolved_args = resolveArgs(node.args_template, ...)
+mark node status = "running", write session-state.json
+
+result = Agent({
+  subagent_type: node.executor,
+  prompt: resolved_args,
+  run_in_background: node.run_in_background ?? false,
+  description: node.name
+})
+
+update node_states[node.id]:
+  status = "completed"
+  output_path = result.output_path or session_dir + "/artifacts/" + node.id + ".md"
+  completed_at = now()
+write session-state.json
+advance to next node
+```
+
+**Parallel agent nodes** (same parallel_group):
+```
+// Launch all agents in parallel
+for each node in parallel_batch:
+  mark node status = "running"
+
+  Agent({
+    subagent_type: node.executor,
+    prompt: resolveArgs(node.args_template, ...),
+    run_in_background: true,  // parallel
+    description: node.name
+  })
+
+// Wait for all to complete (Agent with run_in_background=false blocks — use team-coordinate pattern)
+// team-coordinate: spawn as team-workers with callbacks if complex
+// For simple parallel: use multiple Agent calls synchronously or use team-coordinate's spawn-and-stop
+```
+
+### checkpoint node
+
+```
+// Save snapshot
+snapshot = {
+  session_id: session_state.session_id,
+  checkpoint_id: node.id,
+  checkpoint_name: node.name,
+  saved_at: now(),
+  node_states_snapshot: session_state.node_states,
+  last_completed_node: previous_node_id
+}
+
+write session-state.json (last_checkpoint = node.id)
+write <session_dir>/checkpoints/<node.id>.json
+
+if node.auto_continue == false:
+  // Pause for user
+  AskUserQuestion({
+    questions: [{
+      question: node.description + "\n\nReview checkpoint state and confirm to continue.",
+      header: "Checkpoint: " + node.name,
+      options: [
+        { label: "Continue", description: "Proceed to next node" },
+        { label: "Pause", description: "Save state and exit (resume later)" },
+        { label: "Abort", description: "Stop execution" }
+      ]
+    }]
+  })
+
+  on "Pause":
+    session_state.status = "paused"
+    write session-state.json
+    output "Session paused. Resume with: Skill(skill='wf-player', args='--resume <session_id>')"
+    EXIT
+
+  on "Abort":
+    session_state.status = "aborted"
+    write session-state.json
+    EXIT
+
+// auto_continue or user chose Continue
+mark checkpoint status = "completed"
+write session-state.json
+advance to next node
+```
+
+## Progress Display
+
+After each node completes, print progress:
+```
+[wf-player] [2/5] CP-01 checkpoint saved ✓
+[wf-player] [3/5] N-002 workflow-execute ... running
+```
+
+## Error Handling
+
+On node failure (exception or skill returning error state):
+
+```
+on_fail = node.on_fail || "abort"
+
+if on_fail == "skip":
+  mark node status = "skipped"
+  log warning
+  advance to next node
+
+if on_fail == "retry":
+  retry once
+  if still fails: fall through to abort
+
+if on_fail == "abort":
+  AskUserQuestion:
+    - Retry
+    - Skip this node
+    - Abort workflow
+  handle choice accordingly
+```
+
+## Loop Termination
+
+After last node in execution_plan completes:
+- All node_states should be "completed" or "skipped"
+- Proceed to Phase 4 (Complete)
diff --git a/.claude/skills/wf-player/phases/04-complete.md b/.claude/skills/wf-player/phases/04-complete.md
new file mode 100644
index 00000000..0e7ed510
--- /dev/null
+++ b/.claude/skills/wf-player/phases/04-complete.md
@@ -0,0 +1,93 @@
+# Phase 4: Complete — Archive + Summary
+
+## Objective
+
+Mark session complete, output execution summary with artifact paths, offer archive/keep options.
+
+## Workflow
+
+### Step 4.1 — Mark Session Complete
+
+Load `session-state.json`.
+
+Set:
+```json
+{
+  "status": "completed",
+  "completed_at": "<ISO timestamp>"
+}
+```
+
+Write back to `session-state.json`.
+
+### Step 4.2 — Collect Artifacts
+
+Aggregate all artifacts from node_states:
+```javascript
+const artifacts = Object.values(node_states)
+  .filter(s => s.artifacts && s.artifacts.length > 0)
+  .flatMap(s => s.artifacts.map(a => ({ node: s.node_id, path: a })));
+
+const outputPaths = Object.values(node_states)
+  .filter(s => s.output_path)
+  .map(s => ({ node: s.node_id, path: s.output_path }));
+```
+
+### Step 4.3 — Execution Summary
+
+```
+[wf-player] ============================================
+[wf-player] COMPLETE: <template_name>
+[wf-player]
+[wf-player] Session: <session_id>
+[wf-player] Context: goal="<value>"
+[wf-player]
+[wf-player] Nodes: <completed>/<total> completed
+[wf-player]   N-001  workflow-lite-plan     ✓  (WFS-plan-xxx)
+[wf-player]   CP-01  After Plan             ✓  (checkpoint saved)
+[wf-player]   N-002  workflow-execute       ✓  (WFS-exec-xxx)
+[wf-player]   CP-02  Before Tests           ✓  (checkpoint saved)
+[wf-player]   N-003  workflow-test-fix      ✓  (WFS-test-xxx)
+[wf-player]
+[wf-player] Artifacts:
+[wf-player]   - IMPL_PLAN.md         (N-001)
+[wf-player]   - src/auth/index.ts    (N-002)
+[wf-player]   - test/auth.test.ts    (N-003)
+[wf-player]
+[wf-player] Session dir: .workflow/sessions/<session_id>/
+[wf-player] ============================================
+```
+
+### Step 4.4 — Completion Action
+
+```
+AskUserQuestion({
+  questions: [{
+    question: "Workflow complete. What would you like to do?",
+    header: "Completion Action",
+    options: [
+      { label: "Archive session", description: "Move session to .workflow/sessions/archive/" },
+      { label: "Keep session", description: "Leave session active for follow-up" },
+      { label: "Run again", description: "Re-run template with same or new context" },
+      { label: "Nothing", description: "Done" }
+    ]
+  }]
+})
+```
+
+**Archive**:
+- Move `<session_dir>` to `.workflow/sessions/archive/<session_id>/`
+- Update `session-state.json` status = "archived"
+
+**Keep**: No action, session stays at `.workflow/sessions/<session_id>/`
+
+**Run again**:
+- AskUserQuestion: "Same context or new?" → new context → re-enter Phase 1
+
+**Nothing**: Output final artifact paths list, done.
+
+## Success Criteria
+
+- session-state.json status = "completed" or "archived"
+- All artifact paths listed in console output
+- User presented completion action options
diff --git a/.claude/skills/wf-player/specs/node-executor.md b/.claude/skills/wf-player/specs/node-executor.md
new file mode 100644
index 00000000..f52c62f1
--- /dev/null
+++ b/.claude/skills/wf-player/specs/node-executor.md
@@ -0,0 +1,187 @@
+# Node Executor — Execution Mechanisms per Node Type
+
+## Overview
+
+Each node type uses a specific execution mechanism. This spec defines the exact invocation pattern.
+
+## 1. skill node
+
+**Mechanism**: `Skill()` tool — synchronous, blocks until complete.
+
+```
+Skill({
+  skill: "<node.executor>",
+  args: "<resolved_args>"
+})
+```
+
+**Output extraction**: Parse Skill() result for:
+- Session ID pattern: `WFS-[a-z]+-\d{8}` or `TC-[a-z]+-\d{8}`
+- Output path: last `.md` or `.json` file path mentioned
+- Artifacts: all file paths in output
+
+**Session ID sources**:
+- Explicit: "Session: WFS-plan-20260317" in output
+- Implicit: first session-like ID in output
+
+**Examples**:
+```
+// Planning skill
+Skill({ skill: "workflow-lite-plan", args: "Implement user authentication" })
+
+// Execute skill (with prior session)
+Skill({ skill: "workflow-execute", args: "--resume-session WFS-plan-20260317" })
+
+// Test skill (with prior session)
+Skill({ skill: "workflow-test-fix", args: "--session WFS-exec-20260317" })
+```
+
+---
+
+## 2. command node
+
+**Mechanism**: `Skill()` tool with namespace command name — synchronous.
+
+```
+Skill({
+  skill: "<node.executor>",  // e.g. "workflow:refactor-cycle"
+  args: "<resolved_args>"
+})
+```
+
+**Examples**:
+```
+Skill({ skill: "workflow:refactor-cycle", args: "Reduce coupling in auth module" })
+Skill({ skill: "workflow:debug-with-file", args: "Login fails with 401 on valid tokens" })
+Skill({ skill: "issue:discover", args: "" })
+Skill({ skill: "issue:queue", args: "" })
+```
+
+---
+
+## 3. cli node
+
+**Mechanism**: `Bash()` with `run_in_background: true` — STOP after launch, resume via hook callback.
+
+```
+// Build command
+const prompt = resolveArgs(node.args_template, ...)
+const cmd = `ccw cli -p "${escapeForShell(prompt)}" --tool ${node.cli_tool} --mode ${node.cli_mode} --rule ${node.cli_rule}`
+
+// Launch background
+Bash({ command: cmd, run_in_background: true })
+
+// Save CLI task ID to node state for hook matching
+node_state.cli_task_id = <captured from stderr CCW_EXEC_ID>
+
+// Write session-state.json
+// STOP — do not proceed until hook callback fires
+```
+
+**Hook callback** (triggered when ccw cli completes):
+```
+// Identify which node was running (status = "running" with cli_task_id set)
+// Extract from CLI output:
+//   - output_path: file written by CLI
+//   - cli_exec_id: from CCW_EXEC_ID
+// Mark node completed
+// Advance to next node
+```
+
+**CLI output escaping**:
+```javascript
+function escapeForShell(s) {
+  // Use single quotes with escaped single quotes inside
+  return "'" + s.replace(/'/g, "'\\''") + "'"
+}
+```
+
+**Example**:
+```
+Bash({
+  command: `ccw cli -p 'PURPOSE: Analyze auth module architecture\nTASK: • Review class structure • Check dependencies\nMODE: analysis\nCONTEXT: @src/auth/**/*\nEXPECTED: Architecture report with issues list\nCONSTRAINTS: Read only' --tool gemini --mode analysis --rule analysis-review-architecture`,
+  run_in_background: true
+})
+```
+
+---
+
+## 4. agent node
+
+**Mechanism**: `Agent()` tool.
+
+Single agent (serial):
+```
+Agent({
+  subagent_type: node.executor,       // "general-purpose" or "code-reviewer"
+  prompt: resolveArgs(node.args_template, ...),
+  run_in_background: false,           // blocks until complete
+  description: node.name
+})
+```
+
+Parallel agents (same parallel_group — use team-coordinate pattern):
+```
+// For 2-3 parallel agents: launch all with run_in_background: true
+// Use SendMessage/callback or wait with sequential Skill() calls
+// For complex parallel pipelines: delegate to team-coordinate
+
+Skill({
+  skill: "team-coordinate",
+  args: "<description of parallel work>"
+})
+```
+
+**Output extraction**:
+- Agent output is usually the full response text
+- Look for file paths in output for `output_path`
+
+---
+
+## 5. checkpoint node
+
+**Mechanism**: Pure state management — no external calls unless `auto_continue: false`.
+
+```
+// 1. Write checkpoint snapshot
+Write({
+  file_path: "<session_dir>/checkpoints/<node.id>.json",
+  content: JSON.stringify({
+    session_id, checkpoint_id: node.id, checkpoint_name: node.name,
+    saved_at: now(), context_snapshot: session_state.context,
+    node_states_snapshot: session_state.node_states,
+    last_completed_node: prev_node_id,
+    next_node: next_node_id
+  }, null, 2)
+})
+
+// 2. Update session state
+session_state.last_checkpoint = node.id
+node_states[node.id].status = "completed"
+node_states[node.id].saved_at = now()
+node_states[node.id].snapshot_path = checkpointPath
+
+Write({ file_path: session_state_path, content: JSON.stringify(session_state, null, 2) })
+
+// 3. If auto_continue = false: pause for user (see 03-execute.md)
+// 4. If auto_continue = true: proceed immediately
+```
+
+---
+
+## Context Passing Between Nodes
+
+The runtime reference resolver in `03-execute.md` handles `{N-xxx.field}` substitution.
+
+**Key resolved fields by node type**:
+
+| Node type | Exposes | Referenced as |
+|-----------|---------|---------------|
+| skill | session_id | `{N-001.session_id}` |
+| skill | output_path | `{N-001.output_path}` |
+| skill | artifacts[0] | `{N-001.artifacts[0]}` |
+| cli | output_path | `{N-001.output_path}` |
+| agent | output_path | `{N-001.output_path}` |
+| any | shorthand prev | `{prev_session_id}`, `{prev_output_path}` |
+
+**Fallback**: If referenced field is null/empty, the args_template substitution results in empty string. The executor should handle gracefully (most skills default to latest session).
diff --git a/.claude/skills/wf-player/specs/state-schema.md b/.claude/skills/wf-player/specs/state-schema.md
new file mode 100644
index 00000000..27532d4b
--- /dev/null
+++ b/.claude/skills/wf-player/specs/state-schema.md
@@ -0,0 +1,136 @@
+# Session State Schema
+
+## File Location
+
+`.workflow/sessions/WFR-<slug>-<date>-<time>/session-state.json`
+
+## Full Schema
+
+```json
+{
+  "session_id": "WFR-feature-tdd-review-20260317-143022",
+  "template_id": "wft-feature-tdd-review-20260310",
+  "template_path": ".workflow/templates/feature-tdd-review.json",
+  "template_name": "Feature TDD with Review",
+
+  "status": "running | paused | completed | failed | aborted | archived",
+
+  "context": {
+    "goal": "Implement user authentication",
+    "scope": "src/auth"
+  },
+
+  "execution_plan": [
+    { "batch": 1, "nodes": ["N-001"], "parallel": false },
+    { "batch": 2, "nodes": ["CP-01"], "parallel": false },
+    { "batch": 3, "nodes": ["N-002"], "parallel": false },
+    { "batch": 4, "nodes": ["CP-02"], "parallel": false },
+    { "batch": 5, "nodes": ["N-003a", "N-003b"], "parallel": true },
+    { "batch": 6, "nodes": ["N-004"], "parallel": false }
+  ],
+
+  "current_batch": 3,
+  "current_node": "N-002",
+  "last_checkpoint": "CP-01",
+
+  "node_states": {
+    "N-001": {
+      "status": "completed",
+      "started_at": "2026-03-17T14:30:25Z",
+      "completed_at": "2026-03-17T14:35:10Z",
+      "session_id": "WFS-plan-20260317",
+      "output_path": ".workflow/sessions/WFS-plan-20260317/IMPL_PLAN.md",
+      "artifacts": [
+        ".workflow/sessions/WFS-plan-20260317/IMPL_PLAN.md"
+      ],
+      "error": null
+    },
+    "CP-01": {
+      "status": "completed",
+      "saved_at": "2026-03-17T14:35:12Z",
+      "snapshot_path": ".workflow/sessions/WFR-feature-tdd-review-20260317-143022/checkpoints/CP-01.json",
+      "auto_continue": true
+    },
+    "N-002": {
+      "status": "running",
+      "started_at": "2026-03-17T14:35:14Z",
+      "completed_at": null,
+      "session_id": null,
+      "output_path": null,
+      "artifacts": [],
+      "error": null,
+      "cli_task_id": "gem-143514-x7k2"
+    },
+    "CP-02": {
+      "status": "pending",
+      "saved_at": null,
+      "snapshot_path": null
+    },
+    "N-003a": {
+      "status": "pending",
+      "started_at": null,
+      "completed_at": null,
+      "session_id": null,
+      "output_path": null,
+      "artifacts": [],
+      "error": null
+    },
+    "N-003b": { "status": "pending", "..." : "..." },
+    "N-004": { "status": "pending", "..." : "..." }
+  },
+
+  "created_at": "2026-03-17T14:30:22Z",
+  "updated_at": "2026-03-17T14:35:14Z",
+  "completed_at": null
+}
+```
+
+## Status Values
+
+| Status | Description |
+|--------|-------------|
+| `running` | Active execution in progress |
+| `paused` | User paused at checkpoint — resume with `--resume` |
+| `completed` | All nodes executed successfully |
+| `failed` | A node failed and abort was chosen |
+| `aborted` | User aborted at checkpoint |
+| `archived` | Completed and moved to archive/ |
+
+## Node State Status Values
+
+| Status | Description |
+|--------|-------------|
+| `pending` | Not yet started |
+| `running` | Currently executing (may be waiting for CLI callback) |
+| `completed` | Successfully finished |
+| `skipped` | Skipped due to `on_fail: skip` |
+| `failed` | Execution error |
+
+## Checkpoint Snapshot Schema
+
+`.workflow/sessions/<wfr-id>/checkpoints/<CP-id>.json`:
+
+```json
+{
+  "session_id": "WFR-<id>",
+  "checkpoint_id": "CP-01",
+  "checkpoint_name": "After Plan",
+  "saved_at": "2026-03-17T14:35:12Z",
+  "context_snapshot": { "goal": "...", "scope": "..." },
+  "node_states_snapshot": { /* full node_states at this point */ },
+  "last_completed_node": "N-001",
+  "next_node": "N-002"
+}
+```
+
+## Session Directory Structure
+
+```
+.workflow/sessions/WFR-<slug>-<date>-<time>/
++-- session-state.json       # Main state file, updated after every node
++-- checkpoints/             # Checkpoint snapshots
+|   +-- CP-01.json
+|   +-- CP-02.json
++-- artifacts/               # Optional: copies of key artifacts
+    +-- N-001-output.md
+```
diff --git a/ccw/frontend/src/components/codexlens/AdvancedTab.test.tsx b/ccw/frontend/src/components/codexlens/AdvancedTab.test.tsx
deleted file mode 100644
index 42c7349f..00000000
--- a/ccw/frontend/src/components/codexlens/AdvancedTab.test.tsx
+++ /dev/null
@@ -1,154 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { fireEvent } from '@testing-library/react';
-import { render, screen, waitFor } from '@/test/i18n';
-import { AdvancedTab } from './AdvancedTab';
-
-vi.mock('@/hooks', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('@/hooks')>();
-  return {
-    ...actual,
-    useCodexLensEnv: vi.fn(),
-    useUpdateCodexLensEnv: vi.fn(),
-    useCodexLensIgnorePatterns: vi.fn(),
-    useUpdateIgnorePatterns: vi.fn(),
-    useNotifications: vi.fn(),
-  };
-});
-
-import {
-  useCodexLensEnv,
-  useUpdateCodexLensEnv,
-  useCodexLensIgnorePatterns,
-  useUpdateIgnorePatterns,
-  useNotifications,
-} from '@/hooks';
-
-const mockRefetchEnv = vi.fn().mockResolvedValue(undefined);
-const mockRefetchPatterns = vi.fn().mockResolvedValue(undefined);
-const mockUpdateEnv = vi.fn().mockResolvedValue({ success: true, message: 'Saved' });
-const mockUpdatePatterns = vi.fn().mockResolvedValue({
-  success: true,
-  patterns: ['dist', 'frontend/dist'],
-  extensionFilters: ['*.min.js', 'frontend/skip.ts'],
-  defaults: {
-    patterns: ['dist', 'build'],
-    extensionFilters: ['*.min.js'],
-  },
-});
-const mockToastSuccess = vi.fn();
-const mockToastError = vi.fn();
-
-function setupDefaultMocks() {
-  vi.mocked(useCodexLensEnv).mockReturnValue({
-    data: { success: true, env: {}, settings: {}, raw: '', path: '~/.codexlens/.env' },
-    raw: '',
-    env: {},
-    settings: {},
-    isLoading: false,
-    error: null,
-    refetch: mockRefetchEnv,
-  });
-
-  vi.mocked(useUpdateCodexLensEnv).mockReturnValue({
-    updateEnv: mockUpdateEnv,
-    isUpdating: false,
-    error: null,
-  });
-
-  vi.mocked(useCodexLensIgnorePatterns).mockReturnValue({
-    data: {
-      success: true,
-      patterns: ['dist', 'coverage'],
-      extensionFilters: ['*.min.js', '*.map'],
-      defaults: {
-        patterns: ['dist', 'build', 'coverage'],
-        extensionFilters: ['*.min.js', '*.map'],
-      },
-    },
-    patterns: ['dist', 'coverage'],
-    extensionFilters: ['*.min.js', '*.map'],
-    defaults: {
-      patterns: ['dist', 'build', 'coverage'],
-      extensionFilters: ['*.min.js', '*.map'],
-    },
-    isLoading: false,
-    error: null,
-    refetch: mockRefetchPatterns,
-  });
-
-  vi.mocked(useUpdateIgnorePatterns).mockReturnValue({
-    updatePatterns: mockUpdatePatterns,
-    isUpdating: false,
-    error: null,
-  });
-
-  vi.mocked(useNotifications).mockReturnValue({
-    success: mockToastSuccess,
-    error: mockToastError,
-  } as unknown as ReturnType<typeof useNotifications>);
-}
-
-describe('AdvancedTab', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    setupDefaultMocks();
-  });
-
-  it('renders existing filter configuration', () => {
-    render(<AdvancedTab enabled={true} />);
-
-    expect(screen.getByLabelText(/Ignored directories \/ paths/i)).toHaveValue('dist\ncoverage');
-    expect(screen.getByLabelText(/Skipped files \/ globs/i)).toHaveValue('*.min.js\n*.map');
-    expect(screen.getByText(/Directory filters: 2/i)).toBeInTheDocument();
-    expect(screen.getByText(/File filters: 2/i)).toBeInTheDocument();
-  });
-
-  it('saves parsed filter configuration', async () => {
-    render(<AdvancedTab enabled={true} />);
-
-    const ignorePatternsInput = screen.getByLabelText(/Ignored directories \/ paths/i);
-    const extensionFiltersInput = screen.getByLabelText(/Skipped files \/ globs/i);
-
-    fireEvent.change(ignorePatternsInput, { target: { value: 'dist,\nfrontend/dist' } });
-    fireEvent.change(extensionFiltersInput, { target: { value: '*.min.js,\nfrontend/skip.ts' } });
-    fireEvent.click(screen.getByRole('button', { name: /Save filters/i }));
-
-    await waitFor(() => {
-      expect(mockUpdatePatterns).toHaveBeenCalledWith({
-        patterns: ['dist', 'frontend/dist'],
-        extensionFilters: ['*.min.js', 'frontend/skip.ts'],
-      });
-    });
-    expect(mockRefetchPatterns).toHaveBeenCalled();
-  });
-
-  it('restores default filter values before saving', async () => {
-    render(<AdvancedTab enabled={true} />);
-
-    fireEvent.click(screen.getByRole('button', { name: /Restore defaults/i }));
-
-    expect(screen.getByLabelText(/Ignored directories \/ paths/i)).toHaveValue('dist\nbuild\ncoverage');
-    expect(screen.getByLabelText(/Skipped files \/ globs/i)).toHaveValue('*.min.js\n*.map');
-
-    fireEvent.click(screen.getByRole('button', { name: /Save filters/i }));
-
-    await waitFor(() => {
-      expect(mockUpdatePatterns).toHaveBeenCalledWith({
-        patterns: ['dist', 'build', 'coverage'],
-        extensionFilters: ['*.min.js', '*.map'],
-      });
-    });
-  });
-
-  it('blocks invalid filter entries before saving', async () => {
-    render(<AdvancedTab enabled={true} />);
-
-    fireEvent.change(screen.getByLabelText(/Ignored directories \/ paths/i), {
-      target: { value: 'bad pattern!' },
-    });
-    fireEvent.click(screen.getByRole('button', { name: /Save filters/i }));
-
-    expect(mockUpdatePatterns).not.toHaveBeenCalled();
-    expect(screen.getByText(/Invalid ignore patterns/i)).toBeInTheDocument();
-  });
-});
diff --git a/ccw/frontend/src/components/codexlens/AdvancedTab.tsx b/ccw/frontend/src/components/codexlens/AdvancedTab.tsx
deleted file mode 100644
index e19bb070..00000000
--- a/ccw/frontend/src/components/codexlens/AdvancedTab.tsx
+++ /dev/null
@@ -1,704 +0,0 @@
-// ========================================
-// CodexLens Advanced Tab
-// ========================================
-// Advanced settings including .env editor and ignore patterns
-
-import { useState, useEffect } from 'react';
-import { useIntl } from 'react-intl';
-import { Save, RefreshCw, AlertTriangle, FileCode, AlertCircle, Filter } from 'lucide-react';
-import { Card } from '@/components/ui/Card';
-import { Textarea } from '@/components/ui/Textarea';
-import { Button } from '@/components/ui/Button';
-import { Label } from '@/components/ui/Label';
-import { Badge } from '@/components/ui/Badge';
-import {
-  useCodexLensEnv,
-  useCodexLensIgnorePatterns,
-  useUpdateCodexLensEnv,
-  useUpdateIgnorePatterns,
-} from '@/hooks';
-import { useNotifications } from '@/hooks';
-import { cn } from '@/lib/utils';
-import { CcwToolsCard } from './CcwToolsCard';
-
-interface AdvancedTabProps {
-  enabled?: boolean;
-}
-
-interface FormErrors {
-  env?: string;
-  ignorePatterns?: string;
-  extensionFilters?: string;
-}
-
-const FILTER_ENTRY_PATTERN = /^[-\w.*\\/]+$/;
-
-function parseListEntries(text: string): string[] {
-  return text
-    .split(/[\n,]/)
-    .map((entry) => entry.trim())
-    .filter(Boolean);
-}
-
-function normalizeListEntries(entries: string[]): string {
-  return entries
-    .map((entry) => entry.trim())
-    .filter(Boolean)
-    .join('\n');
-}
-
-function normalizeListText(text: string): string {
-  return normalizeListEntries(parseListEntries(text));
-}
-
-export function AdvancedTab({ enabled = true }: AdvancedTabProps) {
-  const { formatMessage } = useIntl();
-  const { success, error: showError } = useNotifications();
-
-  const {
-    raw,
-    env,
-    settings,
-    isLoading: isLoadingEnv,
-    error: envError,
-    refetch,
-  } = useCodexLensEnv({ enabled });
-
-  const {
-    patterns,
-    extensionFilters,
-    defaults,
-    isLoading: isLoadingPatterns,
-    error: patternsError,
-    refetch: refetchPatterns,
-  } = useCodexLensIgnorePatterns({ enabled });
-
-  const { updateEnv, isUpdating } = useUpdateCodexLensEnv();
-  const { updatePatterns, isUpdating: isUpdatingPatterns } = useUpdateIgnorePatterns();
-
-  // Form state
-  const [envInput, setEnvInput] = useState('');
-  const [ignorePatternsInput, setIgnorePatternsInput] = useState('');
-  const [extensionFiltersInput, setExtensionFiltersInput] = useState('');
-  const [errors, setErrors] = useState<FormErrors>({});
-  const [hasChanges, setHasChanges] = useState(false);
-  const [hasFilterChanges, setHasFilterChanges] = useState(false);
-  const [showWarning, setShowWarning] = useState(false);
-
-  const currentIgnorePatterns = patterns ?? [];
-  const currentExtensionFilters = extensionFilters ?? [];
-  const defaultIgnorePatterns = defaults?.patterns ?? [];
-  const defaultExtensionFilters = defaults?.extensionFilters ?? [];
-
-  // Initialize form from env - handles both undefined (loading) and empty string (empty file)
-  // The hook returns raw directly, so we check if it's been set (not undefined means data loaded)
-  useEffect(() => {
-    // Initialize when data is loaded (raw may be empty string but not undefined during loading)
-    // Note: During initial load, raw is undefined. After load completes, raw is set (even if empty string)
-    if (!isLoadingEnv) {
-      setEnvInput(raw ?? ''); // Use empty string if raw is undefined/null
-      setErrors({});
-      setHasChanges(false);
-      setShowWarning(false);
-    }
-  }, [raw, isLoadingEnv]);
-
-  useEffect(() => {
-    if (!isLoadingPatterns) {
-      const nextIgnorePatterns = patterns ?? [];
-      const nextExtensionFilters = extensionFilters ?? [];
-      setIgnorePatternsInput(nextIgnorePatterns.join('\n'));
-      setExtensionFiltersInput(nextExtensionFilters.join('\n'));
-      setErrors((prev) => ({
-        ...prev,
-        ignorePatterns: undefined,
-        extensionFilters: undefined,
-      }));
-      setHasFilterChanges(false);
-    }
-  }, [extensionFilters, isLoadingPatterns, patterns]);
-
-  const updateFilterChangeState = (nextIgnorePatternsInput: string, nextExtensionFiltersInput: string) => {
-    const normalizedCurrentIgnorePatterns = normalizeListEntries(currentIgnorePatterns);
-    const normalizedCurrentExtensionFilters = normalizeListEntries(currentExtensionFilters);
-
-    setHasFilterChanges(
-      normalizeListText(nextIgnorePatternsInput) !== normalizedCurrentIgnorePatterns
-      || normalizeListText(nextExtensionFiltersInput) !== normalizedCurrentExtensionFilters
-    );
-  };
-
-  const handleEnvChange = (value: string) => {
-    setEnvInput(value);
-    // Check if there are changes - compare with raw value (handle undefined as empty)
-    const currentRaw = raw ?? '';
-    setHasChanges(value !== currentRaw);
-    setShowWarning(value !== currentRaw);
-    if (errors.env) {
-      setErrors((prev) => ({ ...prev, env: undefined }));
-    }
-  };
-
-  const handleIgnorePatternsChange = (value: string) => {
-    setIgnorePatternsInput(value);
-    updateFilterChangeState(value, extensionFiltersInput);
-    if (errors.ignorePatterns) {
-      setErrors((prev) => ({ ...prev, ignorePatterns: undefined }));
-    }
-  };
-
-  const handleExtensionFiltersChange = (value: string) => {
-    setExtensionFiltersInput(value);
-    updateFilterChangeState(ignorePatternsInput, value);
-    if (errors.extensionFilters) {
-      setErrors((prev) => ({ ...prev, extensionFilters: undefined }));
-    }
-  };
-
-  const parseEnvVariables = (text: string): Record<string, string> => {
-    const envObj: Record<string, string> = {};
-    const lines = text.split('\n');
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (trimmed && !trimmed.startsWith('#') && trimmed.includes('=')) {
-        const [key, ...valParts] = trimmed.split('=');
-        const val = valParts.join('=');
-        if (key) {
-          envObj[key.trim()] = val.trim();
-        }
-      }
-    }
-    return envObj;
-  };
-
-  const validateForm = (): boolean => {
-    const newErrors: FormErrors = {};
-    const parsed = parseEnvVariables(envInput);
-
-    // Check for invalid variable names
-    const invalidKeys = Object.keys(parsed).filter(
-      (key) => !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key)
-    );
-
-    if (invalidKeys.length > 0) {
-      newErrors.env = formatMessage(
-        { id: 'codexlens.advanced.validation.invalidKeys' },
-        { keys: invalidKeys.join(', ') }
-      );
-    }
-
-    setErrors((prev) => ({ ...prev, env: newErrors.env }));
-    return Object.keys(newErrors).length === 0;
-  };
-
-  const validateFilterForm = (): boolean => {
-    const nextErrors: Pick<FormErrors, 'ignorePatterns' | 'extensionFilters'> = {};
-    const parsedIgnorePatterns = parseListEntries(ignorePatternsInput);
-    const parsedExtensionFilters = parseListEntries(extensionFiltersInput);
-
-    const invalidIgnorePatterns = parsedIgnorePatterns.filter(
-      (entry) => !FILTER_ENTRY_PATTERN.test(entry)
-    );
-    if (invalidIgnorePatterns.length > 0) {
-      nextErrors.ignorePatterns = formatMessage(
-        {
-          id: 'codexlens.advanced.validation.invalidIgnorePatterns',
-          defaultMessage: 'Invalid ignore patterns: {values}',
-        },
-        { values: invalidIgnorePatterns.join(', ') }
-      );
-    }
-
-    const invalidExtensionFilters = parsedExtensionFilters.filter(
-      (entry) => !FILTER_ENTRY_PATTERN.test(entry)
-    );
-    if (invalidExtensionFilters.length > 0) {
-      nextErrors.extensionFilters = formatMessage(
-        {
-          id: 'codexlens.advanced.validation.invalidExtensionFilters',
-          defaultMessage: 'Invalid file filters: {values}',
-        },
-        { values: invalidExtensionFilters.join(', ') }
-      );
-    }
-
-    setErrors((prev) => ({
-      ...prev,
-      ignorePatterns: nextErrors.ignorePatterns,
-      extensionFilters: nextErrors.extensionFilters,
-    }));
-
-    return Object.values(nextErrors).every((value) => !value);
-  };
-
-  const handleSave = async () => {
-    if (!validateForm()) {
-      return;
-    }
-
-    try {
-      const parsed = parseEnvVariables(envInput);
-      const result = await updateEnv({ env: parsed });
-
-      if (result.success) {
-        success(
-          formatMessage({ id: 'codexlens.advanced.saveSuccess' }),
-          result.message || formatMessage({ id: 'codexlens.advanced.envUpdated' })
-        );
-        refetch();
-        setShowWarning(false);
-      } else {
-        showError(
-          formatMessage({ id: 'codexlens.advanced.saveFailed' }),
-          result.message || formatMessage({ id: 'codexlens.advanced.saveError' })
-        );
-      }
-    } catch (err) {
-      showError(
-        formatMessage({ id: 'codexlens.advanced.saveFailed' }),
-        err instanceof Error ? err.message : formatMessage({ id: 'codexlens.advanced.unknownError' })
-      );
-    }
-  };
-
-  const handleReset = () => {
-    // Reset to current raw value (handle undefined as empty)
-    setEnvInput(raw ?? '');
-    setErrors((prev) => ({ ...prev, env: undefined }));
-    setHasChanges(false);
-    setShowWarning(false);
-  };
-
-  const handleSaveFilters = async () => {
-    if (!validateFilterForm()) {
-      return;
-    }
-
-    const parsedIgnorePatterns = parseListEntries(ignorePatternsInput);
-    const parsedExtensionFilters = parseListEntries(extensionFiltersInput);
-
-    try {
-      const result = await updatePatterns({
-        patterns: parsedIgnorePatterns,
-        extensionFilters: parsedExtensionFilters,
-      });
-
-      if (result.success) {
-        setIgnorePatternsInput((result.patterns ?? parsedIgnorePatterns).join('\n'));
-        setExtensionFiltersInput((result.extensionFilters ?? parsedExtensionFilters).join('\n'));
-        setHasFilterChanges(false);
-        setErrors((prev) => ({
-          ...prev,
-          ignorePatterns: undefined,
-          extensionFilters: undefined,
-        }));
-        await refetchPatterns();
-      }
-    } catch {
-      // Hook-level mutation already reports the error.
-    }
-  };
-
-  const handleResetFilters = () => {
-    setIgnorePatternsInput(currentIgnorePatterns.join('\n'));
-    setExtensionFiltersInput(currentExtensionFilters.join('\n'));
-    setErrors((prev) => ({
-      ...prev,
-      ignorePatterns: undefined,
-      extensionFilters: undefined,
-    }));
-    setHasFilterChanges(false);
-  };
-
-  const handleRestoreDefaultFilters = () => {
-    const defaultIgnoreText = defaultIgnorePatterns.join('\n');
-    const defaultExtensionText = defaultExtensionFilters.join('\n');
-
-    setIgnorePatternsInput(defaultIgnoreText);
-    setExtensionFiltersInput(defaultExtensionText);
-    setErrors((prev) => ({
-      ...prev,
-      ignorePatterns: undefined,
-      extensionFilters: undefined,
-    }));
-    updateFilterChangeState(defaultIgnoreText, defaultExtensionText);
-  };
-
-  const isLoading = isLoadingEnv;
-  const isLoadingFilters = isLoadingPatterns;
-
-  // Get current env variables as array for display
-  const currentEnvVars = env
-    ? Object.entries(env).map(([key, value]) => ({ key, value }))
-    : [];
-
-  // Get settings variables
-  const settingsVars = settings
-    ? Object.entries(settings).map(([key, value]) => ({ key, value }))
-    : [];
-
-  return (
-    <div className="space-y-6">
-      {/* Error Card */}
-      {envError && (
-        <Card className="p-4 bg-destructive/10 border-destructive/20">
-          <div className="flex items-start gap-3">
-            <AlertCircle className="w-5 h-5 text-destructive flex-shrink-0 mt-0.5" />
-            <div className="flex-1">
-              <h4 className="text-sm font-medium text-destructive-foreground">
-                {formatMessage({ id: 'codexlens.advanced.loadError' })}
-              </h4>
-              <p className="text-xs text-destructive-foreground/80 mt-1">
-                {envError.message || formatMessage({ id: 'codexlens.advanced.loadErrorDesc' })}
-              </p>
-              <Button
-                variant="outline"
-                size="sm"
-                onClick={() => refetch()}
-                className="mt-2"
-              >
-                <RefreshCw className="w-3 h-3 mr-1" />
-                {formatMessage({ id: 'common.actions.retry' })}
-              </Button>
-            </div>
-          </div>
-        </Card>
-      )}
-
-      {/* Sensitivity Warning Card */}
-      {showWarning && (
-        <Card className="p-4 bg-warning/10 border-warning/20">
-          <div className="flex items-start gap-3">
-            <AlertTriangle className="w-5 h-5 text-warning flex-shrink-0 mt-0.5" />
-            <div>
-              <h4 className="text-sm font-medium text-warning-foreground">
-                {formatMessage({ id: 'codexlens.advanced.warningTitle' })}
-              </h4>
-              <p className="text-xs text-warning-foreground/80 mt-1">
-                {formatMessage({ id: 'codexlens.advanced.warningMessage' })}
-              </p>
-            </div>
-          </div>
-        </Card>
-      )}
-
-      {/* Current Variables Summary */}
-      {(currentEnvVars.length > 0 || settingsVars.length > 0) && (
-        <Card className="p-4 bg-muted/30">
-          <h4 className="text-sm font-medium text-foreground mb-3">
-            {formatMessage({ id: 'codexlens.advanced.currentVars' })}
-          </h4>
-          <div className="space-y-3">
-            {settingsVars.length > 0 && (
-              <div>
-                <p className="text-xs text-muted-foreground mb-2">
-                  {formatMessage({ id: 'codexlens.advanced.settingsVars' })}
-                </p>
-                <div className="flex flex-wrap gap-2">
-                  {settingsVars.map(({ key }) => (
-                    <Badge key={key} variant="outline" className="font-mono text-xs">
-                      {key}
-                    </Badge>
-                  ))}
-                </div>
-              </div>
-            )}
-            {currentEnvVars.length > 0 && (
-              <div>
-                <p className="text-xs text-muted-foreground mb-2">
-                  {formatMessage({ id: 'codexlens.advanced.customVars' })}
-                </p>
-                <div className="flex flex-wrap gap-2">
-                  {currentEnvVars.map(({ key }) => (
-                    <Badge key={key} variant="secondary" className="font-mono text-xs">
-                      {key}
-                    </Badge>
-                  ))}
-                </div>
-              </div>
-            )}
-          </div>
-        </Card>
-      )}
-
-      {/* CCW Tools Card */}
-      <CcwToolsCard />
-
-      {/* Index Filters */}
-      <Card className="p-6">
-        <div className="flex flex-col gap-3 mb-4 lg:flex-row lg:items-center lg:justify-between">
-          <div className="flex items-center gap-2">
-            <Filter className="w-5 h-5 text-muted-foreground" />
-            <h3 className="text-lg font-semibold text-foreground">
-              {formatMessage({
-                id: 'codexlens.advanced.indexFilters',
-                defaultMessage: 'Index Filters',
-              })}
-            </h3>
-          </div>
-          <div className="flex flex-wrap items-center gap-2">
-            <Badge variant="outline" className="text-xs">
-              {formatMessage(
-                {
-                  id: 'codexlens.advanced.ignorePatternCount',
-                  defaultMessage: 'Directory filters: {count}',
-                },
-                { count: currentIgnorePatterns.length }
-              )}
-            </Badge>
-            <Badge variant="outline" className="text-xs">
-              {formatMessage(
-                {
-                  id: 'codexlens.advanced.extensionFilterCount',
-                  defaultMessage: 'File filters: {count}',
-                },
-                { count: currentExtensionFilters.length }
-              )}
-            </Badge>
-          </div>
-        </div>
-
-        <div className="space-y-4">
-          {patternsError && (
-            <div className="rounded-md border border-destructive/20 bg-destructive/5 p-3">
-              <div className="flex items-start gap-2">
-                <AlertCircle className="w-4 h-4 mt-0.5 text-destructive" />
-                <div>
-                  <p className="text-sm font-medium text-destructive">
-                    {formatMessage({
-                      id: 'codexlens.advanced.filtersLoadError',
-                      defaultMessage: 'Unable to load current filter settings',
-                    })}
-                  </p>
-                  <p className="text-xs text-destructive/80 mt-1">{patternsError.message}</p>
-                </div>
-              </div>
-            </div>
-          )}
-
-          <div className="grid gap-4 xl:grid-cols-2">
-            <div className="space-y-2">
-              <Label htmlFor="ignore-patterns-input">
-                {formatMessage({
-                  id: 'codexlens.advanced.ignorePatterns',
-                  defaultMessage: 'Ignored directories / paths',
-                })}
-              </Label>
-              <Textarea
-                id="ignore-patterns-input"
-                value={ignorePatternsInput}
-                onChange={(event) => handleIgnorePatternsChange(event.target.value)}
-                placeholder={formatMessage({
-                  id: 'codexlens.advanced.ignorePatternsPlaceholder',
-                  defaultMessage: 'dist\nfrontend/dist\ncoverage',
-                })}
-                className={cn(
-                  'min-h-[220px] font-mono text-sm',
-                  errors.ignorePatterns && 'border-destructive focus-visible:ring-destructive'
-                )}
-                disabled={isLoadingFilters || isUpdatingPatterns}
-              />
-              {errors.ignorePatterns && (
-                <p className="text-sm text-destructive">{errors.ignorePatterns}</p>
-              )}
-              <p className="text-xs text-muted-foreground">
-                {formatMessage({
-                  id: 'codexlens.advanced.ignorePatternsHint',
-                  defaultMessage: 'One entry per line. Supports exact names, relative paths, and glob patterns.',
-                })}
-              </p>
-            </div>
-
-            <div className="space-y-2">
-              <Label htmlFor="extension-filters-input">
-                {formatMessage({
-                  id: 'codexlens.advanced.extensionFilters',
-                  defaultMessage: 'Skipped files / globs',
-                })}
-              </Label>
-              <Textarea
-                id="extension-filters-input"
-                value={extensionFiltersInput}
-                onChange={(event) => handleExtensionFiltersChange(event.target.value)}
-                placeholder={formatMessage({
-                  id: 'codexlens.advanced.extensionFiltersPlaceholder',
-                  defaultMessage: '*.min.js\n*.map\npackage-lock.json',
-                })}
-                className={cn(
-                  'min-h-[220px] font-mono text-sm',
-                  errors.extensionFilters && 'border-destructive focus-visible:ring-destructive'
-                )}
-                disabled={isLoadingFilters || isUpdatingPatterns}
-              />
-              {errors.extensionFilters && (
-                <p className="text-sm text-destructive">{errors.extensionFilters}</p>
-              )}
-              <p className="text-xs text-muted-foreground">
-                {formatMessage({
-                  id: 'codexlens.advanced.extensionFiltersHint',
-                  defaultMessage: 'Use this for generated or low-value files that should stay out of the index.',
-                })}
-              </p>
-            </div>
-          </div>
-
-          <div className="grid gap-3 rounded-md border border-border/60 bg-muted/30 p-3 md:grid-cols-2">
-            <div>
-              <p className="text-xs font-medium text-foreground">
-                {formatMessage({
-                  id: 'codexlens.advanced.defaultIgnorePatterns',
-                  defaultMessage: 'Default directory filters',
-                })}
-              </p>
-              <div className="mt-2 flex flex-wrap gap-2">
-                {defaultIgnorePatterns.slice(0, 6).map((pattern) => (
-                  <Badge key={pattern} variant="secondary" className="font-mono text-xs">
-                    {pattern}
-                  </Badge>
-                ))}
-                {defaultIgnorePatterns.length > 6 && (
-                  <Badge variant="outline" className="text-xs">
-                    +{defaultIgnorePatterns.length - 6}
-                  </Badge>
-                )}
-              </div>
-            </div>
-
-            <div>
-              <p className="text-xs font-medium text-foreground">
-                {formatMessage({
-                  id: 'codexlens.advanced.defaultExtensionFilters',
-                  defaultMessage: 'Default file filters',
-                })}
-              </p>
-              <div className="mt-2 flex flex-wrap gap-2">
-                {defaultExtensionFilters.slice(0, 6).map((pattern) => (
-                  <Badge key={pattern} variant="secondary" className="font-mono text-xs">
-                    {pattern}
-                  </Badge>
-                ))}
-                {defaultExtensionFilters.length > 6 && (
-                  <Badge variant="outline" className="text-xs">
-                    +{defaultExtensionFilters.length - 6}
-                  </Badge>
-                )}
-              </div>
-            </div>
-          </div>
-
-          <div className="flex flex-wrap items-center gap-2">
-            <Button
-              onClick={handleSaveFilters}
-              disabled={isLoadingFilters || isUpdatingPatterns || !hasFilterChanges}
-            >
-              <Save className={cn('w-4 h-4 mr-2', isUpdatingPatterns && 'animate-spin')} />
-              {isUpdatingPatterns
-                ? formatMessage({ id: 'codexlens.advanced.saving', defaultMessage: 'Saving...' })
-                : formatMessage({
-                  id: 'codexlens.advanced.saveFilters',
-                  defaultMessage: 'Save filters',
-                })
-              }
-            </Button>
-            <Button
-              variant="outline"
-              onClick={handleResetFilters}
-              disabled={isLoadingFilters || !hasFilterChanges}
-            >
-              <RefreshCw className="w-4 h-4 mr-2" />
-              {formatMessage({ id: 'codexlens.advanced.reset', defaultMessage: 'Reset' })}
-            </Button>
-            <Button
-              variant="outline"
-              onClick={handleRestoreDefaultFilters}
-              disabled={isLoadingFilters || isUpdatingPatterns}
-            >
-              {formatMessage({
-                id: 'codexlens.advanced.restoreDefaults',
-                defaultMessage: 'Restore defaults',
-              })}
-            </Button>
-          </div>
-        </div>
-      </Card>
-
-      {/* Environment Variables Editor */}
-      <Card className="p-6">
-        <div className="flex items-center justify-between mb-4">
-          <div className="flex items-center gap-2">
-            <FileCode className="w-5 h-5 text-muted-foreground" />
-            <h3 className="text-lg font-semibold text-foreground">
-              {formatMessage({ id: 'codexlens.advanced.envEditor' })}
-            </h3>
-          </div>
-          <Badge variant="outline" className="text-xs">
-            {formatMessage({ id: 'codexlens.advanced.envFile' })}: .env
-          </Badge>
-        </div>
-
-        <div className="space-y-4">
-          {/* Env Textarea */}
-          <div className="space-y-2">
-            <Label htmlFor="env-input">
-              {formatMessage({ id: 'codexlens.advanced.envContent' })}
-            </Label>
-            <Textarea
-              id="env-input"
-              value={envInput}
-              onChange={(e) => handleEnvChange(e.target.value)}
-              placeholder={formatMessage({ id: 'codexlens.advanced.envPlaceholder' })}
-              className={cn(
-                'min-h-[300px] font-mono text-sm',
-                errors.env && 'border-destructive focus-visible:ring-destructive'
-              )}
-              disabled={isLoading}
-            />
-            {errors.env && (
-              <p className="text-sm text-destructive">{errors.env}</p>
-            )}
-            <p className="text-xs text-muted-foreground">
-              {formatMessage({ id: 'codexlens.advanced.envHint' })}
-            </p>
-          </div>
-
-          {/* Action Buttons */}
-          <div className="flex items-center gap-2">
-            <Button
-              onClick={handleSave}
-              disabled={isLoading || isUpdating || !hasChanges}
-            >
-              <Save className={cn('w-4 h-4 mr-2', isUpdating && 'animate-spin')} />
-              {isUpdating
-                ? formatMessage({ id: 'codexlens.advanced.saving' })
-                : formatMessage({ id: 'codexlens.advanced.save' })
-              }
-            </Button>
-            <Button
-              variant="outline"
-              onClick={handleReset}
-              disabled={isLoading || !hasChanges}
-            >
-              <RefreshCw className="w-4 h-4 mr-2" />
-              {formatMessage({ id: 'codexlens.advanced.reset' })}
-            </Button>
-          </div>
-        </div>
-      </Card>
-
-      {/* Help Card */}
-      <Card className="p-4 bg-info/10 border-info/20">
-        <h4 className="text-sm font-medium text-info-foreground mb-2">
-          {formatMessage({ id: 'codexlens.advanced.helpTitle' })}
-        </h4>
-        <ul className="text-xs text-info-foreground/80 space-y-1">
-          <li>• {formatMessage({ id: 'codexlens.advanced.helpComment' })}</li>
-          <li>• {formatMessage({ id: 'codexlens.advanced.helpFormat' })}</li>
-          <li>• {formatMessage({ id: 'codexlens.advanced.helpQuotes' })}</li>
-          <li>• {formatMessage({ id: 'codexlens.advanced.helpRestart' })}</li>
-        </ul>
-      </Card>
-    </div>
-  );
-}
-
-export default AdvancedTab;
diff --git a/ccw/frontend/src/components/codexlens/CcwToolsCard.tsx b/ccw/frontend/src/components/codexlens/CcwToolsCard.tsx
deleted file mode 100644
index 037d238e..00000000
--- a/ccw/frontend/src/components/codexlens/CcwToolsCard.tsx
+++ /dev/null
@@ -1,153 +0,0 @@
-// ========================================
-// CCW Tools Card Component
-// ========================================
-// Displays all registered CCW tools, highlighting codex-lens related tools
-
-import { useIntl } from 'react-intl';
-import { Wrench, AlertCircle, Loader2 } from 'lucide-react';
-import { Card, CardHeader, CardTitle, CardContent } from '@/components/ui/Card';
-import { Badge } from '@/components/ui/Badge';
-import { useCcwToolsList } from '@/hooks';
-import type { CcwToolInfo } from '@/lib/api';
-
-const CODEX_LENS_PREFIX = 'codex_lens';
-
-function isCodexLensTool(tool: CcwToolInfo): boolean {
-  return tool.name.startsWith(CODEX_LENS_PREFIX);
-}
-
-export function CcwToolsCard() {
-  const { formatMessage } = useIntl();
-  const { tools, isLoading, error } = useCcwToolsList();
-
-  const codexLensTools = tools.filter(isCodexLensTool);
-  const otherTools = tools.filter((t) => !isCodexLensTool(t));
-
-  if (isLoading) {
-    return (
-      <Card>
-        <CardHeader>
-          <CardTitle className="text-base flex items-center gap-2">
-            <Wrench className="w-4 h-4" />
-            <span>{formatMessage({ id: 'codexlens.mcp.title' })}</span>
-          </CardTitle>
-        </CardHeader>
-        <CardContent>
-          <div className="flex items-center gap-2 text-sm text-muted-foreground">
-            <Loader2 className="w-4 h-4 animate-spin" />
-            <span>{formatMessage({ id: 'codexlens.mcp.loading' })}</span>
-          </div>
-        </CardContent>
-      </Card>
-    );
-  }
-
-  if (error) {
-    return (
-      <Card className="border-destructive/20">
-        <CardHeader>
-          <CardTitle className="text-base flex items-center gap-2">
-            <Wrench className="w-4 h-4" />
-            <span>{formatMessage({ id: 'codexlens.mcp.title' })}</span>
-          </CardTitle>
-        </CardHeader>
-        <CardContent>
-          <div className="flex items-start gap-2 text-sm">
-            <AlertCircle className="w-4 h-4 text-destructive flex-shrink-0 mt-0.5" />
-            <div>
-              <p className="font-medium text-destructive">
-                {formatMessage({ id: 'codexlens.mcp.error' })}
-              </p>
-              <p className="text-xs text-muted-foreground mt-1">
-                {formatMessage({ id: 'codexlens.mcp.errorDesc' })}
-              </p>
-            </div>
-          </div>
-        </CardContent>
-      </Card>
-    );
-  }
-
-  if (tools.length === 0) {
-    return (
-      <Card>
-        <CardHeader>
-          <CardTitle className="text-base flex items-center gap-2">
-            <Wrench className="w-4 h-4" />
-            <span>{formatMessage({ id: 'codexlens.mcp.title' })}</span>
-          </CardTitle>
-        </CardHeader>
-        <CardContent>
-          <p className="text-sm text-muted-foreground">
-            {formatMessage({ id: 'codexlens.mcp.emptyDesc' })}
-          </p>
-        </CardContent>
-      </Card>
-    );
-  }
-
-  return (
-    <Card>
-      <CardHeader>
-        <CardTitle className="text-base flex items-center justify-between">
-          <div className="flex items-center gap-2">
-            <Wrench className="w-4 h-4" />
-            <span>{formatMessage({ id: 'codexlens.mcp.title' })}</span>
-          </div>
-          <Badge variant="outline" className="text-xs">
-            {formatMessage({ id: 'codexlens.mcp.totalCount' }, { count: tools.length })}
-          </Badge>
-        </CardTitle>
-      </CardHeader>
-      <CardContent className="space-y-4">
-        {/* CodexLens Tools Section */}
-        {codexLensTools.length > 0 && (
-          <div>
-            <p className="text-xs font-medium text-muted-foreground uppercase mb-2">
-              {formatMessage({ id: 'codexlens.mcp.codexLensSection' })}
-            </p>
-            <div className="space-y-1.5">
-              {codexLensTools.map((tool) => (
-                <ToolRow key={tool.name} tool={tool} variant="default" />
-              ))}
-            </div>
-          </div>
-        )}
-
-        {/* Other Tools Section */}
-        {otherTools.length > 0 && (
-          <div>
-            <p className="text-xs font-medium text-muted-foreground uppercase mb-2">
-              {formatMessage({ id: 'codexlens.mcp.otherSection' })}
-            </p>
-            <div className="space-y-1.5">
-              {otherTools.map((tool) => (
-                <ToolRow key={tool.name} tool={tool} variant="secondary" />
-              ))}
-            </div>
-          </div>
-        )}
-      </CardContent>
-    </Card>
-  );
-}
-
-interface ToolRowProps {
-  tool: CcwToolInfo;
-  variant: 'default' | 'secondary';
-}
-
-function ToolRow({ tool, variant }: ToolRowProps) {
-  return (
-    <div className="flex items-center gap-2 py-1 px-2 rounded-md hover:bg-muted/50 transition-colors">
-      <Badge variant={variant} className="text-xs font-mono shrink-0">
-        {tool.name}
-      </Badge>
-      <span className="text-xs text-muted-foreground truncate" title={tool.description}>
-        {tool.description}
-      </span>
-    </div>
-  );
-}
-
-export default CcwToolsCard;
diff --git a/ccw/frontend/src/components/codexlens/FileWatcherCard.tsx b/ccw/frontend/src/components/codexlens/FileWatcherCard.tsx
deleted file mode 100644
index b1a6869b..00000000
--- a/ccw/frontend/src/components/codexlens/FileWatcherCard.tsx
+++ /dev/null
@@ -1,135 +0,0 @@
-// ========================================
-// CodexLens File Watcher Card
-// ========================================
-// Displays file watcher status, stats, and toggle control
-
-import { useIntl } from 'react-intl';
-import {
-  Eye,
-  EyeOff,
-  Activity,
-  Clock,
-  FolderOpen,
-} from 'lucide-react';
-import { Card, CardHeader, CardTitle, CardContent } from '@/components/ui/Card';
-import { Badge } from '@/components/ui/Badge';
-import { Button } from '@/components/ui/Button';
-import { cn } from '@/lib/utils';
-import { useCodexLensWatcher, useCodexLensWatcherMutations } from '@/hooks';
-import { useWorkflowStore, selectProjectPath } from '@/stores/workflowStore';
-
-function formatUptime(seconds: number): string {
-  if (seconds < 60) return `${seconds}s`;
-  if (seconds < 3600) {
-    const m = Math.floor(seconds / 60);
-    const s = seconds % 60;
-    return `${m}m ${s}s`;
-  }
-  const h = Math.floor(seconds / 3600);
-  const m = Math.floor((seconds % 3600) / 60);
-  return `${h}h ${m}m`;
-}
-
-interface FileWatcherCardProps {
-  disabled?: boolean;
-}
-
-export function FileWatcherCard({ disabled = false }: FileWatcherCardProps) {
-  const { formatMessage } = useIntl();
-  const projectPath = useWorkflowStore(selectProjectPath);
-  const { running, rootPath, eventsProcessed, uptimeSeconds, isLoading } = useCodexLensWatcher();
-  const { startWatcher, stopWatcher, isStarting, isStopping } = useCodexLensWatcherMutations();
-
-  const isMutating = isStarting || isStopping;
-
-  const handleToggle = async () => {
-    if (running) {
-      await stopWatcher();
-    } else {
-      await startWatcher(projectPath);
-    }
-  };
-
-  return (
-    <Card>
-      <CardHeader>
-        <CardTitle className="text-base flex items-center justify-between">
-          <div className="flex items-center gap-2">
-            <Activity className="w-4 h-4" />
-            <span>{formatMessage({ id: 'codexlens.watcher.title' })}</span>
-          </div>
-          <Badge variant={running ? 'success' : 'secondary'}>
-            {running
-              ? formatMessage({ id: 'codexlens.watcher.status.running' })
-              : formatMessage({ id: 'codexlens.watcher.status.stopped' })
-            }
-          </Badge>
-        </CardTitle>
-      </CardHeader>
-      <CardContent className="space-y-4">
-        {/* Stats Grid */}
-        <div className="grid grid-cols-2 gap-3">
-          <div className="flex items-center gap-2 text-sm">
-            <Activity className={cn('w-4 h-4', running ? 'text-success' : 'text-muted-foreground')} />
-            <div>
-              <p className="text-muted-foreground text-xs">
-                {formatMessage({ id: 'codexlens.watcher.eventsProcessed' })}
-              </p>
-              <p className="font-semibold text-foreground">{eventsProcessed}</p>
-            </div>
-          </div>
-          <div className="flex items-center gap-2 text-sm">
-            <Clock className={cn('w-4 h-4', running ? 'text-info' : 'text-muted-foreground')} />
-            <div>
-              <p className="text-muted-foreground text-xs">
-                {formatMessage({ id: 'codexlens.watcher.uptime' })}
-              </p>
-              <p className="font-semibold text-foreground">
-                {running ? formatUptime(uptimeSeconds) : '--'}
-              </p>
-            </div>
-          </div>
-        </div>
-
-        {/* Watched Path */}
-        {running && rootPath && (
-          <div className="flex items-center gap-2 text-sm">
-            <FolderOpen className="w-4 h-4 text-muted-foreground flex-shrink-0" />
-            <span className="text-muted-foreground truncate" title={rootPath}>
-              {rootPath}
-            </span>
-          </div>
-        )}
-
-        {/* Toggle Button */}
-        <Button
-          variant={running ? 'outline' : 'default'}
-          size="sm"
-          className="w-full"
-          onClick={handleToggle}
-          disabled={disabled || isMutating || isLoading}
-        >
-          {running ? (
-            <>
-              <EyeOff className="w-4 h-4 mr-2" />
-              {isStopping
-                ? formatMessage({ id: 'codexlens.watcher.stopping' })
-                : formatMessage({ id: 'codexlens.watcher.stop' })
-              }
-            </>
-          ) : (
-            <>
-              <Eye className="w-4 h-4 mr-2" />
-              {isStarting
-                ? formatMessage({ id: 'codexlens.watcher.starting' })
-                : formatMessage({ id: 'codexlens.watcher.start' })
-              }
-            </>
-          )}
-        </Button>
-      </CardContent>
-    </Card>
-  );
-}
-
-export default FileWatcherCard;
diff --git a/ccw/frontend/src/components/codexlens/GpuSelector.tsx b/ccw/frontend/src/components/codexlens/GpuSelector.tsx
deleted file mode 100644
index 13d22e1c..00000000
--- a/ccw/frontend/src/components/codexlens/GpuSelector.tsx
+++ /dev/null
@@ -1,293 +0,0 @@
-// ========================================
-// CodexLens GPU Selector
-// ========================================
-// GPU detection, listing, and selection component
-
-import { useState } from 'react';
-import { useIntl } from 'react-intl';
-import { Cpu, Search, Check, X, RefreshCw } from 'lucide-react';
-import { Card } from '@/components/ui/Card';
-import { Button } from '@/components/ui/Button';
-import { Badge } from '@/components/ui/Badge';
-import { useCodexLensGpu, useSelectGpu } from '@/hooks';
-import { useNotifications } from '@/hooks';
-import { cn } from '@/lib/utils';
-import type { CodexLensGpuDevice } from '@/lib/api';
-
-interface GpuSelectorProps {
-  enabled?: boolean;
-  compact?: boolean;
-}
-
-export function GpuSelector({ enabled = true, compact = false }: GpuSelectorProps) {
-  const { formatMessage } = useIntl();
-  const { success, error: showError } = useNotifications();
-
-  const {
-    supported,
-    devices,
-    selectedDeviceId,
-    isLoadingDetect,
-    isLoadingList,
-    refetch,
-  } = useCodexLensGpu({ enabled });
-
-  const { selectGpu, resetGpu, isSelecting, isResetting } = useSelectGpu();
-
-  const [isDetecting, setIsDetecting] = useState(false);
-
-  const isLoading = isLoadingDetect || isLoadingList || isDetecting;
-
-  const handleDetect = async () => {
-    setIsDetecting(true);
-    try {
-      await refetch();
-      success(
-        formatMessage({ id: 'codexlens.gpu.detectSuccess' }),
-        formatMessage({ id: 'codexlens.gpu.detectComplete' }, { count: devices?.length ?? 0 })
-      );
-    } catch (err) {
-      showError(
-        formatMessage({ id: 'codexlens.gpu.detectFailed' }),
-        err instanceof Error ? err.message : formatMessage({ id: 'codexlens.gpu.detectError' })
-      );
-    } finally {
-      setIsDetecting(false);
-    }
-  };
-
-  const handleSelect = async (deviceId: string | number) => {
-    try {
-      const result = await selectGpu(deviceId);
-      if (result.success) {
-        success(
-          formatMessage({ id: 'codexlens.gpu.selectSuccess' }),
-          result.message || formatMessage({ id: 'codexlens.gpu.gpuSelected' })
-        );
-        refetch();
-      } else {
-        showError(
-          formatMessage({ id: 'codexlens.gpu.selectFailed' }),
-          result.message || formatMessage({ id: 'codexlens.gpu.selectError' })
-        );
-      }
-    } catch (err) {
-      showError(
-        formatMessage({ id: 'codexlens.gpu.selectFailed' }),
-        err instanceof Error ? err.message : formatMessage({ id: 'codexlens.gpu.unknownError' })
-      );
-    }
-  };
-
-  const handleReset = async () => {
-    try {
-      const result = await resetGpu();
-      if (result.success) {
-        success(
-          formatMessage({ id: 'codexlens.gpu.resetSuccess' }),
-          result.message || formatMessage({ id: 'codexlens.gpu.gpuReset' })
-        );
-        refetch();
-      } else {
-        showError(
-          formatMessage({ id: 'codexlens.gpu.resetFailed' }),
-          result.message || formatMessage({ id: 'codexlens.gpu.resetError' })
-        );
-      }
-    } catch (err) {
-      showError(
-        formatMessage({ id: 'codexlens.gpu.resetFailed' }),
-        err instanceof Error ? err.message : formatMessage({ id: 'codexlens.gpu.unknownError' })
-      );
-    }
-  };
-
-  if (compact) {
-    return (
-      <Card className="p-4">
-        <div className="flex items-center justify-between">
-          <div className="flex items-center gap-2">
-            <Cpu className="w-4 h-4 text-muted-foreground" />
-            <span className="text-sm text-muted-foreground">
-              {formatMessage({ id: 'codexlens.gpu.status' })}:
-            </span>
-            {supported !== false ? (
-              selectedDeviceId !== undefined ? (
-                <Badge variant="success" className="text-xs">
-                  {formatMessage({ id: 'codexlens.gpu.enabled' })}
-                </Badge>
-              ) : (
-                <Badge variant="outline" className="text-xs">
-                  {formatMessage({ id: 'codexlens.gpu.available' })}
-                </Badge>
-              )
-            ) : (
-              <Badge variant="secondary" className="text-xs">
-                {formatMessage({ id: 'codexlens.gpu.unavailable' })}
-              </Badge>
-            )}
-          </div>
-          <div className="flex gap-2">
-            <Button
-              variant="outline"
-              size="sm"
-              onClick={handleDetect}
-              disabled={isLoading}
-            >
-              <Search className={cn('w-3 h-3 mr-1', isLoading && 'animate-spin')} />
-              {formatMessage({ id: 'codexlens.gpu.detect' })}
-            </Button>
-            {selectedDeviceId !== undefined && (
-              <Button
-                variant="outline"
-                size="sm"
-                onClick={handleReset}
-                disabled={isResetting}
-              >
-                <X className="w-3 h-3 mr-1" />
-                {formatMessage({ id: 'codexlens.gpu.reset' })}
-              </Button>
-            )}
-          </div>
-        </div>
-      </Card>
-    );
-  }
-
-  return (
-    <div className="space-y-4">
-      {/* Header Card */}
-      <Card className="p-4">
-        <div className="flex items-center justify-between">
-          <div className="flex items-center gap-3">
-            <div className={cn(
-              'p-2 rounded-lg',
-              supported !== false ? 'bg-success/10' : 'bg-secondary'
-            )}>
-              <Cpu className={cn(
-                'w-5 h-5',
-                supported !== false ? 'text-success' : 'text-muted-foreground'
-              )} />
-            </div>
-            <div>
-              <h4 className="text-sm font-medium text-foreground">
-                {formatMessage({ id: 'codexlens.gpu.title' })}
-              </h4>
-              <p className="text-xs text-muted-foreground">
-                {supported !== false
-                  ? formatMessage({ id: 'codexlens.gpu.supported' })
-                  : formatMessage({ id: 'codexlens.gpu.notSupported' })
-                }
-              </p>
-            </div>
-          </div>
-          <div className="flex gap-2">
-            <Button
-              variant="outline"
-              size="sm"
-              onClick={handleDetect}
-              disabled={isLoading}
-            >
-              <Search className={cn('w-4 h-4 mr-2', isLoading && 'animate-spin')} />
-              {formatMessage({ id: 'codexlens.gpu.detect' })}
-            </Button>
-            {selectedDeviceId !== undefined && (
-              <Button
-                variant="outline"
-                size="sm"
-                onClick={handleReset}
-                disabled={isResetting}
-              >
-                <RefreshCw className={cn('w-4 h-4 mr-2', isResetting && 'animate-spin')} />
-                {formatMessage({ id: 'codexlens.gpu.reset' })}
-              </Button>
-            )}
-          </div>
-        </div>
-      </Card>
-
-      {/* Device List */}
-      {devices && devices.length > 0 ? (
-        <div className="space-y-2">
-          {devices.map((device) => {
-            const deviceId = device.device_id ?? device.index;
-            return (
-              <DeviceCard
-                key={deviceId}
-                device={device}
-                isSelected={deviceId === selectedDeviceId}
-                onSelect={() => handleSelect(deviceId)}
-                isSelecting={isSelecting}
-              />
-            );
-          })}
-        </div>
-      ) : (
-        <Card className="p-8 text-center">
-          <Cpu className="w-12 h-12 mx-auto text-muted-foreground/50 mb-4" />
-          <p className="text-muted-foreground">
-            {supported !== false
-              ? formatMessage({ id: 'codexlens.gpu.noDevices' })
-              : formatMessage({ id: 'codexlens.gpu.notAvailable' })
-            }
-          </p>
-        </Card>
-      )}
-    </div>
-  );
-}
-
-interface DeviceCardProps {
-  device: CodexLensGpuDevice;
-  isSelected: boolean;
-  onSelect: () => void;
-  isSelecting: boolean;
-}
-
-function DeviceCard({ device, isSelected, onSelect, isSelecting }: DeviceCardProps) {
-  const { formatMessage } = useIntl();
-
-  return (
-    <Card className={cn(
-      'p-4 transition-colors',
-      isSelected && 'border-primary bg-primary/5'
-    )}>
-      <div className="flex items-start justify-between">
-        <div className="flex-1 min-w-0">
-          <div className="flex items-center gap-2 mb-1">
-            <h5 className="text-sm font-medium text-foreground">
-              {device.name || formatMessage({ id: 'codexlens.gpu.unknownDevice' })}
-            </h5>
-            {isSelected && (
-              <Badge variant="success" className="text-xs">
-                <Check className="w-3 h-3 mr-1" />
-                {formatMessage({ id: 'codexlens.gpu.selected' })}
-              </Badge>
-            )}
-          </div>
-          <p className="text-xs text-muted-foreground">
-            {formatMessage({ id: 'codexlens.gpu.type' })}: {formatMessage({ id: device.type === 'discrete' ? 'codexlens.gpu.discrete' : 'codexlens.gpu.integrated' })}
-          </p>
-          {device.memory?.total && (
-            <p className="text-xs text-muted-foreground">
-              {formatMessage({ id: 'codexlens.gpu.memory' })}: {(device.memory.total / 1024).toFixed(1)} GB
-            </p>
-          )}
-        </div>
-        <Button
-          variant={isSelected ? 'outline' : 'default'}
-          size="sm"
-          onClick={onSelect}
-          disabled={isSelected || isSelecting}
-        >
-          {isSelected
-            ? formatMessage({ id: 'codexlens.gpu.active' })
-            : formatMessage({ id: 'codexlens.gpu.select' })
-          }
-        </Button>
-      </div>
-    </Card>
-  );
-}
-
-export default GpuSelector;
diff --git a/ccw/frontend/src/components/codexlens/IndexOperations.tsx b/ccw/frontend/src/components/codexlens/IndexOperations.tsx
deleted file mode 100644
index fc015987..00000000
--- a/ccw/frontend/src/components/codexlens/IndexOperations.tsx
+++ /dev/null
@@ -1,286 +0,0 @@
-// ========================================
-// CodexLens Index Operations Component
-// ========================================
-// Index management operations with progress tracking
-
-import { useIntl } from 'react-intl';
-import { useEffect, useState } from 'react';
-import {
-  RotateCw,
-  Zap,
-  AlertCircle,
-  CheckCircle2,
-  X,
-} from 'lucide-react';
-import { Button } from '@/components/ui/Button';
-import { Progress } from '@/components/ui/Progress';
-import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/Card';
-import { cn } from '@/lib/utils';
-import { useWorkflowStore, selectProjectPath } from '@/stores/workflowStore';
-import {
-  useCodexLensIndexingStatus,
-  useRebuildIndex,
-  useUpdateIndex,
-  useCancelIndexing,
-} from '@/hooks';
-import { useNotifications } from '@/hooks/useNotifications';
-import { useWebSocket } from '@/hooks/useWebSocket';
-
-interface IndexOperationsProps {
-  disabled?: boolean;
-  onRefresh?: () => void;
-}
-
-interface IndexProgress {
-  stage: string;
-  message: string;
-  percent: number;
-  path?: string;
-}
-
-type IndexOperation = {
-  id: string;
-  type: 'fts_full' | 'fts_incremental' | 'vector_full' | 'vector_incremental';
-  label: string;
-  description: string;
-  icon: React.ReactNode;
-};
-
-export function IndexOperations({ disabled = false, onRefresh }: IndexOperationsProps) {
-  const { formatMessage } = useIntl();
-  const { success, error: showError, wsLastMessage } = useNotifications();
-  const projectPath = useWorkflowStore(selectProjectPath);
-  const { inProgress } = useCodexLensIndexingStatus();
-  const { rebuildIndex, isRebuilding } = useRebuildIndex();
-  const { updateIndex, isUpdating } = useUpdateIndex();
-  const { cancelIndexing, isCancelling } = useCancelIndexing();
-  useWebSocket();
-
-  const [indexProgress, setIndexProgress] = useState<IndexProgress | null>(null);
-  const [activeOperation, setActiveOperation] = useState<string | null>(null);
-
-  // Listen for WebSocket progress updates
-  useEffect(() => {
-    if (wsLastMessage?.type === 'CODEXLENS_INDEX_PROGRESS') {
-      const progress = wsLastMessage.payload as IndexProgress;
-      setIndexProgress(progress);
-
-      // Clear active operation when complete or error
-      if (progress.stage === 'complete' || progress.stage === 'error' || progress.stage === 'cancelled') {
-        if (progress.stage === 'complete') {
-          success(
-            formatMessage({ id: 'codexlens.index.operationComplete' }),
-            progress.message
-          );
-          onRefresh?.();
-        } else if (progress.stage === 'error') {
-          showError(
-            formatMessage({ id: 'codexlens.index.operationFailed' }),
-            progress.message
-          );
-        }
-        setActiveOperation(null);
-        setIndexProgress(null);
-      }
-    }
-  }, [wsLastMessage, formatMessage, success, showError, onRefresh]);
-
-  const isOperating = isRebuilding || isUpdating || inProgress || !!activeOperation;
-
-  const handleOperation = async (operation: IndexOperation) => {
-    if (!projectPath) {
-      showError(
-        formatMessage({ id: 'codexlens.index.noProject' }),
-        formatMessage({ id: 'codexlens.index.noProjectDesc' })
-      );
-      return;
-    }
-
-    setActiveOperation(operation.id);
-    setIndexProgress({ stage: 'start', message: formatMessage({ id: 'codexlens.index.starting' }), percent: 0 });
-
-    try {
-      // Determine index type and operation
-      const isVector = operation.type.includes('vector');
-      const isIncremental = operation.type.includes('incremental');
-
-      if (isIncremental) {
-        const result = await updateIndex(projectPath, {
-          indexType: isVector ? 'vector' : 'normal',
-        });
-        if (!result.success) {
-          throw new Error(result.error || 'Update failed');
-        }
-      } else {
-        const result = await rebuildIndex(projectPath, {
-          indexType: isVector ? 'vector' : 'normal',
-        });
-        if (!result.success) {
-          throw new Error(result.error || 'Rebuild failed');
-        }
-      }
-    } catch (err) {
-      setActiveOperation(null);
-      setIndexProgress(null);
-      showError(
-        formatMessage({ id: 'codexlens.index.operationFailed' }),
-        err instanceof Error ? err.message : formatMessage({ id: 'codexlens.index.unknownError' })
-      );
-    }
-  };
-
-  const handleCancel = async () => {
-    const result = await cancelIndexing();
-    if (result.success) {
-      setActiveOperation(null);
-      setIndexProgress(null);
-    } else {
-      showError(
-        formatMessage({ id: 'codexlens.index.cancelFailed' }),
-        result.error || formatMessage({ id: 'codexlens.index.unknownError' })
-      );
-    }
-  };
-
-  const operations: IndexOperation[] = [
-    {
-      id: 'fts_full',
-      type: 'fts_full',
-      label: formatMessage({ id: 'codexlens.overview.actions.ftsFull' }),
-      description: formatMessage({ id: 'codexlens.overview.actions.ftsFullDesc' }),
-      icon: <RotateCw className="w-4 h-4" />,
-    },
-    {
-      id: 'fts_incremental',
-      type: 'fts_incremental',
-      label: formatMessage({ id: 'codexlens.overview.actions.ftsIncremental' }),
-      description: formatMessage({ id: 'codexlens.overview.actions.ftsIncrementalDesc' }),
-      icon: <Zap className="w-4 h-4" />,
-    },
-    {
-      id: 'vector_full',
-      type: 'vector_full',
-      label: formatMessage({ id: 'codexlens.overview.actions.vectorFull' }),
-      description: formatMessage({ id: 'codexlens.overview.actions.vectorFullDesc' }),
-      icon: <RotateCw className="w-4 h-4" />,
-    },
-    {
-      id: 'vector_incremental',
-      type: 'vector_incremental',
-      label: formatMessage({ id: 'codexlens.overview.actions.vectorIncremental' }),
-      description: formatMessage({ id: 'codexlens.overview.actions.vectorIncrementalDesc' }),
-      icon: <Zap className="w-4 h-4" />,
-    },
-  ];
-
-  if (indexProgress && activeOperation) {
-    const operation = operations.find((op) => op.id === activeOperation);
-    const isComplete = indexProgress.stage === 'complete';
-    const isError = indexProgress.stage === 'error';
-    const isCancelled = indexProgress.stage === 'cancelled';
-
-    return (
-      <Card>
-        <CardHeader>
-          <CardTitle className="text-base flex items-center justify-between">
-            <span>{operation?.label}</span>
-            {!isComplete && !isError && !isCancelled && (
-              <Button
-                variant="ghost"
-                size="sm"
-                onClick={handleCancel}
-                disabled={isCancelling}
-              >
-                <X className="w-4 h-4 mr-1" />
-                {formatMessage({ id: 'common.actions.cancel' })}
-              </Button>
-            )}
-          </CardTitle>
-        </CardHeader>
-        <CardContent className="space-y-4">
-          {/* Status Icon */}
-          <div className="flex items-center gap-3">
-            {isComplete ? (
-              <CheckCircle2 className="w-6 h-6 text-success" />
-            ) : isError || isCancelled ? (
-              <AlertCircle className="w-6 h-6 text-destructive" />
-            ) : (
-              <RotateCw className="w-6 h-6 text-primary animate-spin" />
-            )}
-            <div className="flex-1">
-              <p className="text-sm font-medium text-foreground">
-                {isComplete
-                  ? formatMessage({ id: 'codexlens.index.complete' })
-                  : isError
-                    ? formatMessage({ id: 'codexlens.index.failed' })
-                    : isCancelled
-                      ? formatMessage({ id: 'codexlens.index.cancelled' })
-                      : formatMessage({ id: 'codexlens.index.inProgress' })}
-              </p>
-              <p className="text-xs text-muted-foreground mt-1">{indexProgress.message}</p>
-            </div>
-          </div>
-
-          {/* Progress Bar */}
-          {!isComplete && !isError && !isCancelled && (
-            <div className="space-y-2">
-              <Progress value={indexProgress.percent} className="h-2" />
-              <p className="text-xs text-muted-foreground text-right">
-                {indexProgress.percent}%
-              </p>
-            </div>
-          )}
-
-          {/* Close Button */}
-          {(isComplete || isError || isCancelled) && (
-            <div className="flex justify-end">
-              <Button
-                variant="outline"
-                size="sm"
-                onClick={() => {
-                  setActiveOperation(null);
-                  setIndexProgress(null);
-                }}
-              >
-                {formatMessage({ id: 'common.actions.close' })}
-              </Button>
-            </div>
-          )}
-        </CardContent>
-      </Card>
-    );
-  }
-
-  return (
-    <Card>
-      <CardHeader>
-        <CardTitle className="text-base">
-          {formatMessage({ id: 'codexlens.overview.actions.title' })}
-        </CardTitle>
-      </CardHeader>
-      <CardContent>
-        <div className="grid grid-cols-1 md:grid-cols-2 gap-3">
-          {operations.map((operation) => (
-            <Button
-              key={operation.id}
-              variant="outline"
-              className="h-auto p-4 flex flex-col items-start gap-2 text-left"
-              onClick={() => handleOperation(operation)}
-              disabled={disabled || isOperating}
-            >
-              <div className="flex items-center gap-2 w-full">
-                <span className={cn('text-muted-foreground', (disabled || isOperating) && 'opacity-50')}>
-                  {operation.icon}
-                </span>
-                <span className="font-medium">{operation.label}</span>
-              </div>
-              <p className="text-xs text-muted-foreground">{operation.description}</p>
-            </Button>
-          ))}
-        </div>
-      </CardContent>
-    </Card>
-  );
-}
-
-export default IndexOperations;
diff --git a/ccw/frontend/src/components/codexlens/InstallProgressOverlay.tsx b/ccw/frontend/src/components/codexlens/InstallProgressOverlay.tsx
deleted file mode 100644
index 55fb410b..00000000
--- a/ccw/frontend/src/components/codexlens/InstallProgressOverlay.tsx
+++ /dev/null
@@ -1,256 +0,0 @@
-// ========================================
-// CodexLens Install Progress Overlay
-// ========================================
-// Dialog overlay showing 5-stage simulated progress during CodexLens bootstrap installation
-
-import { useState, useEffect, useRef, useCallback } from 'react';
-import { useIntl } from 'react-intl';
-import {
-  Check,
-  Download,
-  Info,
-  Loader2,
-} from 'lucide-react';
-import {
-  Dialog,
-  DialogContent,
-  DialogDescription,
-  DialogFooter,
-  DialogHeader,
-  DialogTitle,
-} from '@/components/ui/Dialog';
-import { Button } from '@/components/ui/Button';
-import { Progress } from '@/components/ui/Progress';
-import { Card, CardContent } from '@/components/ui/Card';
-
-// ----------------------------------------
-// Types
-// ----------------------------------------
-
-interface InstallStage {
-  progress: number;
-  messageId: string;
-}
-
-interface InstallProgressOverlayProps {
-  open: boolean;
-  onOpenChange: (open: boolean) => void;
-  onInstall: () => Promise<{ success: boolean }>;
-  onSuccess?: () => void;
-}
-
-// ----------------------------------------
-// Constants
-// ----------------------------------------
-
-const INSTALL_STAGES: InstallStage[] = [
-  { progress: 10, messageId: 'codexlens.install.stage.creatingVenv' },
-  { progress: 30, messageId: 'codexlens.install.stage.installingPip' },
-  { progress: 50, messageId: 'codexlens.install.stage.installingPackage' },
-  { progress: 70, messageId: 'codexlens.install.stage.settingUpDeps' },
-  { progress: 90, messageId: 'codexlens.install.stage.finalizing' },
-];
-
-const STAGE_INTERVAL_MS = 1500;
-
-// ----------------------------------------
-// Checklist items
-// ----------------------------------------
-
-interface ChecklistItem {
-  labelId: string;
-  descId: string;
-}
-
-const CHECKLIST_ITEMS: ChecklistItem[] = [
-  { labelId: 'codexlens.install.pythonVenv', descId: 'codexlens.install.pythonVenvDesc' },
-  { labelId: 'codexlens.install.codexlensPackage', descId: 'codexlens.install.codexlensPackageDesc' },
-  { labelId: 'codexlens.install.sqliteFts', descId: 'codexlens.install.sqliteFtsDesc' },
-];
-
-// ----------------------------------------
-// Component
-// ----------------------------------------
-
-export function InstallProgressOverlay({
-  open,
-  onOpenChange,
-  onInstall,
-  onSuccess,
-}: InstallProgressOverlayProps) {
-  const { formatMessage } = useIntl();
-  const [isInstalling, setIsInstalling] = useState(false);
-  const [progress, setProgress] = useState(0);
-  const [stageText, setStageText] = useState('');
-  const [isComplete, setIsComplete] = useState(false);
-  const intervalRef = useRef<ReturnType<typeof setInterval> | null>(null);
-
-  const clearStageInterval = useCallback(() => {
-    if (intervalRef.current) {
-      clearInterval(intervalRef.current);
-      intervalRef.current = null;
-    }
-  }, []);
-
-  // Reset state when dialog closes
-  useEffect(() => {
-    if (!open) {
-      setIsInstalling(false);
-      setProgress(0);
-      setStageText('');
-      setIsComplete(false);
-      clearStageInterval();
-    }
-  }, [open, clearStageInterval]);
-
-  // Cleanup on unmount
-  useEffect(() => {
-    return () => clearStageInterval();
-  }, [clearStageInterval]);
-
-  const handleInstall = async () => {
-    setIsInstalling(true);
-    setProgress(0);
-    setIsComplete(false);
-
-    // Start stage simulation
-    let currentStage = 0;
-    setStageText(formatMessage({ id: INSTALL_STAGES[0].messageId }));
-    setProgress(INSTALL_STAGES[0].progress);
-    currentStage = 1;
-
-    intervalRef.current = setInterval(() => {
-      if (currentStage < INSTALL_STAGES.length) {
-        setStageText(formatMessage({ id: INSTALL_STAGES[currentStage].messageId }));
-        setProgress(INSTALL_STAGES[currentStage].progress);
-        currentStage++;
-      }
-    }, STAGE_INTERVAL_MS);
-
-    try {
-      const result = await onInstall();
-      clearStageInterval();
-
-      if (result.success) {
-        setProgress(100);
-        setStageText(formatMessage({ id: 'codexlens.install.stage.complete' }));
-        setIsComplete(true);
-
-        // Auto-close after showing completion
-        setTimeout(() => {
-          onOpenChange(false);
-          onSuccess?.();
-        }, 1200);
-      } else {
-        setIsInstalling(false);
-        setProgress(0);
-        setStageText('');
-      }
-    } catch {
-      clearStageInterval();
-      setIsInstalling(false);
-      setProgress(0);
-      setStageText('');
-    }
-  };
-
-  return (
-    <Dialog open={open} onOpenChange={isInstalling ? undefined : onOpenChange}>
-      <DialogContent className="max-w-lg" onPointerDownOutside={isInstalling ? (e) => e.preventDefault() : undefined}>
-        <DialogHeader>
-          <DialogTitle className="flex items-center gap-2">
-            <Download className="w-5 h-5 text-primary" />
-            {formatMessage({ id: 'codexlens.install.title' })}
-          </DialogTitle>
-          <DialogDescription>
-            {formatMessage({ id: 'codexlens.install.description' })}
-          </DialogDescription>
-        </DialogHeader>
-
-        <div className="space-y-4 py-4">
-          {/* Install Checklist */}
-          <div>
-            <h4 className="text-sm font-medium mb-2">
-              {formatMessage({ id: 'codexlens.install.checklist' })}
-            </h4>
-            <ul className="space-y-2">
-              {CHECKLIST_ITEMS.map((item) => (
-                <li key={item.labelId} className="flex items-start gap-2 text-sm">
-                  <Check className="w-4 h-4 text-green-500 mt-0.5 flex-shrink-0" />
-                  <span>
-                    <strong>{formatMessage({ id: item.labelId })}</strong>
-                    {' - '}
-                    {formatMessage({ id: item.descId })}
-                  </span>
-                </li>
-              ))}
-            </ul>
-          </div>
-
-          {/* Install Location Info */}
-          <Card className="bg-primary/5 border-primary/20">
-            <CardContent className="p-3 flex items-start gap-2">
-              <Info className="w-4 h-4 text-primary mt-0.5 flex-shrink-0" />
-              <div className="text-sm text-muted-foreground">
-                <p className="font-medium text-foreground">
-                  {formatMessage({ id: 'codexlens.install.location' })}
-                </p>
-                <p className="mt-1">
-                  <code className="bg-muted px-1.5 py-0.5 rounded text-xs">
-                    {formatMessage({ id: 'codexlens.install.locationPath' })}
-                  </code>
-                </p>
-                <p className="mt-1">
-                  {formatMessage({ id: 'codexlens.install.timeEstimate' })}
-                </p>
-              </div>
-            </CardContent>
-          </Card>
-
-          {/* Progress Section - shown during install */}
-          {isInstalling && (
-            <div className="space-y-2">
-              <div className="flex items-center gap-3">
-                {isComplete ? (
-                  <Check className="w-5 h-5 text-green-500" />
-                ) : (
-                  <Loader2 className="w-5 h-5 text-primary animate-spin" />
-                )}
-                <span className="text-sm">{stageText}</span>
-              </div>
-              <Progress value={progress} className="h-2" />
-            </div>
-          )}
-        </div>
-
-        <DialogFooter>
-          <Button
-            variant="outline"
-            onClick={() => onOpenChange(false)}
-            disabled={isInstalling}
-          >
-            {formatMessage({ id: 'common.actions.cancel' })}
-          </Button>
-          <Button
-            onClick={handleInstall}
-            disabled={isInstalling}
-          >
-            {isInstalling ? (
-              <>
-                <Loader2 className="w-4 h-4 mr-2 animate-spin" />
-                {formatMessage({ id: 'codexlens.install.installing' })}
-              </>
-            ) : (
-              <>
-                <Download className="w-4 h-4 mr-2" />
-                {formatMessage({ id: 'codexlens.install.installNow' })}
-              </>
-            )}
-          </Button>
-        </DialogFooter>
-      </DialogContent>
-    </Dialog>
-  );
-}
-
-export default InstallProgressOverlay;
diff --git a/ccw/frontend/src/components/codexlens/LspServerCard.tsx b/ccw/frontend/src/components/codexlens/LspServerCard.tsx
deleted file mode 100644
index de7fb917..00000000
--- a/ccw/frontend/src/components/codexlens/LspServerCard.tsx
+++ /dev/null
@@ -1,157 +0,0 @@
-// ========================================
-// CodexLens LSP Server Card
-// ========================================
-// Displays LSP server status, stats, and start/stop/restart controls
-
-import { useIntl } from 'react-intl';
-import {
-  Server,
-  Power,
-  PowerOff,
-  RotateCw,
-  FolderOpen,
-  Layers,
-  Cpu,
-} from 'lucide-react';
-import { Card, CardHeader, CardTitle, CardContent } from '@/components/ui/Card';
-import { Badge } from '@/components/ui/Badge';
-import { Button } from '@/components/ui/Button';
-import { cn } from '@/lib/utils';
-import { useCodexLensLspStatus, useCodexLensLspMutations } from '@/hooks';
-import { useWorkflowStore, selectProjectPath } from '@/stores/workflowStore';
-
-interface LspServerCardProps {
-  disabled?: boolean;
-}
-
-export function LspServerCard({ disabled = false }: LspServerCardProps) {
-  const { formatMessage } = useIntl();
-  const projectPath = useWorkflowStore(selectProjectPath);
-  const {
-    available,
-    semanticAvailable,
-    projectCount,
-    modes,
-    isLoading,
-  } = useCodexLensLspStatus();
-  const { startLsp, stopLsp, restartLsp, isStarting, isStopping, isRestarting } = useCodexLensLspMutations();
-
-  const isMutating = isStarting || isStopping || isRestarting;
-
-  const handleToggle = async () => {
-    if (available) {
-      await stopLsp(projectPath);
-    } else {
-      await startLsp(projectPath);
-    }
-  };
-
-  const handleRestart = async () => {
-    await restartLsp(projectPath);
-  };
-
-  return (
-    <Card>
-      <CardHeader>
-        <CardTitle className="text-base flex items-center justify-between">
-          <div className="flex items-center gap-2">
-            <Server className="w-4 h-4" />
-            <span>{formatMessage({ id: 'codexlens.lsp.title' })}</span>
-          </div>
-          <Badge variant={available ? 'success' : 'secondary'}>
-            {available
-              ? formatMessage({ id: 'codexlens.lsp.status.running' })
-              : formatMessage({ id: 'codexlens.lsp.status.stopped' })
-            }
-          </Badge>
-        </CardTitle>
-      </CardHeader>
-      <CardContent className="space-y-4">
-        {/* Stats Grid */}
-        <div className="grid grid-cols-3 gap-3">
-          <div className="flex items-center gap-2 text-sm">
-            <FolderOpen className={cn('w-4 h-4', available ? 'text-success' : 'text-muted-foreground')} />
-            <div>
-              <p className="text-muted-foreground text-xs">
-                {formatMessage({ id: 'codexlens.lsp.projects' })}
-              </p>
-              <p className="font-semibold text-foreground">
-                {available ? projectCount : '--'}
-              </p>
-            </div>
-          </div>
-          <div className="flex items-center gap-2 text-sm">
-            <Cpu className={cn('w-4 h-4', semanticAvailable ? 'text-info' : 'text-muted-foreground')} />
-            <div>
-              <p className="text-muted-foreground text-xs">
-                {formatMessage({ id: 'codexlens.lsp.semanticAvailable' })}
-              </p>
-              <p className="font-semibold text-foreground">
-                {semanticAvailable
-                  ? formatMessage({ id: 'codexlens.lsp.available' })
-                  : formatMessage({ id: 'codexlens.lsp.unavailable' })
-                }
-              </p>
-            </div>
-          </div>
-          <div className="flex items-center gap-2 text-sm">
-            <Layers className={cn('w-4 h-4', available && modes.length > 0 ? 'text-accent' : 'text-muted-foreground')} />
-            <div>
-              <p className="text-muted-foreground text-xs">
-                {formatMessage({ id: 'codexlens.lsp.modes' })}
-              </p>
-              <p className="font-semibold text-foreground">
-                {available ? modes.length : '--'}
-              </p>
-            </div>
-          </div>
-        </div>
-
-        {/* Action Buttons */}
-        <div className="flex gap-2">
-          <Button
-            variant={available ? 'outline' : 'default'}
-            size="sm"
-            className="flex-1"
-            onClick={handleToggle}
-            disabled={disabled || isMutating || isLoading}
-          >
-            {available ? (
-              <>
-                <PowerOff className="w-4 h-4 mr-2" />
-                {isStopping
-                  ? formatMessage({ id: 'codexlens.lsp.stopping' })
-                  : formatMessage({ id: 'codexlens.lsp.stop' })
-                }
-              </>
-            ) : (
-              <>
-                <Power className="w-4 h-4 mr-2" />
-                {isStarting
-                  ? formatMessage({ id: 'codexlens.lsp.starting' })
-                  : formatMessage({ id: 'codexlens.lsp.start' })
-                }
-              </>
-            )}
-          </Button>
-          {available && (
-            <Button
-              variant="outline"
-              size="sm"
-              onClick={handleRestart}
-              disabled={disabled || isMutating || isLoading}
-            >
-              <RotateCw className={cn('w-4 h-4 mr-2', isRestarting && 'animate-spin')} />
-              {isRestarting
-                ? formatMessage({ id: 'codexlens.lsp.restarting' })
-                : formatMessage({ id: 'codexlens.lsp.restart' })
-              }
-            </Button>
-          )}
-        </div>
-      </CardContent>
-    </Card>
-  );
-}
-
-export default LspServerCard;
diff --git a/ccw/frontend/src/components/codexlens/ModelCard.tsx b/ccw/frontend/src/components/codexlens/ModelCard.tsx
deleted file mode 100644
index 0be86f27..00000000
--- a/ccw/frontend/src/components/codexlens/ModelCard.tsx
+++ /dev/null
@@ -1,234 +0,0 @@
-// ========================================
-// Model Card Component
-// ========================================
-// Individual model display card with actions
-
-import { useState } from 'react';
-import { useIntl } from 'react-intl';
-import {
-  Download,
-  Trash2,
-  Package,
-  HardDrive,
-  X,
-  Loader2,
-} from 'lucide-react';
-import { Card } from '@/components/ui/Card';
-import { Button } from '@/components/ui/Button';
-import { Badge } from '@/components/ui/Badge';
-import { Progress } from '@/components/ui/Progress';
-import { Input } from '@/components/ui/Input';
-import type { CodexLensModel } from '@/lib/api';
-import { cn } from '@/lib/utils';
-
-// ========== Types ==========
-
-export interface ModelCardProps {
-  model: CodexLensModel;
-  isDownloading?: boolean;
-  downloadProgress?: number;
-  isDeleting?: boolean;
-  onDownload: (profile: string) => void;
-  onDelete: (profile: string) => void;
-  onCancelDownload?: () => void;
-}
-
-// ========== Helper Functions ==========
-
-function getModelTypeVariant(type: 'embedding' | 'reranker'): 'default' | 'secondary' {
-  return type === 'embedding' ? 'default' : 'secondary';
-}
-
-function formatSize(size?: string): string {
-  if (!size) return '-';
-  return size;
-}
-
-// ========== Component ==========
-
-export function ModelCard({
-  model,
-  isDownloading = false,
-  downloadProgress = 0,
-  isDeleting = false,
-  onDownload,
-  onDelete,
-  onCancelDownload,
-}: ModelCardProps) {
-  const { formatMessage } = useIntl();
-
-  const handleDownload = () => {
-    onDownload(model.profile);
-  };
-
-  const handleDelete = () => {
-    if (confirm(formatMessage({ id: 'codexlens.models.deleteConfirm' }, { modelName: model.name }))) {
-      onDelete(model.profile);
-    }
-  };
-
-  return (
-    <Card className={cn('overflow-hidden hover-glow', !model.installed && 'opacity-80')}>
-      {/* Header */}
-      <div className="p-4">
-        <div className="flex items-start justify-between gap-3">
-          <div className="flex items-center gap-3 flex-1 min-w-0">
-            <div className={cn(
-              'p-2 rounded-lg flex-shrink-0',
-              model.installed ? 'bg-success/10' : 'bg-muted'
-            )}>
-              {model.installed ? (
-                <HardDrive className="w-4 h-4 text-success" />
-              ) : (
-                <Package className="w-4 h-4 text-muted-foreground" />
-              )}
-            </div>
-            <div className="flex-1 min-w-0">
-              <div className="flex items-center gap-2 flex-wrap">
-                <span className="text-sm font-medium text-foreground truncate">
-                  {model.name}
-                </span>
-                <Badge
-                  variant={getModelTypeVariant(model.type)}
-                  className="text-xs flex-shrink-0"
-                >
-                  {model.type}
-                </Badge>
-                <Badge
-                  variant={model.installed ? 'success' : 'outline'}
-                  className="text-xs flex-shrink-0"
-                >
-                  {model.installed
-                    ? formatMessage({ id: 'codexlens.models.status.downloaded' })
-                    : formatMessage({ id: 'codexlens.models.status.available' })
-                  }
-                </Badge>
-              </div>
-              <div className="flex items-center gap-3 mt-1 text-xs text-muted-foreground">
-                {model.dimensions && <span>{model.dimensions}d</span>}
-                <span>{formatSize(model.size)}</span>
-                {model.recommended && (
-                  <Badge variant="success" className="text-[10px] px-1 py-0">Rec</Badge>
-                )}
-              </div>
-              {model.description && (
-                <p className="text-xs text-muted-foreground mt-1">
-                  {model.description}
-                </p>
-              )}
-            </div>
-          </div>
-
-          {/* Action Buttons */}
-          <div className="flex items-center gap-1 flex-shrink-0">
-            {isDownloading ? (
-              <Button
-                variant="ghost"
-                size="sm"
-                className="h-8 w-8 p-0 text-destructive hover:text-destructive hover:bg-destructive/10"
-                onClick={onCancelDownload}
-                title={formatMessage({ id: 'codexlens.models.actions.cancel' })}
-              >
-                <X className="w-4 h-4" />
-              </Button>
-            ) : model.installed ? (
-              <Button
-                variant="ghost"
-                size="sm"
-                className="h-8 w-8 p-0 text-destructive hover:text-destructive hover:bg-destructive/10"
-                onClick={handleDelete}
-                disabled={isDeleting}
-                title={formatMessage({ id: 'codexlens.models.actions.delete' })}
-              >
-                {isDeleting ? (
-                  <Loader2 className="w-4 h-4 animate-spin" />
-                ) : (
-                  <Trash2 className="w-4 h-4" />
-                )}
-              </Button>
-            ) : (
-              <Button
-                variant="ghost"
-                size="sm"
-                className="h-8 px-2"
-                onClick={handleDownload}
-                title={formatMessage({ id: 'codexlens.models.actions.download' })}
-              >
-                <Download className="w-4 h-4 mr-1" />
-                <span className="text-xs">{formatMessage({ id: 'codexlens.models.actions.download' })}</span>
-              </Button>
-            )}
-          </div>
-        </div>
-
-        {/* Download Progress */}
-        {isDownloading && (
-          <div className="mt-3 space-y-1">
-            <div className="flex items-center justify-between text-xs">
-              <span className="text-muted-foreground">
-                {formatMessage({ id: 'codexlens.models.downloading' })}
-              </span>
-              <span className="font-medium">{downloadProgress}%</span>
-            </div>
-            <Progress value={downloadProgress} className="h-2" />
-          </div>
-        )}
-      </div>
-    </Card>
-  );
-}
-
-// ========== Custom Model Input ==========
-
-export interface CustomModelInputProps {
-  isDownloading: boolean;
-  onDownload: (modelName: string, modelType: 'embedding' | 'reranker') => void;
-}
-
-export function CustomModelInput({ isDownloading, onDownload }: CustomModelInputProps) {
-  const { formatMessage } = useIntl();
-  const [modelName, setModelName] = useState('');
-  const [modelType, setModelType] = useState<'embedding' | 'reranker'>('embedding');
-
-  const handleSubmit = (e: React.FormEvent) => {
-    e.preventDefault();
-    if (modelName.trim()) {
-      onDownload(modelName.trim(), modelType);
-      setModelName('');
-    }
-  };
-
-  return (
-    <Card className="p-4 bg-primary/5 border-primary/20">
-      <h3 className="text-sm font-medium text-foreground mb-3 flex items-center gap-2">
-        <Package className="w-4 h-4 text-primary" />
-        {formatMessage({ id: 'codexlens.models.custom.title' })}
-      </h3>
-      <form onSubmit={handleSubmit} className="space-y-3">
-        <div className="flex gap-2">
-          <Input
-            placeholder={formatMessage({ id: 'codexlens.models.custom.placeholder' })}
-            value={modelName}
-            onChange={(e) => setModelName(e.target.value)}
-            disabled={isDownloading}
-            className="flex-1"
-          />
-          <select
-            value={modelType}
-            onChange={(e) => setModelType(e.target.value as 'embedding' | 'reranker')}
-            disabled={isDownloading}
-            className="px-3 py-2 text-sm rounded-md border border-input bg-background"
-          >
-            <option value="embedding">{formatMessage({ id: 'codexlens.models.types.embedding' })}</option>
-            <option value="reranker">{formatMessage({ id: 'codexlens.models.types.reranker' })}</option>
-          </select>
-        </div>
-        <p className="text-xs text-muted-foreground">
-          {formatMessage({ id: 'codexlens.models.custom.description' })}
-        </p>
-      </form>
-    </Card>
-  );
-}
-
-export default ModelCard;
diff --git a/ccw/frontend/src/components/codexlens/ModelSelectField.tsx b/ccw/frontend/src/components/codexlens/ModelSelectField.tsx
deleted file mode 100644
index 876888ff..00000000
--- a/ccw/frontend/src/components/codexlens/ModelSelectField.tsx
+++ /dev/null
@@ -1,195 +0,0 @@
-// ========================================
-// ModelSelectField Component
-// ========================================
-// Combobox-style input for selecting models from local + API sources
-
-import { useState, useRef, useEffect, useMemo } from 'react';
-import { useIntl } from 'react-intl';
-import { ChevronDown } from 'lucide-react';
-import { cn } from '@/lib/utils';
-import type { EnvVarFieldSchema, ModelGroup } from '@/types/codexlens';
-import type { CodexLensModel } from '@/lib/api';
-
-interface ModelSelectFieldProps {
-  field: EnvVarFieldSchema;
-  value: string;
-  onChange: (value: string) => void;
-  /** Currently loaded local models (installed) */
-  localModels?: CodexLensModel[];
-  /** Backend type determines which model list to show */
-  backendType: 'local' | 'api';
-  disabled?: boolean;
-}
-
-interface ModelOption {
-  id: string;
-  label: string;
-  group: string;
-}
-
-export function ModelSelectField({
-  field,
-  value,
-  onChange,
-  localModels = [],
-  backendType,
-  disabled = false,
-}: ModelSelectFieldProps) {
-  const { formatMessage } = useIntl();
-  const [open, setOpen] = useState(false);
-  const [search, setSearch] = useState('');
-  const containerRef = useRef<HTMLDivElement>(null);
-  const inputRef = useRef<HTMLInputElement>(null);
-
-  // Close on outside click
-  useEffect(() => {
-    function handleClickOutside(e: MouseEvent) {
-      if (containerRef.current && !containerRef.current.contains(e.target as Node)) {
-        setOpen(false);
-      }
-    }
-    if (open) {
-      document.addEventListener('mousedown', handleClickOutside);
-      return () => document.removeEventListener('mousedown', handleClickOutside);
-    }
-  }, [open]);
-
-  // Build model options based on backend type
-  const options = useMemo<ModelOption[]>(() => {
-    const result: ModelOption[] = [];
-
-    if (backendType === 'api') {
-      // API mode: show preset API models from schema
-      const apiGroups: ModelGroup[] = field.apiModels || [];
-      for (const group of apiGroups) {
-        for (const item of group.items) {
-          result.push({ id: item, label: item, group: group.group });
-        }
-      }
-    } else {
-      // Local mode: show installed local models, then preset profiles as fallback
-      if (localModels.length > 0) {
-        for (const model of localModels) {
-          const modelId = model.profile || model.name;
-          const displayText =
-            model.profile && model.name && model.profile !== model.name
-              ? `${model.profile} (${model.name})`
-              : model.name || model.profile;
-          result.push({
-            id: modelId,
-            label: displayText,
-            group: formatMessage({ id: 'codexlens.downloadedModels', defaultMessage: 'Downloaded Models' }),
-          });
-        }
-      } else {
-        // Fallback to preset local models from schema
-        const localGroups: ModelGroup[] = field.localModels || [];
-        for (const group of localGroups) {
-          for (const item of group.items) {
-            result.push({ id: item, label: item, group: group.group });
-          }
-        }
-      }
-    }
-
-    return result;
-  }, [backendType, field.apiModels, field.localModels, localModels, formatMessage]);
-
-  // Filter by search
-  const filtered = useMemo(() => {
-    if (!search) return options;
-    const q = search.toLowerCase();
-    return options.filter(
-      (opt) => opt.id.toLowerCase().includes(q) || opt.label.toLowerCase().includes(q)
-    );
-  }, [options, search]);
-
-  // Group filtered options
-  const grouped = useMemo(() => {
-    const groups: Record<string, ModelOption[]> = {};
-    for (const opt of filtered) {
-      if (!groups[opt.group]) groups[opt.group] = [];
-      groups[opt.group].push(opt);
-    }
-    return groups;
-  }, [filtered]);
-
-  const handleSelect = (modelId: string) => {
-    onChange(modelId);
-    setOpen(false);
-    setSearch('');
-  };
-
-  const handleInputChange = (e: React.ChangeEvent<HTMLInputElement>) => {
-    const val = e.target.value;
-    setSearch(val);
-    onChange(val);
-    if (!open) setOpen(true);
-  };
-
-  return (
-    <div ref={containerRef} className="relative flex-1">
-      <div className="relative">
-        <input
-          ref={inputRef}
-          type="text"
-          value={open ? search || value : value}
-          onChange={handleInputChange}
-          onFocus={() => {
-            setOpen(true);
-            setSearch('');
-          }}
-          placeholder={field.placeholder || 'Select model...'}
-          disabled={disabled}
-          className={cn(
-            'flex h-9 w-full rounded-md border border-input bg-background px-3 py-1 pr-8 text-sm',
-            'ring-offset-background placeholder:text-muted-foreground',
-            'focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2',
-            'disabled:cursor-not-allowed disabled:opacity-50'
-          )}
-        />
-        <ChevronDown
-          className="absolute right-2 top-1/2 -translate-y-1/2 h-4 w-4 text-muted-foreground pointer-events-none"
-        />
-      </div>
-
-      {open && !disabled && (
-        <div className="absolute z-50 mt-1 w-full rounded-md border border-border bg-card shadow-md">
-          <div className="max-h-56 overflow-y-auto p-1">
-            {Object.keys(grouped).length === 0 ? (
-              <div className="py-3 text-center text-xs text-muted-foreground">
-                {backendType === 'api'
-                  ? formatMessage({ id: 'codexlens.noConfiguredModels', defaultMessage: 'No models configured' })
-                  : formatMessage({ id: 'codexlens.noLocalModels', defaultMessage: 'No models downloaded' })}
-              </div>
-            ) : (
-              Object.entries(grouped).map(([group, items]) => (
-                <div key={group}>
-                  <div className="px-2 py-1 text-xs font-medium text-muted-foreground">
-                    {group}
-                  </div>
-                  {items.map((item) => (
-                    <button
-                      key={item.id}
-                      type="button"
-                      onClick={() => handleSelect(item.id)}
-                      className={cn(
-                        'flex w-full items-center rounded-sm px-2 py-1.5 text-xs cursor-pointer',
-                        'hover:bg-accent hover:text-accent-foreground',
-                        value === item.id && 'bg-accent/50'
-                      )}
-                    >
-                      {item.label}
-                    </button>
-                  ))}
-                </div>
-              ))
-            )}
-          </div>
-        </div>
-      )}
-    </div>
-  );
-}
-
-export default ModelSelectField;
diff --git a/ccw/frontend/src/components/codexlens/ModelsTab.test.tsx b/ccw/frontend/src/components/codexlens/ModelsTab.test.tsx
deleted file mode 100644
index 0c619b67..00000000
--- a/ccw/frontend/src/components/codexlens/ModelsTab.test.tsx
+++ /dev/null
@@ -1,405 +0,0 @@
-// ========================================
-// Models Tab Component Tests
-// ========================================
-// Tests for CodexLens Models Tab component
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { render, screen, waitFor } from '@/test/i18n';
-import userEvent from '@testing-library/user-event';
-import { ModelsTab } from './ModelsTab';
-import type { CodexLensModel } from '@/lib/api';
-
-// Mock hooks - use importOriginal to preserve all exports
-vi.mock('@/hooks', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('@/hooks')>();
-  return {
-    ...actual,
-    useCodexLensModels: vi.fn(),
-    useCodexLensMutations: vi.fn(),
-  };
-});
-
-import { useCodexLensModels, useCodexLensMutations } from '@/hooks';
-
-const mockModels: CodexLensModel[] = [
-  {
-    profile: 'embedding1',
-    name: 'BAAI/bge-small-en-v1.5',
-    type: 'embedding',
-    backend: 'onnx',
-    installed: true,
-    cache_path: '/cache/embedding1',
-  },
-  {
-    profile: 'reranker1',
-    name: 'BAAI/bge-reranker-v2-m3',
-    type: 'reranker',
-    backend: 'onnx',
-    installed: false,
-    cache_path: '/cache/reranker1',
-  },
-  {
-    profile: 'embedding2',
-    name: 'sentence-transformers/all-MiniLM-L6-v2',
-    type: 'embedding',
-    backend: 'torch',
-    installed: false,
-    cache_path: '/cache/embedding2',
-  },
-];
-
-const mockMutations = {
-  updateConfig: vi.fn().mockResolvedValue({ success: true }) as any,
-  isUpdatingConfig: false,
-  bootstrap: vi.fn().mockResolvedValue({ success: true }) as any,
-  isBootstrapping: false,
-  installSemantic: vi.fn().mockResolvedValue({ success: true }) as any,
-  isInstallingSemantic: false,
-  uninstall: vi.fn().mockResolvedValue({ success: true }) as any,
-  isUninstalling: false,
-  downloadModel: vi.fn().mockResolvedValue({ success: true }) as any,
-  downloadCustomModel: vi.fn().mockResolvedValue({ success: true }) as any,
-  isDownloading: false,
-  deleteModel: vi.fn().mockResolvedValue({ success: true }) as any,
-  deleteModelByPath: vi.fn().mockResolvedValue({ success: true }) as any,
-  isDeleting: false,
-  updateEnv: vi.fn().mockResolvedValue({ success: true, env: {}, settings: {}, raw: '' }) as any,
-  isUpdatingEnv: false,
-  selectGpu: vi.fn().mockResolvedValue({ success: true }) as any,
-  resetGpu: vi.fn().mockResolvedValue({ success: true }) as any,
-  isSelectingGpu: false,
-  updatePatterns: vi.fn().mockResolvedValue({ patterns: [], extensionFilters: [], defaults: {} }) as any,
-  isUpdatingPatterns: false,
-  rebuildIndex: vi.fn().mockResolvedValue({ success: true }) as any,
-  isRebuildingIndex: false,
-  updateIndex: vi.fn().mockResolvedValue({ success: true }) as any,
-  isUpdatingIndex: false,
-  cancelIndexing: vi.fn().mockResolvedValue({ success: true }) as any,
-  isCancellingIndexing: false,
-  isMutating: false,
-};
-
-describe('ModelsTab', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('when installed', () => {
-    beforeEach(() => {
-      vi.mocked(useCodexLensModels).mockReturnValue({
-        models: mockModels,
-        embeddingModels: mockModels.filter(m => m.type === 'embedding'),
-        rerankerModels: mockModels.filter(m => m.type === 'reranker'),
-        isLoading: false,
-        error: null,
-        refetch: vi.fn(),
-      });
-      vi.mocked(useCodexLensMutations).mockReturnValue(mockMutations);
-    });
-
-    it('should render search input', () => {
-      render(<ModelsTab installed={true} />);
-
-      expect(screen.getByPlaceholderText(/Search models/i)).toBeInTheDocument();
-    });
-
-    it('should render filter buttons with counts', () => {
-      render(<ModelsTab installed={true} />);
-
-      expect(screen.getByText(/All/)).toBeInTheDocument();
-      expect(screen.getByText(/Embedding Models/)).toBeInTheDocument();
-      expect(screen.getByText(/Reranker Models/)).toBeInTheDocument();
-      expect(screen.getByText(/Downloaded/)).toBeInTheDocument();
-      expect(screen.getByText(/Available/)).toBeInTheDocument();
-    });
-
-    it('should render model list', () => {
-      render(<ModelsTab installed={true} />);
-
-      expect(screen.getByText('BAAI/bge-small-en-v1.5')).toBeInTheDocument();
-      expect(screen.getByText('BAAI/bge-reranker-v2-m3')).toBeInTheDocument();
-      expect(screen.getByText('sentence-transformers/all-MiniLM-L6-v2')).toBeInTheDocument();
-    });
-
-    it('should filter models by search query', async () => {
-      const user = userEvent.setup();
-      render(<ModelsTab installed={true} />);
-
-      const searchInput = screen.getByPlaceholderText(/Search models/i);
-      await user.type(searchInput, 'bge');
-
-      expect(screen.getByText('BAAI/bge-small-en-v1.5')).toBeInTheDocument();
-      expect(screen.getByText('BAAI/bge-reranker-v2-m3')).toBeInTheDocument();
-      expect(screen.queryByText('sentence-transformers/all-MiniLM-L6-v2')).not.toBeInTheDocument();
-    });
-
-    it('should filter by embedding type', async () => {
-      const user = userEvent.setup();
-      render(<ModelsTab installed={true} />);
-
-      const embeddingButton = screen.getByText(/Embedding Models/i);
-      await user.click(embeddingButton);
-
-      expect(screen.getByText('BAAI/bge-small-en-v1.5')).toBeInTheDocument();
-      expect(screen.queryByText('BAAI/bge-reranker-v2-m3')).not.toBeInTheDocument();
-    });
-
-    it('should filter by reranker type', async () => {
-      const user = userEvent.setup();
-      render(<ModelsTab installed={true} />);
-
-      const rerankerButton = screen.getByText(/Reranker Models/i);
-      await user.click(rerankerButton);
-
-      expect(screen.getByText('BAAI/bge-reranker-v2-m3')).toBeInTheDocument();
-      expect(screen.queryByText('BAAI/bge-small-en-v1.5')).not.toBeInTheDocument();
-    });
-
-    it('should filter by downloaded status', async () => {
-      const user = userEvent.setup();
-      render(<ModelsTab installed={true} />);
-
-      const downloadedButton = screen.getByText(/Downloaded/i);
-      await user.click(downloadedButton);
-
-      expect(screen.getByText('BAAI/bge-small-en-v1.5')).toBeInTheDocument();
-      expect(screen.queryByText('BAAI/bge-reranker-v2-m3')).not.toBeInTheDocument();
-    });
-
-    it('should filter by available status', async () => {
-      const user = userEvent.setup();
-      render(<ModelsTab installed={true} />);
-
-      const availableButton = screen.getByText(/Available/i);
-      await user.click(availableButton);
-
-      expect(screen.getByText('BAAI/bge-reranker-v2-m3')).toBeInTheDocument();
-      expect(screen.queryByText('BAAI/bge-small-en-v1.5')).not.toBeInTheDocument();
-    });
-
-    it('should call downloadModel when download clicked', async () => {
-      const downloadModel = vi.fn().mockResolvedValue({ success: true });
-      vi.mocked(useCodexLensMutations).mockReturnValue({
-        ...mockMutations,
-        downloadModel,
-      });
-
-      const user = userEvent.setup();
-      render(<ModelsTab installed={true} />);
-
-      // Filter to show available models
-      const availableButton = screen.getByText(/Available/i);
-      await user.click(availableButton);
-
-      const downloadButton = screen.getAllByText(/Download/i)[0];
-      await user.click(downloadButton);
-
-      await waitFor(() => {
-        expect(downloadModel).toHaveBeenCalled();
-      });
-    });
-
-    it('should refresh models on refresh button click', async () => {
-      const refetch = vi.fn();
-      vi.mocked(useCodexLensModels).mockReturnValue({
-        models: mockModels,
-        embeddingModels: mockModels.filter(m => m.type === 'embedding'),
-        rerankerModels: mockModels.filter(m => m.type === 'reranker'),
-        isLoading: false,
-        error: null,
-        refetch,
-      });
-
-      const user = userEvent.setup();
-      render(<ModelsTab installed={true} />);
-
-      const refreshButton = screen.getByText(/Refresh/i);
-      await user.click(refreshButton);
-
-      expect(refetch).toHaveBeenCalledOnce();
-    });
-  });
-
-  describe('when not installed', () => {
-    beforeEach(() => {
-      vi.mocked(useCodexLensModels).mockReturnValue({
-        models: undefined,
-        embeddingModels: undefined,
-        rerankerModels: undefined,
-        isLoading: false,
-        error: null,
-        refetch: vi.fn(),
-      });
-      vi.mocked(useCodexLensMutations).mockReturnValue(mockMutations);
-    });
-
-    it('should show not installed message', () => {
-      render(<ModelsTab installed={false} />);
-
-      expect(screen.getByText(/CodexLens Not Installed/i)).toBeInTheDocument();
-      expect(screen.getByText(/Please install CodexLens to use model management features/i)).toBeInTheDocument();
-    });
-  });
-
-  describe('loading states', () => {
-    it('should show loading state', () => {
-      vi.mocked(useCodexLensModels).mockReturnValue({
-        models: undefined,
-        embeddingModels: undefined,
-        rerankerModels: undefined,
-        isLoading: true,
-        error: null,
-        refetch: vi.fn(),
-      });
-      vi.mocked(useCodexLensMutations).mockReturnValue(mockMutations);
-
-      render(<ModelsTab installed={true} />);
-
-      expect(screen.getByText(/Loading/i)).toBeInTheDocument();
-    });
-  });
-
-  describe('empty states', () => {
-    it('should show empty state when no models', () => {
-      vi.mocked(useCodexLensModels).mockReturnValue({
-        models: [],
-        embeddingModels: [],
-        rerankerModels: [],
-        isLoading: false,
-        error: null,
-        refetch: vi.fn(),
-      });
-      vi.mocked(useCodexLensMutations).mockReturnValue(mockMutations);
-
-      render(<ModelsTab installed={true} />);
-
-      expect(screen.getByText(/No models found/i)).toBeInTheDocument();
-      expect(screen.getByText(/Try adjusting your search or filter criteria/i)).toBeInTheDocument();
-    });
-
-    it('should show empty state when search returns no results', async () => {
-      const user = userEvent.setup();
-      vi.mocked(useCodexLensModels).mockReturnValue({
-        models: mockModels,
-        embeddingModels: mockModels.filter(m => m.type === 'embedding'),
-        rerankerModels: mockModels.filter(m => m.type === 'reranker'),
-        isLoading: false,
-        error: null,
-        refetch: vi.fn(),
-      });
-      vi.mocked(useCodexLensMutations).mockReturnValue(mockMutations);
-
-      render(<ModelsTab installed={true} />);
-
-      const searchInput = screen.getByPlaceholderText(/Search models/i);
-      await user.type(searchInput, 'nonexistent-model');
-
-      expect(screen.getByText(/No models found/i)).toBeInTheDocument();
-    });
-  });
-
-  describe('i18n - Chinese locale', () => {
-    beforeEach(() => {
-      vi.mocked(useCodexLensModels).mockReturnValue({
-        models: mockModels,
-        embeddingModels: mockModels.filter(m => m.type === 'embedding'),
-        rerankerModels: mockModels.filter(m => m.type === 'reranker'),
-        isLoading: false,
-        error: null,
-        refetch: vi.fn(),
-      });
-      vi.mocked(useCodexLensMutations).mockReturnValue(mockMutations);
-    });
-
-    it('should display translated text', () => {
-      render(<ModelsTab installed={true} />, { locale: 'zh' });
-
-      expect(screen.getByPlaceholderText(/搜索模型/i)).toBeInTheDocument();
-      expect(screen.getByText(/筛选/i)).toBeInTheDocument();
-      expect(screen.getByText(/全部/i)).toBeInTheDocument();
-      expect(screen.getByText(/嵌入模型/i)).toBeInTheDocument();
-      expect(screen.getByText(/重排序模型/i)).toBeInTheDocument();
-      expect(screen.getByText(/已下载/i)).toBeInTheDocument();
-      expect(screen.getByText(/可用/i)).toBeInTheDocument();
-      expect(screen.getByText(/刷新/i)).toBeInTheDocument();
-    });
-
-    it('should translate empty state', () => {
-      vi.mocked(useCodexLensModels).mockReturnValue({
-        models: [],
-        embeddingModels: [],
-        rerankerModels: [],
-        isLoading: false,
-        error: null,
-        refetch: vi.fn(),
-      });
-      vi.mocked(useCodexLensMutations).mockReturnValue(mockMutations);
-
-      render(<ModelsTab installed={true} />, { locale: 'zh' });
-
-      expect(screen.getByText(/没有找到模型/i)).toBeInTheDocument();
-      expect(screen.getByText(/尝试调整搜索或筛选条件/i)).toBeInTheDocument();
-    });
-
-    it('should translate not installed state', () => {
-      vi.mocked(useCodexLensModels).mockReturnValue({
-        models: undefined,
-        embeddingModels: undefined,
-        rerankerModels: undefined,
-        isLoading: false,
-        error: null,
-        refetch: vi.fn(),
-      });
-      vi.mocked(useCodexLensMutations).mockReturnValue(mockMutations);
-
-      render(<ModelsTab installed={false} />, { locale: 'zh' });
-
-      expect(screen.getByText(/CodexLens 未安装/i)).toBeInTheDocument();
-    });
-  });
-
-  describe('custom model input', () => {
-    beforeEach(() => {
-      vi.mocked(useCodexLensModels).mockReturnValue({
-        models: mockModels,
-        embeddingModels: mockModels.filter(m => m.type === 'embedding'),
-        rerankerModels: mockModels.filter(m => m.type === 'reranker'),
-        isLoading: false,
-        error: null,
-        refetch: vi.fn(),
-      });
-      vi.mocked(useCodexLensMutations).mockReturnValue(mockMutations);
-    });
-
-    it('should render custom model input section', () => {
-      render(<ModelsTab installed={true} />);
-
-      expect(screen.getByText(/Custom Model/i)).toBeInTheDocument();
-    });
-
-    it('should translate custom model section in Chinese', () => {
-      render(<ModelsTab installed={true} />, { locale: 'zh' });
-
-      expect(screen.getByText(/自定义模型/i)).toBeInTheDocument();
-    });
-  });
-
-  describe('error handling', () => {
-    it('should handle API errors gracefully', () => {
-      vi.mocked(useCodexLensModels).mockReturnValue({
-        models: mockModels,
-        embeddingModels: mockModels.filter(m => m.type === 'embedding'),
-        rerankerModels: mockModels.filter(m => m.type === 'reranker'),
-        isLoading: false,
-        error: new Error('API Error'),
-        refetch: vi.fn(),
-      });
-      vi.mocked(useCodexLensMutations).mockReturnValue(mockMutations);
-
-      render(<ModelsTab installed={true} />);
-
-      // Component should still render despite error
-      expect(screen.getByText(/BAAI\/bge-small-en-v1.5/i)).toBeInTheDocument();
-    });
-  });
-});
diff --git a/ccw/frontend/src/components/codexlens/ModelsTab.tsx b/ccw/frontend/src/components/codexlens/ModelsTab.tsx
deleted file mode 100644
index 4450c173..00000000
--- a/ccw/frontend/src/components/codexlens/ModelsTab.tsx
+++ /dev/null
@@ -1,309 +0,0 @@
-// ========================================
-// Models Tab Component
-// ========================================
-// Model management tab with list, search, and download actions
-
-import { useState, useMemo } from 'react';
-import { useIntl } from 'react-intl';
-import {
-  Search,
-  RefreshCw,
-  Package,
-  Filter,
-  AlertCircle,
-} from 'lucide-react';
-import { Card } from '@/components/ui/Card';
-import { Button } from '@/components/ui/Button';
-import { Input } from '@/components/ui/Input';
-import { Badge } from '@/components/ui/Badge';
-import { ModelCard, CustomModelInput } from './ModelCard';
-import { useCodexLensModels, useCodexLensMutations } from '@/hooks';
-import type { CodexLensModel } from '@/lib/api';
-import { cn } from '@/lib/utils';
-
-// ========== Types ==========
-
-type FilterType = 'all' | 'embedding' | 'reranker' | 'downloaded' | 'available';
-
-// ========== Helper Functions ==========
-
-function filterModels(models: CodexLensModel[], filter: FilterType, search: string): CodexLensModel[] {
-  let filtered = models;
-
-  // Apply type/status filter
-  if (filter === 'embedding') {
-    filtered = filtered.filter(m => m.type === 'embedding');
-  } else if (filter === 'reranker') {
-    filtered = filtered.filter(m => m.type === 'reranker');
-  } else if (filter === 'downloaded') {
-    filtered = filtered.filter(m => m.installed);
-  } else if (filter === 'available') {
-    filtered = filtered.filter(m => !m.installed);
-  }
-
-  // Apply search filter
-  if (search.trim()) {
-    const query = search.toLowerCase();
-    filtered = filtered.filter(m =>
-      m.name.toLowerCase().includes(query) ||
-      m.profile.toLowerCase().includes(query) ||
-      (m.description?.toLowerCase().includes(query) ?? false)
-    );
-  }
-
-  return filtered;
-}
-
-// ========== Component ==========
-
-export interface ModelsTabProps {
-  installed?: boolean;
-}
-
-export function ModelsTab({ installed = false }: ModelsTabProps) {
-  const { formatMessage } = useIntl();
-  const [searchQuery, setSearchQuery] = useState('');
-  const [filterType, setFilterType] = useState<FilterType>('all');
-  const [downloadingProfile, setDownloadingProfile] = useState<string | null>(null);
-  const [downloadProgress, setDownloadProgress] = useState(0);
-
-  const {
-    models,
-    isLoading,
-    error,
-    refetch,
-  } = useCodexLensModels({
-    enabled: installed,
-  });
-
-  const {
-    downloadModel,
-    downloadCustomModel,
-    deleteModel,
-    isDownloading,
-    isDeleting,
-  } = useCodexLensMutations();
-
-  // Filter models based on search and filter
-  const filteredModels = useMemo(() => {
-    if (!models) return [];
-    return filterModels(models, filterType, searchQuery);
-  }, [models, filterType, searchQuery]);
-
-  // Count models by type and status
-  const stats = useMemo(() => {
-    if (!models) return null;
-    return {
-      total: models.length,
-      embedding: models.filter(m => m.type === 'embedding').length,
-      reranker: models.filter(m => m.type === 'reranker').length,
-      downloaded: models.filter(m => m.installed).length,
-      available: models.filter(m => !m.installed).length,
-    };
-  }, [models]);
-
-  // Handle model download
-  const handleDownload = async (profile: string) => {
-    setDownloadingProfile(profile);
-    setDownloadProgress(0);
-
-    // Simulate progress for demo (in real implementation, use WebSocket or polling)
-    const progressInterval = setInterval(() => {
-      setDownloadProgress(prev => {
-        if (prev >= 95) {
-          clearInterval(progressInterval);
-          return 95;
-        }
-        return prev + 5;
-      });
-    }, 500);
-
-    try {
-      const result = await downloadModel(profile);
-      if (result.success) {
-        setDownloadProgress(100);
-        setTimeout(() => {
-          setDownloadingProfile(null);
-          setDownloadProgress(0);
-          refetch();
-        }, 500);
-      } else {
-        setDownloadingProfile(null);
-        setDownloadProgress(0);
-      }
-    } catch (error) {
-      setDownloadingProfile(null);
-      setDownloadProgress(0);
-    } finally {
-      clearInterval(progressInterval);
-    }
-  };
-
-  // Handle custom model download
-  const handleCustomDownload = async (modelName: string, modelType: 'embedding' | 'reranker') => {
-    try {
-      const result = await downloadCustomModel(modelName, modelType);
-      if (result.success) {
-        refetch();
-      }
-    } catch (error) {
-      console.error('Failed to download custom model:', error);
-    }
-  };
-
-  // Handle model delete
-  const handleDelete = async (profile: string) => {
-    const result = await deleteModel(profile);
-    if (result.success) {
-      refetch();
-    }
-  };
-
-  // Filter buttons
-  const filterButtons: Array<{ type: FilterType; label: string; count: number | undefined }> = [
-    { type: 'all', label: formatMessage({ id: 'codexlens.models.filters.all' }), count: stats?.total },
-    { type: 'embedding', label: formatMessage({ id: 'codexlens.models.types.embedding' }), count: stats?.embedding },
-    { type: 'reranker', label: formatMessage({ id: 'codexlens.models.types.reranker' }), count: stats?.reranker },
-    { type: 'downloaded', label: formatMessage({ id: 'codexlens.models.status.downloaded' }), count: stats?.downloaded },
-    { type: 'available', label: formatMessage({ id: 'codexlens.models.status.available' }), count: stats?.available },
-  ];
-
-  if (!installed) {
-    return (
-      <Card className="p-12 text-center">
-        <Package className="w-16 h-16 mx-auto text-muted-foreground/30 mb-4" />
-        <h3 className="text-lg font-semibold text-foreground mb-2">
-          {formatMessage({ id: 'codexlens.models.notInstalled.title' })}
-        </h3>
-        <p className="text-muted-foreground">
-          {formatMessage({ id: 'codexlens.models.notInstalled.description' })}
-        </p>
-      </Card>
-    );
-  }
-
-  return (
-    <div className="space-y-4">
-      {/* Header with Search and Actions */}
-      <Card className="p-4">
-        <div className="flex flex-col sm:flex-row sm:items-center justify-between gap-4">
-          <div className="relative flex-1 max-w-md">
-            <Search className="absolute left-3 top-1/2 -translate-y-1/2 w-4 h-4 text-muted-foreground" />
-            <Input
-              placeholder={formatMessage({ id: 'codexlens.models.searchPlaceholder' })}
-              value={searchQuery}
-              onChange={(e) => setSearchQuery(e.target.value)}
-              className="pl-9"
-            />
-          </div>
-          <div className="flex items-center gap-2">
-            <Button
-              variant="outline"
-              size="sm"
-              onClick={() => refetch()}
-              disabled={isLoading}
-            >
-              <RefreshCw className={cn('w-4 h-4 mr-1', isLoading && 'animate-spin')} />
-              {formatMessage({ id: 'common.actions.refresh' })}
-            </Button>
-          </div>
-        </div>
-      </Card>
-
-      {/* Stats and Filters */}
-      <Card className="p-4">
-        <div className="flex items-center gap-2 mb-3">
-          <Filter className="w-4 h-4 text-muted-foreground" />
-          <span className="text-sm font-medium text-foreground">
-            {formatMessage({ id: 'codexlens.models.filters.label' })}
-          </span>
-        </div>
-        <div className="flex flex-wrap gap-2">
-          {filterButtons.map(({ type, label, count }) => (
-            <Button
-              key={type}
-              variant={filterType === type ? 'default' : 'outline'}
-              size="sm"
-              onClick={() => setFilterType(type)}
-              className="relative"
-            >
-              {label}
-              {count !== undefined && (
-                <Badge variant={filterType === type ? 'secondary' : 'default'} className="ml-2">
-                  {count}
-                </Badge>
-              )}
-            </Button>
-          ))}
-        </div>
-      </Card>
-
-      {/* Custom Model Input */}
-      <CustomModelInput
-        isDownloading={isDownloading}
-        onDownload={handleCustomDownload}
-      />
-
-      {/* Model List */}
-      {error ? (
-        <Card className="p-8 text-center">
-          <AlertCircle className="w-12 h-12 mx-auto text-destructive/50 mb-3" />
-          <h3 className="text-sm font-medium text-destructive-foreground mb-1">
-            {formatMessage({ id: 'codexlens.models.error.title' })}
-          </h3>
-          <p className="text-xs text-muted-foreground mb-3">
-            {error.message || formatMessage({ id: 'codexlens.models.error.description' })}
-          </p>
-          <Button
-            variant="outline"
-            size="sm"
-            onClick={() => refetch()}
-          >
-            <RefreshCw className="w-3 h-3 mr-1" />
-            {formatMessage({ id: 'common.actions.retry' })}
-          </Button>
-        </Card>
-      ) : isLoading ? (
-        <Card className="p-8 text-center">
-          <p className="text-muted-foreground">{formatMessage({ id: 'common.actions.loading' })}</p>
-        </Card>
-      ) : filteredModels.length === 0 ? (
-        <Card className="p-8 text-center">
-          <Package className="w-12 h-12 mx-auto text-muted-foreground/30 mb-3" />
-          <h3 className="text-sm font-medium text-foreground mb-1">
-            {models && models.length > 0
-              ? formatMessage({ id: 'codexlens.models.empty.filtered' })
-              : formatMessage({ id: 'codexlens.models.empty.title' })
-            }
-          </h3>
-          <p className="text-xs text-muted-foreground">
-            {models && models.length > 0
-              ? formatMessage({ id: 'codexlens.models.empty.filteredDesc' })
-              : formatMessage({ id: 'codexlens.models.empty.description' })
-            }
-          </p>
-        </Card>
-      ) : (
-        <div className="space-y-3">
-          {filteredModels.map((model) => (
-            <ModelCard
-              key={model.profile}
-              model={model}
-              isDownloading={downloadingProfile === model.profile}
-              downloadProgress={downloadProgress}
-              isDeleting={isDeleting && downloadingProfile !== model.profile}
-              onDownload={handleDownload}
-              onDelete={handleDelete}
-              onCancelDownload={() => {
-                setDownloadingProfile(null);
-                setDownloadProgress(0);
-              }}
-            />
-          ))}
-        </div>
-      )}
-    </div>
-  );
-}
-
-export default ModelsTab;
diff --git a/ccw/frontend/src/components/codexlens/OverviewTab.test.tsx b/ccw/frontend/src/components/codexlens/OverviewTab.test.tsx
deleted file mode 100644
index af8b9a9b..00000000
--- a/ccw/frontend/src/components/codexlens/OverviewTab.test.tsx
+++ /dev/null
@@ -1,276 +0,0 @@
-// ========================================
-// Overview Tab Component Tests
-// ========================================
-// Tests for CodexLens Overview Tab component
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { render, screen } from '@/test/i18n';
-import userEvent from '@testing-library/user-event';
-import { OverviewTab } from './OverviewTab';
-import type { CodexLensVenvStatus, CodexLensConfig } from '@/lib/api';
-
-const mockStatus: CodexLensVenvStatus = {
-  ready: true,
-  installed: true,
-  version: '1.0.0',
-  pythonVersion: '3.11.0',
-  venvPath: '/path/to/venv',
-};
-
-const mockConfig: CodexLensConfig = {
-  index_dir: '~/.codexlens/indexes',
-  index_count: 100,
-};
-
-// Mock window.alert
-global.alert = vi.fn();
-
-describe('OverviewTab', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('when installed and ready', () => {
-    const defaultProps = {
-      installed: true,
-      status: mockStatus,
-      config: mockConfig,
-      isLoading: false,
-    };
-
-    it('should render status cards', () => {
-      render(<OverviewTab {...defaultProps} />);
-
-      expect(screen.getByText(/Installation Status/i)).toBeInTheDocument();
-      expect(screen.getByText(/Ready/i)).toBeInTheDocument();
-      expect(screen.getByText(/Version/i)).toBeInTheDocument();
-      expect(screen.getByText(/1.0.0/i)).toBeInTheDocument();
-    });
-
-    it('should render index path with full path in title', () => {
-      render(<OverviewTab {...defaultProps} />);
-
-      const indexPath = screen.getByText(/Index Path/i).nextElementSibling as HTMLElement;
-      expect(indexPath).toHaveTextContent('~/.codexlens/indexes');
-      expect(indexPath).toHaveAttribute('title', '~/.codexlens/indexes');
-    });
-
-    it('should render index count', () => {
-      render(<OverviewTab {...defaultProps} />);
-
-      expect(screen.getByText(/Index Count/i)).toBeInTheDocument();
-      expect(screen.getByText('100')).toBeInTheDocument();
-    });
-
-    it('should render quick actions section', () => {
-      render(<OverviewTab {...defaultProps} />);
-
-      expect(screen.getByText(/Quick Actions/i)).toBeInTheDocument();
-      expect(screen.getByText(/FTS Full/i)).toBeInTheDocument();
-      expect(screen.getByText(/FTS Incremental/i)).toBeInTheDocument();
-      expect(screen.getByText(/Vector Full/i)).toBeInTheDocument();
-      expect(screen.getByText(/Vector Incremental/i)).toBeInTheDocument();
-    });
-
-    it('should render venv details section', () => {
-      render(<OverviewTab {...defaultProps} />);
-
-      expect(screen.getByText(/Python Virtual Environment Details/i)).toBeInTheDocument();
-      expect(screen.getByText(/Python Version/i)).toBeInTheDocument();
-      expect(screen.getByText(/3.11.0/i)).toBeInTheDocument();
-    });
-
-    it('should show coming soon alert when action clicked', async () => {
-      const user = userEvent.setup();
-      render(<OverviewTab {...defaultProps} />);
-
-      const ftsFullButton = screen.getByText(/FTS Full/i);
-      await user.click(ftsFullButton);
-
-      expect(global.alert).toHaveBeenCalledWith(expect.stringContaining('Coming Soon'));
-    });
-  });
-
-  describe('when installed but not ready', () => {
-    const notReadyProps = {
-      installed: true,
-      status: { ...mockStatus, ready: false },
-      config: mockConfig,
-      isLoading: false,
-    };
-
-    it('should show not ready status', () => {
-      render(<OverviewTab {...notReadyProps} />);
-
-      expect(screen.getByText(/Not Ready/i)).toBeInTheDocument();
-    });
-
-    it('should disable action buttons when not ready', () => {
-      render(<OverviewTab {...notReadyProps} />);
-
-      const ftsFullButton = screen.getByText(/FTS Full/i).closest('button');
-      expect(ftsFullButton).toBeDisabled();
-    });
-  });
-
-  describe('when not installed', () => {
-    const notInstalledProps = {
-      installed: false,
-      status: undefined,
-      config: undefined,
-      isLoading: false,
-    };
-
-    it('should show not installed message', () => {
-      render(<OverviewTab {...notInstalledProps} />);
-
-      expect(screen.getByText(/CodexLens Not Installed/i)).toBeInTheDocument();
-      expect(screen.getByText(/Please install CodexLens to use semantic code search features/i)).toBeInTheDocument();
-    });
-  });
-
-  describe('loading state', () => {
-    it('should show loading skeleton', () => {
-      const { container } = render(
-        <OverviewTab
-          installed={false}
-          status={undefined}
-          config={undefined}
-          isLoading={true}
-        />
-      );
-
-      // Check for pulse/skeleton elements
-      const skeletons = container.querySelectorAll('.animate-pulse');
-      expect(skeletons.length).toBeGreaterThan(0);
-    });
-  });
-
-  describe('i18n - Chinese locale', () => {
-    const defaultProps = {
-      installed: true,
-      status: mockStatus,
-      config: mockConfig,
-      isLoading: false,
-    };
-
-    it('should display translated text in Chinese', () => {
-      render(<OverviewTab {...defaultProps} />, { locale: 'zh' });
-
-      expect(screen.getByText(/安装状态/i)).toBeInTheDocument();
-      expect(screen.getByText(/就绪/i)).toBeInTheDocument();
-      expect(screen.getByText(/版本/i)).toBeInTheDocument();
-      expect(screen.getByText(/索引路径/i)).toBeInTheDocument();
-      expect(screen.getByText(/索引数量/i)).toBeInTheDocument();
-      expect(screen.getByText(/快速操作/i)).toBeInTheDocument();
-      expect(screen.getByText(/Python 虚拟环境详情/i)).toBeInTheDocument();
-    });
-
-    it('should translate action buttons', () => {
-      render(<OverviewTab {...defaultProps} />, { locale: 'zh' });
-
-      expect(screen.getByText(/FTS 全量/i)).toBeInTheDocument();
-      expect(screen.getByText(/FTS 增量/i)).toBeInTheDocument();
-      expect(screen.getByText(/向量全量/i)).toBeInTheDocument();
-      expect(screen.getByText(/向量增量/i)).toBeInTheDocument();
-    });
-  });
-
-  describe('status card colors', () => {
-    it('should show success color when ready', () => {
-      const { container } = render(
-        <OverviewTab
-          installed={true}
-          status={mockStatus}
-          config={mockConfig}
-          isLoading={false}
-        />
-      );
-
-      // Check for success/ready indication (check icon or success color)
-      const statusCard = container.querySelector('.bg-success\\/10');
-      expect(statusCard).toBeInTheDocument();
-    });
-
-    it('should show warning color when not ready', () => {
-      const { container } = render(
-        <OverviewTab
-          installed={true}
-          status={{ ...mockStatus, ready: false }}
-          config={mockConfig}
-          isLoading={false}
-        />
-      );
-
-      // Check for warning/not ready indication
-      const statusCard = container.querySelector('.bg-warning\\/10');
-      expect(statusCard).toBeInTheDocument();
-    });
-  });
-
-  describe('edge cases', () => {
-    it('should handle missing status gracefully', () => {
-      render(
-        <OverviewTab
-          installed={true}
-          status={undefined}
-          config={mockConfig}
-          isLoading={false}
-        />
-      );
-
-      // Should not crash and render available data
-      expect(screen.getByText(/Version/i)).toBeInTheDocument();
-    });
-
-    it('should handle missing config gracefully', () => {
-      render(
-        <OverviewTab
-          installed={true}
-          status={mockStatus}
-          config={undefined}
-          isLoading={false}
-        />
-      );
-
-      // Should not crash and render available data
-      expect(screen.getByText(/Installation Status/i)).toBeInTheDocument();
-    });
-
-    it('should handle empty index path', () => {
-      const emptyConfig: CodexLensConfig = {
-        index_dir: '',
-        index_count: 0,
-      };
-
-      render(
-        <OverviewTab
-          installed={true}
-          status={mockStatus}
-          config={emptyConfig}
-          isLoading={false}
-        />
-      );
-
-      expect(screen.getByText(/Index Path/i)).toBeInTheDocument();
-    });
-
-    it('should handle unknown version', () => {
-      const unknownVersionStatus: CodexLensVenvStatus = {
-        ...mockStatus,
-        version: '',
-      };
-
-      render(
-        <OverviewTab
-          installed={true}
-          status={unknownVersionStatus}
-          config={mockConfig}
-          isLoading={false}
-        />
-      );
-
-      expect(screen.getByText(/Version/i)).toBeInTheDocument();
-    });
-  });
-});
diff --git a/ccw/frontend/src/components/codexlens/OverviewTab.tsx b/ccw/frontend/src/components/codexlens/OverviewTab.tsx
deleted file mode 100644
index 65faa539..00000000
--- a/ccw/frontend/src/components/codexlens/OverviewTab.tsx
+++ /dev/null
@@ -1,184 +0,0 @@
-// ========================================
-// CodexLens Overview Tab
-// ========================================
-// Overview status display and quick actions for CodexLens
-
-import { useIntl } from 'react-intl';
-import {
-  Database,
-  FileText,
-  CheckCircle2,
-  XCircle,
-  Zap,
-} from 'lucide-react';
-import { Card, CardHeader, CardTitle, CardContent } from '@/components/ui/Card';
-import { cn } from '@/lib/utils';
-import type { CodexLensVenvStatus, CodexLensConfig } from '@/lib/api';
-import { IndexOperations } from './IndexOperations';
-import { FileWatcherCard } from './FileWatcherCard';
-
-interface OverviewTabProps {
-  installed: boolean;
-  status?: CodexLensVenvStatus;
-  config?: CodexLensConfig;
-  isLoading: boolean;
-  onRefresh?: () => void;
-}
-
-export function OverviewTab({ installed, status, config, isLoading, onRefresh }: OverviewTabProps) {
-  const { formatMessage } = useIntl();
-
-  if (isLoading) {
-    return (
-      <div className="space-y-4">
-        <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-4">
-          {[1, 2, 3, 4].map((i) => (
-            <Card key={i} className="p-4">
-              <div className="animate-pulse">
-                <div className="h-4 bg-muted rounded w-20 mb-2" />
-                <div className="h-8 bg-muted rounded w-16" />
-              </div>
-            </Card>
-          ))}
-        </div>
-      </div>
-    );
-  }
-
-  if (!installed) {
-    return (
-      <Card className="p-8 text-center">
-        <Database className="w-12 h-12 mx-auto text-muted-foreground/50 mb-4" />
-        <h3 className="text-lg font-medium text-foreground mb-2">
-          {formatMessage({ id: 'codexlens.overview.notInstalled.title' })}
-        </h3>
-        <p className="text-muted-foreground">
-          {formatMessage({ id: 'codexlens.overview.notInstalled.message' })}
-        </p>
-      </Card>
-    );
-  }
-
-  const isReady = status?.ready ?? false;
-  const version = status?.version ?? 'Unknown';
-  const indexDir = config?.index_dir ?? '~/.codexlens/indexes';
-  const indexCount = config?.index_count ?? 0;
-
-  return (
-    <div className="space-y-6">
-      {/* Status Cards */}
-      <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-4">
-        {/* Installation Status */}
-        <Card className="p-4">
-          <div className="flex items-center gap-3">
-            <div className={cn(
-              'p-2 rounded-lg',
-              isReady ? 'bg-success/10' : 'bg-warning/10'
-            )}>
-              {isReady ? (
-                <CheckCircle2 className="w-5 h-5 text-success" />
-              ) : (
-                <XCircle className="w-5 h-5 text-warning" />
-              )}
-            </div>
-            <div>
-              <p className="text-sm text-muted-foreground">
-                {formatMessage({ id: 'codexlens.overview.status.installation' })}
-              </p>
-              <p className="text-lg font-semibold text-foreground">
-                {isReady
-                  ? formatMessage({ id: 'codexlens.overview.status.ready' })
-                  : formatMessage({ id: 'codexlens.overview.status.notReady' })
-                }
-              </p>
-            </div>
-          </div>
-        </Card>
-
-        {/* Version */}
-        <Card className="p-4">
-          <div className="flex items-center gap-3">
-            <div className="p-2 rounded-lg bg-primary/10">
-              <Database className="w-5 h-5 text-primary" />
-            </div>
-            <div>
-              <p className="text-sm text-muted-foreground">
-                {formatMessage({ id: 'codexlens.overview.status.version' })}
-              </p>
-              <p className="text-lg font-semibold text-foreground">{version}</p>
-            </div>
-          </div>
-        </Card>
-
-        {/* Index Path */}
-        <Card className="p-4">
-          <div className="flex items-center gap-3">
-            <div className="p-2 rounded-lg bg-info/10">
-              <FileText className="w-5 h-5 text-info" />
-            </div>
-            <div className="flex-1 min-w-0">
-              <p className="text-sm text-muted-foreground">
-                {formatMessage({ id: 'codexlens.overview.status.indexPath' })}
-              </p>
-              <p className="text-sm font-semibold text-foreground truncate" title={indexDir}>
-                {indexDir}
-              </p>
-            </div>
-          </div>
-        </Card>
-
-        {/* Index Count */}
-        <Card className="p-4">
-          <div className="flex items-center gap-3">
-            <div className="p-2 rounded-lg bg-accent/10">
-              <Zap className="w-5 h-5 text-accent" />
-            </div>
-            <div>
-              <p className="text-sm text-muted-foreground">
-                {formatMessage({ id: 'codexlens.overview.status.indexCount' })}
-              </p>
-              <p className="text-lg font-semibold text-foreground">{indexCount}</p>
-            </div>
-          </div>
-        </Card>
-      </div>
-
-      {/* Service Management */}
-      <div className="grid grid-cols-1 gap-4">
-        <FileWatcherCard disabled={!isReady} />
-      </div>
-
-      {/* Index Operations */}
-      <IndexOperations disabled={!isReady} onRefresh={onRefresh} />
-
-      {/* Venv Details */}
-      {status && (
-        <Card>
-          <CardHeader>
-            <CardTitle className="text-base">
-              {formatMessage({ id: 'codexlens.overview.venv.title' })}
-            </CardTitle>
-          </CardHeader>
-          <CardContent>
-            <div className="space-y-2 text-sm">
-              <div className="flex justify-between">
-                <span className="text-muted-foreground">
-                  {formatMessage({ id: 'codexlens.overview.venv.pythonVersion' })}
-                </span>
-                <span className="text-foreground font-mono">{status.pythonVersion || 'Unknown'}</span>
-              </div>
-              <div className="flex justify-between">
-                <span className="text-muted-foreground">
-                  {formatMessage({ id: 'codexlens.overview.venv.venvPath' })}
-                </span>
-                <span className="text-foreground font-mono truncate ml-4" title={status.venvPath}>
-                  {status.venvPath || 'Unknown'}
-                </span>
-              </div>
-            </div>
-          </CardContent>
-        </Card>
-      )}
-    </div>
-  );
-}
diff --git a/ccw/frontend/src/components/codexlens/SchemaFormRenderer.tsx b/ccw/frontend/src/components/codexlens/SchemaFormRenderer.tsx
deleted file mode 100644
index 3fbb506b..00000000
--- a/ccw/frontend/src/components/codexlens/SchemaFormRenderer.tsx
+++ /dev/null
@@ -1,286 +0,0 @@
-// ========================================
-// SchemaFormRenderer Component
-// ========================================
-// Renders structured form groups from EnvVarGroupsSchema definition
-// Supports select, number, checkbox, text, and model-select field types
-
-import { useMemo } from 'react';
-import { useIntl } from 'react-intl';
-import {
-  Box,
-  ArrowUpDown,
-  Cpu,
-  GitBranch,
-  type LucideIcon,
-} from 'lucide-react';
-import { Label } from '@/components/ui/Label';
-import { Input } from '@/components/ui/Input';
-import { Checkbox } from '@/components/ui/Checkbox';
-import {
-  Select,
-  SelectContent,
-  SelectItem,
-  SelectTrigger,
-  SelectValue,
-} from '@/components/ui/Select';
-import {
-  Collapsible,
-  CollapsibleContent,
-  CollapsibleTrigger,
-} from '@/components/ui/Collapsible';
-import { cn } from '@/lib/utils';
-import { evaluateShowWhen } from './envVarSchema';
-import { ModelSelectField } from './ModelSelectField';
-import type { EnvVarGroupsSchema, EnvVarFieldSchema } from '@/types/codexlens';
-import type { CodexLensModel } from '@/lib/api';
-
-// Icon mapping for group icons
-const iconMap: Record<string, LucideIcon> = {
-  box: Box,
-  'arrow-up-down': ArrowUpDown,
-  cpu: Cpu,
-  'git-branch': GitBranch,
-};
-
-interface SchemaFormRendererProps {
-  /** The schema defining all groups and fields */
-  groups: EnvVarGroupsSchema;
-  /** Current form values keyed by env var name */
-  values: Record<string, string>;
-  /** Called when a field value changes */
-  onChange: (key: string, value: string) => void;
-  /** Whether the form is disabled (loading state) */
-  disabled?: boolean;
-  /** Local embedding models (installed) for model-select */
-  localEmbeddingModels?: CodexLensModel[];
-  /** Local reranker models (installed) for model-select */
-  localRerankerModels?: CodexLensModel[];
-}
-
-export function SchemaFormRenderer({
-  groups,
-  values,
-  onChange,
-  disabled = false,
-  localEmbeddingModels = [],
-  localRerankerModels = [],
-}: SchemaFormRendererProps) {
-  const { formatMessage } = useIntl();
-
-  const groupEntries = useMemo(() => Object.entries(groups), [groups]);
-
-  return (
-    <div className="space-y-3">
-      {groupEntries.map(([groupKey, group]) => {
-        const IconComponent = iconMap[group.icon] || Box;
-
-        return (
-          <Collapsible key={groupKey} defaultOpen>
-            <div className="border border-border rounded-lg">
-              <CollapsibleTrigger className="flex w-full items-center gap-2 p-3 text-xs font-medium text-muted-foreground hover:text-foreground transition-colors">
-                <IconComponent className="w-3.5 h-3.5" />
-                {formatMessage({ id: group.labelKey, defaultMessage: groupKey })}
-              </CollapsibleTrigger>
-              <CollapsibleContent>
-                <div className="px-3 pb-3 space-y-2">
-                  {Object.entries(group.vars).map(([varKey, field]) => {
-                    const visible = evaluateShowWhen(field, values);
-                    if (!visible) return null;
-
-                    return (
-                      <FieldRenderer
-                        key={varKey}
-                        field={field}
-                        value={values[varKey] ?? field.default ?? ''}
-                        onChange={(val) => onChange(varKey, val)}
-                        allValues={values}
-                        disabled={disabled}
-                        localModels={
-                          varKey.includes('EMBEDDING')
-                            ? localEmbeddingModels
-                            : localRerankerModels
-                        }
-                        formatMessage={formatMessage}
-                      />
-                    );
-                  })}
-                </div>
-              </CollapsibleContent>
-            </div>
-          </Collapsible>
-        );
-      })}
-    </div>
-  );
-}
-
-// ========================================
-// Individual Field Renderer
-// ========================================
-
-interface FieldRendererProps {
-  field: EnvVarFieldSchema;
-  value: string;
-  onChange: (value: string) => void;
-  allValues: Record<string, string>;
-  disabled: boolean;
-  localModels: CodexLensModel[];
-  formatMessage: (descriptor: { id: string; defaultMessage?: string }) => string;
-}
-
-function FieldRenderer({
-  field,
-  value,
-  onChange,
-  allValues,
-  disabled,
-  localModels,
-  formatMessage,
-}: FieldRendererProps) {
-  const label = formatMessage({ id: field.labelKey, defaultMessage: field.key });
-
-  switch (field.type) {
-    case 'select':
-      return (
-        <div className="flex items-center gap-2">
-          <Label
-            className="text-xs text-muted-foreground w-28 flex-shrink-0"
-            title={field.key}
-          >
-            {label}
-          </Label>
-          <Select
-            value={value}
-            onValueChange={onChange}
-            disabled={disabled}
-          >
-            <SelectTrigger className={cn('flex-1 h-8 text-xs')}>
-              <SelectValue />
-            </SelectTrigger>
-            <SelectContent>
-              {(field.options || []).map((opt) => (
-                <SelectItem key={opt} value={opt} className="text-xs">
-                  {opt}
-                </SelectItem>
-              ))}
-            </SelectContent>
-          </Select>
-        </div>
-      );
-
-    case 'number':
-      return (
-        <div className="flex items-center gap-2">
-          <Label
-            className="text-xs text-muted-foreground w-28 flex-shrink-0"
-            title={field.key}
-          >
-            {label}
-          </Label>
-          <Input
-            type="number"
-            className="flex-1 h-8 text-xs"
-            value={value}
-            onChange={(e) => onChange(e.target.value)}
-            placeholder={field.placeholder}
-            min={field.min}
-            max={field.max}
-            step={field.step ?? 1}
-            disabled={disabled}
-          />
-        </div>
-      );
-
-    case 'checkbox':
-      return (
-        <div className="flex items-center gap-2">
-          <Label
-            className="text-xs text-muted-foreground w-28 flex-shrink-0"
-            title={field.key}
-          >
-            {label}
-          </Label>
-          <div className="flex-1 flex items-center h-8">
-            <Checkbox
-              checked={value === 'true'}
-              onCheckedChange={(checked) => onChange(checked ? 'true' : 'false')}
-              disabled={disabled}
-            />
-          </div>
-        </div>
-      );
-
-    case 'model-select': {
-      // Determine backend type from related backend env var
-      const isEmbedding = field.key.includes('EMBED');
-      const backendKey = isEmbedding
-        ? 'CODEXLENS_EMBEDDING_BACKEND'
-        : 'CODEXLENS_RERANKER_BACKEND';
-      const backendValue = allValues[backendKey];
-      const backendType = backendValue === 'api' ? 'api' : 'local';
-
-      return (
-        <div className="flex items-center gap-2">
-          <Label
-            className="text-xs text-muted-foreground w-28 flex-shrink-0"
-            title={field.key}
-          >
-            {label}
-          </Label>
-          <ModelSelectField
-            field={field}
-            value={value}
-            onChange={onChange}
-            localModels={localModels}
-            backendType={backendType}
-            disabled={disabled}
-          />
-        </div>
-      );
-    }
-
-    case 'password':
-      return (
-        <div className="flex items-center gap-2">
-          <Label
-            className="text-xs text-muted-foreground w-28 flex-shrink-0"
-            title={field.key}
-          >
-            {label}
-          </Label>
-          <Input
-            type="password"
-            className="flex-1 h-8 text-xs"
-            value={value}
-            onChange={(e) => onChange(e.target.value)}
-            placeholder={field.placeholder}
-            disabled={disabled}
-            autoComplete="off"
-          />
-        </div>
-      );
-
-    case 'text':
-    default:
-      return (
-        <div className="flex items-center gap-2">
-          <Label
-            className="text-xs text-muted-foreground w-28 flex-shrink-0"
-            title={field.key}
-          >
-            {label}
-          </Label>
-          <Input
-            type="text"
-            className="flex-1 h-8 text-xs"
-            value={value}
-            onChange={(e) => onChange(e.target.value)}
-            placeholder={field.placeholder}
-            disabled={disabled}
-          />
-        </div>
-      );
-  }
-}
-
-export default SchemaFormRenderer;
diff --git a/ccw/frontend/src/components/codexlens/SearchTab.tsx b/ccw/frontend/src/components/codexlens/SearchTab.tsx
deleted file mode 100644
index 513878ff..00000000
--- a/ccw/frontend/src/components/codexlens/SearchTab.tsx
+++ /dev/null
@@ -1,445 +0,0 @@
-// ========================================
-// CodexLens Search Tab
-// ========================================
-// Semantic code search interface with multiple search types
-// Includes LSP availability check and hybrid search mode switching
-
-import { useState } from 'react';
-import { useIntl } from 'react-intl';
-import { Search, FileCode, Code, Sparkles, CheckCircle, AlertTriangle } from 'lucide-react';
-import { Button } from '@/components/ui/Button';
-import { Input } from '@/components/ui/Input';
-import { Label } from '@/components/ui/Label';
-import {
-  Select,
-  SelectContent,
-  SelectItem,
-  SelectTrigger,
-  SelectValue,
-} from '@/components/ui/Select';
-import {
-  useCodexLensSearch,
-  useCodexLensFilesSearch,
-  useCodexLensSymbolSearch,
-  useCodexLensLspStatus,
-  useCodexLensSemanticSearch,
-} from '@/hooks/useCodexLens';
-import type {
-  CodexLensSearchParams,
-  CodexLensSemanticSearchMode,
-  CodexLensFusionStrategy,
-  CodexLensStagedStage2Mode,
-} from '@/lib/api';
-import { cn } from '@/lib/utils';
-
-type SearchType = 'search' | 'search_files' | 'symbol' | 'semantic';
-type SearchMode = 'dense_rerank' | 'fts' | 'fuzzy';
-
-interface SearchTabProps {
-  enabled: boolean;
-}
-
-export function SearchTab({ enabled }: SearchTabProps) {
-  const { formatMessage } = useIntl();
-  const [searchType, setSearchType] = useState<SearchType>('search');
-  const [searchMode, setSearchMode] = useState<SearchMode>('dense_rerank');
-  const [semanticMode, setSemanticMode] = useState<CodexLensSemanticSearchMode>('fusion');
-  const [fusionStrategy, setFusionStrategy] = useState<CodexLensFusionStrategy>('rrf');
-  const [stagedStage2Mode, setStagedStage2Mode] = useState<CodexLensStagedStage2Mode>('precomputed');
-  const [query, setQuery] = useState('');
-  const [hasSearched, setHasSearched] = useState(false);
-
-  // LSP status check
-  const lspStatus = useCodexLensLspStatus({ enabled });
-
-  // Build search params based on search type
-  const searchParams: CodexLensSearchParams = {
-    query,
-    limit: 20,
-    mode: searchType !== 'symbol' && searchType !== 'semantic' ? searchMode : undefined,
-    max_content_length: 200,
-    extra_files_count: 10,
-  };
-
-  // Search hooks - only enable when hasSearched is true and query is not empty
-  const contentSearch = useCodexLensSearch(
-    searchParams,
-    { enabled: enabled && hasSearched && searchType === 'search' && query.trim().length > 0 }
-  );
-
-  const fileSearch = useCodexLensFilesSearch(
-    searchParams,
-    { enabled: enabled && hasSearched && searchType === 'search_files' && query.trim().length > 0 }
-  );
-
-  const symbolSearch = useCodexLensSymbolSearch(
-    { query, limit: 20 },
-    { enabled: enabled && hasSearched && searchType === 'symbol' && query.trim().length > 0 }
-  );
-
-  const semanticSearch = useCodexLensSemanticSearch(
-    {
-      query,
-      mode: semanticMode,
-      fusion_strategy: semanticMode === 'fusion' ? fusionStrategy : undefined,
-      staged_stage2_mode: semanticMode === 'fusion' && fusionStrategy === 'staged' ? stagedStage2Mode : undefined,
-      limit: 20,
-      include_match_reason: true,
-    },
-    { enabled: enabled && hasSearched && searchType === 'semantic' && query.trim().length > 0 }
-  );
-
-  // Get loading state based on search type
-  const isLoading = searchType === 'search'
-    ? contentSearch.isLoading
-    : searchType === 'search_files'
-      ? fileSearch.isLoading
-      : searchType === 'symbol'
-        ? symbolSearch.isLoading
-        : semanticSearch.isLoading;
-
-  const handleSearch = () => {
-    if (query.trim()) {
-      setHasSearched(true);
-    }
-  };
-
-  const handleKeyPress = (e: React.KeyboardEvent) => {
-    if (e.key === 'Enter') {
-      handleSearch();
-    }
-  };
-
-  const handleSearchTypeChange = (value: SearchType) => {
-    setSearchType(value);
-    setHasSearched(false);
-  };
-
-  const handleSearchModeChange = (value: SearchMode) => {
-    setSearchMode(value);
-    setHasSearched(false);
-  };
-
-  const handleSemanticModeChange = (value: CodexLensSemanticSearchMode) => {
-    setSemanticMode(value);
-    setHasSearched(false);
-  };
-
-  const handleFusionStrategyChange = (value: CodexLensFusionStrategy) => {
-    setFusionStrategy(value);
-    setHasSearched(false);
-  };
-
-  const handleStagedStage2ModeChange = (value: CodexLensStagedStage2Mode) => {
-    setStagedStage2Mode(value);
-    setHasSearched(false);
-  };
-
-  const handleQueryChange = (value: string) => {
-    setQuery(value);
-    setHasSearched(false);
-  };
-
-  // Get result count for display
-  const getResultCount = (): string => {
-    if (searchType === 'symbol') {
-      return symbolSearch.data?.success
-        ? `${symbolSearch.data.symbols?.length ?? 0} ${formatMessage({ id: 'codexlens.search.resultsCount' })}`
-        : '';
-    }
-    if (searchType === 'search') {
-      return contentSearch.data?.success
-        ? `${contentSearch.data.results?.length ?? 0} ${formatMessage({ id: 'codexlens.search.resultsCount' })}`
-        : '';
-    }
-    if (searchType === 'search_files') {
-      return fileSearch.data?.success
-        ? `${fileSearch.data.files?.length ?? 0} ${formatMessage({ id: 'codexlens.search.resultsCount' })}`
-        : '';
-    }
-    if (searchType === 'semantic') {
-      return semanticSearch.data?.success
-        ? `${semanticSearch.data.count ?? 0} ${formatMessage({ id: 'codexlens.search.resultsCount' })}`
-        : '';
-    }
-    return '';
-  };
-
-  if (!enabled) {
-    return (
-      <div className="flex items-center justify-center p-12">
-        <div className="text-center">
-          <Search className="w-12 h-12 mx-auto text-muted-foreground/50 mb-4" />
-          <h3 className="text-lg font-medium text-foreground mb-2">
-            {formatMessage({ id: 'codexlens.search.notInstalled.title' })}
-          </h3>
-          <p className="text-muted-foreground">
-            {formatMessage({ id: 'codexlens.search.notInstalled.description' })}
-          </p>
-        </div>
-      </div>
-    );
-  }
-
-  return (
-    <div className="space-y-6">
-      {/* LSP Status Indicator */}
-      <div className="flex items-center gap-2 text-sm">
-        <span className="text-muted-foreground">{formatMessage({ id: 'codexlens.search.lspStatus' })}:</span>
-        {lspStatus.isLoading ? (
-          <span className="text-muted-foreground">...</span>
-        ) : lspStatus.available ? (
-          <span className="flex items-center gap-1 text-green-600 dark:text-green-400">
-            <CheckCircle className="w-3.5 h-3.5" />
-            {formatMessage({ id: 'codexlens.search.lspAvailable' })}
-          </span>
-        ) : !lspStatus.semanticAvailable ? (
-          <span className="flex items-center gap-1 text-yellow-600 dark:text-yellow-400">
-            <AlertTriangle className="w-3.5 h-3.5" />
-            {formatMessage({ id: 'codexlens.search.lspNoSemantic' })}
-          </span>
-        ) : (
-          <span className="flex items-center gap-1 text-yellow-600 dark:text-yellow-400">
-            <AlertTriangle className="w-3.5 h-3.5" />
-            {formatMessage({ id: 'codexlens.search.lspNoVector' })}
-          </span>
-        )}
-      </div>
-
-      {/* Search Options */}
-      <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
-        {/* Search Type */}
-        <div className="space-y-2">
-          <Label>{formatMessage({ id: 'codexlens.search.type' })}</Label>
-          <Select value={searchType} onValueChange={handleSearchTypeChange}>
-            <SelectTrigger>
-              <SelectValue />
-            </SelectTrigger>
-            <SelectContent>
-              <SelectItem value="search">
-                <div className="flex items-center gap-2">
-                  <Search className="w-4 h-4" />
-                  {formatMessage({ id: 'codexlens.search.content' })}
-                </div>
-              </SelectItem>
-              <SelectItem value="search_files">
-                <div className="flex items-center gap-2">
-                  <FileCode className="w-4 h-4" />
-                  {formatMessage({ id: 'codexlens.search.files' })}
-                </div>
-              </SelectItem>
-              <SelectItem value="symbol">
-                <div className="flex items-center gap-2">
-                  <Code className="w-4 h-4" />
-                  {formatMessage({ id: 'codexlens.search.symbol' })}
-                </div>
-              </SelectItem>
-              <SelectItem value="semantic" disabled={!lspStatus.available}>
-                <div className="flex items-center gap-2">
-                  <Sparkles className="w-4 h-4" />
-                  {formatMessage({ id: 'codexlens.search.semantic' })}
-                </div>
-              </SelectItem>
-            </SelectContent>
-          </Select>
-        </div>
-
-        {/* Search Mode - for CLI search types (content / file) */}
-        {(searchType === 'search' || searchType === 'search_files') && (
-          <div className="space-y-2">
-            <Label>{formatMessage({ id: 'codexlens.search.mode' })}</Label>
-            <Select value={searchMode} onValueChange={handleSearchModeChange}>
-              <SelectTrigger>
-                <SelectValue />
-              </SelectTrigger>
-              <SelectContent>
-                <SelectItem value="dense_rerank">
-                  {formatMessage({ id: 'codexlens.search.mode.semantic' })}
-                </SelectItem>
-                <SelectItem value="fts">
-                  {formatMessage({ id: 'codexlens.search.mode.exact' })}
-                </SelectItem>
-                <SelectItem value="fuzzy">
-                  {formatMessage({ id: 'codexlens.search.mode.fuzzy' })}
-                </SelectItem>
-              </SelectContent>
-            </Select>
-          </div>
-        )}
-
-        {/* Semantic Search Mode - for semantic search type */}
-        {searchType === 'semantic' && (
-          <div className="space-y-2">
-            <Label>{formatMessage({ id: 'codexlens.search.semanticMode' })}</Label>
-            <Select value={semanticMode} onValueChange={handleSemanticModeChange}>
-              <SelectTrigger>
-                <SelectValue />
-              </SelectTrigger>
-              <SelectContent>
-                <SelectItem value="fusion">
-                  {formatMessage({ id: 'codexlens.search.semanticMode.fusion' })}
-                </SelectItem>
-                <SelectItem value="vector">
-                  {formatMessage({ id: 'codexlens.search.semanticMode.vector' })}
-                </SelectItem>
-                <SelectItem value="structural">
-                  {formatMessage({ id: 'codexlens.search.semanticMode.structural' })}
-                </SelectItem>
-              </SelectContent>
-            </Select>
-          </div>
-        )}
-      </div>
-
-      {/* Fusion Strategy - only when semantic + fusion mode */}
-      {searchType === 'semantic' && semanticMode === 'fusion' && (
-        <div className="space-y-2">
-          <Label>{formatMessage({ id: 'codexlens.search.fusionStrategy' })}</Label>
-          <Select value={fusionStrategy} onValueChange={handleFusionStrategyChange}>
-            <SelectTrigger>
-              <SelectValue />
-            </SelectTrigger>
-            <SelectContent>
-              <SelectItem value="rrf">
-                {formatMessage({ id: 'codexlens.search.fusionStrategy.rrf' })}
-              </SelectItem>
-              <SelectItem value="dense_rerank">
-                {formatMessage({ id: 'codexlens.search.fusionStrategy.dense_rerank' })}
-              </SelectItem>
-              <SelectItem value="binary">
-                {formatMessage({ id: 'codexlens.search.fusionStrategy.binary' })}
-              </SelectItem>
-              <SelectItem value="hybrid">
-                {formatMessage({ id: 'codexlens.search.fusionStrategy.hybrid' })}
-              </SelectItem>
-              <SelectItem value="staged">
-                {formatMessage({ id: 'codexlens.search.fusionStrategy.staged' })}
-              </SelectItem>
-            </SelectContent>
-          </Select>
-        </div>
-      )}
-
-      {/* Staged Stage-2 Mode - only when semantic + fusion + staged */}
-      {searchType === 'semantic' && semanticMode === 'fusion' && fusionStrategy === 'staged' && (
-        <div className="space-y-2">
-          <Label>{formatMessage({ id: 'codexlens.search.stagedStage2Mode' })}</Label>
-          <Select value={stagedStage2Mode} onValueChange={handleStagedStage2ModeChange}>
-            <SelectTrigger>
-              <SelectValue />
-            </SelectTrigger>
-            <SelectContent>
-              <SelectItem value="precomputed">
-                {formatMessage({ id: 'codexlens.search.stagedStage2Mode.precomputed' })}
-              </SelectItem>
-              <SelectItem value="realtime">
-                {formatMessage({ id: 'codexlens.search.stagedStage2Mode.realtime' })}
-              </SelectItem>
-              <SelectItem value="static_global_graph">
-                {formatMessage({ id: 'codexlens.search.stagedStage2Mode.static_global_graph' })}
-              </SelectItem>
-            </SelectContent>
-          </Select>
-        </div>
-      )}
-
-      {/* Query Input */}
-      <div className="space-y-2">
-        <Label htmlFor="search-query">{formatMessage({ id: 'codexlens.search.query' })}</Label>
-        <Input
-          id="search-query"
-          placeholder={formatMessage({ id: 'codexlens.search.queryPlaceholder' })}
-          value={query}
-          onChange={(e) => handleQueryChange(e.target.value)}
-          onKeyPress={handleKeyPress}
-          disabled={isLoading}
-        />
-      </div>
-
-      {/* Search Button */}
-      <Button
-        onClick={handleSearch}
-        disabled={!query.trim() || isLoading}
-        className="w-full"
-      >
-        <Search className={cn('w-4 h-4 mr-2', isLoading && 'animate-spin')} />
-        {isLoading
-          ? formatMessage({ id: 'codexlens.search.searching' })
-          : formatMessage({ id: 'codexlens.search.button' })
-        }
-      </Button>
-
-      {/* Results */}
-      {hasSearched && !isLoading && (
-        <div className="space-y-4">
-          <div className="flex items-center justify-between">
-            <h3 className="text-sm font-medium">
-              {formatMessage({ id: 'codexlens.search.results' })}
-            </h3>
-            <span className="text-xs text-muted-foreground">
-              {getResultCount()}
-            </span>
-          </div>
-
-          {searchType === 'symbol' && symbolSearch.data && (
-            symbolSearch.data.success ? (
-              <div className="rounded-lg border bg-muted/50 p-4">
-                <pre className="text-xs overflow-auto max-h-96">
-                  {JSON.stringify(symbolSearch.data.symbols, null, 2)}
-                </pre>
-              </div>
-            ) : (
-              <div className="text-sm text-destructive">
-                {symbolSearch.data.error || formatMessage({ id: 'common.error' })}
-              </div>
-            )
-          )}
-
-          {searchType === 'search' && contentSearch.data && (
-            contentSearch.data.success ? (
-              <div className="rounded-lg border bg-muted/50 p-4">
-                <pre className="text-xs overflow-auto max-h-96">
-                  {JSON.stringify(contentSearch.data.results, null, 2)}
-                </pre>
-              </div>
-            ) : (
-              <div className="text-sm text-destructive">
-                {contentSearch.data.error || formatMessage({ id: 'common.error' })}
-              </div>
-            )
-          )}
-
-          {searchType === 'search_files' && fileSearch.data && (
-            fileSearch.data.success ? (
-              <div className="rounded-lg border bg-muted/50 p-4">
-                <pre className="text-xs overflow-auto max-h-96">
-                  {JSON.stringify(fileSearch.data.files, null, 2)}
-                </pre>
-              </div>
-            ) : (
-              <div className="text-sm text-destructive">
-                {fileSearch.data.error || formatMessage({ id: 'common.error' })}
-              </div>
-            )
-          )}
-
-          {searchType === 'semantic' && semanticSearch.data && (
-            semanticSearch.data.success ? (
-              <div className="rounded-lg border bg-muted/50 p-4">
-                <pre className="text-xs overflow-auto max-h-96">
-                  {JSON.stringify(semanticSearch.data.results, null, 2)}
-                </pre>
-              </div>
-            ) : (
-              <div className="text-sm text-destructive">
-                {semanticSearch.data.error || formatMessage({ id: 'common.error' })}
-              </div>
-            )
-          )}
-        </div>
-      )}
-    </div>
-  );
-}
-
-export default SearchTab;
diff --git a/ccw/frontend/src/components/codexlens/SemanticInstallDialog.tsx b/ccw/frontend/src/components/codexlens/SemanticInstallDialog.tsx
deleted file mode 100644
index 89d2ecfb..00000000
--- a/ccw/frontend/src/components/codexlens/SemanticInstallDialog.tsx
+++ /dev/null
@@ -1,205 +0,0 @@
-// ========================================
-// CodexLens Semantic Install Dialog
-// ========================================
-// Dialog for installing semantic search dependencies with GPU mode selection
-
-import { useState } from 'react';
-import { useIntl } from 'react-intl';
-import {
-  Cpu,
-  Zap,
-  Monitor,
-  CheckCircle2,
-  AlertCircle,
-} from 'lucide-react';
-import {
-  Dialog,
-  DialogContent,
-  DialogDescription,
-  DialogFooter,
-  DialogHeader,
-  DialogTitle,
-} from '@/components/ui/Dialog';
-import { Button } from '@/components/ui/Button';
-import { RadioGroup, RadioGroupItem } from '@/components/ui/RadioGroup';
-import { Label } from '@/components/ui/Label';
-import { Card, CardContent } from '@/components/ui/Card';
-import { useNotifications } from '@/hooks/useNotifications';
-import { useCodexLensMutations } from '@/hooks';
-import { cn } from '@/lib/utils';
-
-type GpuMode = 'cpu' | 'cuda' | 'directml';
-
-interface GpuModeOption {
-  value: GpuMode;
-  label: string;
-  description: string;
-  icon: React.ReactNode;
-  recommended?: boolean;
-}
-
-interface SemanticInstallDialogProps {
-  open: boolean;
-  onOpenChange: (open: boolean) => void;
-  onSuccess?: () => void;
-}
-
-export function SemanticInstallDialog({ open, onOpenChange, onSuccess }: SemanticInstallDialogProps) {
-  const { formatMessage } = useIntl();
-  const { success, error: showError } = useNotifications();
-  const { installSemantic, isInstallingSemantic } = useCodexLensMutations();
-
-  const [selectedMode, setSelectedMode] = useState<GpuMode>('cpu');
-
-  const gpuModes: GpuModeOption[] = [
-    {
-      value: 'cpu',
-      label: formatMessage({ id: 'codexlens.semantic.gpu.cpu' }),
-      description: formatMessage({ id: 'codexlens.semantic.gpu.cpuDesc' }),
-      icon: <Cpu className="w-5 h-5" />,
-    },
-    {
-      value: 'directml',
-      label: formatMessage({ id: 'codexlens.semantic.gpu.directml' }),
-      description: formatMessage({ id: 'codexlens.semantic.gpu.directmlDesc' }),
-      icon: <Monitor className="w-5 h-5" />,
-      recommended: true,
-    },
-    {
-      value: 'cuda',
-      label: formatMessage({ id: 'codexlens.semantic.gpu.cuda' }),
-      description: formatMessage({ id: 'codexlens.semantic.gpu.cudaDesc' }),
-      icon: <Zap className="w-5 h-5" />,
-    },
-  ];
-
-  const handleInstall = async () => {
-    try {
-      const result = await installSemantic(selectedMode);
-      if (result.success) {
-        success(
-          formatMessage({ id: 'codexlens.semantic.installSuccess' }),
-          result.message || formatMessage({ id: 'codexlens.semantic.installSuccessDesc' }, { mode: selectedMode })
-        );
-        onSuccess?.();
-        onOpenChange(false);
-      } else {
-        throw new Error(result.message || 'Installation failed');
-      }
-    } catch (err) {
-      showError(
-        formatMessage({ id: 'codexlens.semantic.installFailed' }),
-        err instanceof Error ? err.message : formatMessage({ id: 'codexlens.semantic.unknownError' })
-      );
-    }
-  };
-
-  return (
-    <Dialog open={open} onOpenChange={onOpenChange}>
-      <DialogContent className="max-w-2xl">
-        <DialogHeader>
-          <DialogTitle className="flex items-center gap-2">
-            <Zap className="w-5 h-5 text-primary" />
-            {formatMessage({ id: 'codexlens.semantic.installTitle' })}
-          </DialogTitle>
-          <DialogDescription>
-            {formatMessage({ id: 'codexlens.semantic.installDescription' })}
-          </DialogDescription>
-        </DialogHeader>
-
-        <div className="space-y-4 py-4">
-          {/* Info Card */}
-          <Card className="bg-muted/50 border-muted">
-            <CardContent className="p-4 flex items-start gap-3">
-              <AlertCircle className="w-5 h-5 text-info mt-0.5 flex-shrink-0" />
-              <div className="text-sm text-muted-foreground">
-                {formatMessage({ id: 'codexlens.semantic.installInfo' })}
-              </div>
-            </CardContent>
-          </Card>
-
-          {/* GPU Mode Selection */}
-          <RadioGroup value={selectedMode} onValueChange={(v) => setSelectedMode(v as GpuMode)}>
-            <div className="grid grid-cols-1 gap-3">
-              {gpuModes.map((mode) => (
-                <Card
-                  key={mode.value}
-                  className={cn(
-                    "cursor-pointer transition-colors hover:bg-accent/50",
-                    selectedMode === mode.value && "border-primary bg-accent"
-                  )}
-                >
-                  <CardContent className="p-4">
-                    <div className="flex items-start gap-4">
-                      <RadioGroupItem
-                        value={mode.value}
-                        id={`gpu-mode-${mode.value}`}
-                        className="mt-1"
-                      />
-                      <div className="flex items-start gap-3 flex-1">
-                        <div className={cn(
-                          "p-2 rounded-lg",
-                          selectedMode === mode.value
-                            ? "bg-primary/20 text-primary"
-                            : "bg-muted text-muted-foreground"
-                        )}>
-                          {mode.icon}
-                        </div>
-                        <div className="flex-1">
-                          <div className="flex items-center gap-2">
-                            <Label
-                              htmlFor={`gpu-mode-${mode.value}`}
-                              className="font-medium cursor-pointer"
-                            >
-                              {mode.label}
-                            </Label>
-                            {mode.recommended && (
-                              <span className="text-xs px-2 py-0.5 rounded-full bg-primary/10 text-primary">
-                                {formatMessage({ id: 'codexlens.semantic.recommended' })}
-                              </span>
-                            )}
-                          </div>
-                          <p className="text-sm text-muted-foreground mt-1">
-                            {mode.description}
-                          </p>
-                        </div>
-                      </div>
-                    </div>
-                  </CardContent>
-                </Card>
-              ))}
-            </div>
-          </RadioGroup>
-        </div>
-
-        <DialogFooter>
-          <Button
-            variant="outline"
-            onClick={() => onOpenChange(false)}
-            disabled={isInstallingSemantic}
-          >
-            {formatMessage({ id: 'common.actions.cancel' })}
-          </Button>
-          <Button
-            onClick={handleInstall}
-            disabled={isInstallingSemantic}
-          >
-            {isInstallingSemantic ? (
-              <>
-                <Zap className="w-4 h-4 mr-2 animate-pulse" />
-                {formatMessage({ id: 'codexlens.semantic.installing' })}
-              </>
-            ) : (
-              <>
-                <CheckCircle2 className="w-4 h-4 mr-2" />
-                {formatMessage({ id: 'codexlens.semantic.install' })}
-              </>
-            )}
-          </Button>
-        </DialogFooter>
-      </DialogContent>
-    </Dialog>
-  );
-}
-
-export default SemanticInstallDialog;
diff --git a/ccw/frontend/src/components/codexlens/SettingsTab.test.tsx b/ccw/frontend/src/components/codexlens/SettingsTab.test.tsx
deleted file mode 100644
index 6cff429f..00000000
--- a/ccw/frontend/src/components/codexlens/SettingsTab.test.tsx
+++ /dev/null
@@ -1,431 +0,0 @@
-// ========================================
-// Settings Tab Component Tests
-// ========================================
-// Tests for CodexLens Settings Tab component with schema-driven form
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { render, screen, waitFor } from '@/test/i18n';
-import userEvent from '@testing-library/user-event';
-import { SettingsTab } from './SettingsTab';
-import type { CodexLensConfig } from '@/lib/api';
-
-// Mock hooks - use importOriginal to preserve all exports
-vi.mock('@/hooks', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('@/hooks')>();
-  return {
-    ...actual,
-    useCodexLensConfig: vi.fn(),
-    useCodexLensEnv: vi.fn(),
-    useUpdateCodexLensEnv: vi.fn(),
-    useCodexLensModels: vi.fn(),
-    useNotifications: vi.fn(() => ({
-      toasts: [],
-      wsStatus: 'disconnected' as const,
-      wsLastMessage: null,
-      isWsConnected: false,
-      isPanelVisible: false,
-      persistentNotifications: [],
-      addToast: vi.fn(),
-      info: vi.fn(),
-      success: vi.fn(),
-      warning: vi.fn(),
-      error: vi.fn(),
-      removeToast: vi.fn(),
-      clearAllToasts: vi.fn(),
-      setWsStatus: vi.fn(),
-      setWsLastMessage: vi.fn(),
-      togglePanel: vi.fn(),
-      setPanelVisible: vi.fn(),
-      addPersistentNotification: vi.fn(),
-      removePersistentNotification: vi.fn(),
-      clearPersistentNotifications: vi.fn(),
-    })),
-  };
-});
-
-import {
-  useCodexLensConfig,
-  useCodexLensEnv,
-  useUpdateCodexLensEnv,
-  useCodexLensModels,
-  useNotifications,
-} from '@/hooks';
-
-const mockConfig: CodexLensConfig = {
-  index_dir: '~/.codexlens/indexes',
-  index_count: 100,
-};
-
-const mockEnv: Record<string, string> = {
-  CODEXLENS_EMBEDDING_BACKEND: 'local',
-  CODEXLENS_EMBEDDING_MODEL: 'fast',
-  CODEXLENS_AUTO_EMBED_MISSING: 'true',
-  CODEXLENS_USE_GPU: 'true',
-  CODEXLENS_RERANKER_ENABLED: 'true',
-  CODEXLENS_RERANKER_BACKEND: 'onnx',
-  CODEXLENS_API_MAX_WORKERS: '4',
-  CODEXLENS_API_BATCH_SIZE: '8',
-  CODEXLENS_CASCADE_STRATEGY: 'dense_rerank',
-};
-
-function setupDefaultMocks() {
-  vi.mocked(useCodexLensConfig).mockReturnValue({
-    config: mockConfig,
-    indexDir: mockConfig.index_dir,
-    indexCount: 100,
-    isLoading: false,
-    error: null,
-    refetch: vi.fn(),
-  });
-  vi.mocked(useCodexLensEnv).mockReturnValue({
-    data: { success: true, env: mockEnv, settings: {}, path: '~/.codexlens/.env' },
-    env: mockEnv,
-    settings: {},
-    raw: '',
-    isLoading: false,
-    error: null,
-    refetch: vi.fn(),
-  });
-  vi.mocked(useUpdateCodexLensEnv).mockReturnValue({
-    updateEnv: vi.fn().mockResolvedValue({ success: true, message: 'Saved' }),
-    isUpdating: false,
-    error: null,
-  });
-  vi.mocked(useCodexLensModels).mockReturnValue({
-    models: [],
-    embeddingModels: [],
-    rerankerModels: [],
-    isLoading: false,
-    error: null,
-    refetch: vi.fn(),
-  });
-}
-
-describe('SettingsTab', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('when enabled and config loaded', () => {
-    beforeEach(() => {
-      setupDefaultMocks();
-    });
-
-    it('should render current info card', () => {
-      render(<SettingsTab enabled={true} />);
-
-      expect(screen.getByText(/Current Index Count/i)).toBeInTheDocument();
-      expect(screen.getByText('100')).toBeInTheDocument();
-      expect(screen.getByText(/Current Workers/i)).toBeInTheDocument();
-      expect(screen.getByText('4')).toBeInTheDocument();
-      expect(screen.getByText(/Current Batch Size/i)).toBeInTheDocument();
-      expect(screen.getByText('8')).toBeInTheDocument();
-    });
-
-    it('should render configuration form with index directory', () => {
-      render(<SettingsTab enabled={true} />);
-
-      expect(screen.getByText(/Basic Configuration/i)).toBeInTheDocument();
-      expect(screen.getByLabelText(/Index Directory/i)).toBeInTheDocument();
-    });
-
-    it('should render env var group sections', () => {
-      render(<SettingsTab enabled={true} />);
-
-      // Schema groups should be rendered (labels come from i18n, check for group icons/sections)
-      expect(screen.getByText(/Embedding/i)).toBeInTheDocument();
-      expect(screen.getByText(/Reranker/i)).toBeInTheDocument();
-      expect(screen.getByText(/Concurrency/i)).toBeInTheDocument();
-      expect(screen.getByText(/Cascade/i)).toBeInTheDocument();
-      expect(screen.getByText(/Chunking/i)).toBeInTheDocument();
-      expect(screen.getByText(/Auto Build Missing Vectors/i)).toBeInTheDocument();
-    });
-
-    it('should initialize index dir from config', () => {
-      render(<SettingsTab enabled={true} />);
-
-      const indexDirInput = screen.getByLabelText(/Index Directory/i) as HTMLInputElement;
-      expect(indexDirInput.value).toBe('~/.codexlens/indexes');
-    });
-
-    it('should show save button enabled when changes are made', async () => {
-      const user = userEvent.setup();
-      render(<SettingsTab enabled={true} />);
-
-      const indexDirInput = screen.getByLabelText(/Index Directory/i);
-      await user.clear(indexDirInput);
-      await user.type(indexDirInput, '/new/index/path');
-
-      const saveButton = screen.getByText(/Save/i);
-      expect(saveButton).toBeEnabled();
-    });
-
-    it('should disable save and reset buttons when no changes', () => {
-      render(<SettingsTab enabled={true} />);
-
-      const saveButton = screen.getByText(/Save/i);
-      const resetButton = screen.getByText(/Reset/i);
-
-      expect(saveButton).toBeDisabled();
-      expect(resetButton).toBeDisabled();
-    });
-
-    it('should call updateEnv on save', async () => {
-      const updateEnv = vi.fn().mockResolvedValue({ success: true, message: 'Saved' });
-      vi.mocked(useUpdateCodexLensEnv).mockReturnValue({
-        updateEnv,
-        isUpdating: false,
-        error: null,
-      });
-
-      const success = vi.fn();
-      vi.mocked(useNotifications).mockReturnValue({
-        toasts: [],
-        wsStatus: 'disconnected' as const,
-        wsLastMessage: null,
-        isWsConnected: false,
-        isPanelVisible: false,
-        persistentNotifications: [],
-        addToast: vi.fn(),
-        info: vi.fn(),
-        success,
-        warning: vi.fn(),
-        error: vi.fn(),
-        removeToast: vi.fn(),
-        clearAllToasts: vi.fn(),
-        setWsStatus: vi.fn(),
-        setWsLastMessage: vi.fn(),
-        togglePanel: vi.fn(),
-        setPanelVisible: vi.fn(),
-        addPersistentNotification: vi.fn(),
-        removePersistentNotification: vi.fn(),
-        clearPersistentNotifications: vi.fn(),
-      });
-
-      const user = userEvent.setup();
-      render(<SettingsTab enabled={true} />);
-
-      const indexDirInput = screen.getByLabelText(/Index Directory/i);
-      await user.clear(indexDirInput);
-      await user.type(indexDirInput, '/new/index/path');
-
-      const saveButton = screen.getByText(/Save/i);
-      await user.click(saveButton);
-
-      await waitFor(() => {
-        expect(updateEnv).toHaveBeenCalledWith({
-          env: expect.objectContaining({
-            CODEXLENS_EMBEDDING_BACKEND: 'local',
-            CODEXLENS_EMBEDDING_MODEL: 'fast',
-          }),
-        });
-      });
-    });
-
-    it('should reset form on reset button click', async () => {
-      const user = userEvent.setup();
-      render(<SettingsTab enabled={true} />);
-
-      const indexDirInput = screen.getByLabelText(/Index Directory/i) as HTMLInputElement;
-      await user.clear(indexDirInput);
-      await user.type(indexDirInput, '/new/index/path');
-
-      expect(indexDirInput.value).toBe('/new/index/path');
-
-      const resetButton = screen.getByText(/Reset/i);
-      await user.click(resetButton);
-
-      expect(indexDirInput.value).toBe('~/.codexlens/indexes');
-    });
-  });
-
-  describe('form validation', () => {
-    beforeEach(() => {
-      setupDefaultMocks();
-    });
-
-    it('should validate index dir is required', async () => {
-      const user = userEvent.setup();
-      render(<SettingsTab enabled={true} />);
-
-      const indexDirInput = screen.getByLabelText(/Index Directory/i);
-      await user.clear(indexDirInput);
-
-      const saveButton = screen.getByText(/Save/i);
-      await user.click(saveButton);
-
-      expect(screen.getByText(/Index directory is required/i)).toBeInTheDocument();
-    });
-
-    it('should clear error when user fixes invalid input', async () => {
-      const user = userEvent.setup();
-      render(<SettingsTab enabled={true} />);
-
-      const indexDirInput = screen.getByLabelText(/Index Directory/i);
-      await user.clear(indexDirInput);
-
-      const saveButton = screen.getByText(/Save/i);
-      await user.click(saveButton);
-
-      expect(screen.getByText(/Index directory is required/i)).toBeInTheDocument();
-
-      await user.type(indexDirInput, '/valid/path');
-
-      expect(screen.queryByText(/Index directory is required/i)).not.toBeInTheDocument();
-    });
-  });
-
-  describe('when disabled', () => {
-    beforeEach(() => {
-      setupDefaultMocks();
-    });
-
-    it('should not render when enabled is false', () => {
-      render(<SettingsTab enabled={false} />);
-
-      // When not enabled, hooks are disabled so no config/env data
-      expect(screen.queryByText(/Basic Configuration/i)).not.toBeInTheDocument();
-    });
-  });
-
-  describe('loading states', () => {
-    it('should disable inputs when loading config', () => {
-      vi.mocked(useCodexLensConfig).mockReturnValue({
-        config: mockConfig,
-        indexDir: mockConfig.index_dir,
-        indexCount: 100,
-        isLoading: true,
-        error: null,
-        refetch: vi.fn(),
-      });
-      vi.mocked(useCodexLensEnv).mockReturnValue({
-        data: { success: true, env: mockEnv, settings: {}, path: '' },
-        env: mockEnv,
-        settings: {},
-        raw: '',
-        isLoading: false,
-        error: null,
-        refetch: vi.fn(),
-      });
-      vi.mocked(useUpdateCodexLensEnv).mockReturnValue({
-        updateEnv: vi.fn().mockResolvedValue({ success: true }),
-        isUpdating: false,
-        error: null,
-      });
-      vi.mocked(useCodexLensModels).mockReturnValue({
-        models: [],
-        embeddingModels: [],
-        rerankerModels: [],
-        isLoading: false,
-        error: null,
-        refetch: vi.fn(),
-      });
-
-      render(<SettingsTab enabled={true} />);
-
-      const indexDirInput = screen.getByLabelText(/Index Directory/i);
-      expect(indexDirInput).toBeDisabled();
-    });
-
-    it('should show saving state when updating', async () => {
-      setupDefaultMocks();
-      vi.mocked(useUpdateCodexLensEnv).mockReturnValue({
-        updateEnv: vi.fn().mockResolvedValue({ success: true }),
-        isUpdating: true,
-        error: null,
-      });
-
-      const user = userEvent.setup();
-      render(<SettingsTab enabled={true} />);
-
-      const indexDirInput = screen.getByLabelText(/Index Directory/i);
-      await user.clear(indexDirInput);
-      await user.type(indexDirInput, '/new/path');
-
-      const saveButton = screen.getByText(/Saving/i);
-      expect(saveButton).toBeInTheDocument();
-    });
-  });
-
-  describe('i18n - Chinese locale', () => {
-    beforeEach(() => {
-      setupDefaultMocks();
-    });
-
-    it('should display translated labels', () => {
-      render(<SettingsTab enabled={true} />, { locale: 'zh' });
-
-      expect(screen.getByText(/当前索引数量/i)).toBeInTheDocument();
-      expect(screen.getByText(/当前工作线程/i)).toBeInTheDocument();
-      expect(screen.getByText(/当前批次大小/i)).toBeInTheDocument();
-      expect(screen.getByText(/基本配置/i)).toBeInTheDocument();
-      expect(screen.getByText(/索引目录/i)).toBeInTheDocument();
-      expect(screen.getByText(/保存/i)).toBeInTheDocument();
-      expect(screen.getByText(/重置/i)).toBeInTheDocument();
-    });
-
-    it('should display translated validation errors', async () => {
-      const user = userEvent.setup();
-      render(<SettingsTab enabled={true} />, { locale: 'zh' });
-
-      const indexDirInput = screen.getByLabelText(/索引目录/i);
-      await user.clear(indexDirInput);
-
-      const saveButton = screen.getByText(/保存/i);
-      await user.click(saveButton);
-
-      expect(screen.getByText(/索引目录不能为空/i)).toBeInTheDocument();
-    });
-  });
-
-  describe('error handling', () => {
-    it('should show error notification on save failure', async () => {
-      setupDefaultMocks();
-      const error = vi.fn();
-      vi.mocked(useNotifications).mockReturnValue({
-        toasts: [],
-        wsStatus: 'disconnected' as const,
-        wsLastMessage: null,
-        isWsConnected: false,
-        isPanelVisible: false,
-        persistentNotifications: [],
-        addToast: vi.fn(),
-        info: vi.fn(),
-        success: vi.fn(),
-        warning: vi.fn(),
-        error,
-        removeToast: vi.fn(),
-        clearAllToasts: vi.fn(),
-        setWsStatus: vi.fn(),
-        setWsLastMessage: vi.fn(),
-        togglePanel: vi.fn(),
-        setPanelVisible: vi.fn(),
-        addPersistentNotification: vi.fn(),
-        removePersistentNotification: vi.fn(),
-        clearPersistentNotifications: vi.fn(),
-      });
-      vi.mocked(useUpdateCodexLensEnv).mockReturnValue({
-        updateEnv: vi.fn().mockResolvedValue({ success: false, message: 'Save failed' }),
-        isUpdating: false,
-        error: null,
-      });
-
-      const user = userEvent.setup();
-      render(<SettingsTab enabled={true} />);
-
-      const indexDirInput = screen.getByLabelText(/Index Directory/i);
-      await user.clear(indexDirInput);
-      await user.type(indexDirInput, '/new/path');
-
-      const saveButton = screen.getByText(/Save/i);
-      await user.click(saveButton);
-
-      await waitFor(() => {
-        expect(error).toHaveBeenCalledWith(
-          expect.stringContaining('Save failed'),
-          expect.any(String)
-        );
-      });
-    });
-  });
-});
diff --git a/ccw/frontend/src/components/codexlens/SettingsTab.tsx b/ccw/frontend/src/components/codexlens/SettingsTab.tsx
deleted file mode 100644
index f991a739..00000000
--- a/ccw/frontend/src/components/codexlens/SettingsTab.tsx
+++ /dev/null
@@ -1,276 +0,0 @@
-// ========================================
-// CodexLens Settings Tab
-// ========================================
-// Structured form for CodexLens v2 env configuration
-// Renders 4 groups: embedding, reranker, search, indexing
-// Plus a general config section (index_dir)
-
-import { useState, useEffect, useCallback, useMemo } from 'react';
-import { useIntl } from 'react-intl';
-import { Save, RefreshCw } from 'lucide-react';
-import { Card } from '@/components/ui/Card';
-import { Input } from '@/components/ui/Input';
-import { Button } from '@/components/ui/Button';
-import { Label } from '@/components/ui/Label';
-import {
-  useCodexLensConfig,
-  useCodexLensEnv,
-  useUpdateCodexLensEnv,
-  useCodexLensModels,
-} from '@/hooks';
-import { useNotifications } from '@/hooks';
-import { cn } from '@/lib/utils';
-import { SchemaFormRenderer } from './SchemaFormRenderer';
-import { envVarGroupsSchema, getSchemaDefaults } from './envVarSchema';
-
-// ========== Settings Tab ==========
-
-interface SettingsTabProps {
-  enabled?: boolean;
-}
-
-export function SettingsTab({ enabled = true }: SettingsTabProps) {
-  const { formatMessage } = useIntl();
-  const { success, error: showError } = useNotifications();
-
-  // Fetch current config (index_dir, index_count)
-  const {
-    config,
-    indexCount,
-    isLoading: isLoadingConfig,
-    refetch: refetchConfig,
-  } = useCodexLensConfig({ enabled });
-
-  // Fetch env vars and settings
-  const {
-    env: serverEnv,
-    settings: serverSettings,
-    isLoading: isLoadingEnv,
-    refetch: refetchEnv,
-  } = useCodexLensEnv({ enabled });
-
-  // Fetch local models for model-select fields
-  const {
-    embeddingModels: localEmbeddingModels,
-    rerankerModels: localRerankerModels,
-  } = useCodexLensModels({ enabled });
-
-  const { updateEnv, isUpdating } = useUpdateCodexLensEnv();
-
-  // General form state (index_dir)
-  const [indexDir, setIndexDir] = useState('');
-  const [indexDirError, setIndexDirError] = useState('');
-
-  // Schema-driven env var form state
-  const [envValues, setEnvValues] = useState<Record<string, string>>({});
-  const [hasChanges, setHasChanges] = useState(false);
-
-  // Store the initial values for change detection
-  const [initialEnvValues, setInitialEnvValues] = useState<Record<string, string>>({});
-  const [initialIndexDir, setInitialIndexDir] = useState('');
-
-  // Initialize form from server data
-  useEffect(() => {
-    if (config) {
-      setIndexDir(config.index_dir || '');
-      setInitialIndexDir(config.index_dir || '');
-    }
-  }, [config]);
-
-  useEffect(() => {
-    if (serverEnv || serverSettings) {
-      const defaults = getSchemaDefaults();
-      const merged: Record<string, string> = { ...defaults };
-
-      // Settings.json values override defaults
-      if (serverSettings) {
-        for (const [key, val] of Object.entries(serverSettings)) {
-          if (val) merged[key] = val;
-        }
-      }
-
-      // .env values override settings
-      if (serverEnv) {
-        for (const [key, val] of Object.entries(serverEnv)) {
-          if (val) merged[key] = val;
-        }
-      }
-
-      setEnvValues(merged);
-      setInitialEnvValues(merged);
-      setHasChanges(false);
-    }
-  }, [serverEnv, serverSettings]);
-
-  // Check for changes
-  const detectChanges = useCallback(
-    (currentEnv: Record<string, string>, currentIndexDir: string) => {
-      if (currentIndexDir !== initialIndexDir) return true;
-      for (const key of Object.keys(currentEnv)) {
-        if (currentEnv[key] !== initialEnvValues[key]) return true;
-      }
-      return false;
-    },
-    [initialEnvValues, initialIndexDir]
-  );
-
-  const handleEnvChange = useCallback(
-    (key: string, value: string) => {
-      setEnvValues((prev) => {
-        const next = { ...prev, [key]: value };
-        setHasChanges(detectChanges(next, indexDir));
-        return next;
-      });
-    },
-    [detectChanges, indexDir]
-  );
-
-  const handleIndexDirChange = useCallback(
-    (value: string) => {
-      setIndexDir(value);
-      setIndexDirError('');
-      setHasChanges(detectChanges(envValues, value));
-    },
-    [detectChanges, envValues]
-  );
-
-  // Installed local models filtered to installed-only
-  const installedEmbeddingModels = useMemo(
-    () => (localEmbeddingModels || []).filter((m) => m.installed),
-    [localEmbeddingModels]
-  );
-  const installedRerankerModels = useMemo(
-    () => (localRerankerModels || []).filter((m) => m.installed),
-    [localRerankerModels]
-  );
-
-  const handleSave = async () => {
-    // Validate index_dir
-    if (!indexDir.trim()) {
-      setIndexDirError(
-        formatMessage({ id: 'codexlens.settings.validation.indexDirRequired' })
-      );
-      return;
-    }
-
-    try {
-      const result = await updateEnv({ env: envValues });
-
-      if (result.success) {
-        success(
-          formatMessage({ id: 'codexlens.settings.saveSuccess' }),
-          result.message ||
-            formatMessage({ id: 'codexlens.settings.configUpdated' })
-        );
-        refetchEnv();
-        refetchConfig();
-        setHasChanges(false);
-        setInitialEnvValues(envValues);
-        setInitialIndexDir(indexDir);
-      } else {
-        showError(
-          formatMessage({ id: 'codexlens.settings.saveFailed' }),
-          result.message ||
-            formatMessage({ id: 'codexlens.settings.saveError' })
-        );
-      }
-    } catch (err) {
-      showError(
-        formatMessage({ id: 'codexlens.settings.saveFailed' }),
-        err instanceof Error
-          ? err.message
-          : formatMessage({ id: 'codexlens.settings.unknownError' })
-      );
-    }
-  };
-
-  const handleReset = () => {
-    setEnvValues(initialEnvValues);
-    setIndexDir(initialIndexDir);
-    setIndexDirError('');
-    setHasChanges(false);
-  };
-
-  const isLoading = isLoadingConfig || isLoadingEnv;
-
-  return (
-    <div className="space-y-6">
-      {/* Current Info Card */}
-      <Card className="p-4 bg-muted/30">
-        <div className="text-sm">
-          <div>
-            <span className="text-muted-foreground">
-              {formatMessage({ id: 'codexlens.settings.currentCount' })}
-            </span>
-            <p className="text-foreground font-medium">{indexCount}</p>
-          </div>
-        </div>
-      </Card>
-
-      {/* General Configuration */}
-      <Card className="p-6">
-        <h3 className="text-lg font-semibold text-foreground mb-4">
-          {formatMessage({ id: 'codexlens.settings.configTitle' })}
-        </h3>
-
-        {/* Index Directory */}
-        <div className="space-y-2 mb-4">
-          <Label htmlFor="index_dir">
-            {formatMessage({ id: 'codexlens.settings.indexDir.label' })}
-          </Label>
-          <Input
-            id="index_dir"
-            value={indexDir}
-            onChange={(e) => handleIndexDirChange(e.target.value)}
-            placeholder={formatMessage({
-              id: 'codexlens.settings.indexDir.placeholder',
-            })}
-            error={!!indexDirError}
-            disabled={isLoading}
-          />
-          {indexDirError && (
-            <p className="text-sm text-destructive">{indexDirError}</p>
-          )}
-          <p className="text-xs text-muted-foreground">
-            {formatMessage({ id: 'codexlens.settings.indexDir.hint' })}
-          </p>
-        </div>
-
-        {/* Schema-driven Env Var Groups */}
-        <SchemaFormRenderer
-          groups={envVarGroupsSchema}
-          values={envValues}
-          onChange={handleEnvChange}
-          disabled={isLoading}
-          localEmbeddingModels={installedEmbeddingModels}
-          localRerankerModels={installedRerankerModels}
-        />
-
-        {/* Action Buttons */}
-        <div className="flex items-center gap-2 mt-6">
-          <Button
-            onClick={handleSave}
-            disabled={isLoading || isUpdating || !hasChanges}
-          >
-            <Save
-              className={cn('w-4 h-4 mr-2', isUpdating && 'animate-spin')}
-            />
-            {isUpdating
-              ? formatMessage({ id: 'codexlens.settings.saving' })
-              : formatMessage({ id: 'codexlens.settings.save' })}
-          </Button>
-          <Button
-            variant="outline"
-            onClick={handleReset}
-            disabled={isLoading || !hasChanges}
-          >
-            <RefreshCw className="w-4 h-4 mr-2" />
-            {formatMessage({ id: 'codexlens.settings.reset' })}
-          </Button>
-        </div>
-      </Card>
-    </div>
-  );
-}
-
-export default SettingsTab;
diff --git a/ccw/frontend/src/components/codexlens/envVarSchema.ts b/ccw/frontend/src/components/codexlens/envVarSchema.ts
deleted file mode 100644
index 5034b0f4..00000000
--- a/ccw/frontend/src/components/codexlens/envVarSchema.ts
+++ /dev/null
@@ -1,389 +0,0 @@
-// ========================================
-// CodexLens v2 Environment Variable Schema
-// ========================================
-// Defines structured groups for codexlens-search v2 configuration.
-// Env var names match what the Python bridge CLI reads.
-
-import type { EnvVarGroupsSchema } from '@/types/codexlens';
-
-export const envVarGroupsSchema: EnvVarGroupsSchema = {
-  embedding: {
-    id: 'embedding',
-    labelKey: 'codexlens.envGroup.embedding',
-    icon: 'box',
-    vars: {
-      CODEXLENS_EMBEDDING_BACKEND: {
-        key: 'CODEXLENS_EMBEDDING_BACKEND',
-        labelKey: 'codexlens.envField.backend',
-        type: 'select',
-        options: ['local', 'api'],
-        default: 'local',
-        settingsPath: 'embedding.backend',
-      },
-      CODEXLENS_EMBED_API_URL: {
-        key: 'CODEXLENS_EMBED_API_URL',
-        labelKey: 'codexlens.envField.apiUrl',
-        type: 'text',
-        placeholder: 'https://api.siliconflow.cn/v1',
-        default: '',
-        settingsPath: 'embedding.api_url',
-        showWhen: (env) => env['CODEXLENS_EMBEDDING_BACKEND'] === 'api',
-      },
-      CODEXLENS_EMBED_API_KEY: {
-        key: 'CODEXLENS_EMBED_API_KEY',
-        labelKey: 'codexlens.envField.apiKey',
-        type: 'password',
-        placeholder: 'sk-...',
-        default: '',
-        settingsPath: 'embedding.api_key',
-        showWhen: (env) => env['CODEXLENS_EMBEDDING_BACKEND'] === 'api',
-      },
-      CODEXLENS_EMBED_API_MODEL: {
-        key: 'CODEXLENS_EMBED_API_MODEL',
-        labelKey: 'codexlens.envField.model',
-        type: 'model-select',
-        placeholder: 'Select or enter model...',
-        default: '',
-        settingsPath: 'embedding.api_model',
-        showWhen: (env) => env['CODEXLENS_EMBEDDING_BACKEND'] === 'api',
-        localModels: [],
-        apiModels: [
-          {
-            group: 'SiliconFlow',
-            items: ['BAAI/bge-m3', 'BAAI/bge-large-zh-v1.5', 'BAAI/bge-large-en-v1.5'],
-          },
-          {
-            group: 'OpenAI',
-            items: ['text-embedding-3-small', 'text-embedding-3-large', 'text-embedding-ada-002'],
-          },
-          {
-            group: 'Cohere',
-            items: ['embed-english-v3.0', 'embed-multilingual-v3.0', 'embed-english-light-v3.0'],
-          },
-          {
-            group: 'Voyage',
-            items: ['voyage-3', 'voyage-3-lite', 'voyage-code-3'],
-          },
-          {
-            group: 'Jina',
-            items: ['jina-embeddings-v3', 'jina-embeddings-v2-base-en'],
-          },
-        ],
-      },
-      CODEXLENS_EMBED_API_ENDPOINTS: {
-        key: 'CODEXLENS_EMBED_API_ENDPOINTS',
-        labelKey: 'codexlens.envField.multiEndpoints',
-        type: 'text',
-        placeholder: 'url1|key1|model1,url2|key2|model2',
-        default: '',
-        settingsPath: 'embedding.api_endpoints',
-        showWhen: (env) => env['CODEXLENS_EMBEDDING_BACKEND'] === 'api',
-      },
-      CODEXLENS_EMBED_DIM: {
-        key: 'CODEXLENS_EMBED_DIM',
-        labelKey: 'codexlens.envField.embedDim',
-        type: 'number',
-        placeholder: '384',
-        default: '384',
-        settingsPath: 'embedding.dim',
-        min: 64,
-        max: 4096,
-        showWhen: (env) => env['CODEXLENS_EMBEDDING_BACKEND'] === 'api',
-      },
-      CODEXLENS_EMBED_API_CONCURRENCY: {
-        key: 'CODEXLENS_EMBED_API_CONCURRENCY',
-        labelKey: 'codexlens.envField.apiConcurrency',
-        type: 'number',
-        placeholder: '4',
-        default: '4',
-        settingsPath: 'embedding.api_concurrency',
-        min: 1,
-        max: 32,
-        showWhen: (env) => env['CODEXLENS_EMBEDDING_BACKEND'] === 'api',
-      },
-      CODEXLENS_EMBED_API_MAX_TOKENS: {
-        key: 'CODEXLENS_EMBED_API_MAX_TOKENS',
-        labelKey: 'codexlens.envField.maxTokensPerBatch',
-        type: 'number',
-        placeholder: '8192',
-        default: '8192',
-        settingsPath: 'embedding.api_max_tokens_per_batch',
-        min: 512,
-        max: 65536,
-        showWhen: (env) => env['CODEXLENS_EMBEDDING_BACKEND'] === 'api',
-      },
-      CODEXLENS_EMBEDDING_MODEL: {
-        key: 'CODEXLENS_EMBEDDING_MODEL',
-        labelKey: 'codexlens.envField.localModel',
-        type: 'model-select',
-        placeholder: 'Select local model...',
-        default: 'BAAI/bge-small-en-v1.5',
-        settingsPath: 'embedding.model',
-        showWhen: (env) => env['CODEXLENS_EMBEDDING_BACKEND'] !== 'api',
-        localModels: [
-          {
-            group: 'FastEmbed Profiles',
-            items: ['small', 'base', 'large', 'code'],
-          },
-        ],
-        apiModels: [],
-      },
-      CODEXLENS_USE_GPU: {
-        key: 'CODEXLENS_USE_GPU',
-        labelKey: 'codexlens.envField.useGpu',
-        type: 'select',
-        options: ['auto', 'cuda', 'cpu'],
-        default: 'auto',
-        settingsPath: 'embedding.device',
-        showWhen: (env) => env['CODEXLENS_EMBEDDING_BACKEND'] !== 'api',
-      },
-      CODEXLENS_EMBED_BATCH_SIZE: {
-        key: 'CODEXLENS_EMBED_BATCH_SIZE',
-        labelKey: 'codexlens.envField.batchSize',
-        type: 'number',
-        placeholder: '64',
-        default: '64',
-        settingsPath: 'embedding.batch_size',
-        min: 1,
-        max: 512,
-      },
-    },
-  },
-  reranker: {
-    id: 'reranker',
-    labelKey: 'codexlens.envGroup.reranker',
-    icon: 'arrow-up-down',
-    vars: {
-      CODEXLENS_RERANKER_BACKEND: {
-        key: 'CODEXLENS_RERANKER_BACKEND',
-        labelKey: 'codexlens.envField.backend',
-        type: 'select',
-        options: ['local', 'api'],
-        default: 'local',
-        settingsPath: 'reranker.backend',
-      },
-      CODEXLENS_RERANKER_API_URL: {
-        key: 'CODEXLENS_RERANKER_API_URL',
-        labelKey: 'codexlens.envField.apiUrl',
-        type: 'text',
-        placeholder: 'https://api.siliconflow.cn/v1',
-        default: '',
-        settingsPath: 'reranker.api_url',
-        showWhen: (env) => env['CODEXLENS_RERANKER_BACKEND'] === 'api',
-      },
-      CODEXLENS_RERANKER_API_KEY: {
-        key: 'CODEXLENS_RERANKER_API_KEY',
-        labelKey: 'codexlens.envField.apiKey',
-        type: 'password',
-        placeholder: 'sk-...',
-        default: '',
-        settingsPath: 'reranker.api_key',
-        showWhen: (env) => env['CODEXLENS_RERANKER_BACKEND'] === 'api',
-      },
-      CODEXLENS_RERANKER_API_MODEL: {
-        key: 'CODEXLENS_RERANKER_API_MODEL',
-        labelKey: 'codexlens.envField.model',
-        type: 'model-select',
-        placeholder: 'Select or enter model...',
-        default: '',
-        settingsPath: 'reranker.api_model',
-        showWhen: (env) => env['CODEXLENS_RERANKER_BACKEND'] === 'api',
-        localModels: [],
-        apiModels: [
-          {
-            group: 'SiliconFlow',
-            items: ['BAAI/bge-reranker-v2-m3', 'BAAI/bge-reranker-large', 'BAAI/bge-reranker-base'],
-          },
-          {
-            group: 'Cohere',
-            items: ['rerank-english-v3.0', 'rerank-multilingual-v3.0'],
-          },
-          {
-            group: 'Jina',
-            items: ['jina-reranker-v2-base-multilingual'],
-          },
-        ],
-      },
-      CODEXLENS_RERANKER_MODEL: {
-        key: 'CODEXLENS_RERANKER_MODEL',
-        labelKey: 'codexlens.envField.localModel',
-        type: 'model-select',
-        placeholder: 'Select local model...',
-        default: 'Xenova/ms-marco-MiniLM-L-6-v2',
-        settingsPath: 'reranker.model',
-        showWhen: (env) => env['CODEXLENS_RERANKER_BACKEND'] !== 'api',
-        localModels: [
-          {
-            group: 'FastEmbed/ONNX',
-            items: [
-              'Xenova/ms-marco-MiniLM-L-6-v2',
-              'cross-encoder/ms-marco-MiniLM-L-6-v2',
-              'BAAI/bge-reranker-base',
-            ],
-          },
-        ],
-        apiModels: [],
-      },
-      CODEXLENS_RERANKER_TOP_K: {
-        key: 'CODEXLENS_RERANKER_TOP_K',
-        labelKey: 'codexlens.envField.topKResults',
-        type: 'number',
-        placeholder: '20',
-        default: '20',
-        settingsPath: 'reranker.top_k',
-        min: 5,
-        max: 200,
-      },
-      CODEXLENS_RERANKER_BATCH_SIZE: {
-        key: 'CODEXLENS_RERANKER_BATCH_SIZE',
-        labelKey: 'codexlens.envField.batchSize',
-        type: 'number',
-        placeholder: '32',
-        default: '32',
-        settingsPath: 'reranker.batch_size',
-        min: 1,
-        max: 128,
-      },
-    },
-  },
-  search: {
-    id: 'search',
-    labelKey: 'codexlens.envGroup.search',
-    icon: 'git-branch',
-    vars: {
-      CODEXLENS_BINARY_TOP_K: {
-        key: 'CODEXLENS_BINARY_TOP_K',
-        labelKey: 'codexlens.envField.binaryTopK',
-        type: 'number',
-        placeholder: '200',
-        default: '200',
-        settingsPath: 'search.binary_top_k',
-        min: 10,
-        max: 1000,
-      },
-      CODEXLENS_ANN_TOP_K: {
-        key: 'CODEXLENS_ANN_TOP_K',
-        labelKey: 'codexlens.envField.annTopK',
-        type: 'number',
-        placeholder: '50',
-        default: '50',
-        settingsPath: 'search.ann_top_k',
-        min: 5,
-        max: 500,
-      },
-      CODEXLENS_FTS_TOP_K: {
-        key: 'CODEXLENS_FTS_TOP_K',
-        labelKey: 'codexlens.envField.ftsTopK',
-        type: 'number',
-        placeholder: '50',
-        default: '50',
-        settingsPath: 'search.fts_top_k',
-        min: 5,
-        max: 500,
-      },
-      CODEXLENS_FUSION_K: {
-        key: 'CODEXLENS_FUSION_K',
-        labelKey: 'codexlens.envField.fusionK',
-        type: 'number',
-        placeholder: '60',
-        default: '60',
-        settingsPath: 'search.fusion_k',
-        min: 1,
-        max: 200,
-      },
-    },
-  },
-  indexing: {
-    id: 'indexing',
-    labelKey: 'codexlens.envGroup.indexing',
-    icon: 'cpu',
-    vars: {
-      CODEXLENS_CODE_AWARE_CHUNKING: {
-        key: 'CODEXLENS_CODE_AWARE_CHUNKING',
-        labelKey: 'codexlens.envField.codeAwareChunking',
-        type: 'checkbox',
-        default: 'true',
-        settingsPath: 'indexing.code_aware_chunking',
-      },
-      CODEXLENS_INDEX_WORKERS: {
-        key: 'CODEXLENS_INDEX_WORKERS',
-        labelKey: 'codexlens.envField.indexWorkers',
-        type: 'number',
-        placeholder: '2',
-        default: '2',
-        settingsPath: 'indexing.workers',
-        min: 1,
-        max: 16,
-      },
-      CODEXLENS_MAX_FILE_SIZE: {
-        key: 'CODEXLENS_MAX_FILE_SIZE',
-        labelKey: 'codexlens.envField.maxFileSize',
-        type: 'number',
-        placeholder: '1000000',
-        default: '1000000',
-        settingsPath: 'indexing.max_file_size_bytes',
-        min: 10000,
-        max: 10000000,
-      },
-      CODEXLENS_HNSW_EF: {
-        key: 'CODEXLENS_HNSW_EF',
-        labelKey: 'codexlens.envField.hnswEf',
-        type: 'number',
-        placeholder: '150',
-        default: '150',
-        settingsPath: 'indexing.hnsw_ef',
-        min: 10,
-        max: 500,
-      },
-      CODEXLENS_HNSW_M: {
-        key: 'CODEXLENS_HNSW_M',
-        labelKey: 'codexlens.envField.hnswM',
-        type: 'number',
-        placeholder: '32',
-        default: '32',
-        settingsPath: 'indexing.hnsw_M',
-        min: 4,
-        max: 128,
-      },
-    },
-  },
-};
-
-/**
- * Get all env var keys from the schema
- */
-export function getAllEnvVarKeys(): string[] {
-  const keys: string[] = [];
-  for (const group of Object.values(envVarGroupsSchema)) {
-    for (const key of Object.keys(group.vars)) {
-      keys.push(key);
-    }
-  }
-  return keys;
-}
-
-/**
- * Evaluate showWhen condition for a field
- */
-export function evaluateShowWhen(
-  field: { showWhen?: (env: Record<string, string>) => boolean },
-  values: Record<string, string>
-): boolean {
-  if (!field.showWhen) return true;
-  return field.showWhen(values);
-}
-
-/**
- * Get default values for all env vars in the schema
- */
-export function getSchemaDefaults(): Record<string, string> {
-  const defaults: Record<string, string> = {};
-  for (const group of Object.values(envVarGroupsSchema)) {
-    for (const [key, field] of Object.entries(group.vars)) {
-      if (field.default !== undefined) {
-        defaults[key] = field.default;
-      }
-    }
-  }
-  return defaults;
-}
diff --git a/ccw/frontend/src/hooks/index.ts b/ccw/frontend/src/hooks/index.ts
index 2a282ffc..d280caa1 100644
--- a/ccw/frontend/src/hooks/index.ts
+++ b/ccw/frontend/src/hooks/index.ts
@@ -290,84 +290,15 @@ export type {
   WorkspaceQueryKeys,
 } from './useWorkspaceQueryKeys';
 
-// ========== CodexLens ==========
+// ========== CodexLens (v2) ==========
 export {
-  useCodexLensDashboard,
-  useCodexLensStatus,
-  useCodexLensWorkspaceStatus,
-  useCodexLensConfig,
-  useCodexLensModels,
-  useCodexLensModelInfo,
-  useCodexLensEnv,
-  useCodexLensGpu,
-  useCodexLensIgnorePatterns,
-  useUpdateCodexLensConfig,
-  useBootstrapCodexLens,
-  useUninstallCodexLens,
-  useDownloadModel,
-  useDeleteModel,
-  useUpdateCodexLensEnv,
-  useSelectGpu,
-  useUpdateIgnorePatterns,
-  useCodexLensMutations,
-  codexLensKeys,
-  useCodexLensIndexes,
-  useCodexLensIndexingStatus,
-  useRebuildIndex,
-  useUpdateIndex,
-  useCancelIndexing,
-  useCodexLensWatcher,
-  useCodexLensWatcherMutations,
-  useCodexLensLspStatus,
-  useCodexLensLspMutations,
-  useCodexLensRerankerConfig,
-  useUpdateRerankerConfig,
-  useCcwToolsList,
-} from './useCodexLens';
+  useV2SearchManager,
+} from './useV2SearchManager';
 export type {
-  UseCodexLensDashboardOptions,
-  UseCodexLensDashboardReturn,
-  UseCodexLensStatusOptions,
-  UseCodexLensStatusReturn,
-  UseCodexLensWorkspaceStatusOptions,
-  UseCodexLensWorkspaceStatusReturn,
-  UseCodexLensConfigOptions,
-  UseCodexLensConfigReturn,
-  UseCodexLensModelsOptions,
-  UseCodexLensModelsReturn,
-  UseCodexLensModelInfoOptions,
-  UseCodexLensModelInfoReturn,
-  UseCodexLensEnvOptions,
-  UseCodexLensEnvReturn,
-  UseCodexLensGpuOptions,
-  UseCodexLensGpuReturn,
-  UseCodexLensIgnorePatternsOptions,
-  UseCodexLensIgnorePatternsReturn,
-  UseUpdateCodexLensConfigReturn,
-  UseBootstrapCodexLensReturn,
-  UseUninstallCodexLensReturn,
-  UseDownloadModelReturn,
-  UseDeleteModelReturn,
-  UseUpdateCodexLensEnvReturn,
-  UseSelectGpuReturn,
-  UseUpdateIgnorePatternsReturn,
-  UseCodexLensIndexesOptions,
-  UseCodexLensIndexesReturn,
-  UseCodexLensIndexingStatusReturn,
-  UseRebuildIndexReturn,
-  UseUpdateIndexReturn,
-  UseCancelIndexingReturn,
-  UseCodexLensWatcherOptions,
-  UseCodexLensWatcherReturn,
-  UseCodexLensWatcherMutationsReturn,
-  UseCodexLensLspStatusOptions,
-  UseCodexLensLspStatusReturn,
-  UseCodexLensLspMutationsReturn,
-  UseCodexLensRerankerConfigOptions,
-  UseCodexLensRerankerConfigReturn,
-  UseUpdateRerankerConfigReturn,
-  UseCcwToolsListReturn,
-} from './useCodexLens';
+  V2IndexStatus,
+  V2SearchTestResult,
+  UseV2SearchManagerReturn,
+} from './useV2SearchManager';
 
 // ========== Skill Hub ==========
 export {
diff --git a/ccw/frontend/src/hooks/useCodexLens.test.tsx b/ccw/frontend/src/hooks/useCodexLens.test.tsx
deleted file mode 100644
index 9e7a0d6c..00000000
--- a/ccw/frontend/src/hooks/useCodexLens.test.tsx
+++ /dev/null
@@ -1,418 +0,0 @@
-// ========================================
-// useCodexLens Hook Tests
-// ========================================
-// Tests for all CodexLens TanStack Query hooks
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { renderHook, waitFor } from '@testing-library/react';
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import * as api from '../lib/api';
-import {
-  useCodexLensDashboard,
-  useCodexLensStatus,
-  useCodexLensConfig,
-  useCodexLensModels,
-  useCodexLensEnv,
-  useCodexLensGpu,
-  useUpdateCodexLensConfig,
-  useBootstrapCodexLens,
-  useUninstallCodexLens,
-  useDownloadModel,
-  useDeleteModel,
-  useUpdateCodexLensEnv,
-  useSelectGpu,
-} from './useCodexLens';
-
-// Mock api module
-vi.mock('../lib/api', () => ({
-  fetchCodexLensDashboardInit: vi.fn(),
-  fetchCodexLensStatus: vi.fn(),
-  fetchCodexLensConfig: vi.fn(),
-  updateCodexLensConfig: vi.fn(),
-  bootstrapCodexLens: vi.fn(),
-  uninstallCodexLens: vi.fn(),
-  fetchCodexLensModels: vi.fn(),
-  fetchCodexLensModelInfo: vi.fn(),
-  downloadCodexLensModel: vi.fn(),
-  downloadCodexLensCustomModel: vi.fn(),
-  deleteCodexLensModel: vi.fn(),
-  deleteCodexLensModelByPath: vi.fn(),
-  fetchCodexLensEnv: vi.fn(),
-  updateCodexLensEnv: vi.fn(),
-  fetchCodexLensGpuDetect: vi.fn(),
-  fetchCodexLensGpuList: vi.fn(),
-  selectCodexLensGpu: vi.fn(),
-  resetCodexLensGpu: vi.fn(),
-  fetchCodexLensIgnorePatterns: vi.fn(),
-  updateCodexLensIgnorePatterns: vi.fn(),
-}));
-
-// Mock workflowStore
-vi.mock('../stores/workflowStore', () => ({
-  useWorkflowStore: vi.fn(() => () => '/test/project'),
-  selectProjectPath: vi.fn(() => '/test/project'),
-}));
-
-const mockDashboardData = {
-  installed: true,
-  status: {
-    ready: true,
-    installed: true,
-    version: '1.0.0',
-    pythonVersion: '3.11.0',
-    venvPath: '/path/to/venv',
-  },
-  config: {
-    index_dir: '~/.codexlens/indexes',
-    index_count: 100,
-  },
-  semantic: { available: true },
-};
-
-const mockModelsData = {
-  models: [
-    {
-      profile: 'model1',
-      name: 'Embedding Model 1',
-      type: 'embedding',
-      backend: 'onnx',
-      installed: true,
-      cache_path: '/path/to/cache1',
-    },
-    {
-      profile: 'model2',
-      name: 'Reranker Model 1',
-      type: 'reranker',
-      backend: 'onnx',
-      installed: false,
-      cache_path: '/path/to/cache2',
-    },
-  ],
-};
-
-function createTestQueryClient() {
-  return new QueryClient({
-    defaultOptions: {
-      queries: { retry: false, gcTime: 0 },
-      mutations: { retry: false },
-    },
-  });
-}
-
-function wrapper({ children }: { children: React.ReactNode }) {
-  const queryClient = createTestQueryClient();
-  return <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>;
-}
-
-describe('useCodexLens Hook', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('useCodexLensDashboard', () => {
-    it('should fetch dashboard data', async () => {
-      vi.mocked(api.fetchCodexLensDashboardInit).mockResolvedValue(mockDashboardData);
-
-      const { result } = renderHook(() => useCodexLensDashboard(), { wrapper });
-
-      await waitFor(() => expect(result.current.isLoading).toBe(false));
-
-      expect(api.fetchCodexLensDashboardInit).toHaveBeenCalledOnce();
-      expect(result.current.installed).toBe(true);
-      expect(result.current.status?.ready).toBe(true);
-      expect(result.current.config?.index_dir).toBe('~/.codexlens/indexes');
-    });
-
-    it('should handle errors', async () => {
-      vi.mocked(api.fetchCodexLensDashboardInit).mockRejectedValue(new Error('API Error'));
-
-      const { result } = renderHook(() => useCodexLensDashboard(), { wrapper });
-
-      await waitFor(() => expect(result.current.isLoading).toBe(false));
-
-      expect(result.current.error).toBeTruthy();
-      // TanStack Query wraps errors, so just check error exists
-      expect(result.current.error).toBeDefined();
-    });
-
-    it('should be disabled when enabled is false', async () => {
-      const { result } = renderHook(() => useCodexLensDashboard({ enabled: false }), { wrapper });
-
-      expect(api.fetchCodexLensDashboardInit).not.toHaveBeenCalled();
-      expect(result.current.isLoading).toBe(false);
-    });
-  });
-
-  describe('useCodexLensStatus', () => {
-    it('should fetch status data', async () => {
-      const mockStatus = { ready: true, installed: true, version: '1.0.0' };
-      vi.mocked(api.fetchCodexLensStatus).mockResolvedValue(mockStatus);
-
-      const { result } = renderHook(() => useCodexLensStatus(), { wrapper });
-
-      await waitFor(() => expect(result.current.isLoading).toBe(false));
-
-      expect(api.fetchCodexLensStatus).toHaveBeenCalledOnce();
-      expect(result.current.ready).toBe(true);
-      expect(result.current.installed).toBe(true);
-    });
-  });
-
-  describe('useCodexLensConfig', () => {
-    it('should fetch config data', async () => {
-      const mockConfig = {
-        index_dir: '~/.codexlens/indexes',
-        index_count: 100,
-      };
-      vi.mocked(api.fetchCodexLensConfig).mockResolvedValue(mockConfig);
-
-      const { result } = renderHook(() => useCodexLensConfig(), { wrapper });
-
-      await waitFor(() => expect(result.current.isLoading).toBe(false));
-
-      expect(api.fetchCodexLensConfig).toHaveBeenCalledOnce();
-      expect(result.current.indexDir).toBe('~/.codexlens/indexes');
-      expect(result.current.indexCount).toBe(100);
-    });
-  });
-
-  describe('useCodexLensModels', () => {
-    it('should fetch and filter models by type', async () => {
-      vi.mocked(api.fetchCodexLensModels).mockResolvedValue(mockModelsData as any);
-
-      const { result } = renderHook(() => useCodexLensModels(), { wrapper });
-
-      await waitFor(() => expect(result.current.isLoading).toBe(false));
-
-      expect(result.current.models).toHaveLength(2);
-      expect(result.current.embeddingModels).toHaveLength(1);
-      expect(result.current.rerankerModels).toHaveLength(1);
-      expect(result.current.embeddingModels?.[0].type).toBe('embedding');
-    });
-  });
-
-  describe('useCodexLensEnv', () => {
-    it('should fetch environment variables', async () => {
-      const mockEnv = {
-        env: { KEY1: 'value1', KEY2: 'value2' },
-        settings: { SETTING1: 'setting1' },
-        raw: 'KEY1=value1\nKEY2=value2',
-      };
-      vi.mocked(api.fetchCodexLensEnv).mockResolvedValue(mockEnv as any);
-
-      const { result } = renderHook(() => useCodexLensEnv(), { wrapper });
-
-      await waitFor(() => expect(result.current.isLoading).toBe(false));
-
-      expect(api.fetchCodexLensEnv).toHaveBeenCalledOnce();
-      expect(result.current.env).toEqual({ KEY1: 'value1', KEY2: 'value2' });
-      expect(result.current.settings).toEqual({ SETTING1: 'setting1' });
-      expect(result.current.raw).toBe('KEY1=value1\nKEY2=value2');
-    });
-  });
-
-  describe('useCodexLensGpu', () => {
-    it('should fetch GPU detect and list data', async () => {
-      const mockDetect = { supported: true, has_cuda: true };
-      const mockList = {
-        devices: [
-          { id: 0, name: 'GPU 0', type: 'cuda', driver: '12.0', memory: '8GB' },
-        ],
-        selected_device_id: 0,
-      };
-      vi.mocked(api.fetchCodexLensGpuDetect).mockResolvedValue(mockDetect as any);
-      vi.mocked(api.fetchCodexLensGpuList).mockResolvedValue(mockList as any);
-
-      const { result } = renderHook(() => useCodexLensGpu(), { wrapper });
-
-      await waitFor(() => expect(result.current.isLoadingDetect).toBe(false));
-      await waitFor(() => expect(result.current.isLoadingList).toBe(false));
-
-      expect(api.fetchCodexLensGpuDetect).toHaveBeenCalledOnce();
-      expect(api.fetchCodexLensGpuList).toHaveBeenCalledOnce();
-      expect(result.current.supported).toBe(true);
-      expect(result.current.devices).toHaveLength(1);
-      expect(result.current.selectedDeviceId).toBe(0);
-    });
-  });
-
-  describe('useUpdateCodexLensConfig', () => {
-    it('should update config and invalidate queries', async () => {
-      vi.mocked(api.updateCodexLensConfig).mockResolvedValue({
-        success: true,
-        message: 'Config updated',
-      });
-
-      const { result } = renderHook(() => useUpdateCodexLensConfig(), { wrapper });
-
-      const updateResult = await result.current.updateConfig({
-        index_dir: '~/.codexlens/indexes',
-      });
-
-      expect(api.updateCodexLensConfig).toHaveBeenCalledWith({
-        index_dir: '~/.codexlens/indexes',
-      });
-      expect(updateResult.success).toBe(true);
-      expect(updateResult.message).toBe('Config updated');
-    });
-  });
-
-  describe('useBootstrapCodexLens', () => {
-    it('should bootstrap CodexLens and invalidate queries', async () => {
-      vi.mocked(api.bootstrapCodexLens).mockResolvedValue({
-        success: true,
-        version: '1.0.0',
-      });
-
-      const { result } = renderHook(() => useBootstrapCodexLens(), { wrapper });
-
-      const bootstrapResult = await result.current.bootstrap();
-
-      expect(api.bootstrapCodexLens).toHaveBeenCalledOnce();
-      expect(bootstrapResult.success).toBe(true);
-      expect(bootstrapResult.version).toBe('1.0.0');
-    });
-  });
-
-  describe('useUninstallCodexLens', () => {
-    it('should uninstall CodexLens and invalidate queries', async () => {
-      vi.mocked(api.uninstallCodexLens).mockResolvedValue({
-        success: true,
-        message: 'CodexLens uninstalled',
-      });
-
-      const { result } = renderHook(() => useUninstallCodexLens(), { wrapper });
-
-      const uninstallResult = await result.current.uninstall();
-
-      expect(api.uninstallCodexLens).toHaveBeenCalledOnce();
-      expect(uninstallResult.success).toBe(true);
-    });
-  });
-
-  describe('useDownloadModel', () => {
-    it('should download model by profile', async () => {
-      vi.mocked(api.downloadCodexLensModel).mockResolvedValue({
-        success: true,
-        message: 'Model downloaded',
-      });
-
-      const { result } = renderHook(() => useDownloadModel(), { wrapper });
-
-      const downloadResult = await result.current.downloadModel('model1');
-
-      expect(api.downloadCodexLensModel).toHaveBeenCalledWith('model1');
-      expect(downloadResult.success).toBe(true);
-    });
-
-    it('should download custom model', async () => {
-      vi.mocked(api.downloadCodexLensCustomModel).mockResolvedValue({
-        success: true,
-        message: 'Custom model downloaded',
-      });
-
-      const { result } = renderHook(() => useDownloadModel(), { wrapper });
-
-      const downloadResult = await result.current.downloadCustomModel('custom/model', 'embedding');
-
-      expect(api.downloadCodexLensCustomModel).toHaveBeenCalledWith('custom/model', 'embedding');
-      expect(downloadResult.success).toBe(true);
-    });
-  });
-
-  describe('useDeleteModel', () => {
-    it('should delete model by profile', async () => {
-      vi.mocked(api.deleteCodexLensModel).mockResolvedValue({
-        success: true,
-        message: 'Model deleted',
-      });
-
-      const { result } = renderHook(() => useDeleteModel(), { wrapper });
-
-      const deleteResult = await result.current.deleteModel('model1');
-
-      expect(api.deleteCodexLensModel).toHaveBeenCalledWith('model1');
-      expect(deleteResult.success).toBe(true);
-    });
-
-    it('should delete model by path', async () => {
-      vi.mocked(api.deleteCodexLensModelByPath).mockResolvedValue({
-        success: true,
-        message: 'Model deleted',
-      });
-
-      const { result } = renderHook(() => useDeleteModel(), { wrapper });
-
-      const deleteResult = await result.current.deleteModelByPath('/path/to/model');
-
-      expect(api.deleteCodexLensModelByPath).toHaveBeenCalledWith('/path/to/model');
-      expect(deleteResult.success).toBe(true);
-    });
-  });
-
-  describe('useUpdateCodexLensEnv', () => {
-    it('should update environment variables', async () => {
-      vi.mocked(api.updateCodexLensEnv).mockResolvedValue({
-        success: true,
-        env: { KEY1: 'newvalue' },
-        settings: {},
-        raw: 'KEY1=newvalue',
-      } as any);
-
-      const { result } = renderHook(() => useUpdateCodexLensEnv(), { wrapper });
-
-      const updateResult = await result.current.updateEnv({
-        raw: 'KEY1=newvalue',
-      } as any);
-
-      expect(api.updateCodexLensEnv).toHaveBeenCalledWith({ raw: 'KEY1=newvalue' });
-      expect(updateResult.success).toBe(true);
-    });
-  });
-
-  describe('useSelectGpu', () => {
-    it('should select GPU', async () => {
-      vi.mocked(api.selectCodexLensGpu).mockResolvedValue({
-        success: true,
-        message: 'GPU selected',
-      });
-
-      const { result } = renderHook(() => useSelectGpu(), { wrapper });
-
-      const selectResult = await result.current.selectGpu(0);
-
-      expect(api.selectCodexLensGpu).toHaveBeenCalledWith(0);
-      expect(selectResult.success).toBe(true);
-    });
-
-    it('should reset GPU', async () => {
-      vi.mocked(api.resetCodexLensGpu).mockResolvedValue({
-        success: true,
-        message: 'GPU reset',
-      });
-
-      const { result } = renderHook(() => useSelectGpu(), { wrapper });
-
-      const resetResult = await result.current.resetGpu();
-
-      expect(api.resetCodexLensGpu).toHaveBeenCalledOnce();
-      expect(resetResult.success).toBe(true);
-    });
-  });
-
-  describe('query refetch', () => {
-    it('should refetch dashboard data', async () => {
-      vi.mocked(api.fetchCodexLensDashboardInit).mockResolvedValue(mockDashboardData);
-
-      const { result } = renderHook(() => useCodexLensDashboard(), { wrapper });
-
-      await waitFor(() => expect(result.current.isLoading).toBe(false));
-
-      expect(api.fetchCodexLensDashboardInit).toHaveBeenCalledTimes(1);
-
-      await result.current.refetch();
-
-      expect(api.fetchCodexLensDashboardInit).toHaveBeenCalledTimes(2);
-    });
-  });
-});
diff --git a/ccw/frontend/src/hooks/useCodexLens.ts b/ccw/frontend/src/hooks/useCodexLens.ts
deleted file mode 100644
index 57690e1d..00000000
--- a/ccw/frontend/src/hooks/useCodexLens.ts
+++ /dev/null
@@ -1,1789 +0,0 @@
-// ========================================
-// useCodexLens Hook
-// ========================================
-// TanStack Query hooks for CodexLens management
-
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
-import { useFormatMessage } from '../hooks/useLocale';
-import { useNotifications } from '../hooks/useNotifications';
-import { sanitizeErrorMessage } from '../utils/errorSanitizer';
-import {
-  fetchCodexLensDashboardInit,
-  fetchCodexLensStatus,
-  fetchCodexLensWorkspaceStatus,
-  fetchCodexLensConfig,
-  updateCodexLensConfig,
-  bootstrapCodexLens,
-  installCodexLensSemantic,
-  uninstallCodexLens,
-  fetchCodexLensModels,
-  fetchCodexLensModelInfo,
-  downloadCodexLensModel,
-  downloadCodexLensCustomModel,
-  deleteCodexLensModel,
-  deleteCodexLensModelByPath,
-  fetchCodexLensEnv,
-  updateCodexLensEnv,
-  fetchCodexLensGpuDetect,
-  fetchCodexLensGpuList,
-  selectCodexLensGpu,
-  resetCodexLensGpu,
-  fetchCodexLensIgnorePatterns,
-  updateCodexLensIgnorePatterns,
-  searchCodexLens,
-  searchFilesCodexLens,
-  searchSymbolCodexLens,
-  fetchCodexLensIndexes,
-  rebuildCodexLensIndex,
-  updateCodexLensIndex,
-  cancelCodexLensIndexing,
-  checkCodexLensIndexingStatus,
-  fetchCodexLensWatcherStatus,
-  startCodexLensWatcher,
-  stopCodexLensWatcher,
-  type CodexLensDashboardInitResponse,
-  type CodexLensVenvStatus,
-  type CodexLensConfig,
-  type CodexLensModelsResponse,
-  type CodexLensModelInfoResponse,
-  type CodexLensEnvResponse,
-  type CodexLensUpdateEnvResponse,
-  type CodexLensGpuDetectResponse,
-  type CodexLensGpuListResponse,
-  type CodexLensIgnorePatternsResponse,
-  type CodexLensUpdateEnvRequest,
-  type CodexLensUpdateIgnorePatternsRequest,
-  type CodexLensWorkspaceStatus,
-  type CodexLensSearchParams,
-  type CodexLensSearchResponse,
-  type CodexLensFileSearchResponse,
-  type CodexLensSymbolSearchResponse,
-  type CodexLensIndexesResponse,
-  type CodexLensIndexingStatusResponse,
-  type CodexLensWatcherStatusResponse,
-  type CodexLensLspStatusResponse,
-  type CodexLensSemanticSearchParams,
-  type CodexLensSemanticSearchResponse,
-  type RerankerConfigResponse,
-  type RerankerConfigUpdateRequest,
-  type RerankerConfigUpdateResponse,
-  fetchCodexLensLspStatus,
-  startCodexLensLsp,
-  stopCodexLensLsp,
-  restartCodexLensLsp,
-  semanticSearchCodexLens,
-  fetchRerankerConfig,
-  updateRerankerConfig,
-  fetchCcwTools,
-  type CcwToolInfo,
-} from '../lib/api';
-import { useWorkflowStore, selectProjectPath } from '@/stores/workflowStore';
-
-// Query key factory
-export const codexLensKeys = {
-  all: ['codexLens'] as const,
-  dashboard: () => [...codexLensKeys.all, 'dashboard'] as const,
-  status: () => [...codexLensKeys.all, 'status'] as const,
-  workspace: (path?: string) => [...codexLensKeys.all, 'workspace', path] as const,
-  config: () => [...codexLensKeys.all, 'config'] as const,
-  models: () => [...codexLensKeys.all, 'models'] as const,
-  modelInfo: (profile: string) => [...codexLensKeys.models(), 'info', profile] as const,
-  env: () => [...codexLensKeys.all, 'env'] as const,
-  gpu: () => [...codexLensKeys.all, 'gpu'] as const,
-  gpuList: () => [...codexLensKeys.gpu(), 'list'] as const,
-  gpuDetect: () => [...codexLensKeys.gpu(), 'detect'] as const,
-  ignorePatterns: () => [...codexLensKeys.all, 'ignorePatterns'] as const,
-  indexes: () => [...codexLensKeys.all, 'indexes'] as const,
-  indexingStatus: () => [...codexLensKeys.all, 'indexingStatus'] as const,
-  search: (params: CodexLensSearchParams) => [...codexLensKeys.all, 'search', params] as const,
-  filesSearch: (params: CodexLensSearchParams) => [...codexLensKeys.all, 'filesSearch', params] as const,
-  symbolSearch: (params: Pick<CodexLensSearchParams, 'query' | 'limit'>) => [...codexLensKeys.all, 'symbolSearch', params] as const,
-  lspStatus: () => [...codexLensKeys.all, 'lspStatus'] as const,
-  semanticSearch: (params: CodexLensSemanticSearchParams) => [...codexLensKeys.all, 'semanticSearch', params] as const,
-  watcher: () => [...codexLensKeys.all, 'watcher'] as const,
-  rerankerConfig: () => [...codexLensKeys.all, 'rerankerConfig'] as const,
-  ccwTools: () => [...codexLensKeys.all, 'ccwTools'] as const,
-};
-
-// Default stale times
-const STALE_TIME_SHORT = 30 * 1000; // 30 seconds for frequently changing data
-const STALE_TIME_MEDIUM = 2 * 60 * 1000; // 2 minutes for moderately changing data
-const STALE_TIME_LONG = 10 * 60 * 1000; // 10 minutes for rarely changing data
-
-// ========== Query Hooks ==========
-
-export interface UseCodexLensDashboardOptions {
-  enabled?: boolean;
-  staleTime?: number;
-}
-
-export interface UseCodexLensDashboardReturn {
-  data: CodexLensDashboardInitResponse | undefined;
-  installed: boolean;
-  status: CodexLensVenvStatus | undefined;
-  config: CodexLensConfig | undefined;
-  semantic: { available: boolean } | undefined;
-  isLoading: boolean;
-  isFetching: boolean;
-  error: Error | null;
-  refetch: () => Promise<void>;
-}
-
-/**
- * Hook for fetching CodexLens dashboard initialization data
- */
-export function useCodexLensDashboard(options: UseCodexLensDashboardOptions = {}): UseCodexLensDashboardReturn {
-  const { enabled = true, staleTime = STALE_TIME_SHORT } = options;
-
-  const query = useQuery({
-    queryKey: codexLensKeys.dashboard(),
-    queryFn: fetchCodexLensDashboardInit,
-    staleTime,
-    enabled,
-    retry: 2,
-  });
-
-  const refetch = async () => {
-    await query.refetch();
-  };
-
-  return {
-    data: query.data,
-    installed: query.data?.installed ?? false,
-    status: query.data?.status,
-    config: query.data?.config,
-    semantic: query.data?.semantic,
-    isLoading: query.isLoading,
-    isFetching: query.isFetching,
-    error: query.error,
-    refetch,
-  };
-}
-
-export interface UseCodexLensStatusOptions {
-  enabled?: boolean;
-  staleTime?: number;
-}
-
-export interface UseCodexLensStatusReturn {
-  status: CodexLensVenvStatus | undefined;
-  ready: boolean;
-  installed: boolean;
-  isLoading: boolean;
-  error: Error | null;
-  refetch: () => Promise<void>;
-}
-
-/**
- * Hook for fetching CodexLens venv status
- */
-export function useCodexLensStatus(options: UseCodexLensStatusOptions = {}): UseCodexLensStatusReturn {
-  const { enabled = true, staleTime = STALE_TIME_SHORT } = options;
-
-  const query = useQuery({
-    queryKey: codexLensKeys.status(),
-    queryFn: fetchCodexLensStatus,
-    staleTime,
-    enabled,
-    retry: 2,
-  });
-
-  const refetch = async () => {
-    await query.refetch();
-  };
-
-  return {
-    status: query.data,
-    ready: query.data?.ready ?? false,
-    installed: query.data?.installed ?? false,
-    isLoading: query.isLoading,
-    error: query.error,
-    refetch,
-  };
-}
-
-export interface UseCodexLensWorkspaceStatusOptions {
-  projectPath?: string;
-  enabled?: boolean;
-  staleTime?: number;
-}
-
-export interface UseCodexLensWorkspaceStatusReturn {
-  data: CodexLensWorkspaceStatus | undefined;
-  hasIndex: boolean;
-  ftsPercent: number;
-  vectorPercent: number;
-  isLoading: boolean;
-  error: Error | null;
-  refetch: () => Promise<void>;
-}
-
-/**
- * Hook for fetching CodexLens workspace index status
- */
-export function useCodexLensWorkspaceStatus(options: UseCodexLensWorkspaceStatusOptions = {}): UseCodexLensWorkspaceStatusReturn {
-  const { projectPath, enabled = true, staleTime = STALE_TIME_SHORT } = options;
-  const projectPathFromStore = useWorkflowStore(selectProjectPath);
-  const actualProjectPath = projectPath ?? projectPathFromStore;
-  const queryEnabled = enabled && !!actualProjectPath;
-
-  const query = useQuery({
-    queryKey: codexLensKeys.workspace(actualProjectPath),
-    queryFn: () => fetchCodexLensWorkspaceStatus(actualProjectPath),
-    staleTime,
-    enabled: queryEnabled,
-    retry: 2,
-  });
-
-  const refetch = async () => {
-    await query.refetch();
-  };
-
-  return {
-    data: query.data,
-    hasIndex: query.data?.hasIndex ?? false,
-    ftsPercent: query.data?.fts.percent ?? 0,
-    vectorPercent: query.data?.vector.percent ?? 0,
-    isLoading: query.isLoading,
-    error: query.error,
-    refetch,
-  };
-}
-
-export interface UseCodexLensConfigOptions {
-  enabled?: boolean;
-  staleTime?: number;
-}
-
-export interface UseCodexLensConfigReturn {
-  config: CodexLensConfig | undefined;
-  indexDir: string;
-  indexCount: number;
-  isLoading: boolean;
-  error: Error | null;
-  refetch: () => Promise<void>;
-}
-
-/**
- * Hook for fetching CodexLens configuration
- */
-export function useCodexLensConfig(options: UseCodexLensConfigOptions = {}): UseCodexLensConfigReturn {
-  const { enabled = true, staleTime = STALE_TIME_MEDIUM } = options;
-
-  const query = useQuery({
-    queryKey: codexLensKeys.config(),
-    queryFn: fetchCodexLensConfig,
-    staleTime,
-    enabled,
-    retry: 2,
-  });
-
-  const refetch = async () => {
-    await query.refetch();
-  };
-
-  return {
-    config: query.data,
-    indexDir: query.data?.index_dir ?? '~/.codexlens/indexes',
-    indexCount: query.data?.index_count ?? 0,
-    isLoading: query.isLoading,
-    error: query.error,
-    refetch,
-  };
-}
-
-export interface UseCodexLensModelsOptions {
-  enabled?: boolean;
-  staleTime?: number;
-}
-
-export interface UseCodexLensModelsReturn {
-  models: CodexLensModelsResponse['models'] | undefined;
-  embeddingModels: CodexLensModelsResponse['models'] | undefined;
-  rerankerModels: CodexLensModelsResponse['models'] | undefined;
-  isLoading: boolean;
-  error: Error | null;
-  refetch: () => Promise<void>;
-}
-
-/**
- * Hook for fetching CodexLens models list
- */
-export function useCodexLensModels(options: UseCodexLensModelsOptions = {}): UseCodexLensModelsReturn {
-  const { enabled = true, staleTime = STALE_TIME_MEDIUM } = options;
-
-  const query = useQuery({
-    queryKey: codexLensKeys.models(),
-    queryFn: fetchCodexLensModels,
-    staleTime,
-    enabled,
-    retry: 2,
-  });
-
-  const refetch = async () => {
-    await query.refetch();
-  };
-
-  const models = query.data?.models ?? [];
-  const embeddingModels = models?.filter(m => m.type === 'embedding');
-  const rerankerModels = models?.filter(m => m.type === 'reranker');
-
-  return {
-    models,
-    embeddingModels,
-    rerankerModels,
-    isLoading: query.isLoading,
-    error: query.error,
-    refetch,
-  };
-}
-
-export interface UseCodexLensModelInfoOptions {
-  profile: string;
-  enabled?: boolean;
-  staleTime?: number;
-}
-
-export interface UseCodexLensModelInfoReturn {
-  info: CodexLensModelInfoResponse['info'] | undefined;
-  isLoading: boolean;
-  error: Error | null;
-  refetch: () => Promise<void>;
-}
-
-/**
- * Hook for fetching CodexLens model info by profile
- */
-export function useCodexLensModelInfo(options: UseCodexLensModelInfoOptions): UseCodexLensModelInfoReturn {
-  const { profile, enabled = true, staleTime = STALE_TIME_LONG } = options;
-  const queryEnabled = enabled && !!profile;
-
-  const query = useQuery({
-    queryKey: codexLensKeys.modelInfo(profile),
-    queryFn: () => fetchCodexLensModelInfo(profile),
-    staleTime,
-    enabled: queryEnabled,
-    retry: 2,
-  });
-
-  const refetch = async () => {
-    await query.refetch();
-  };
-
-  return {
-    info: query.data?.info,
-    isLoading: query.isLoading,
-    error: query.error,
-    refetch,
-  };
-}
-
-export interface UseCodexLensEnvOptions {
-  enabled?: boolean;
-  staleTime?: number;
-}
-
-export interface UseCodexLensEnvReturn {
-  data: CodexLensEnvResponse | undefined;
-  env: Record<string, string> | undefined;
-  settings: Record<string, string> | undefined;
-  raw: string | undefined;
-  isLoading: boolean;
-  error: Error | null;
-  refetch: () => Promise<void>;
-}
-
-/**
- * Hook for fetching CodexLens environment variables
- */
-export function useCodexLensEnv(options: UseCodexLensEnvOptions = {}): UseCodexLensEnvReturn {
-  const { enabled = true, staleTime = STALE_TIME_MEDIUM } = options;
-
-  const query = useQuery({
-    queryKey: codexLensKeys.env(),
-    queryFn: fetchCodexLensEnv,
-    staleTime,
-    enabled,
-    retry: 2,
-  });
-
-  const refetch = async () => {
-    await query.refetch();
-  };
-
-  return {
-    data: query.data,
-    env: query.data?.env,
-    settings: query.data?.settings,
-    raw: query.data?.raw,
-    isLoading: query.isLoading,
-    error: query.error,
-    refetch,
-  };
-}
-
-export interface UseCodexLensGpuOptions {
-  enabled?: boolean;
-  staleTime?: number;
-}
-
-export interface UseCodexLensGpuReturn {
-  detectData: CodexLensGpuDetectResponse | undefined;
-  listData: CodexLensGpuListResponse | undefined;
-  supported: boolean;
-  devices: CodexLensGpuListResponse['devices'] | undefined;
-  selectedDeviceId: string | number | undefined;
-  isLoadingDetect: boolean;
-  isLoadingList: boolean;
-  error: Error | null;
-  refetch: () => Promise<void>;
-}
-
-/**
- * Hook for fetching CodexLens GPU information
- * Combines both detect and list queries
- */
-export function useCodexLensGpu(options: UseCodexLensGpuOptions = {}): UseCodexLensGpuReturn {
-  const { enabled = true, staleTime = STALE_TIME_LONG } = options;
-
-  const detectQuery = useQuery({
-    queryKey: codexLensKeys.gpuDetect(),
-    queryFn: fetchCodexLensGpuDetect,
-    staleTime,
-    enabled,
-    retry: 2,
-  });
-
-  const listQuery = useQuery({
-    queryKey: codexLensKeys.gpuList(),
-    queryFn: fetchCodexLensGpuList,
-    staleTime,
-    enabled,
-    retry: 2,
-  });
-
-  const refetch = async () => {
-    await Promise.all([detectQuery.refetch(), listQuery.refetch()]);
-  };
-
-  return {
-    detectData: detectQuery.data,
-    listData: listQuery.data,
-    supported: detectQuery.data?.supported ?? false,
-    devices: listQuery.data?.devices,
-    selectedDeviceId: listQuery.data?.selected_device_id,
-    isLoadingDetect: detectQuery.isLoading,
-    isLoadingList: listQuery.isLoading,
-    error: detectQuery.error || listQuery.error,
-    refetch,
-  };
-}
-
-export interface UseCodexLensIgnorePatternsOptions {
-  enabled?: boolean;
-  staleTime?: number;
-}
-
-export interface UseCodexLensIgnorePatternsReturn {
-  data: CodexLensIgnorePatternsResponse | undefined;
-  patterns: string[] | undefined;
-  extensionFilters: string[] | undefined;
-  defaults: CodexLensIgnorePatternsResponse['defaults'] | undefined;
-  isLoading: boolean;
-  error: Error | null;
-  refetch: () => Promise<void>;
-}
-
-/**
- * Hook for fetching CodexLens ignore patterns
- */
-export function useCodexLensIgnorePatterns(options: UseCodexLensIgnorePatternsOptions = {}): UseCodexLensIgnorePatternsReturn {
-  const { enabled = true, staleTime = STALE_TIME_LONG } = options;
-
-  const query = useQuery({
-    queryKey: codexLensKeys.ignorePatterns(),
-    queryFn: fetchCodexLensIgnorePatterns,
-    staleTime,
-    enabled,
-    retry: 2,
-  });
-
-  const refetch = async () => {
-    await query.refetch();
-  };
-
-  return {
-    data: query.data,
-    patterns: query.data?.patterns,
-    extensionFilters: query.data?.extensionFilters,
-    defaults: query.data?.defaults,
-    isLoading: query.isLoading,
-    error: query.error,
-    refetch,
-  };
-}
-
-// ========== Mutation Hooks ==========
-
-export interface UseUpdateCodexLensConfigReturn {
-  updateConfig: (config: { index_dir: string }) => Promise<{ success: boolean; message?: string }>;
-  isUpdating: boolean;
-  error: Error | null;
-}
-
-/**
- * Hook for updating CodexLens configuration
- */
-export function useUpdateCodexLensConfig(): UseUpdateCodexLensConfigReturn {
-  const queryClient = useQueryClient();
-  const formatMessage = useFormatMessage();
-  const { success, info, error: errorToast } = useNotifications();
-
-  const mutation = useMutation({
-    mutationFn: updateCodexLensConfig,
-    onMutate: () => {
-      info(
-        formatMessage({ id: 'common.status.inProgress' }),
-        formatMessage({ id: 'common.feedback.codexLensConfigUpdate.success' })
-      );
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.config() });
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.dashboard() });
-      success(
-        formatMessage({ id: 'common.success' }),
-        formatMessage({ id: 'common.feedback.codexLensConfigUpdate.success' })
-      );
-    },
-    onError: (err) => {
-      const sanitized = sanitizeErrorMessage(err, 'codexLensConfigUpdate');
-      const message = formatMessage({ id: sanitized.messageKey });
-      const title = formatMessage({ id: 'common.error' });
-      errorToast(title, message);
-    },
-  });
-
-  return {
-    updateConfig: mutation.mutateAsync,
-    isUpdating: mutation.isPending,
-    error: mutation.error,
-  };
-}
-
-export interface UseBootstrapCodexLensReturn {
-  bootstrap: () => Promise<{ success: boolean; message?: string; version?: string }>;
-  isBootstrapping: boolean;
-  error: Error | null;
-}
-
-/**
- * Hook for bootstrapping/installing CodexLens
- */
-export function useBootstrapCodexLens(): UseBootstrapCodexLensReturn {
-  const queryClient = useQueryClient();
-  const formatMessage = useFormatMessage();
-  const { success, info, error: errorToast } = useNotifications();
-
-  const mutation = useMutation({
-    mutationFn: bootstrapCodexLens,
-    onMutate: () => {
-      info(
-        formatMessage({ id: 'codexlens.bootstrapping' }),
-        formatMessage({ id: 'common.feedback.codexLensBootstrap.success' })
-      );
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.all });
-      success(
-        formatMessage({ id: 'common.success' }),
-        formatMessage({ id: 'common.feedback.codexLensBootstrap.success' })
-      );
-    },
-    onError: (err) => {
-      const sanitized = sanitizeErrorMessage(err, 'codexLensBootstrap');
-      const message = formatMessage({ id: sanitized.messageKey });
-      const title = formatMessage({ id: 'common.error' });
-      errorToast(title, message);
-    },
-  });
-
-  return {
-    bootstrap: mutation.mutateAsync,
-    isBootstrapping: mutation.isPending,
-    error: mutation.error,
-  };
-}
-
-export interface UseInstallSemanticReturn {
-  installSemantic: (gpuMode: 'cpu' | 'cuda' | 'directml') => Promise<{ success: boolean; message?: string; gpuMode?: string }>;
-  isInstalling: boolean;
-  error: Error | null;
-}
-
-/**
- * Hook for installing CodexLens semantic dependencies
- */
-export function useInstallSemantic(): UseInstallSemanticReturn {
-  const queryClient = useQueryClient();
-  const formatMessage = useFormatMessage();
-  const { success, info, error: errorToast } = useNotifications();
-
-  const mutation = useMutation({
-    mutationFn: installCodexLensSemantic,
-    onMutate: () => {
-      info(
-        formatMessage({ id: 'codexlens.semantic.installing' }),
-        formatMessage({ id: 'common.feedback.codexLensInstallSemantic.success' })
-      );
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.all });
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.dashboard() });
-      success(
-        formatMessage({ id: 'common.success' }),
-        formatMessage({ id: 'common.feedback.codexLensInstallSemantic.success' })
-      );
-    },
-    onError: (err) => {
-      const sanitized = sanitizeErrorMessage(err, 'codexLensInstallSemantic');
-      const message = formatMessage({ id: sanitized.messageKey });
-      const title = formatMessage({ id: 'common.error' });
-      errorToast(title, message);
-    },
-  });
-
-  return {
-    installSemantic: mutation.mutateAsync,
-    isInstalling: mutation.isPending,
-    error: mutation.error,
-  };
-}
-
-export interface UseUninstallCodexLensReturn {
-  uninstall: () => Promise<{ success: boolean; message?: string }>;
-  isUninstalling: boolean;
-  error: Error | null;
-}
-
-/**
- * Hook for uninstalling CodexLens
- */
-export function useUninstallCodexLens(): UseUninstallCodexLensReturn {
-  const queryClient = useQueryClient();
-  const formatMessage = useFormatMessage();
-  const { success, info, error: errorToast } = useNotifications();
-
-  const mutation = useMutation({
-    mutationFn: uninstallCodexLens,
-    onMutate: () => {
-      info(
-        formatMessage({ id: 'codexlens.uninstalling' }),
-        formatMessage({ id: 'common.feedback.codexLensUninstall.success' })
-      );
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.all });
-      success(
-        formatMessage({ id: 'common.success' }),
-        formatMessage({ id: 'common.feedback.codexLensUninstall.success' })
-      );
-    },
-    onError: (err) => {
-      const sanitized = sanitizeErrorMessage(err, 'codexLensUninstall');
-      const message = formatMessage({ id: sanitized.messageKey });
-      const title = formatMessage({ id: 'common.error' });
-      errorToast(title, message);
-    },
-  });
-
-  return {
-    uninstall: mutation.mutateAsync,
-    isUninstalling: mutation.isPending,
-    error: mutation.error,
-  };
-}
-
-export interface UseDownloadModelReturn {
-  downloadModel: (profile: string) => Promise<{ success: boolean; message?: string }>;
-  downloadCustomModel: (modelName: string, modelType?: string) => Promise<{ success: boolean; message?: string }>;
-  isDownloading: boolean;
-  error: Error | null;
-}
-
-/**
- * Hook for downloading CodexLens models
- */
-export function useDownloadModel(): UseDownloadModelReturn {
-  const queryClient = useQueryClient();
-  const formatMessage = useFormatMessage();
-  const { success, info, error: errorToast } = useNotifications();
-
-  const mutation = useMutation({
-    mutationFn: async ({ profile, modelName, modelType }: { profile?: string; modelName?: string; modelType?: string }) => {
-      if (profile) return downloadCodexLensModel(profile);
-      if (modelName) return downloadCodexLensCustomModel(modelName, modelType);
-      throw new Error('Either profile or modelName must be provided');
-    },
-    onMutate: () => {
-      info(
-        formatMessage({ id: 'codexlens.models.downloading' }),
-        formatMessage({ id: 'common.feedback.codexLensDownloadModel.success' })
-      );
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.models() });
-      success(
-        formatMessage({ id: 'common.success' }),
-        formatMessage({ id: 'common.feedback.codexLensDownloadModel.success' })
-      );
-    },
-    onError: (err) => {
-      const sanitized = sanitizeErrorMessage(err, 'codexLensDownloadModel');
-      const message = formatMessage({ id: sanitized.messageKey });
-      const title = formatMessage({ id: 'common.error' });
-      errorToast(title, message);
-    },
-  });
-
-  return {
-    downloadModel: (profile) => mutation.mutateAsync({ profile }),
-    downloadCustomModel: (modelName, modelType) => mutation.mutateAsync({ modelName, modelType }),
-    isDownloading: mutation.isPending,
-    error: mutation.error,
-  };
-}
-
-export interface UseDeleteModelReturn {
-  deleteModel: (profile: string) => Promise<{ success: boolean; message?: string }>;
-  deleteModelByPath: (cachePath: string) => Promise<{ success: boolean; message?: string }>;
-  isDeleting: boolean;
-  error: Error | null;
-}
-
-/**
- * Hook for deleting CodexLens models
- */
-export function useDeleteModel(): UseDeleteModelReturn {
-  const queryClient = useQueryClient();
-  const formatMessage = useFormatMessage();
-  const { success, info, error: errorToast } = useNotifications();
-
-  const mutation = useMutation({
-    mutationFn: async ({ profile, cachePath }: { profile?: string; cachePath?: string }) => {
-      if (profile) return deleteCodexLensModel(profile);
-      if (cachePath) return deleteCodexLensModelByPath(cachePath);
-      throw new Error('Either profile or cachePath must be provided');
-    },
-    onMutate: () => {
-      info(
-        formatMessage({ id: 'common.actions.deleting' }),
-        formatMessage({ id: 'common.feedback.codexLensDeleteModel.success' })
-      );
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.models() });
-      success(
-        formatMessage({ id: 'common.success' }),
-        formatMessage({ id: 'common.feedback.codexLensDeleteModel.success' })
-      );
-    },
-    onError: (err) => {
-      const sanitized = sanitizeErrorMessage(err, 'codexLensDeleteModel');
-      const message = formatMessage({ id: sanitized.messageKey });
-      const title = formatMessage({ id: 'common.error' });
-      errorToast(title, message);
-    },
-  });
-
-  return {
-    deleteModel: (profile) => mutation.mutateAsync({ profile }),
-    deleteModelByPath: (cachePath) => mutation.mutateAsync({ cachePath }),
-    isDeleting: mutation.isPending,
-    error: mutation.error,
-  };
-}
-
-export interface UseUpdateCodexLensEnvReturn {
-  updateEnv: (request: CodexLensUpdateEnvRequest) => Promise<CodexLensUpdateEnvResponse>;
-  isUpdating: boolean;
-  error: Error | null;
-}
-
-/**
- * Hook for updating CodexLens environment variables
- */
-export function useUpdateCodexLensEnv(): UseUpdateCodexLensEnvReturn {
-  const queryClient = useQueryClient();
-  const formatMessage = useFormatMessage();
-  const { success, info, error: errorToast } = useNotifications();
-
-  const mutation = useMutation({
-    mutationFn: (request: CodexLensUpdateEnvRequest) => updateCodexLensEnv(request),
-    onMutate: () => {
-      info(
-        formatMessage({ id: 'common.status.inProgress' }),
-        formatMessage({ id: 'common.feedback.codexLensUpdateEnv.success' })
-      );
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.env() });
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.dashboard() });
-      success(
-        formatMessage({ id: 'common.success' }),
-        formatMessage({ id: 'common.feedback.codexLensUpdateEnv.success' })
-      );
-    },
-    onError: (err) => {
-      const sanitized = sanitizeErrorMessage(err, 'codexLensUpdateEnv');
-      const message = formatMessage({ id: sanitized.messageKey });
-      const title = formatMessage({ id: 'common.error' });
-      errorToast(title, message);
-    },
-  });
-
-  return {
-    updateEnv: mutation.mutateAsync,
-    isUpdating: mutation.isPending,
-    error: mutation.error,
-  };
-}
-
-export interface UseSelectGpuReturn {
-  selectGpu: (deviceId: string | number) => Promise<{ success: boolean; message?: string }>;
-  resetGpu: () => Promise<{ success: boolean; message?: string }>;
-  isSelecting: boolean;
-  isResetting: boolean;
-  error: Error | null;
-}
-
-/**
- * Hook for selecting/resetting GPU for CodexLens
- */
-export function useSelectGpu(): UseSelectGpuReturn {
-  const queryClient = useQueryClient();
-  const formatMessage = useFormatMessage();
-  const { success, info, error: errorToast } = useNotifications();
-
-  const selectMutation = useMutation({
-    mutationFn: (deviceId: string | number) => selectCodexLensGpu(deviceId),
-    onMutate: () => {
-      info(
-        formatMessage({ id: 'common.status.inProgress' }),
-        formatMessage({ id: 'common.feedback.codexLensSelectGpu.success' })
-      );
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.gpu() });
-      success(
-        formatMessage({ id: 'common.success' }),
-        formatMessage({ id: 'common.feedback.codexLensSelectGpu.success' })
-      );
-    },
-    onError: (err) => {
-      const sanitized = sanitizeErrorMessage(err, 'codexLensSelectGpu');
-      const message = formatMessage({ id: sanitized.messageKey });
-      const title = formatMessage({ id: 'common.error' });
-      errorToast(title, message);
-    },
-  });
-
-  const resetMutation = useMutation({
-    mutationFn: () => resetCodexLensGpu(),
-    onMutate: () => {
-      info(
-        formatMessage({ id: 'common.status.inProgress' }),
-        formatMessage({ id: 'common.feedback.codexLensResetGpu.success' })
-      );
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.gpu() });
-      success(
-        formatMessage({ id: 'common.success' }),
-        formatMessage({ id: 'common.feedback.codexLensResetGpu.success' })
-      );
-    },
-    onError: (err) => {
-      const sanitized = sanitizeErrorMessage(err, 'codexLensResetGpu');
-      const message = formatMessage({ id: sanitized.messageKey });
-      const title = formatMessage({ id: 'common.error' });
-      errorToast(title, message);
-    },
-  });
-
-  return {
-    selectGpu: selectMutation.mutateAsync,
-    resetGpu: resetMutation.mutateAsync,
-    isSelecting: selectMutation.isPending,
-    isResetting: resetMutation.isPending,
-    error: selectMutation.error || resetMutation.error,
-  };
-}
-
-export interface UseUpdateIgnorePatternsReturn {
-  updatePatterns: (request: CodexLensUpdateIgnorePatternsRequest) => Promise<CodexLensIgnorePatternsResponse>;
-  isUpdating: boolean;
-  error: Error | null;
-}
-
-/**
- * Hook for updating CodexLens ignore patterns
- */
-export function useUpdateIgnorePatterns(): UseUpdateIgnorePatternsReturn {
-  const queryClient = useQueryClient();
-  const formatMessage = useFormatMessage();
-  const { success, info, error: errorToast } = useNotifications();
-
-  const mutation = useMutation({
-    mutationFn: updateCodexLensIgnorePatterns,
-    onMutate: () => {
-      info(
-        formatMessage({ id: 'common.status.inProgress' }),
-        formatMessage({ id: 'common.feedback.codexLensUpdatePatterns.success' })
-      );
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.ignorePatterns() });
-      success(
-        formatMessage({ id: 'common.success' }),
-        formatMessage({ id: 'common.feedback.codexLensUpdatePatterns.success' })
-      );
-    },
-    onError: (err) => {
-      const sanitized = sanitizeErrorMessage(err, 'codexLensUpdatePatterns');
-      const message = formatMessage({ id: sanitized.messageKey });
-      const title = formatMessage({ id: 'common.error' });
-      errorToast(title, message);
-    },
-  });
-
-  return {
-    updatePatterns: mutation.mutateAsync,
-    isUpdating: mutation.isPending,
-    error: mutation.error,
-  };
-}
-
-// ========== Index Management Hooks ==========
-
-export interface UseCodexLensIndexesOptions {
-  enabled?: boolean;
-  staleTime?: number;
-}
-
-export interface UseCodexLensIndexesReturn {
-  data: CodexLensIndexesResponse | undefined;
-  indexes: CodexLensIndexesResponse['indexes'] | undefined;
-  isLoading: boolean;
-  error: Error | null;
-  refetch: () => Promise<void>;
-}
-
-/**
- * Hook for fetching CodexLens indexes
- */
-export function useCodexLensIndexes(options: UseCodexLensIndexesOptions = {}): UseCodexLensIndexesReturn {
-  const { enabled = true, staleTime = STALE_TIME_MEDIUM } = options;
-
-  const query = useQuery({
-    queryKey: codexLensKeys.indexes(),
-    queryFn: fetchCodexLensIndexes,
-    staleTime,
-    enabled,
-    retry: 2,
-  });
-
-  const refetch = async () => {
-    await query.refetch();
-  };
-
-  return {
-    data: query.data,
-    indexes: query.data?.indexes,
-    isLoading: query.isLoading,
-    error: query.error,
-    refetch,
-  };
-}
-
-export interface UseCodexLensIndexingStatusReturn {
-  data: CodexLensIndexingStatusResponse | undefined;
-  inProgress: boolean;
-  isLoading: boolean;
-  error: Error | null;
-}
-
-/**
- * Hook for checking CodexLens indexing status
- */
-export function useCodexLensIndexingStatus(): UseCodexLensIndexingStatusReturn {
-  const query = useQuery({
-    queryKey: codexLensKeys.indexingStatus(),
-    queryFn: checkCodexLensIndexingStatus,
-    staleTime: STALE_TIME_SHORT,
-    refetchInterval: (query) => ((query.state.data as any)?.inProgress ? 2000 : false), // Poll every 2s when indexing
-    retry: false,
-  });
-
-  return {
-    data: query.data,
-    inProgress: query.data?.inProgress ?? false,
-    isLoading: query.isLoading,
-    error: query.error,
-  };
-}
-
-export interface UseRebuildIndexReturn {
-  rebuildIndex: (projectPath: string, options?: {
-    indexType?: 'normal' | 'vector';
-    embeddingModel?: string;
-    embeddingBackend?: 'fastembed' | 'litellm';
-    maxWorkers?: number;
-  }) => Promise<{ success: boolean; message?: string; error?: string }>;
-  isRebuilding: boolean;
-  error: Error | null;
-}
-
-/**
- * Hook for rebuilding CodexLens index (full rebuild)
- */
-export function useRebuildIndex(): UseRebuildIndexReturn {
-  const queryClient = useQueryClient();
-  const formatMessage = useFormatMessage();
-  const { success, info, error: errorToast } = useNotifications();
-
-  const mutation = useMutation({
-    mutationFn: async ({
-      projectPath,
-      options = {},
-    }: {
-      projectPath: string;
-      options?: {
-        indexType?: 'normal' | 'vector';
-        embeddingModel?: string;
-        embeddingBackend?: 'fastembed' | 'litellm';
-        maxWorkers?: number;
-      };
-    }) => rebuildCodexLensIndex(projectPath, options),
-    onMutate: () => {
-      info(
-        formatMessage({ id: 'common.status.inProgress' }),
-        formatMessage({ id: 'common.feedback.codexLensRebuildIndex.success' })
-      );
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.indexes() });
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.dashboard() });
-      success(
-        formatMessage({ id: 'common.success' }),
-        formatMessage({ id: 'common.feedback.codexLensRebuildIndex.success' })
-      );
-    },
-    onError: (err) => {
-      const sanitized = sanitizeErrorMessage(err, 'codexLensRebuildIndex');
-      const message = formatMessage({ id: sanitized.messageKey });
-      const title = formatMessage({ id: 'common.error' });
-      errorToast(title, message);
-    },
-  });
-
-  return {
-    rebuildIndex: (projectPath, options) =>
-      mutation.mutateAsync({ projectPath, options }),
-    isRebuilding: mutation.isPending,
-    error: mutation.error,
-  };
-}
-
-export interface UseUpdateIndexReturn {
-  updateIndex: (projectPath: string, options?: {
-    indexType?: 'normal' | 'vector';
-    embeddingModel?: string;
-    embeddingBackend?: 'fastembed' | 'litellm';
-    maxWorkers?: number;
-  }) => Promise<{ success: boolean; message?: string; error?: string }>;
-  isUpdating: boolean;
-  error: Error | null;
-}
-
-/**
- * Hook for updating CodexLens index (incremental update)
- */
-export function useUpdateIndex(): UseUpdateIndexReturn {
-  const queryClient = useQueryClient();
-  const formatMessage = useFormatMessage();
-  const { success, info, error: errorToast } = useNotifications();
-
-  const mutation = useMutation({
-    mutationFn: async ({
-      projectPath,
-      options = {},
-    }: {
-      projectPath: string;
-      options?: {
-        indexType?: 'normal' | 'vector';
-        embeddingModel?: string;
-        embeddingBackend?: 'fastembed' | 'litellm';
-        maxWorkers?: number;
-      };
-    }) => updateCodexLensIndex(projectPath, options),
-    onMutate: () => {
-      info(
-        formatMessage({ id: 'common.status.inProgress' }),
-        formatMessage({ id: 'common.feedback.codexLensUpdateIndex.success' })
-      );
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.indexes() });
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.dashboard() });
-      success(
-        formatMessage({ id: 'common.success' }),
-        formatMessage({ id: 'common.feedback.codexLensUpdateIndex.success' })
-      );
-    },
-    onError: (err) => {
-      const sanitized = sanitizeErrorMessage(err, 'codexLensUpdateIndex');
-      const message = formatMessage({ id: sanitized.messageKey });
-      const title = formatMessage({ id: 'common.error' });
-      errorToast(title, message);
-    },
-  });
-
-  return {
-    updateIndex: (projectPath, options) =>
-      mutation.mutateAsync({ projectPath, options }),
-    isUpdating: mutation.isPending,
-    error: mutation.error,
-  };
-}
-
-export interface UseCancelIndexingReturn {
-  cancelIndexing: () => Promise<{ success: boolean; error?: string }>;
-  isCancelling: boolean;
-  error: Error | null;
-}
-
-/**
- * Hook for canceling CodexLens indexing
- */
-export function useCancelIndexing(): UseCancelIndexingReturn {
-  const queryClient = useQueryClient();
-  const formatMessage = useFormatMessage();
-  const { success, info, error: errorToast } = useNotifications();
-
-  const mutation = useMutation({
-    mutationFn: cancelCodexLensIndexing,
-    onMutate: () => {
-      info(
-        formatMessage({ id: 'common.status.inProgress' }),
-        formatMessage({ id: 'common.feedback.codexLensCancelIndexing.success' })
-      );
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.indexingStatus() });
-      success(
-        formatMessage({ id: 'common.success' }),
-        formatMessage({ id: 'common.feedback.codexLensCancelIndexing.success' })
-      );
-    },
-    onError: (err) => {
-      const sanitized = sanitizeErrorMessage(err, 'codexLensCancelIndexing');
-      const message = formatMessage({ id: sanitized.messageKey });
-      const title = formatMessage({ id: 'common.error' });
-      errorToast(title, message);
-    },
-  });
-
-  return {
-    cancelIndexing: mutation.mutateAsync,
-    isCancelling: mutation.isPending,
-    error: mutation.error,
-  };
-}
-
-/**
- * Combined hook for all CodexLens mutations
- */
-export function useCodexLensMutations() {
-  const updateConfig = useUpdateCodexLensConfig();
-  const bootstrap = useBootstrapCodexLens();
-  const installSemantic = useInstallSemantic();
-  const uninstall = useUninstallCodexLens();
-  const download = useDownloadModel();
-  const deleteModel = useDeleteModel();
-  const updateEnv = useUpdateCodexLensEnv();
-  const gpu = useSelectGpu();
-  const updatePatterns = useUpdateIgnorePatterns();
-  const rebuildIndex = useRebuildIndex();
-  const updateIndex = useUpdateIndex();
-  const cancelIndexing = useCancelIndexing();
-
-  return {
-    updateConfig: updateConfig.updateConfig,
-    isUpdatingConfig: updateConfig.isUpdating,
-    bootstrap: bootstrap.bootstrap,
-    isBootstrapping: bootstrap.isBootstrapping,
-    installSemantic: installSemantic.installSemantic,
-    isInstallingSemantic: installSemantic.isInstalling,
-    uninstall: uninstall.uninstall,
-    isUninstalling: uninstall.isUninstalling,
-    downloadModel: download.downloadModel,
-    downloadCustomModel: download.downloadCustomModel,
-    isDownloading: download.isDownloading,
-    deleteModel: deleteModel.deleteModel,
-    deleteModelByPath: deleteModel.deleteModelByPath,
-    isDeleting: deleteModel.isDeleting,
-    updateEnv: updateEnv.updateEnv,
-    isUpdatingEnv: updateEnv.isUpdating,
-    selectGpu: gpu.selectGpu,
-    resetGpu: gpu.resetGpu,
-    isSelectingGpu: gpu.isSelecting || gpu.isResetting,
-    updatePatterns: updatePatterns.updatePatterns,
-    isUpdatingPatterns: updatePatterns.isUpdating,
-    rebuildIndex: rebuildIndex.rebuildIndex,
-    isRebuildingIndex: rebuildIndex.isRebuilding,
-    updateIndex: updateIndex.updateIndex,
-    isUpdatingIndex: updateIndex.isUpdating,
-    cancelIndexing: cancelIndexing.cancelIndexing,
-    isCancellingIndexing: cancelIndexing.isCancelling,
-    isMutating:
-      updateConfig.isUpdating ||
-      bootstrap.isBootstrapping ||
-      installSemantic.isInstalling ||
-      uninstall.isUninstalling ||
-      download.isDownloading ||
-      deleteModel.isDeleting ||
-      updateEnv.isUpdating ||
-      gpu.isSelecting ||
-      gpu.isResetting ||
-      updatePatterns.isUpdating ||
-      rebuildIndex.isRebuilding ||
-      updateIndex.isUpdating ||
-      cancelIndexing.isCancelling,
-  };
-}
-
-// ========== Search Hooks ==========
-
-export interface UseCodexLensSearchOptions {
-  enabled?: boolean;
-}
-
-export interface UseCodexLensSearchReturn {
-  data: CodexLensSearchResponse | undefined;
-  results: CodexLensSearchResponse['results'] | undefined;
-  isLoading: boolean;
-  error: Error | null;
-  refetch: () => Promise<void>;
-}
-
-/**
- * Hook for content search using CodexLens
- */
-export function useCodexLensSearch(params: CodexLensSearchParams, options: UseCodexLensSearchOptions = {}): UseCodexLensSearchReturn {
-  const { enabled = false } = options;
-
-  const query = useQuery({
-    queryKey: codexLensKeys.search(params),
-    queryFn: () => searchCodexLens(params),
-    enabled,
-    staleTime: STALE_TIME_SHORT,
-    retry: 1,
-  });
-
-  const refetch = async () => {
-    await query.refetch();
-  };
-
-  return {
-    data: query.data,
-    results: query.data?.results,
-    isLoading: query.isLoading,
-    error: query.error,
-    refetch,
-  };
-}
-
-export interface UseCodexLensFileSearchReturn {
-  data: CodexLensFileSearchResponse | undefined;
-  files: string[] | undefined;
-  isLoading: boolean;
-  error: Error | null;
-  refetch: () => Promise<void>;
-}
-
-/**
- * Hook for file search using CodexLens
- */
-export function useCodexLensFilesSearch(params: CodexLensSearchParams, options: UseCodexLensSearchOptions = {}): UseCodexLensFileSearchReturn {
-  const { enabled = false } = options;
-
-  const query = useQuery({
-    queryKey: codexLensKeys.filesSearch(params),
-    queryFn: () => searchFilesCodexLens(params),
-    enabled,
-    staleTime: STALE_TIME_SHORT,
-    retry: 1,
-  });
-
-  const refetch = async () => {
-    await query.refetch();
-  };
-
-  return {
-    data: query.data,
-    files: query.data?.files,
-    isLoading: query.isLoading,
-    error: query.error,
-    refetch,
-  };
-}
-
-export interface UseCodexLensSymbolSearchOptions {
-  enabled?: boolean;
-}
-
-export interface UseCodexLensSymbolSearchReturn {
-  data: CodexLensSymbolSearchResponse | undefined;
-  symbols: CodexLensSymbolSearchResponse['symbols'] | undefined;
-  isLoading: boolean;
-  error: Error | null;
-  refetch: () => Promise<void>;
-}
-
-/**
- * Hook for symbol search using CodexLens
- */
-export function useCodexLensSymbolSearch(
-  params: Pick<CodexLensSearchParams, 'query' | 'limit'>,
-  options: UseCodexLensSymbolSearchOptions = {}
-): UseCodexLensSymbolSearchReturn {
-  const { enabled = false } = options;
-
-  const query = useQuery({
-    queryKey: codexLensKeys.symbolSearch(params),
-    queryFn: () => searchSymbolCodexLens(params),
-    enabled,
-    staleTime: STALE_TIME_SHORT,
-    retry: 1,
-  });
-
-  const refetch = async () => {
-    await query.refetch();
-  };
-
-  return {
-    data: query.data,
-    symbols: query.data?.symbols,
-    isLoading: query.isLoading,
-    error: query.error,
-    refetch,
-  };
-}
-
-// ========== LSP / Semantic Search Hooks ==========
-
-export interface UseCodexLensLspStatusOptions {
-  enabled?: boolean;
-  staleTime?: number;
-}
-
-export interface UseCodexLensLspStatusReturn {
-  data: CodexLensLspStatusResponse | undefined;
-  available: boolean;
-  semanticAvailable: boolean;
-  vectorIndex: boolean;
-  projectCount: number;
-  embeddings: Record<string, unknown> | undefined;
-  modes: string[];
-  strategies: string[];
-  isLoading: boolean;
-  error: Error | null;
-  refetch: () => Promise<void>;
-}
-
-/**
- * Hook for checking CodexLens LSP/semantic search availability
- * Polls every 5 seconds when the LSP server is available
- */
-export function useCodexLensLspStatus(options: UseCodexLensLspStatusOptions = {}): UseCodexLensLspStatusReturn {
-  const { enabled = true, staleTime = STALE_TIME_MEDIUM } = options;
-
-  const query = useQuery({
-    queryKey: codexLensKeys.lspStatus(),
-    queryFn: fetchCodexLensLspStatus,
-    staleTime,
-    enabled,
-    refetchInterval: (query) => {
-      const data = query.state.data as CodexLensLspStatusResponse | undefined;
-      return data?.available ? 5000 : false;
-    },
-    retry: 2,
-  });
-
-  const refetch = async () => {
-    await query.refetch();
-  };
-
-  return {
-    data: query.data,
-    available: query.data?.available ?? false,
-    semanticAvailable: query.data?.semantic_available ?? false,
-    vectorIndex: query.data?.vector_index ?? false,
-    projectCount: query.data?.project_count ?? 0,
-    embeddings: query.data?.embeddings,
-    modes: query.data?.modes ?? [],
-    strategies: query.data?.strategies ?? [],
-    isLoading: query.isLoading,
-    error: query.error,
-    refetch,
-  };
-}
-
-export interface UseCodexLensLspMutationsReturn {
-  startLsp: (path?: string) => Promise<{ success: boolean; message?: string; error?: string }>;
-  stopLsp: (path?: string) => Promise<{ success: boolean; message?: string; error?: string }>;
-  restartLsp: (path?: string) => Promise<{ success: boolean; message?: string; error?: string }>;
-  isStarting: boolean;
-  isStopping: boolean;
-  isRestarting: boolean;
-}
-
-/**
- * Hook for LSP server start/stop/restart mutations
- */
-export function useCodexLensLspMutations(): UseCodexLensLspMutationsReturn {
-  const queryClient = useQueryClient();
-  const formatMessage = useFormatMessage();
-  const { success, error: errorToast } = useNotifications();
-
-  const startMutation = useMutation({
-    mutationFn: ({ path }: { path?: string }) => startCodexLensLsp(path),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.lspStatus() });
-      success(
-        formatMessage({ id: 'common.success' }),
-        formatMessage({ id: 'codexlens.lsp.started' })
-      );
-    },
-    onError: (err) => {
-      const sanitized = sanitizeErrorMessage(err, 'codexLensLspStart');
-      const message = formatMessage({ id: sanitized.messageKey });
-      const title = formatMessage({ id: 'common.error' });
-      errorToast(title, message);
-    },
-  });
-
-  const stopMutation = useMutation({
-    mutationFn: ({ path }: { path?: string }) => stopCodexLensLsp(path),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.lspStatus() });
-      success(
-        formatMessage({ id: 'common.success' }),
-        formatMessage({ id: 'codexlens.lsp.stopped' })
-      );
-    },
-    onError: (err) => {
-      const sanitized = sanitizeErrorMessage(err, 'codexLensLspStop');
-      const message = formatMessage({ id: sanitized.messageKey });
-      const title = formatMessage({ id: 'common.error' });
-      errorToast(title, message);
-    },
-  });
-
-  const restartMutation = useMutation({
-    mutationFn: ({ path }: { path?: string }) => restartCodexLensLsp(path),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.lspStatus() });
-      success(
-        formatMessage({ id: 'common.success' }),
-        formatMessage({ id: 'codexlens.lsp.restarted' })
-      );
-    },
-    onError: (err) => {
-      const sanitized = sanitizeErrorMessage(err, 'codexLensLspRestart');
-      const message = formatMessage({ id: sanitized.messageKey });
-      const title = formatMessage({ id: 'common.error' });
-      errorToast(title, message);
-    },
-  });
-
-  return {
-    startLsp: (path?: string) => startMutation.mutateAsync({ path }),
-    stopLsp: (path?: string) => stopMutation.mutateAsync({ path }),
-    restartLsp: (path?: string) => restartMutation.mutateAsync({ path }),
-    isStarting: startMutation.isPending,
-    isStopping: stopMutation.isPending,
-    isRestarting: restartMutation.isPending,
-  };
-}
-
-export interface UseCodexLensSemanticSearchOptions {
-  enabled?: boolean;
-}
-
-export interface UseCodexLensSemanticSearchReturn {
-  data: CodexLensSemanticSearchResponse | undefined;
-  results: CodexLensSemanticSearchResponse['results'] | undefined;
-  isLoading: boolean;
-  error: Error | null;
-  refetch: () => Promise<void>;
-}
-
-/**
- * Hook for semantic search using CodexLens Python API
- */
-export function useCodexLensSemanticSearch(
-  params: CodexLensSemanticSearchParams,
-  options: UseCodexLensSemanticSearchOptions = {}
-): UseCodexLensSemanticSearchReturn {
-  const { enabled = false } = options;
-
-  const query = useQuery({
-    queryKey: codexLensKeys.semanticSearch(params),
-    queryFn: () => semanticSearchCodexLens(params),
-    enabled,
-    staleTime: STALE_TIME_SHORT,
-    retry: 1,
-  });
-
-  const refetch = async () => {
-    await query.refetch();
-  };
-
-  return {
-    data: query.data,
-    results: query.data?.results,
-    isLoading: query.isLoading,
-    error: query.error,
-    refetch,
-  };
-}
-
-// ========== File Watcher Hooks ==========
-
-export interface UseCodexLensWatcherOptions {
-  enabled?: boolean;
-}
-
-export interface UseCodexLensWatcherReturn {
-  data: CodexLensWatcherStatusResponse | undefined;
-  running: boolean;
-  rootPath: string;
-  eventsProcessed: number;
-  uptimeSeconds: number;
-  isLoading: boolean;
-  error: Error | null;
-}
-
-/**
- * Hook for checking CodexLens file watcher status
- * Polls every 3 seconds when watcher is running
- */
-export function useCodexLensWatcher(options: UseCodexLensWatcherOptions = {}): UseCodexLensWatcherReturn {
-  const { enabled = true } = options;
-
-  const query = useQuery({
-    queryKey: codexLensKeys.watcher(),
-    queryFn: fetchCodexLensWatcherStatus,
-    staleTime: STALE_TIME_SHORT,
-    enabled,
-    refetchInterval: (query) => {
-      const data = query.state.data as CodexLensWatcherStatusResponse | undefined;
-      return data?.running ? 3000 : false;
-    },
-    retry: 2,
-  });
-
-  return {
-    data: query.data,
-    running: query.data?.running ?? false,
-    rootPath: query.data?.root_path ?? '',
-    eventsProcessed: query.data?.events_processed ?? 0,
-    uptimeSeconds: query.data?.uptime_seconds ?? 0,
-    isLoading: query.isLoading,
-    error: query.error,
-  };
-}
-
-export interface UseCodexLensWatcherMutationsReturn {
-  startWatcher: (path?: string, debounceMs?: number) => Promise<{ success: boolean; message?: string; error?: string }>;
-  stopWatcher: () => Promise<{ success: boolean; message?: string; error?: string }>;
-  isStarting: boolean;
-  isStopping: boolean;
-}
-
-/**
- * Hook for file watcher start/stop mutations
- */
-export function useCodexLensWatcherMutations(): UseCodexLensWatcherMutationsReturn {
-  const queryClient = useQueryClient();
-  const formatMessage = useFormatMessage();
-  const { success, error: errorToast } = useNotifications();
-
-  const startMutation = useMutation({
-    mutationFn: ({ path, debounceMs }: { path?: string; debounceMs?: number }) =>
-      startCodexLensWatcher(path, debounceMs),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.watcher() });
-      success(
-        formatMessage({ id: 'common.success' }),
-        formatMessage({ id: 'codexlens.watcher.started' })
-      );
-    },
-    onError: (err) => {
-      const sanitized = sanitizeErrorMessage(err, 'codexLensWatcherStart');
-      const message = formatMessage({ id: sanitized.messageKey });
-      const title = formatMessage({ id: 'common.error' });
-      errorToast(title, message);
-    },
-  });
-
-  const stopMutation = useMutation({
-    mutationFn: () => stopCodexLensWatcher(),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.watcher() });
-      success(
-        formatMessage({ id: 'common.success' }),
-        formatMessage({ id: 'codexlens.watcher.stopped' })
-      );
-    },
-    onError: (err) => {
-      const sanitized = sanitizeErrorMessage(err, 'codexLensWatcherStop');
-      const message = formatMessage({ id: sanitized.messageKey });
-      const title = formatMessage({ id: 'common.error' });
-      errorToast(title, message);
-    },
-  });
-
-  return {
-    startWatcher: (path?: string, debounceMs?: number) =>
-      startMutation.mutateAsync({ path, debounceMs }),
-    stopWatcher: () => stopMutation.mutateAsync(),
-    isStarting: startMutation.isPending,
-    isStopping: stopMutation.isPending,
-  };
-}
-
-// ========== Reranker Config Hooks ==========
-
-export interface UseCodexLensRerankerConfigOptions {
-  enabled?: boolean;
-  staleTime?: number;
-}
-
-export interface UseCodexLensRerankerConfigReturn {
-  data: RerankerConfigResponse | undefined;
-  backend: string;
-  modelName: string;
-  apiProvider: string;
-  apiKeySet: boolean;
-  availableBackends: string[];
-  apiProviders: string[];
-  litellmModels: RerankerConfigResponse['litellm_models'];
-  configSource: string;
-  isLoading: boolean;
-  error: Error | null;
-  refetch: () => Promise<void>;
-}
-
-/**
- * Hook for fetching reranker configuration (backends, models, providers)
- */
-export function useCodexLensRerankerConfig(
-  options: UseCodexLensRerankerConfigOptions = {}
-): UseCodexLensRerankerConfigReturn {
-  const { enabled = true, staleTime = STALE_TIME_MEDIUM } = options;
-
-  const query = useQuery({
-    queryKey: codexLensKeys.rerankerConfig(),
-    queryFn: fetchRerankerConfig,
-    staleTime,
-    enabled,
-    retry: 2,
-  });
-
-  const refetch = async () => {
-    await query.refetch();
-  };
-
-  return {
-    data: query.data,
-    backend: query.data?.backend ?? 'fastembed',
-    modelName: query.data?.model_name ?? '',
-    apiProvider: query.data?.api_provider ?? '',
-    apiKeySet: query.data?.api_key_set ?? false,
-    availableBackends: query.data?.available_backends ?? [],
-    apiProviders: query.data?.api_providers ?? [],
-    litellmModels: query.data?.litellm_models,
-    configSource: query.data?.config_source ?? 'default',
-    isLoading: query.isLoading,
-    error: query.error,
-    refetch,
-  };
-}
-
-export interface UseUpdateRerankerConfigReturn {
-  updateConfig: (request: RerankerConfigUpdateRequest) => Promise<RerankerConfigUpdateResponse>;
-  isUpdating: boolean;
-  error: Error | null;
-}
-
-/**
- * Hook for updating reranker configuration
- */
-export function useUpdateRerankerConfig(): UseUpdateRerankerConfigReturn {
-  const queryClient = useQueryClient();
-  const formatMessage = useFormatMessage();
-  const { success, error: errorToast } = useNotifications();
-
-  const mutation = useMutation({
-    mutationFn: (request: RerankerConfigUpdateRequest) => updateRerankerConfig(request),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.rerankerConfig() });
-      queryClient.invalidateQueries({ queryKey: codexLensKeys.env() });
-      success(
-        formatMessage({ id: 'common.success' }),
-        formatMessage({ id: 'codexlens.reranker.saveSuccess' })
-      );
-    },
-    onError: (err) => {
-      const sanitized = sanitizeErrorMessage(err, 'rerankerConfigUpdate');
-      const message = formatMessage({ id: sanitized.messageKey });
-      const title = formatMessage({ id: 'common.error' });
-      errorToast(title, message);
-    },
-  });
-
-  return {
-    updateConfig: mutation.mutateAsync,
-    isUpdating: mutation.isPending,
-    error: mutation.error,
-  };
-}
-
-// ========== CCW Tools Hook ==========
-
-export interface UseCcwToolsListReturn {
-  tools: CcwToolInfo[];
-  isLoading: boolean;
-  error: Error | null;
-}
-
-/**
- * Hook for fetching all registered CCW tools
- * Uses LONG stale time since tool list rarely changes
- */
-export function useCcwToolsList(): UseCcwToolsListReturn {
-  const query = useQuery({
-    queryKey: codexLensKeys.ccwTools(),
-    queryFn: fetchCcwTools,
-    staleTime: STALE_TIME_LONG,
-    retry: 2,
-  });
-
-  return {
-    tools: query.data ?? [],
-    isLoading: query.isLoading,
-    error: query.error,
-  };
-}
diff --git a/ccw/frontend/src/hooks/useV2SearchManager.ts b/ccw/frontend/src/hooks/useV2SearchManager.ts
new file mode 100644
index 00000000..c0161cae
--- /dev/null
+++ b/ccw/frontend/src/hooks/useV2SearchManager.ts
@@ -0,0 +1,159 @@
+// ========================================
+// useV2SearchManager Hook
+// ========================================
+// React hook for v2 search management via smart_search tool
+
+import { useState, useCallback } from 'react';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+
+// ========== Types ==========
+
+export interface V2IndexStatus {
+  indexed: boolean;
+  totalFiles: number;
+  totalChunks: number;
+  lastIndexedAt: string | null;
+  dbSizeBytes: number;
+  vectorDimension: number | null;
+  ftsEnabled: boolean;
+}
+
+export interface V2SearchTestResult {
+  query: string;
+  results: Array<{
+    file: string;
+    score: number;
+    snippet: string;
+  }>;
+  timingMs: number;
+  totalResults: number;
+}
+
+export interface UseV2SearchManagerReturn {
+  status: V2IndexStatus | null;
+  isLoadingStatus: boolean;
+  statusError: Error | null;
+  refetchStatus: () => void;
+  search: (query: string) => Promise<V2SearchTestResult>;
+  isSearching: boolean;
+  searchResult: V2SearchTestResult | null;
+  reindex: () => Promise<void>;
+  isReindexing: boolean;
+}
+
+// ========== API helpers ==========
+
+async function fetchWithJson<T>(url: string, body?: Record<string, unknown>): Promise<T> {
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    credentials: 'same-origin',
+    body: JSON.stringify(body),
+  });
+  if (!response.ok) {
+    throw new Error(`Request failed: ${response.status}`);
+  }
+  return response.json();
+}
+
+async function fetchV2Status(): Promise<V2IndexStatus> {
+  const data = await fetchWithJson<{ result?: V2IndexStatus; error?: string }>('/api/tools', {
+    tool_name: 'smart_search',
+    action: 'status',
+  });
+  if (data.error) {
+    throw new Error(data.error);
+  }
+  // Provide defaults for fields that may be missing
+  return {
+    indexed: false,
+    totalFiles: 0,
+    totalChunks: 0,
+    lastIndexedAt: null,
+    dbSizeBytes: 0,
+    vectorDimension: null,
+    ftsEnabled: false,
+    ...data.result,
+  };
+}
+
+async function fetchV2Search(query: string): Promise<V2SearchTestResult> {
+  const data = await fetchWithJson<{ result?: V2SearchTestResult; error?: string }>('/api/tools', {
+    tool_name: 'smart_search',
+    action: 'search',
+    params: { query, limit: 10 },
+  });
+  if (data.error) {
+    throw new Error(data.error);
+  }
+  return data.result ?? { query, results: [], timingMs: 0, totalResults: 0 };
+}
+
+async function fetchV2Reindex(): Promise<void> {
+  const data = await fetchWithJson<{ error?: string }>('/api/tools', {
+    tool_name: 'smart_search',
+    action: 'reindex',
+  });
+  if (data.error) {
+    throw new Error(data.error);
+  }
+}
+
+// ========== Query Keys ==========
+
+export const v2SearchKeys = {
+  all: ['v2-search'] as const,
+  status: () => [...v2SearchKeys.all, 'status'] as const,
+};
+
+// ========== Hook ==========
+
+export function useV2SearchManager(): UseV2SearchManagerReturn {
+  const queryClient = useQueryClient();
+  const [searchResult, setSearchResult] = useState<V2SearchTestResult | null>(null);
+
+  // Status query
+  const statusQuery = useQuery({
+    queryKey: v2SearchKeys.status(),
+    queryFn: fetchV2Status,
+    staleTime: 30_000,
+    retry: 1,
+  });
+
+  // Search mutation
+  const searchMutation = useMutation({
+    mutationFn: (query: string) => fetchV2Search(query),
+    onSuccess: (data) => {
+      setSearchResult(data);
+    },
+  });
+
+  // Reindex mutation
+  const reindexMutation = useMutation({
+    mutationFn: fetchV2Reindex,
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: v2SearchKeys.status() });
+    },
+  });
+
+  const search = useCallback(async (query: string) => {
+    const result = await searchMutation.mutateAsync(query);
+    return result;
+  }, [searchMutation]);
+
+  const reindex = useCallback(async () => {
+    await reindexMutation.mutateAsync();
+  }, [reindexMutation]);
+
+  return {
+    status: statusQuery.data ?? null,
+    isLoadingStatus: statusQuery.isLoading,
+    statusError: statusQuery.error as Error | null,
+    refetchStatus: () => statusQuery.refetch(),
+    search,
+    isSearching: searchMutation.isPending,
+    searchResult,
+    reindex,
+    isReindexing: reindexMutation.isPending,
+  };
+}
diff --git a/ccw/frontend/src/lib/api.ts b/ccw/frontend/src/lib/api.ts
index b779e912..06ba090a 100644
--- a/ccw/frontend/src/lib/api.ts
+++ b/ccw/frontend/src/lib/api.ts
@@ -4898,33 +4898,27 @@ export async function updateCcwConfigForCodex(config: {
  * Fetch current index status for a specific workspace
  * @param projectPath - Optional project path to filter data by workspace
  */
-export async function fetchIndexStatus(projectPath?: string): Promise<IndexStatus> {
-  const url = projectPath
-    ? `/api/codexlens/workspace-status?path=${encodeURIComponent(projectPath)}`
-    : '/api/codexlens/workspace-status';
-  const resp = await fetchApi<{
-    success: boolean;
-    hasIndex: boolean;
-    fts?: { indexedFiles: number; totalFiles: number };
-  }>(url);
+export async function fetchIndexStatus(_projectPath?: string): Promise<IndexStatus> {
+  const resp = await fetchApi<{ result?: { indexed?: boolean; totalFiles?: number } }>('/api/tools', {
+    method: 'POST',
+    body: JSON.stringify({ tool_name: 'smart_search', action: 'status' }),
+  });
+  const result = resp.result ?? {};
   return {
-    totalFiles: resp.fts?.totalFiles ?? 0,
+    totalFiles: result.totalFiles ?? 0,
     lastUpdated: new Date().toISOString(),
     buildTime: 0,
-    status: resp.hasIndex ? 'completed' : 'idle',
+    status: result.indexed ? 'completed' : 'idle',
   };
 }
 
 /**
  * Rebuild index
  */
-export async function rebuildIndex(request: IndexRebuildRequest = {}): Promise<IndexStatus> {
-  await fetchApi<{ success: boolean }>('/api/codexlens/init', {
+export async function rebuildIndex(_request: IndexRebuildRequest = {}): Promise<IndexStatus> {
+  await fetchApi<{ error?: string }>('/api/tools', {
     method: 'POST',
-    body: JSON.stringify({
-      path: request.paths?.[0],
-      indexType: 'vector',
-    }),
+    body: JSON.stringify({ tool_name: 'smart_search', action: 'reindex' }),
   });
   return {
     totalFiles: 0,
@@ -5241,992 +5235,6 @@ export async function fetchGraphImpact(request: GraphImpactRequest): Promise<Gra
   return fetchApi<GraphImpactResponse>(`/api/graph/impact?${params.toString()}`);
 }
 
-// ========== CodexLens API ==========
-
-/**
- * CodexLens venv status response
- */
-export interface CodexLensVenvStatus {
-  ready: boolean;
-  installed: boolean;
-  version?: string;
-  pythonVersion?: string;
-  venvPath?: string;
-  error?: string;
-}
-
-/**
- * CodexLens status data
- */
-export interface CodexLensStatusData {
-  projects_count?: number;
-  total_files?: number;
-  total_chunks?: number;
-  api_url?: string;
-  api_ready?: boolean;
-  [key: string]: unknown;
-}
-
-/**
- * CodexLens configuration
- */
-export interface CodexLensConfig {
-  index_dir: string;
-  index_count: number;
-}
-
-/**
- * Semantic search status
- */
-export interface CodexLensSemanticStatus {
-  available: boolean;
-  backend?: string;
-  model?: string;
-  hasEmbeddings?: boolean;
-  [key: string]: unknown;
-}
-
-/**
- * Dashboard init response
- */
-export interface CodexLensDashboardInitResponse {
-  installed: boolean;
-  status: CodexLensVenvStatus;
-  config: CodexLensConfig;
-  semantic: CodexLensSemanticStatus;
-  statusData?: CodexLensStatusData;
-}
-
-/**
- * Workspace index status
- */
-export interface CodexLensWorkspaceStatus {
-  success: boolean;
-  hasIndex: boolean;
-  path?: string;
-  fts: {
-    percent: number;
-    indexedFiles: number;
-    totalFiles: number;
-  };
-  vector: {
-    percent: number;
-    filesWithEmbeddings: number;
-    totalFiles: number;
-    totalChunks: number;
-  };
-}
-
-/**
- * GPU device info
- */
-export interface CodexLensGpuDevice {
-  name: string;
-  type: 'integrated' | 'discrete';
-  index: number;
-  device_id?: string;
-  memory?: {
-    total?: number;
-    free?: number;
-  };
-}
-
-/**
- * GPU detect response
- */
-export interface CodexLensGpuDetectResponse {
-  success: boolean;
-  supported: boolean;
-  platform: string;
-  deviceCount?: number;
-  devices?: CodexLensGpuDevice[];
-  error?: string;
-}
-
-/**
- * GPU list response
- */
-export interface CodexLensGpuListResponse {
-  success: boolean;
-  devices: CodexLensGpuDevice[];
-  selected_device_id?: string | number;
-}
-
-/**
- * Model info (normalized from CLI output)
- */
-export interface CodexLensModel {
-  profile: string;
-  name: string;
-  type: 'embedding' | 'reranker';
-  backend: string;
-  size?: string;
-  installed: boolean;
-  cache_path?: string;
-  /** Original HuggingFace model name */
-  model_name?: string;
-  /** Model description */
-  description?: string;
-  /** Use case description */
-  use_case?: string;
-  /** Embedding dimensions */
-  dimensions?: number;
-  /** Whether this model is recommended */
-  recommended?: boolean;
-  /** Model source: 'predefined' | 'discovered' */
-  source?: string;
-  /** Estimated size in MB */
-  estimated_size_mb?: number;
-  /** Actual size in MB (when installed) */
-  actual_size_mb?: number | null;
-}
-
-/**
- * Model list response (normalized)
- */
-export interface CodexLensModelsResponse {
-  success: boolean;
-  models: CodexLensModel[];
-}
-
-/**
- * Model info response
- */
-export interface CodexLensModelInfoResponse {
-  success: boolean;
-  profile: string;
-  info: {
-    name: string;
-    backend: string;
-    type: string;
-    size?: string;
-    path?: string;
-    [key: string]: unknown;
-  };
-}
-
-/**
- * Download model response
- */
-export interface CodexLensDownloadModelResponse {
-  success: boolean;
-  message?: string;
-  profile?: string;
-  progress?: number;
-  error?: string;
-}
-
-/**
- * Delete model response
- */
-export interface CodexLensDeleteModelResponse {
-  success: boolean;
-  message?: string;
-  error?: string;
-}
-
-/**
- * Environment variables response
- */
-export interface CodexLensEnvResponse {
-  success: boolean;
-  path?: string;
-  env: Record<string, string>;
-  raw?: string;
-  settings?: Record<string, string>;
-}
-
-/**
- * Update environment request
- */
-export interface CodexLensUpdateEnvRequest {
-  env: Record<string, string>;
-}
-
-/**
- * Update environment response
- */
-export interface CodexLensUpdateEnvResponse {
-  success: boolean;
-  message?: string;
-  path?: string;
-  settingsPath?: string;
-}
-
-/**
- * Ignore patterns response
- */
-export interface CodexLensIgnorePatternsResponse {
-  success: boolean;
-  patterns: string[];
-  extensionFilters: string[];
-  defaults: {
-    patterns: string[];
-    extensionFilters: string[];
-  };
-}
-
-/**
- * Update ignore patterns request
- */
-export interface CodexLensUpdateIgnorePatternsRequest {
-  patterns?: string[];
-  extensionFilters?: string[];
-}
-
-/**
- * Bootstrap install response
- */
-export interface CodexLensBootstrapResponse {
-  success: boolean;
-  message?: string;
-  version?: string;
-  error?: string;
-}
-
-/**
- * Uninstall response
- */
-export interface CodexLensUninstallResponse {
-  success: boolean;
-  message?: string;
-  error?: string;
-}
-
-/**
- * Fetch CodexLens dashboard initialization data
- */
-export async function fetchCodexLensDashboardInit(): Promise<CodexLensDashboardInitResponse> {
-  return fetchApi<CodexLensDashboardInitResponse>('/api/codexlens/dashboard-init');
-}
-
-/**
- * Fetch CodexLens venv status
- */
-export async function fetchCodexLensStatus(): Promise<CodexLensVenvStatus> {
-  return fetchApi<CodexLensVenvStatus>('/api/codexlens/status');
-}
-
-/**
- * Fetch CodexLens workspace index status
- */
-export async function fetchCodexLensWorkspaceStatus(projectPath: string): Promise<CodexLensWorkspaceStatus> {
-  const params = new URLSearchParams();
-  params.append('path', projectPath);
-  return fetchApi<CodexLensWorkspaceStatus>(`/api/codexlens/workspace-status?${params.toString()}`);
-}
-
-/**
- * Fetch CodexLens configuration
- */
-export async function fetchCodexLensConfig(): Promise<CodexLensConfig> {
-  return fetchApi<CodexLensConfig>('/api/codexlens/config');
-}
-
-/**
- * Update CodexLens configuration
- */
-export async function updateCodexLensConfig(config: {
-  index_dir: string;
-}): Promise<{ success: boolean; message?: string; error?: string }> {
-  return fetchApi('/api/codexlens/config', {
-    method: 'POST',
-    body: JSON.stringify(config),
-  });
-}
-
-/**
- * Bootstrap/install CodexLens
- */
-export async function bootstrapCodexLens(): Promise<CodexLensBootstrapResponse> {
-  return fetchApi<CodexLensBootstrapResponse>('/api/codexlens/bootstrap', {
-    method: 'POST',
-    body: JSON.stringify({}),
-  });
-}
-
-/**
- * CodexLens semantic install response
- */
-export interface CodexLensSemanticInstallResponse {
-  success: boolean;
-  message?: string;
-  gpuMode?: string;
-  available?: boolean;
-  backend?: string;
-  accelerator?: string;
-  providers?: string[];
-  error?: string;
-}
-
-/**
- * Install CodexLens semantic dependencies with GPU mode
- */
-export async function installCodexLensSemantic(gpuMode: 'cpu' | 'cuda' | 'directml' = 'cpu'): Promise<CodexLensSemanticInstallResponse> {
-  return fetchApi<CodexLensSemanticInstallResponse>('/api/codexlens/semantic/install', {
-    method: 'POST',
-    body: JSON.stringify({ gpuMode }),
-  });
-}
-
-/**
- * Uninstall CodexLens
- */
-export async function uninstallCodexLens(): Promise<CodexLensUninstallResponse> {
-  return fetchApi<CodexLensUninstallResponse>('/api/codexlens/uninstall', {
-    method: 'POST',
-    body: JSON.stringify({}),
-  });
-}
-
-/**
- * Fetch CodexLens models list
- * Normalizes the CLI response format to match the frontend interface.
- * CLI returns: { success, result: { models: [{ model_name, estimated_size_mb, ... }] } }
- * Frontend expects: { success, models: [{ name, size, type, backend, ... }] }
- */
-export async function fetchCodexLensModels(): Promise<CodexLensModelsResponse> {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const raw = await fetchApi<any>('/api/codexlens/models');
-
-  // Handle nested result structure from CLI
-  const rawModels = raw?.result?.models ?? raw?.models ?? [];
-
-  const models: CodexLensModel[] = rawModels.map((m: Record<string, unknown>) => ({
-    profile: (m.profile as string) || '',
-    name: (m.model_name as string) || (m.name as string) || (m.profile as string) || '',
-    type: (m.type as 'embedding' | 'reranker') || 'embedding',
-    backend: (m.source as string) || 'fastembed',
-    size: m.installed && m.actual_size_mb
-      ? `${(m.actual_size_mb as number).toFixed(0)} MB`
-      : m.estimated_size_mb
-        ? `~${m.estimated_size_mb} MB`
-        : undefined,
-    installed: (m.installed as boolean) ?? false,
-    cache_path: m.cache_path as string | undefined,
-    model_name: m.model_name as string | undefined,
-    description: m.description as string | undefined,
-    use_case: m.use_case as string | undefined,
-    dimensions: m.dimensions as number | undefined,
-    recommended: m.recommended as boolean | undefined,
-    source: m.source as string | undefined,
-    estimated_size_mb: m.estimated_size_mb as number | undefined,
-    actual_size_mb: m.actual_size_mb as number | null | undefined,
-  }));
-
-  return {
-    success: raw?.success ?? true,
-    models,
-  };
-}
-
-/**
- * Fetch CodexLens model info by profile
- */
-export async function fetchCodexLensModelInfo(profile: string): Promise<CodexLensModelInfoResponse> {
-  const params = new URLSearchParams();
-  params.append('profile', profile);
-  return fetchApi<CodexLensModelInfoResponse>(`/api/codexlens/models/info?${params.toString()}`);
-}
-
-/**
- * Download CodexLens model by profile
- */
-export async function downloadCodexLensModel(profile: string): Promise<CodexLensDownloadModelResponse> {
-  return fetchApi<CodexLensDownloadModelResponse>('/api/codexlens/models/download', {
-    method: 'POST',
-    body: JSON.stringify({ profile }),
-  });
-}
-
-/**
- * Download custom CodexLens model from HuggingFace
- */
-export async function downloadCodexLensCustomModel(modelName: string, modelType: string = 'embedding'): Promise<CodexLensDownloadModelResponse> {
-  return fetchApi<CodexLensDownloadModelResponse>('/api/codexlens/models/download-custom', {
-    method: 'POST',
-    body: JSON.stringify({ model_name: modelName, model_type: modelType }),
-  });
-}
-
-/**
- * Delete CodexLens model by profile
- */
-export async function deleteCodexLensModel(profile: string): Promise<CodexLensDeleteModelResponse> {
-  return fetchApi<CodexLensDeleteModelResponse>('/api/codexlens/models/delete', {
-    method: 'POST',
-    body: JSON.stringify({ profile }),
-  });
-}
-
-/**
- * Delete CodexLens model by cache path
- */
-export async function deleteCodexLensModelByPath(cachePath: string): Promise<CodexLensDeleteModelResponse> {
-  return fetchApi<CodexLensDeleteModelResponse>('/api/codexlens/models/delete-path', {
-    method: 'POST',
-    body: JSON.stringify({ cache_path: cachePath }),
-  });
-}
-
-/**
- * Fetch CodexLens environment variables
- */
-export async function fetchCodexLensEnv(): Promise<CodexLensEnvResponse> {
-  return fetchApi<CodexLensEnvResponse>('/api/codexlens/env');
-}
-
-/**
- * Update CodexLens environment variables
- */
-export async function updateCodexLensEnv(request: CodexLensUpdateEnvRequest): Promise<CodexLensUpdateEnvResponse> {
-  return fetchApi<CodexLensUpdateEnvResponse>('/api/codexlens/env', {
-    method: 'POST',
-    body: JSON.stringify(request),
-  });
-}
-
-/**
- * Detect GPU support for CodexLens
- */
-export async function fetchCodexLensGpuDetect(): Promise<CodexLensGpuDetectResponse> {
-  return fetchApi<CodexLensGpuDetectResponse>('/api/codexlens/gpu/detect');
-}
-
-/**
- * Fetch available GPU devices
- */
-export async function fetchCodexLensGpuList(): Promise<CodexLensGpuListResponse> {
-  return fetchApi<CodexLensGpuListResponse>('/api/codexlens/gpu/list');
-}
-
-/**
- * Select GPU device for CodexLens
- */
-export async function selectCodexLensGpu(deviceId: string | number): Promise<{ success: boolean; message?: string; error?: string }> {
-  return fetchApi('/api/codexlens/gpu/select', {
-    method: 'POST',
-    body: JSON.stringify({ device_id: deviceId }),
-  });
-}
-
-/**
- * Reset GPU selection to auto-detection
- */
-export async function resetCodexLensGpu(): Promise<{ success: boolean; message?: string; error?: string }> {
-  return fetchApi('/api/codexlens/gpu/reset', {
-    method: 'POST',
-    body: JSON.stringify({}),
-  });
-}
-
-/**
- * Fetch CodexLens ignore patterns
- */
-export async function fetchCodexLensIgnorePatterns(): Promise<CodexLensIgnorePatternsResponse> {
-  return fetchApi<CodexLensIgnorePatternsResponse>('/api/codexlens/ignore-patterns');
-}
-
-/**
- * Update CodexLens ignore patterns
- */
-export async function updateCodexLensIgnorePatterns(request: CodexLensUpdateIgnorePatternsRequest): Promise<CodexLensIgnorePatternsResponse> {
-  return fetchApi<CodexLensIgnorePatternsResponse>('/api/codexlens/ignore-patterns', {
-    method: 'POST',
-    body: JSON.stringify(request),
-  });
-}
-
-// ========== CodexLens Reranker Config API ==========
-
-/**
- * Reranker LiteLLM model info
- */
-export interface RerankerLitellmModel {
-  modelId: string;
-  modelName: string;
-  providers: string[];
-}
-
-/**
- * Reranker configuration response from GET /api/codexlens/reranker/config
- */
-export interface RerankerConfigResponse {
-  success: boolean;
-  backend: string;
-  model_name: string;
-  api_provider: string;
-  api_key_set: boolean;
-  available_backends: string[];
-  api_providers: string[];
-  litellm_endpoints: string[];
-  litellm_models?: RerankerLitellmModel[];
-  config_source: string;
-  error?: string;
-}
-
-/**
- * Reranker configuration update request for POST /api/codexlens/reranker/config
- */
-export interface RerankerConfigUpdateRequest {
-  backend?: string;
-  model_name?: string;
-  api_provider?: string;
-  api_key?: string;
-  litellm_endpoint?: string;
-}
-
-/**
- * Reranker configuration update response
- */
-export interface RerankerConfigUpdateResponse {
-  success: boolean;
-  message?: string;
-  updates?: string[];
-  error?: string;
-}
-
-/**
- * Fetch reranker configuration (backends, models, providers)
- */
-export async function fetchRerankerConfig(): Promise<RerankerConfigResponse> {
-  return fetchApi<RerankerConfigResponse>('/api/codexlens/reranker/config');
-}
-
-/**
- * Update reranker configuration
- */
-export async function updateRerankerConfig(
-  request: RerankerConfigUpdateRequest
-): Promise<RerankerConfigUpdateResponse> {
-  return fetchApi<RerankerConfigUpdateResponse>('/api/codexlens/reranker/config', {
-    method: 'POST',
-    body: JSON.stringify(request),
-  });
-}
-
-// ========== CodexLens Search API ==========
-
-/**
- * CodexLens search request parameters
- */
-export interface CodexLensSearchParams {
-  query: string;
-  limit?: number;
-  mode?: 'dense_rerank' | 'fts' | 'fuzzy';
-  max_content_length?: number;
-  extra_files_count?: number;
-}
-
-/**
- * CodexLens search result
- */
-export interface CodexLensSearchResult {
-  path: string;
-  score: number;
-  content?: string;
-  line_start?: number;
-  line_end?: number;
-  [key: string]: unknown;
-}
-
-/**
- * CodexLens search response
- */
-export interface CodexLensSearchResponse {
-  success: boolean;
-  results: CodexLensSearchResult[];
-  total?: number;
-  query: string;
-  error?: string;
-}
-
-/**
- * CodexLens symbol search response
- */
-export interface CodexLensSymbolSearchResponse {
-  success: boolean;
-  symbols: Array<{
-    name: string;
-    kind: string;
-    path: string;
-    line: number;
-    [key: string]: unknown;
-  }>;
-  error?: string;
-}
-
-/**
- * CodexLens file search response (returns file paths only)
- */
-export interface CodexLensFileSearchResponse {
-  success: boolean;
-  query?: string;
-  count?: number;
-  files: string[];
-  error?: string;
-}
-
-/**
- * Perform content search using CodexLens
- */
-export async function searchCodexLens(params: CodexLensSearchParams): Promise<CodexLensSearchResponse> {
-  const queryParams = new URLSearchParams();
-  queryParams.append('query', params.query);
-  if (params.limit) queryParams.append('limit', String(params.limit));
-  if (params.mode) queryParams.append('mode', params.mode);
-  if (params.max_content_length) queryParams.append('max_content_length', String(params.max_content_length));
-  if (params.extra_files_count) queryParams.append('extra_files_count', String(params.extra_files_count));
-
-  return fetchApi<CodexLensSearchResponse>(`/api/codexlens/search?${queryParams.toString()}`);
-}
-
-/**
- * Perform file search using CodexLens
- */
-export async function searchFilesCodexLens(params: CodexLensSearchParams): Promise<CodexLensFileSearchResponse> {
-  const queryParams = new URLSearchParams();
-  queryParams.append('query', params.query);
-  if (params.limit) queryParams.append('limit', String(params.limit));
-  if (params.mode) queryParams.append('mode', params.mode);
-  if (params.max_content_length) queryParams.append('max_content_length', String(params.max_content_length));
-  if (params.extra_files_count) queryParams.append('extra_files_count', String(params.extra_files_count));
-
-  return fetchApi<CodexLensFileSearchResponse>(`/api/codexlens/search_files?${queryParams.toString()}`);
-}
-
-/**
- * Perform symbol search using CodexLens
- */
-export async function searchSymbolCodexLens(params: Pick<CodexLensSearchParams, 'query' | 'limit'>): Promise<CodexLensSymbolSearchResponse> {
-  const queryParams = new URLSearchParams();
-  queryParams.append('query', params.query);
-  if (params.limit) queryParams.append('limit', String(params.limit));
-
-  return fetchApi<CodexLensSymbolSearchResponse>(`/api/codexlens/symbol?${queryParams.toString()}`);
-}
-
-// ========== CodexLens LSP / Semantic Search API ==========
-
-/**
- * CodexLens LSP status response
- */
-export interface CodexLensLspStatusResponse {
-  available: boolean;
-  semantic_available: boolean;
-  vector_index: boolean;
-  project_count?: number;
-  embeddings?: Record<string, unknown>;
-  modes?: string[];
-  strategies?: string[];
-  error?: string;
-}
-
-/**
- * CodexLens semantic search params (Python API)
- */
-export type CodexLensSemanticSearchMode = 'fusion' | 'vector' | 'structural';
-export type CodexLensFusionStrategy = 'rrf' | 'staged' | 'binary' | 'hybrid' | 'dense_rerank';
-export type CodexLensStagedStage2Mode = 'precomputed' | 'realtime' | 'static_global_graph';
-
-export interface CodexLensSemanticSearchParams {
-  query: string;
-  path?: string;
-  mode?: CodexLensSemanticSearchMode;
-  fusion_strategy?: CodexLensFusionStrategy;
-  staged_stage2_mode?: CodexLensStagedStage2Mode;
-  vector_weight?: number;
-  structural_weight?: number;
-  keyword_weight?: number;
-  kind_filter?: string[];
-  limit?: number;
-  include_match_reason?: boolean;
-}
-
-/**
- * CodexLens semantic search result
- */
-export interface CodexLensSemanticSearchResult {
-  name?: string;
-  kind?: string;
-  file_path?: string;
-  score?: number;
-  match_reason?: string;
-  range?: { start_line: number; end_line: number };
-  [key: string]: unknown;
-}
-
-/**
- * CodexLens semantic search response
- */
-export interface CodexLensSemanticSearchResponse {
-  success: boolean;
-  results?: CodexLensSemanticSearchResult[];
-  query?: string;
-  mode?: string;
-  fusion_strategy?: string;
-  count?: number;
-  error?: string;
-}
-
-/**
- * Fetch CodexLens LSP status
- */
-export async function fetchCodexLensLspStatus(): Promise<CodexLensLspStatusResponse> {
-  return fetchApi<CodexLensLspStatusResponse>('/api/codexlens/lsp/status');
-}
-
-/**
- * Start CodexLens LSP server
- */
-export async function startCodexLensLsp(path?: string): Promise<{ success: boolean; message?: string; workspace_root?: string; error?: string }> {
-  return fetchApi('/api/codexlens/lsp/start', {
-    method: 'POST',
-    body: JSON.stringify({ path }),
-  });
-}
-
-/**
- * Stop CodexLens LSP server
- */
-export async function stopCodexLensLsp(path?: string): Promise<{ success: boolean; message?: string; error?: string }> {
-  return fetchApi('/api/codexlens/lsp/stop', {
-    method: 'POST',
-    body: JSON.stringify({ path }),
-  });
-}
-
-/**
- * Restart CodexLens LSP server
- */
-export async function restartCodexLensLsp(path?: string): Promise<{ success: boolean; message?: string; workspace_root?: string; error?: string }> {
-  return fetchApi('/api/codexlens/lsp/restart', {
-    method: 'POST',
-    body: JSON.stringify({ path }),
-  });
-}
-
-/**
- * Perform semantic search using CodexLens Python API
- */
-export async function semanticSearchCodexLens(params: CodexLensSemanticSearchParams): Promise<CodexLensSemanticSearchResponse> {
-  return fetchApi<CodexLensSemanticSearchResponse>('/api/codexlens/lsp/search', {
-    method: 'POST',
-    body: JSON.stringify(params),
-  });
-}
-
-// ========== CodexLens Index Management API ==========
-
-/**
- * Index operation type
- */
-export type CodexLensIndexOperation = 'fts_full' | 'fts_incremental' | 'vector_full' | 'vector_incremental';
-
-/**
- * CodexLens index entry
- */
-export interface CodexLensIndex {
-  id: string;
-  path: string;
-  indexPath: string;
-  size: number;
-  sizeFormatted: string;
-  fileCount: number;
-  dirCount: number;
-  hasVectorIndex: boolean;
-  hasNormalIndex: boolean;
-  status: string;
-  lastModified: string | null;
-}
-
-/**
- * CodexLens index list response
- */
-export interface CodexLensIndexesResponse {
-  success: boolean;
-  indexDir: string;
-  indexes: CodexLensIndex[];
-  summary: {
-    totalSize: number;
-    totalSizeFormatted: string;
-    vectorIndexCount: number;
-    normalIndexCount: number;
-    totalProjects?: number;
-    totalFiles?: number;
-    totalDirs?: number;
-    indexSizeBytes?: number;
-    indexSizeMb?: number;
-    embeddings?: any;
-    fullIndexDirSize?: number;
-    fullIndexDirSizeFormatted?: string;
-  };
-  error?: string;
-}
-
-/**
- * CodexLens index operation request
- */
-export interface CodexLensIndexOperationRequest {
-  path: string;
-  operation: CodexLensIndexOperation;
-  indexType?: 'normal' | 'vector';
-  embeddingModel?: string;
-  embeddingBackend?: 'fastembed' | 'litellm';
-  maxWorkers?: number;
-}
-
-/**
- * CodexLens index operation response
- */
-export interface CodexLensIndexOperationResponse {
-  success: boolean;
-  message?: string;
-  error?: string;
-  result?: any;
-  output?: string;
-}
-
-/**
- * CodexLens indexing status response
- */
-export interface CodexLensIndexingStatusResponse {
-  success: boolean;
-  inProgress: boolean;
-  error?: string;
-}
-
-/**
- * Fetch all CodexLens indexes
- */
-export async function fetchCodexLensIndexes(): Promise<CodexLensIndexesResponse> {
-  return fetchApi<CodexLensIndexesResponse>('/api/codexlens/indexes');
-}
-
-/**
- * Rebuild CodexLens index (full rebuild)
- * @param projectPath - Project path to index
- * @param options - Index options
- */
-export async function rebuildCodexLensIndex(
-  projectPath: string,
-  options: {
-    indexType?: 'normal' | 'vector';
-    embeddingModel?: string;
-    embeddingBackend?: 'fastembed' | 'litellm';
-    maxWorkers?: number;
-  } = {}
-): Promise<CodexLensIndexOperationResponse> {
-  return fetchApi<CodexLensIndexOperationResponse>('/api/codexlens/init', {
-    method: 'POST',
-    body: JSON.stringify({
-      path: projectPath,
-      indexType: options.indexType || 'vector',
-      embeddingModel: options.embeddingModel || 'code',
-      embeddingBackend: options.embeddingBackend || 'fastembed',
-      maxWorkers: options.maxWorkers || 1
-    }),
-  });
-}
-
-/**
- * Incremental update CodexLens index
- * @param projectPath - Project path to update
- * @param options - Index options
- */
-export async function updateCodexLensIndex(
-  projectPath: string,
-  options: {
-    indexType?: 'normal' | 'vector';
-    embeddingModel?: string;
-    embeddingBackend?: 'fastembed' | 'litellm';
-    maxWorkers?: number;
-  } = {}
-): Promise<CodexLensIndexOperationResponse> {
-  return fetchApi<CodexLensIndexOperationResponse>('/api/codexlens/update', {
-    method: 'POST',
-    body: JSON.stringify({
-      path: projectPath,
-      indexType: options.indexType || 'vector',
-      embeddingModel: options.embeddingModel || 'code',
-      embeddingBackend: options.embeddingBackend || 'fastembed',
-      maxWorkers: options.maxWorkers || 1
-    }),
-  });
-}
-
-/**
- * Cancel ongoing CodexLens indexing
- */
-export async function cancelCodexLensIndexing(): Promise<{ success: boolean; error?: string }> {
-  return fetchApi('/api/codexlens/cancel', {
-    method: 'POST',
-    body: JSON.stringify({}),
-  });
-}
-
-/**
- * Check if CodexLens indexing is in progress
- */
-export async function checkCodexLensIndexingStatus(): Promise<CodexLensIndexingStatusResponse> {
-  return fetchApi<CodexLensIndexingStatusResponse>('/api/codexlens/indexing-status');
-}
-
-/**
- * Clean CodexLens indexes
- * @param options - Clean options
- */
-export async function cleanCodexLensIndexes(options: {
-  all?: boolean;
-  path?: string;
-} = {}): Promise<{ success: boolean; message?: string; error?: string }> {
-  return fetchApi('/api/codexlens/clean', {
-    method: 'POST',
-    body: JSON.stringify(options),
-  });
-}
-
-// ========== CodexLens File Watcher API ==========
-
-/**
- * CodexLens watcher status response
- */
-export interface CodexLensWatcherStatusResponse {
-  success: boolean;
-  running: boolean;
-  root_path: string;
-  events_processed: number;
-  start_time: string | null;
-  uptime_seconds: number;
-}
-
-/**
- * Fetch CodexLens file watcher status
- */
-export async function fetchCodexLensWatcherStatus(): Promise<CodexLensWatcherStatusResponse> {
-  return fetchApi<CodexLensWatcherStatusResponse>('/api/codexlens/watch/status');
-}
-
-/**
- * Start CodexLens file watcher
- */
-export async function startCodexLensWatcher(path?: string, debounceMs?: number): Promise<{ success: boolean; message?: string; path?: string; pid?: number; error?: string }> {
-  return fetchApi('/api/codexlens/watch/start', {
-    method: 'POST',
-    body: JSON.stringify({ path, debounce_ms: debounceMs }),
-  });
-}
-
-/**
- * Stop CodexLens file watcher
- */
-export async function stopCodexLensWatcher(): Promise<{ success: boolean; message?: string; events_processed?: number; uptime_seconds?: number; error?: string }> {
-  return fetchApi('/api/codexlens/watch/stop', {
-    method: 'POST',
-    body: JSON.stringify({}),
-  });
-}
-
 // ========== LiteLLM API Settings API ==========
 
 /**
diff --git a/ccw/frontend/src/locales/en/codexlens.json b/ccw/frontend/src/locales/en/codexlens.json
index 4177bbb5..c571d606 100644
--- a/ccw/frontend/src/locales/en/codexlens.json
+++ b/ccw/frontend/src/locales/en/codexlens.json
@@ -1,390 +1,28 @@
 {
-  "title": "CodexLens",
-  "description": "Semantic code search engine",
-  "bootstrap": "Bootstrap",
-  "bootstrapping": "Bootstrapping...",
-  "uninstall": "Uninstall",
-  "uninstalling": "Uninstalling...",
-  "confirmUninstall": "Are you sure you want to uninstall CodexLens? This action cannot be undone.",
-  "confirmUninstallTitle": "Confirm Uninstall",
-  "notInstalled": "CodexLens is not installed",
-  "comingSoon": "Coming Soon",
-  "tabs": {
-    "overview": "Overview",
-    "settings": "Settings",
-    "models": "Models",
-    "search": "Search",
-    "advanced": "Advanced"
-  },
-  "overview": {
-    "status": {
-      "installation": "Installation Status",
-      "ready": "Ready",
-      "notReady": "Not Ready",
-      "version": "Version",
-      "indexPath": "Index Path",
-      "indexCount": "Index Count"
-    },
-    "notInstalled": {
-      "title": "CodexLens Not Installed",
-      "message": "Please install CodexLens to use semantic code search features."
-    },
-    "actions": {
-      "title": "Quick Actions",
-      "ftsFull": "FTS Full",
-      "ftsFullDesc": "Rebuild full-text index",
-      "ftsIncremental": "FTS Incremental",
-      "ftsIncrementalDesc": "Incremental update full-text index",
-      "vectorFull": "Vector Full",
-      "vectorFullDesc": "Rebuild vector index",
-      "vectorIncremental": "Vector Incremental",
-      "vectorIncrementalDesc": "Incremental update vector index"
-    },
-    "venv": {
-      "title": "Python Virtual Environment Details",
-      "pythonVersion": "Python Version",
-      "venvPath": "Virtual Environment Path",
-      "lastCheck": "Last Check Time"
-    }
-  },
-  "index": {
-    "operationComplete": "Index Operation Complete",
-    "operationFailed": "Index Operation Failed",
-    "noProject": "No Project Selected",
-    "noProjectDesc": "Please open a project to perform index operations.",
-    "starting": "Starting index operation...",
-    "cancelFailed": "Failed to cancel operation",
-    "unknownError": "An unknown error occurred",
-    "complete": "Complete",
-    "failed": "Failed",
-    "cancelled": "Cancelled",
-    "inProgress": "In Progress"
-  },
-  "semantic": {
-    "installTitle": "Install Semantic Search",
-    "installDescription": "Install FastEmbed and semantic search dependencies with GPU acceleration support.",
-    "installInfo": "GPU acceleration requires compatible hardware. CPU mode works on all systems but is slower.",
-    "gpu": {
-      "cpu": "CPU Mode",
-      "cpuDesc": "Universal compatibility, slower processing. Works on all systems.",
-      "directml": "DirectML (Windows GPU)",
-      "directmlDesc": "Best for Windows with AMD/Intel GPUs. Recommended for most users.",
-      "cuda": "CUDA (NVIDIA GPU)",
-      "cudaDesc": "Best performance with NVIDIA GPUs. Requires CUDA toolkit."
-    },
-    "recommended": "Recommended",
-    "install": "Install",
-    "installing": "Installing...",
-    "installSuccess": "Installation Complete",
-    "installSuccessDesc": "Semantic search installed successfully with {mode} mode",
-    "installFailed": "Installation Failed",
-    "unknownError": "An unknown error occurred"
-  },
-  "settings": {
-    "currentCount": "Current Index Count",
-    "currentWorkers": "Current Workers",
-    "currentBatchSize": "Current Batch Size",
-    "configTitle": "Basic Configuration",
-    "indexDir": {
-      "label": "Index Directory",
-      "placeholder": "~/.codexlens/indexes",
-      "hint": "Directory path for storing code indexes"
-    },
-    "maxWorkers": {
-      "label": "Max Workers",
-      "hint": "API concurrent processing threads (1-32)"
-    },
-    "batchSize": {
-      "label": "Batch Size",
-      "hint": "Number of files processed per batch (1-64)"
-    },
-    "validation": {
-      "indexDirRequired": "Index directory is required",
-      "maxWorkersRange": "Workers must be between 1 and 32",
-      "batchSizeRange": "Batch size must be between 1 and 64"
-    },
-    "save": "Save",
-    "saving": "Saving...",
-    "reset": "Reset",
-    "saveSuccess": "Configuration saved",
-    "saveFailed": "Save failed",
-    "configUpdated": "Configuration updated successfully",
-    "saveError": "Error saving configuration",
-    "unknownError": "An unknown error occurred"
-  },
-  "gpu": {
-    "title": "GPU Settings",
-    "status": "GPU Status",
+  "title": "Search Manager",
+  "description": "V2 semantic search index management",
+  "reindex": "Reindex",
+  "reindexing": "Reindexing...",
+  "statusError": "Failed to load search index status",
+  "indexStatus": {
+    "title": "Index Status",
+    "status": "Status",
+    "ready": "Ready",
+    "notIndexed": "Not Indexed",
+    "files": "Files",
+    "dbSize": "DB Size",
+    "lastIndexed": "Last Indexed",
+    "chunks": "Chunks",
+    "vectorDim": "Vector Dim",
     "enabled": "Enabled",
-    "available": "Available",
-    "unavailable": "Unavailable",
-    "supported": "Your system supports GPU acceleration",
-    "notSupported": "Your system does not support GPU acceleration",
-    "detect": "Detect",
-    "detectSuccess": "GPU detection completed",
-    "detectFailed": "GPU detection failed",
-    "detectComplete": "Detected {count} GPU devices",
-    "detectError": "Error detecting GPU",
-    "select": "Select",
-    "selected": "Selected",
-    "active": "Current",
-    "selectSuccess": "GPU selected",
-    "selectFailed": "GPU selection failed",
-    "gpuSelected": "GPU device enabled",
-    "selectError": "Error selecting GPU",
-    "reset": "Reset",
-    "resetSuccess": "GPU reset",
-    "resetFailed": "GPU reset failed",
-    "gpuReset": "GPU disabled, will use CPU",
-    "resetError": "Error resetting GPU",
-    "unknownError": "An unknown error occurred",
-    "noDevices": "No GPU devices detected",
-    "notAvailable": "GPU functionality not available",
-    "unknownDevice": "Unknown device",
-    "type": "Type",
-    "discrete": "Discrete GPU",
-    "integrated": "Integrated GPU",
-    "driver": "Driver Version",
-    "memory": "Memory"
+    "disabled": "Disabled",
+    "unavailable": "Index status unavailable"
   },
-  "advanced": {
-    "warningTitle": "Sensitive Operations Warning",
-    "warningMessage": "Modifying environment variables may affect CodexLens operation. Ensure you understand each variable's purpose.",
-    "loadError": "Failed to load environment variables",
-    "loadErrorDesc": "Unable to fetch environment configuration. Please check if CodexLens is properly installed.",
-    "currentVars": "Current Environment Variables",
-    "settingsVars": "Settings Variables",
-    "customVars": "Custom Variables",
-    "envEditor": "Environment Variable Editor",
-    "envFile": "File",
-    "envContent": "Environment Variable Content",
-    "envPlaceholder": "# Comment lines start with #\nKEY=value\nANOTHER_KEY=\"another value\"",
-    "envHint": "One variable per line, format: KEY=value. Comment lines start with #",
-    "save": "Save",
-    "saving": "Saving...",
-    "reset": "Reset",
-    "saveSuccess": "Environment variables saved",
-    "saveFailed": "Save failed",
-    "envUpdated": "Environment variables updated, restart service to take effect",
-    "saveError": "Error saving environment variables",
-    "unknownError": "An unknown error occurred",
-    "validation": {
-      "invalidKeys": "Invalid variable names: {keys}"
-    },
-    "helpTitle": "Format Help",
-    "helpComment": "Comment lines start with #",
-    "helpFormat": "Variable format: KEY=value",
-    "helpQuotes": "Values with spaces should use quotes",
-    "helpRestart": "Restart service after changes to take effect"
-  },
-  "downloadedModels": "Downloaded Models",
-  "noConfiguredModels": "No models configured",
-  "noLocalModels": "No models downloaded",
-  "models": {
-    "title": "Model Management",
-    "searchPlaceholder": "Search models...",
-    "downloading": "Downloading...",
-    "status": {
-      "downloaded": "Downloaded",
-      "available": "Available"
-    },
-    "types": {
-      "embedding": "Embedding Models",
-      "reranker": "Reranker Models"
-    },
-    "filters": {
-      "label": "Filter",
-      "all": "All"
-    },
-    "actions": {
-      "download": "Download",
-      "delete": "Delete",
-      "cancel": "Cancel"
-    },
-    "custom": {
-      "title": "Custom Model",
-      "placeholder": "HuggingFace model name (e.g., BAAI/bge-small-zh-v1.5)",
-      "description": "Download custom models from HuggingFace. Ensure the model name is correct."
-    },
-    "deleteConfirm": "Are you sure you want to delete model {modelName}?",
-    "notInstalled": {
-      "title": "CodexLens Not Installed",
-      "description": "Please install CodexLens to use model management features."
-    },
-    "error": {
-      "title": "Failed to load models",
-      "description": "Unable to fetch model list. Please check if CodexLens is properly installed."
-    },
-    "empty": {
-      "title": "No models found",
-      "description": "No models are available. Try downloading models from the list.",
-      "filtered": "No models match your filter",
-      "filteredDesc": "Try adjusting your search or filter criteria"
-    }
-  },
-  "search": {
-    "type": "Search Type",
-    "content": "Content Search",
-    "files": "File Search",
-    "symbol": "Symbol Search",
-    "semantic": "Semantic Search (LSP)",
-    "mode": "Mode",
-    "mode.semantic": "Semantic (default)",
-    "mode.exact": "Exact (FTS)",
-    "mode.fuzzy": "Fuzzy",
-    "semanticMode": "Search Mode",
-    "semanticMode.fusion": "Fusion Search",
-    "semanticMode.vector": "Vector Search",
-    "semanticMode.structural": "Structural Search",
-    "fusionStrategy": "Fusion Strategy",
-    "fusionStrategy.rrf": "RRF (default)",
-    "fusionStrategy.dense_rerank": "Dense Rerank",
-    "fusionStrategy.binary": "Binary",
-    "fusionStrategy.hybrid": "Hybrid",
-    "fusionStrategy.staged": "Staged",
-    "stagedStage2Mode": "Staged Stage 2",
-    "stagedStage2Mode.precomputed": "Precomputed (graph_neighbors)",
-    "stagedStage2Mode.realtime": "Realtime (LSP)",
-    "stagedStage2Mode.static_global_graph": "Static Global Graph",
-    "lspStatus": "LSP Status",
-    "lspAvailable": "Semantic search available",
-    "lspUnavailable": "Semantic search unavailable",
-    "lspNoVector": "Vector index required",
-    "lspNoSemantic": "Semantic dependencies required",
-    "query": "Query",
-    "queryPlaceholder": "Enter search query...",
+  "searchTest": {
+    "title": "Search Test",
+    "placeholder": "Enter search query...",
     "button": "Search",
-    "searching": "Searching...",
-    "results": "Results",
-    "resultsCount": "results",
-    "notInstalled": {
-      "title": "CodexLens Not Installed",
-      "description": "Please install CodexLens to use semantic code search features."
-    }
-  },
-  "reranker": {
-    "title": "Reranker Configuration",
-    "description": "Configure the reranker backend, model, and provider for search result ranking.",
-    "backend": "Backend",
-    "backendHint": "Inference backend for reranking",
-    "model": "Model",
-    "modelHint": "Reranker model name or LiteLLM endpoint",
-    "provider": "API Provider",
-    "providerHint": "API provider for reranker service",
-    "apiKeyStatus": "API Key",
-    "apiKeySet": "Configured",
-    "apiKeyNotSet": "Not configured",
-    "configSource": "Config Source",
-    "save": "Save Reranker Config",
-    "saving": "Saving...",
-    "saveSuccess": "Reranker configuration saved",
-    "saveFailed": "Failed to save reranker configuration",
-    "noBackends": "No backends available",
-    "noModels": "No models available",
-    "noProviders": "No providers available",
-    "litellmModels": "LiteLLM Models",
-    "selectBackend": "Select backend...",
-    "selectModel": "Select model...",
-    "selectProvider": "Select provider..."
-  },
-  "envGroup": {
-    "embedding": "Embedding",
-    "reranker": "Reranker",
-    "search": "Search Pipeline",
-    "indexing": "Indexing"
-  },
-  "envField": {
-    "backend": "Backend",
-    "model": "Model",
-    "localModel": "Local Model",
-    "apiUrl": "API URL",
-    "apiKey": "API Key",
-    "multiEndpoints": "Multi-Endpoint",
-    "embedDim": "Embed Dimension",
-    "apiConcurrency": "Concurrency",
-    "maxTokensPerBatch": "Max Tokens/Batch",
-    "useGpu": "Device",
-    "topKResults": "Top K Results",
-    "batchSize": "Batch Size",
-    "binaryTopK": "Binary Top K",
-    "annTopK": "ANN Top K",
-    "ftsTopK": "FTS Top K",
-    "fusionK": "Fusion K",
-    "codeAwareChunking": "Code-Aware Chunking",
-    "indexWorkers": "Index Workers",
-    "maxFileSize": "Max File Size (bytes)",
-    "hnswEf": "HNSW ef",
-    "hnswM": "HNSW M"
-  },
-  "install": {
-    "title": "Install CodexLens",
-    "description": "Set up Python virtual environment and install CodexLens package.",
-    "checklist": "What will be installed",
-    "pythonVenv": "Python Virtual Environment",
-    "pythonVenvDesc": "Isolated Python environment for CodexLens",
-    "codexlensPackage": "CodexLens Package",
-    "codexlensPackageDesc": "Core semantic code search engine",
-    "sqliteFts": "SQLite FTS5",
-    "sqliteFtsDesc": "Full-text search extension for fast code lookup",
-    "location": "Install Location",
-    "locationPath": "~/.codexlens/venv",
-    "timeEstimate": "Installation may take 1-3 minutes depending on network speed.",
-    "stage": {
-      "creatingVenv": "Creating Python virtual environment...",
-      "installingPip": "Installing pip dependencies...",
-      "installingPackage": "Installing CodexLens package...",
-      "settingUpDeps": "Setting up dependencies...",
-      "finalizing": "Finalizing installation...",
-      "complete": "Installation complete!"
-    },
-    "installNow": "Install Now",
-    "installing": "Installing..."
-  },
-  "mcp": {
-    "title": "CCW Tools Registry",
-    "loading": "Loading tools...",
-    "error": "Failed to load tools",
-    "errorDesc": "Unable to fetch CCW tools list. Please check if the server is running.",
-    "emptyDesc": "No tools are currently registered.",
-    "totalCount": "{count} tools",
-    "codexLensSection": "CodexLens Tools",
-    "otherSection": "Other Tools"
-  },
-  "watcher": {
-    "title": "File Watcher",
-    "status": {
-      "running": "Running",
-      "stopped": "Stopped"
-    },
-    "eventsProcessed": "Events Processed",
-    "uptime": "Uptime",
-    "start": "Start Watcher",
-    "starting": "Starting...",
-    "stop": "Stop Watcher",
-    "stopping": "Stopping...",
-    "started": "File watcher started",
-    "stopped": "File watcher stopped"
-  },
-  "lsp": {
-    "title": "LSP Server",
-    "status": {
-      "running": "Running",
-      "stopped": "Stopped"
-    },
-    "projects": "Projects",
-    "embeddings": "Embeddings",
-    "modes": "Modes",
-    "semanticAvailable": "Semantic",
-    "available": "Available",
-    "unavailable": "Unavailable",
-    "start": "Start Server",
-    "starting": "Starting...",
-    "stop": "Stop Server",
-    "stopping": "Stopping...",
-    "restart": "Restart",
-    "restarting": "Restarting...",
-    "started": "LSP server started",
-    "stopped": "LSP server stopped",
-    "restarted": "LSP server restarted"
+    "results": "results",
+    "noResults": "No results found"
   }
 }
diff --git a/ccw/frontend/src/locales/en/navigation.json b/ccw/frontend/src/locales/en/navigation.json
index 1081b39a..da5e8877 100644
--- a/ccw/frontend/src/locales/en/navigation.json
+++ b/ccw/frontend/src/locales/en/navigation.json
@@ -27,7 +27,7 @@
     "prompts": "Prompt History",
     "settings": "Settings",
     "mcp": "MCP Servers",
-    "codexlens": "CodexLens",
+    "codexlens": "Search Manager",
     "apiSettings": "API Settings",
     "endpoints": "CLI Endpoints",
     "installations": "Installations",
diff --git a/ccw/frontend/src/locales/zh/codexlens.json b/ccw/frontend/src/locales/zh/codexlens.json
index f1a65541..d29dc3c9 100644
--- a/ccw/frontend/src/locales/zh/codexlens.json
+++ b/ccw/frontend/src/locales/zh/codexlens.json
@@ -1,390 +1,28 @@
 {
-  "title": "CodexLens",
-  "description": "语义代码搜索引擎",
-  "bootstrap": "引导安装",
-  "bootstrapping": "安装中...",
-  "uninstall": "卸载",
-  "uninstalling": "卸载中...",
-  "confirmUninstall": "确定要卸载 CodexLens 吗？此操作无法撤销。",
-  "confirmUninstallTitle": "确认卸载",
-  "notInstalled": "CodexLens 尚未安装",
-  "comingSoon": "即将推出",
-  "tabs": {
-    "overview": "概览",
-    "settings": "设置",
-    "models": "模型",
-    "search": "搜索",
-    "advanced": "高级"
-  },
-  "overview": {
-    "status": {
-      "installation": "安装状态",
-      "ready": "就绪",
-      "notReady": "未就绪",
-      "version": "版本",
-      "indexPath": "索引路径",
-      "indexCount": "索引数量"
-    },
-    "notInstalled": {
-      "title": "CodexLens 未安装",
-      "message": "请先安装 CodexLens 以使用语义代码搜索功能。"
-    },
-    "actions": {
-      "title": "快速操作",
-      "ftsFull": "FTS 全量",
-      "ftsFullDesc": "重建全文索引",
-      "ftsIncremental": "FTS 增量",
-      "ftsIncrementalDesc": "增量更新全文索引",
-      "vectorFull": "向量全量",
-      "vectorFullDesc": "重建向量索引",
-      "vectorIncremental": "向量增量",
-      "vectorIncrementalDesc": "增量更新向量索引"
-    },
-    "venv": {
-      "title": "Python 虚拟环境详情",
-      "pythonVersion": "Python 版本",
-      "venvPath": "虚拟环境路径",
-      "lastCheck": "最后检查时间"
-    }
-  },
-  "index": {
-    "operationComplete": "索引操作完成",
-    "operationFailed": "索引操作失败",
-    "noProject": "未选择项目",
-    "noProjectDesc": "请打开一个项目以执行索引操作。",
-    "starting": "正在启动索引操作...",
-    "cancelFailed": "取消操作失败",
-    "unknownError": "发生未知错误",
-    "complete": "完成",
-    "failed": "失败",
-    "cancelled": "已取消",
-    "inProgress": "进行中"
-  },
-  "semantic": {
-    "installTitle": "安装语义搜索",
-    "installDescription": "安装 FastEmbed 和语义搜索依赖，支持 GPU 加速。",
-    "installInfo": "GPU 加速需要兼容的硬件。CPU 模式在所有系统上都可用，但速度较慢。",
-    "gpu": {
-      "cpu": "CPU 模式",
-      "cpuDesc": "通用兼容，处理较慢。适用于所有系统。",
-      "directml": "DirectML（Windows GPU）",
-      "directmlDesc": "最适合带 AMD/Intel GPU 的 Windows 系统。推荐大多数用户使用。",
-      "cuda": "CUDA（NVIDIA GPU）",
-      "cudaDesc": "NVIDIA GPU 性能最佳。需要 CUDA 工具包。"
-    },
-    "recommended": "推荐",
-    "install": "安装",
-    "installing": "安装中...",
-    "installSuccess": "安装完成",
-    "installSuccessDesc": "语义搜索已成功安装，使用 {mode} 模式",
-    "installFailed": "安装失败",
-    "unknownError": "发生未知错误"
-  },
-  "settings": {
-    "currentCount": "当前索引数量",
-    "currentWorkers": "当前工作线程",
-    "currentBatchSize": "当前批次大小",
-    "configTitle": "基本配置",
-    "indexDir": {
-      "label": "索引目录",
-      "placeholder": "~/.codexlens/indexes",
-      "hint": "存储代码索引的目录路径"
-    },
-    "maxWorkers": {
-      "label": "最大工作线程",
-      "hint": "API 并发处理线程数 (1-32)"
-    },
-    "batchSize": {
-      "label": "批次大小",
-      "hint": "每次批量处理的文件数量 (1-64)"
-    },
-    "validation": {
-      "indexDirRequired": "索引目录不能为空",
-      "maxWorkersRange": "工作线程数必须在 1-32 之间",
-      "batchSizeRange": "批次大小必须在 1-64 之间"
-    },
-    "save": "保存",
-    "saving": "保存中...",
-    "reset": "重置",
-    "saveSuccess": "配置已保存",
-    "saveFailed": "保存失败",
-    "configUpdated": "配置更新成功",
-    "saveError": "保存配置时出错",
-    "unknownError": "发生未知错误"
-  },
-  "gpu": {
-    "title": "GPU 设置",
-    "status": "GPU 状态",
+  "title": "搜索管理",
+  "description": "V2 语义搜索索引管理",
+  "reindex": "重建索引",
+  "reindexing": "重建中...",
+  "statusError": "加载搜索索引状态失败",
+  "indexStatus": {
+    "title": "索引状态",
+    "status": "状态",
+    "ready": "就绪",
+    "notIndexed": "未索引",
+    "files": "文件数",
+    "dbSize": "数据库大小",
+    "lastIndexed": "上次索引",
+    "chunks": "分块数",
+    "vectorDim": "向量维度",
     "enabled": "已启用",
-    "available": "可用",
-    "unavailable": "不可用",
-    "supported": "您的系统支持 GPU 加速",
-    "notSupported": "您的系统不支持 GPU 加速",
-    "detect": "检测",
-    "detectSuccess": "GPU 检测完成",
-    "detectFailed": "GPU 检测失败",
-    "detectComplete": "检测到 {count} 个 GPU 设备",
-    "detectError": "检测 GPU 时出错",
-    "select": "选择",
-    "selected": "已选择",
-    "active": "当前",
-    "selectSuccess": "GPU 已选择",
-    "selectFailed": "GPU 选择失败",
-    "gpuSelected": "GPU 设备已启用",
-    "selectError": "选择 GPU 时出错",
-    "reset": "重置",
-    "resetSuccess": "GPU 已重置",
-    "resetFailed": "GPU 重置失败",
-    "gpuReset": "GPU 已禁用，将使用 CPU",
-    "resetError": "重置 GPU 时出错",
-    "unknownError": "发生未知错误",
-    "noDevices": "未检测到 GPU 设备",
-    "notAvailable": "GPU 功能不可用",
-    "unknownDevice": "未知设备",
-    "type": "类型",
-    "discrete": "独立显卡",
-    "integrated": "集成显卡",
-    "driver": "驱动版本",
-    "memory": "显存"
+    "disabled": "已禁用",
+    "unavailable": "索引状态不可用"
   },
-  "advanced": {
-    "warningTitle": "敏感操作警告",
-    "warningMessage": "修改环境变量可能影响 CodexLens 的正常运行。请确保您了解每个变量的作用。",
-    "loadError": "加载环境变量失败",
-    "loadErrorDesc": "无法获取环境配置。请检查 CodexLens 是否正确安装。",
-    "currentVars": "当前环境变量",
-    "settingsVars": "设置变量",
-    "customVars": "自定义变量",
-    "envEditor": "环境变量编辑器",
-    "envFile": "文件",
-    "envContent": "环境变量内容",
-    "envPlaceholder": "# 注释行以 # 开头\nKEY=value\nANOTHER_KEY=\"another value\"",
-    "envHint": "每行一个变量，格式：KEY=value。注释行以 # 开头",
-    "save": "保存",
-    "saving": "保存中...",
-    "reset": "重置",
-    "saveSuccess": "环境变量已保存",
-    "saveFailed": "保存失败",
-    "envUpdated": "环境变量更新成功，重启服务后生效",
-    "saveError": "保存环境变量时出错",
-    "unknownError": "发生未知错误",
-    "validation": {
-      "invalidKeys": "无效的变量名: {keys}"
-    },
-    "helpTitle": "格式说明",
-    "helpComment": "注释行以 # 开头",
-    "helpFormat": "变量格式：KEY=value",
-    "helpQuotes": "包含空格的值建议使用引号",
-    "helpRestart": "修改后需要重启服务才能生效"
-  },
-  "downloadedModels": "已下载模型",
-  "noConfiguredModels": "无已配置模型",
-  "noLocalModels": "无已下载模型",
-  "models": {
-    "title": "模型管理",
-    "searchPlaceholder": "搜索模型...",
-    "downloading": "下载中...",
-    "status": {
-      "downloaded": "已下载",
-      "available": "可用"
-    },
-    "types": {
-      "embedding": "嵌入模型",
-      "reranker": "重排序模型"
-    },
-    "filters": {
-      "label": "筛选",
-      "all": "全部"
-    },
-    "actions": {
-      "download": "下载",
-      "delete": "删除",
-      "cancel": "取消"
-    },
-    "custom": {
-      "title": "自定义模型",
-      "placeholder": "HuggingFace 模型名称 (如: BAAI/bge-small-zh-v1.5)",
-      "description": "从 HuggingFace 下载自定义模型。请确保模型名称正确。"
-    },
-    "deleteConfirm": "确定要删除模型 {modelName} 吗？",
-    "notInstalled": {
-      "title": "CodexLens 未安装",
-      "description": "请先安装 CodexLens 以使用模型管理功能。"
-    },
-    "error": {
-      "title": "加载模型失败",
-      "description": "无法获取模型列表。请检查 CodexLens 是否正确安装。"
-    },
-    "empty": {
-      "title": "没有找到模型",
-      "description": "当前没有可用模型。请从列表中下载模型。",
-      "filtered": "没有匹配的模型",
-      "filteredDesc": "尝试调整搜索或筛选条件"
-    }
-  },
-  "search": {
-    "type": "搜索类型",
-    "content": "内容搜索",
-    "files": "文件搜索",
-    "symbol": "符号搜索",
-    "semantic": "语义搜索 (LSP)",
-    "mode": "模式",
-    "mode.semantic": "语义（默认）",
-    "mode.exact": "精确（FTS）",
-    "mode.fuzzy": "模糊",
-    "semanticMode": "搜索模式",
-    "semanticMode.fusion": "融合搜索",
-    "semanticMode.vector": "向量搜索",
-    "semanticMode.structural": "结构搜索",
-    "fusionStrategy": "融合策略",
-    "fusionStrategy.rrf": "RRF（默认）",
-    "fusionStrategy.dense_rerank": "Dense Rerank",
-    "fusionStrategy.binary": "Binary",
-    "fusionStrategy.hybrid": "Hybrid",
-    "fusionStrategy.staged": "Staged",
-    "stagedStage2Mode": "Stage 2 扩展",
-    "stagedStage2Mode.precomputed": "预计算 (graph_neighbors)",
-    "stagedStage2Mode.realtime": "实时 (LSP)",
-    "stagedStage2Mode.static_global_graph": "静态全局图",
-    "lspStatus": "LSP 状态",
-    "lspAvailable": "语义搜索可用",
-    "lspUnavailable": "语义搜索不可用",
-    "lspNoVector": "需要先建立向量索引",
-    "lspNoSemantic": "需要先安装语义依赖",
-    "query": "查询",
-    "queryPlaceholder": "输入搜索查询...",
+  "searchTest": {
+    "title": "搜索测试",
+    "placeholder": "输入搜索查询...",
     "button": "搜索",
-    "searching": "搜索中...",
-    "results": "结果",
-    "resultsCount": "个结果",
-    "notInstalled": {
-      "title": "CodexLens 未安装",
-      "description": "请先安装 CodexLens 以使用语义代码搜索功能。"
-    }
-  },
-  "reranker": {
-    "title": "重排序配置",
-    "description": "配置重排序后端、模型和提供商，用于搜索结果排序。",
-    "backend": "后端",
-    "backendHint": "重排序推理后端",
-    "model": "模型",
-    "modelHint": "重排序模型名称或 LiteLLM 端点",
-    "provider": "API 提供商",
-    "providerHint": "重排序服务的 API 提供商",
-    "apiKeyStatus": "API 密钥",
-    "apiKeySet": "已配置",
-    "apiKeyNotSet": "未配置",
-    "configSource": "配置来源",
-    "save": "保存重排序配置",
-    "saving": "保存中...",
-    "saveSuccess": "重排序配置已保存",
-    "saveFailed": "保存重排序配置失败",
-    "noBackends": "无可用后端",
-    "noModels": "无可用模型",
-    "noProviders": "无可用提供商",
-    "litellmModels": "LiteLLM 模型",
-    "selectBackend": "选择后端...",
-    "selectModel": "选择模型...",
-    "selectProvider": "选择提供商..."
-  },
-  "envGroup": {
-    "embedding": "嵌入模型",
-    "reranker": "重排序",
-    "search": "搜索流水线",
-    "indexing": "索引"
-  },
-  "envField": {
-    "backend": "后端",
-    "model": "模型",
-    "localModel": "本地模型",
-    "apiUrl": "API 地址",
-    "apiKey": "API 密钥",
-    "multiEndpoints": "多端点",
-    "embedDim": "向量维度",
-    "apiConcurrency": "并发数",
-    "maxTokensPerBatch": "每批最大Token数",
-    "useGpu": "设备",
-    "topKResults": "Top K 结果数",
-    "batchSize": "批次大小",
-    "binaryTopK": "二值粗筛 K",
-    "annTopK": "ANN 精筛 K",
-    "ftsTopK": "全文搜索 K",
-    "fusionK": "融合 K",
-    "codeAwareChunking": "代码感知分块",
-    "indexWorkers": "索引线程数",
-    "maxFileSize": "最大文件大小(字节)",
-    "hnswEf": "HNSW ef",
-    "hnswM": "HNSW M"
-  },
-  "install": {
-    "title": "安装 CodexLens",
-    "description": "设置 Python 虚拟环境并安装 CodexLens 包。",
-    "checklist": "将要安装的内容",
-    "pythonVenv": "Python 虚拟环境",
-    "pythonVenvDesc": "CodexLens 的隔离 Python 环境",
-    "codexlensPackage": "CodexLens 包",
-    "codexlensPackageDesc": "核心语义代码搜索引擎",
-    "sqliteFts": "SQLite FTS5",
-    "sqliteFtsDesc": "用于快速代码查找的全文搜索扩展",
-    "location": "安装位置",
-    "locationPath": "~/.codexlens/venv",
-    "timeEstimate": "安装可能需要 1-3 分钟，取决于网络速度。",
-    "stage": {
-      "creatingVenv": "正在创建 Python 虚拟环境...",
-      "installingPip": "正在安装 pip 依赖...",
-      "installingPackage": "正在安装 CodexLens 包...",
-      "settingUpDeps": "正在设置依赖项...",
-      "finalizing": "正在完成安装...",
-      "complete": "安装完成！"
-    },
-    "installNow": "立即安装",
-    "installing": "安装中..."
-  },
-  "mcp": {
-    "title": "CCW 工具注册表",
-    "loading": "加载工具中...",
-    "error": "加载工具失败",
-    "errorDesc": "无法获取 CCW 工具列表。请检查服务器是否正在运行。",
-    "emptyDesc": "当前没有已注册的工具。",
-    "totalCount": "{count} 个工具",
-    "codexLensSection": "CodexLens 工具",
-    "otherSection": "其他工具"
-  },
-  "watcher": {
-    "title": "文件监听器",
-    "status": {
-      "running": "运行中",
-      "stopped": "已停止"
-    },
-    "eventsProcessed": "已处理事件",
-    "uptime": "运行时间",
-    "start": "启动监听",
-    "starting": "启动中...",
-    "stop": "停止监听",
-    "stopping": "停止中...",
-    "started": "文件监听器已启动",
-    "stopped": "文件监听器已停止"
-  },
-  "lsp": {
-    "title": "LSP 服务器",
-    "status": {
-      "running": "运行中",
-      "stopped": "已停止"
-    },
-    "projects": "项目数",
-    "embeddings": "嵌入模型",
-    "modes": "模式",
-    "semanticAvailable": "语义搜索",
-    "available": "可用",
-    "unavailable": "不可用",
-    "start": "启动服务",
-    "starting": "启动中...",
-    "stop": "停止服务",
-    "stopping": "停止中...",
-    "restart": "重启",
-    "restarting": "重启中...",
-    "started": "LSP 服务器已启动",
-    "stopped": "LSP 服务器已停止",
-    "restarted": "LSP 服务器已重启"
+    "results": "个结果",
+    "noResults": "未找到结果"
   }
 }
diff --git a/ccw/frontend/src/locales/zh/navigation.json b/ccw/frontend/src/locales/zh/navigation.json
index 062fbf3b..796fa464 100644
--- a/ccw/frontend/src/locales/zh/navigation.json
+++ b/ccw/frontend/src/locales/zh/navigation.json
@@ -27,7 +27,7 @@
     "prompts": "提示历史",
     "settings": "设置",
     "mcp": "MCP 服务器",
-    "codexlens": "CodexLens",
+    "codexlens": "搜索管理",
     "apiSettings": "API 设置",
     "endpoints": "CLI 端点",
     "installations": "安装",
diff --git a/ccw/frontend/src/pages/CodexLensManagerPage.test.tsx b/ccw/frontend/src/pages/CodexLensManagerPage.test.tsx
index 2b7a25fe..a744ddcb 100644
--- a/ccw/frontend/src/pages/CodexLensManagerPage.test.tsx
+++ b/ccw/frontend/src/pages/CodexLensManagerPage.test.tsx
@@ -1,361 +1,196 @@
 // ========================================
-// CodexLens Manager Page Tests
+// CodexLens Manager Page Tests (v2)
 // ========================================
-// Integration tests for CodexLens manager page with tabs
+// Tests for v2 search management page
 
 import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { render, screen, waitFor } from '@/test/i18n';
+import { render, screen } from '@/test/i18n';
 import userEvent from '@testing-library/user-event';
 import { CodexLensManagerPage } from './CodexLensManagerPage';
 
-// Mock api module
-vi.mock('@/lib/api', () => ({
-  fetchCodexLensDashboardInit: vi.fn(),
-  bootstrapCodexLens: vi.fn(),
-  uninstallCodexLens: vi.fn(),
+// Mock the v2 search manager hook
+vi.mock('@/hooks/useV2SearchManager', () => ({
+  useV2SearchManager: vi.fn(),
 }));
 
-// Mock hooks
-vi.mock('@/hooks/useCodexLens', () => ({
-  useCodexLensDashboard: vi.fn(),
-}));
+import { useV2SearchManager } from '@/hooks/useV2SearchManager';
 
-vi.mock('@/hooks/useCodexLens', () => ({
-  useCodexLensDashboard: vi.fn(),
-}));
-
-vi.mock('@/hooks/useNotifications', () => ({
-  useNotifications: vi.fn(() => ({
-    success: vi.fn(),
-    error: vi.fn(),
-    toasts: [],
-    wsStatus: 'disconnected' as const,
-    wsLastMessage: null,
-    isWsConnected: false,
-    addToast: vi.fn(),
-    removeToast: vi.fn(),
-    clearAllToasts: vi.fn(),
-    connectWebSocket: vi.fn(),
-    disconnectWebSocket: vi.fn(),
-  })),
-}));
-
-// Mock the mutations hook separately
-vi.mock('@/hooks/useCodexLens', async () => {
-  return {
-    useCodexLensDashboard: (await import('@/hooks/useCodexLens')).useCodexLensDashboard,
-    useCodexLensMutations: vi.fn(),
-  };
-});
-
-// Mock window.confirm
-global.confirm = vi.fn(() => true);
-
-const mockDashboardData = {
-  installed: true,
-  status: {
-    ready: true,
-    installed: true,
-    version: '1.0.0',
-    pythonVersion: '3.11.0',
-    venvPath: '/path/to/venv',
-  },
-  config: {
-    index_dir: '~/.codexlens/indexes',
-    index_count: 100,
-  },
-  semantic: { available: true },
+const mockStatus = {
+  indexed: true,
+  totalFiles: 150,
+  totalChunks: 1200,
+  lastIndexedAt: '2026-03-17T10:00:00Z',
+  dbSizeBytes: 5242880,
+  vectorDimension: 384,
+  ftsEnabled: true,
 };
 
-const mockMutations = {
-  bootstrap: vi.fn().mockResolvedValue({ success: true }),
-  uninstall: vi.fn().mockResolvedValue({ success: true }),
-  isBootstrapping: false,
-  isUninstalling: false,
+const defaultHookReturn = {
+  status: mockStatus,
+  isLoadingStatus: false,
+  statusError: null,
+  refetchStatus: vi.fn(),
+  search: vi.fn().mockResolvedValue({
+    query: 'test',
+    results: [],
+    timingMs: 12.5,
+    totalResults: 0,
+  }),
+  isSearching: false,
+  searchResult: null,
+  reindex: vi.fn().mockResolvedValue(undefined),
+  isReindexing: false,
 };
 
-import { useCodexLensDashboard, useCodexLensMutations } from '@/hooks';
-
-describe('CodexLensManagerPage', () => {
+describe('CodexLensManagerPage (v2)', () => {
   beforeEach(() => {
     vi.clearAllMocks();
-    (global.confirm as ReturnType<typeof vi.fn>).mockReturnValue(true);
+    (vi.mocked(useV2SearchManager) as any).mockReturnValue(defaultHookReturn);
   });
 
-  describe('when installed', () => {
-    beforeEach(() => {
-      (vi.mocked(useCodexLensDashboard) as any).mockReturnValue({
-        installed: true,
-        status: mockDashboardData.status,
-        config: mockDashboardData.config,
-        semantic: mockDashboardData.semantic,
-        isLoading: false,
-        isFetching: false,
-        error: null,
-        refetch: vi.fn(),
-      });
-      (vi.mocked(useCodexLensMutations) as any).mockReturnValue(mockMutations);
-    });
-
-    it('should render page title and description', () => {
-      render(<CodexLensManagerPage />);
-
-      expect(screen.getByText(/CodexLens/i)).toBeInTheDocument();
-      expect(screen.getByText(/Semantic code search engine/i)).toBeInTheDocument();
-    });
-
-    it('should render all tabs', () => {
-      render(<CodexLensManagerPage />);
-
-      expect(screen.getByText(/Overview/i)).toBeInTheDocument();
-      expect(screen.getByText(/Settings/i)).toBeInTheDocument();
-      expect(screen.getByText(/Models/i)).toBeInTheDocument();
-      expect(screen.getByText(/Advanced/i)).toBeInTheDocument();
-    });
-
-    it('should show uninstall button when installed', () => {
-      render(<CodexLensManagerPage />);
-
-      expect(screen.getByText(/Uninstall/i)).toBeInTheDocument();
-    });
-
-    it('should switch between tabs', async () => {
-      const user = userEvent.setup();
-      render(<CodexLensManagerPage />);
-
-      const settingsTab = screen.getByText(/Settings/i);
-      await user.click(settingsTab);
-
-      expect(settingsTab).toHaveAttribute('data-state', 'active');
-    });
-
-    it('should call refresh on button click', async () => {
-      const refetch = vi.fn();
-      (vi.mocked(useCodexLensDashboard) as any).mockReturnValue({
-        installed: true,
-        status: mockDashboardData.status,
-        config: mockDashboardData.config,
-        semantic: mockDashboardData.semantic,
-        isLoading: false,
-        isFetching: false,
-        error: null,
-        refetch,
-      });
-
-      const user = userEvent.setup();
-      render(<CodexLensManagerPage />);
-
-      const refreshButton = screen.getByText(/Refresh/i);
-      await user.click(refreshButton);
-
-      expect(refetch).toHaveBeenCalledOnce();
-    });
+  it('should render page title', () => {
+    render(<CodexLensManagerPage />);
+    // The title comes from i18n codexlens.title
+    expect(screen.getByRole('heading', { level: 1 })).toBeInTheDocument();
   });
 
-  describe('when not installed', () => {
-    beforeEach(() => {
-      (vi.mocked(useCodexLensDashboard) as any).mockReturnValue({
-        installed: false,
-        status: undefined,
-        config: undefined,
-        semantic: undefined,
-        isLoading: false,
-        isFetching: false,
-        error: null,
-        refetch: vi.fn(),
-      });
-      (vi.mocked(useCodexLensMutations) as any).mockReturnValue(mockMutations);
-    });
-
-    it('should show bootstrap button', () => {
-      render(<CodexLensManagerPage />);
-
-      expect(screen.getByText(/Bootstrap/i)).toBeInTheDocument();
-    });
-
-    it('should show not installed alert', () => {
-      render(<CodexLensManagerPage />);
-
-      expect(screen.getByText(/CodexLens is not installed/i)).toBeInTheDocument();
-    });
-
-    it('should call bootstrap on button click', async () => {
-      const bootstrap = vi.fn().mockResolvedValue({ success: true });
-      (vi.mocked(useCodexLensMutations) as any).mockReturnValue({
-        ...mockMutations,
-        bootstrap,
-      });
-
-      const user = userEvent.setup();
-      render(<CodexLensManagerPage />);
-
-      const bootstrapButton = screen.getByText(/Bootstrap/i);
-      await user.click(bootstrapButton);
-
-      await waitFor(() => {
-        expect(bootstrap).toHaveBeenCalledOnce();
-      });
-    });
+  it('should render index status section', () => {
+    render(<CodexLensManagerPage />);
+    // Check for file count display
+    expect(screen.getByText('150')).toBeInTheDocument();
   });
 
-  describe('uninstall flow', () => {
-    beforeEach(() => {
-      (vi.mocked(useCodexLensDashboard) as any).mockReturnValue({
-        installed: true,
-        status: mockDashboardData.status,
-        config: mockDashboardData.config,
-        semantic: mockDashboardData.semantic,
-        isLoading: false,
-        isFetching: false,
-        error: null,
-        refetch: vi.fn(),
-      });
-    });
-
-    it('should show confirmation dialog on uninstall', async () => {
-      const uninstall = vi.fn().mockResolvedValue({ success: true });
-      (vi.mocked(useCodexLensMutations) as any).mockReturnValue({
-        ...mockMutations,
-        uninstall,
-      });
-
-      const user = userEvent.setup();
-      render(<CodexLensManagerPage />);
-
-      const uninstallButton = screen.getByText(/Uninstall/i);
-      await user.click(uninstallButton);
-
-      expect(global.confirm).toHaveBeenCalledWith(expect.stringContaining('uninstall'));
-    });
-
-    it('should call uninstall when confirmed', async () => {
-      const uninstall = vi.fn().mockResolvedValue({ success: true });
-      (vi.mocked(useCodexLensMutations) as any).mockReturnValue({
-        ...mockMutations,
-        uninstall,
-      });
-
-      const user = userEvent.setup();
-      render(<CodexLensManagerPage />);
-
-      const uninstallButton = screen.getByText(/Uninstall/i);
-      await user.click(uninstallButton);
-
-      await waitFor(() => {
-        expect(uninstall).toHaveBeenCalledOnce();
-      });
-    });
-
-    it('should not call uninstall when cancelled', async () => {
-      (global.confirm as ReturnType<typeof vi.fn>).mockReturnValue(false);
-      const uninstall = vi.fn().mockResolvedValue({ success: true });
-      (vi.mocked(useCodexLensMutations) as any).mockReturnValue({
-        ...mockMutations,
-        uninstall,
-      });
-
-      const user = userEvent.setup();
-      render(<CodexLensManagerPage />);
-
-      const uninstallButton = screen.getByText(/Uninstall/i);
-      await user.click(uninstallButton);
-
-      expect(uninstall).not.toHaveBeenCalled();
-    });
+  it('should render search input', () => {
+    render(<CodexLensManagerPage />);
+    const input = screen.getByPlaceholderText(/search query/i);
+    expect(input).toBeInTheDocument();
   });
 
-  describe('loading states', () => {
-    it('should show loading skeleton when loading', () => {
-      (vi.mocked(useCodexLensDashboard) as any).mockReturnValue({
-        installed: false,
-        status: undefined,
-        config: undefined,
-        semantic: undefined,
-        isLoading: true,
-        isFetching: true,
-        error: null,
-        refetch: vi.fn(),
-      });
-      (vi.mocked(useCodexLensMutations) as any).mockReturnValue(mockMutations);
-
-      render(<CodexLensManagerPage />);
-
-      // Check for skeleton or loading indicator
-      const refreshButton = screen.getByText(/Refresh/i);
-      expect(refreshButton).toBeDisabled();
+  it('should call refetchStatus on refresh click', async () => {
+    const refetchStatus = vi.fn();
+    (vi.mocked(useV2SearchManager) as any).mockReturnValue({
+      ...defaultHookReturn,
+      refetchStatus,
     });
 
-    it('should disable refresh button when fetching', () => {
-      (vi.mocked(useCodexLensDashboard) as any).mockReturnValue({
-        installed: true,
-        status: mockDashboardData.status,
-        config: mockDashboardData.config,
-        semantic: mockDashboardData.semantic,
-        isLoading: false,
-        isFetching: true,
-        error: null,
-        refetch: vi.fn(),
-      });
-      (vi.mocked(useCodexLensMutations) as any).mockReturnValue(mockMutations);
+    const user = userEvent.setup();
+    render(<CodexLensManagerPage />);
 
-      render(<CodexLensManagerPage />);
+    const refreshButton = screen.getByText(/Refresh/i);
+    await user.click(refreshButton);
 
-      const refreshButton = screen.getByText(/Refresh/i);
-      expect(refreshButton).toBeDisabled();
+    expect(refetchStatus).toHaveBeenCalledOnce();
+  });
+
+  it('should call search when clicking search button', async () => {
+    const searchFn = vi.fn().mockResolvedValue({
+      query: 'test query',
+      results: [],
+      timingMs: 5,
+      totalResults: 0,
     });
+    (vi.mocked(useV2SearchManager) as any).mockReturnValue({
+      ...defaultHookReturn,
+      search: searchFn,
+    });
+
+    const user = userEvent.setup();
+    render(<CodexLensManagerPage />);
+
+    const input = screen.getByPlaceholderText(/search query/i);
+    await user.type(input, 'test query');
+
+    const searchButton = screen.getByText(/Search/i);
+    await user.click(searchButton);
+
+    expect(searchFn).toHaveBeenCalledWith('test query');
+  });
+
+  it('should display search results', () => {
+    (vi.mocked(useV2SearchManager) as any).mockReturnValue({
+      ...defaultHookReturn,
+      searchResult: {
+        query: 'auth',
+        results: [
+          { file: 'src/auth.ts', score: 0.95, snippet: 'export function authenticate()' },
+        ],
+        timingMs: 8.2,
+        totalResults: 1,
+      },
+    });
+
+    render(<CodexLensManagerPage />);
+
+    expect(screen.getByText('src/auth.ts')).toBeInTheDocument();
+    expect(screen.getByText('95.0%')).toBeInTheDocument();
+    expect(screen.getByText('export function authenticate()')).toBeInTheDocument();
+  });
+
+  it('should call reindex on button click', async () => {
+    const reindexFn = vi.fn().mockResolvedValue(undefined);
+    (vi.mocked(useV2SearchManager) as any).mockReturnValue({
+      ...defaultHookReturn,
+      reindex: reindexFn,
+    });
+
+    const user = userEvent.setup();
+    render(<CodexLensManagerPage />);
+
+    const reindexButton = screen.getByText(/Reindex/i);
+    await user.click(reindexButton);
+
+    expect(reindexFn).toHaveBeenCalledOnce();
+  });
+
+  it('should show loading skeleton when status is loading', () => {
+    (vi.mocked(useV2SearchManager) as any).mockReturnValue({
+      ...defaultHookReturn,
+      status: null,
+      isLoadingStatus: true,
+    });
+
+    render(<CodexLensManagerPage />);
+
+    // Should have pulse animation elements
+    const pulseElements = document.querySelectorAll('.animate-pulse');
+    expect(pulseElements.length).toBeGreaterThan(0);
+  });
+
+  it('should show error alert when status fetch fails', () => {
+    (vi.mocked(useV2SearchManager) as any).mockReturnValue({
+      ...defaultHookReturn,
+      status: null,
+      statusError: new Error('Network error'),
+    });
+
+    render(<CodexLensManagerPage />);
+
+    // Error message should be visible
+    expect(screen.getByText(/Failed to load/i)).toBeInTheDocument();
+  });
+
+  it('should show not indexed state', () => {
+    (vi.mocked(useV2SearchManager) as any).mockReturnValue({
+      ...defaultHookReturn,
+      status: {
+        ...mockStatus,
+        indexed: false,
+        totalFiles: 0,
+        totalChunks: 0,
+      },
+    });
+
+    render(<CodexLensManagerPage />);
+
+    expect(screen.getByText(/Not Indexed/i)).toBeInTheDocument();
   });
 
   describe('i18n - Chinese locale', () => {
-    beforeEach(() => {
-      (vi.mocked(useCodexLensDashboard) as any).mockReturnValue({
-        installed: true,
-        status: mockDashboardData.status,
-        config: mockDashboardData.config,
-        semantic: mockDashboardData.semantic,
-        isLoading: false,
-        isFetching: false,
-        error: null,
-        refetch: vi.fn(),
-      });
-      (vi.mocked(useCodexLensMutations) as any).mockReturnValue(mockMutations);
-    });
-
     it('should display translated text in Chinese', () => {
       render(<CodexLensManagerPage />, { locale: 'zh' });
 
-      expect(screen.getByText(/CodexLens/i)).toBeInTheDocument();
-      expect(screen.getByText(/语义代码搜索引擎/i)).toBeInTheDocument();
-      expect(screen.getByText(/概览/i)).toBeInTheDocument();
-      expect(screen.getByText(/设置/i)).toBeInTheDocument();
-      expect(screen.getByText(/模型/i)).toBeInTheDocument();
-      expect(screen.getByText(/高级/i)).toBeInTheDocument();
-    });
-
-    it('should display translated uninstall button', () => {
-      render(<CodexLensManagerPage />, { locale: 'zh' });
-
-      expect(screen.getByText(/卸载/i)).toBeInTheDocument();
-    });
-  });
-
-  describe('error states', () => {
-    it('should handle API errors gracefully', () => {
-      (vi.mocked(useCodexLensDashboard) as any).mockReturnValue({
-        installed: false,
-        status: undefined,
-        config: undefined,
-        semantic: undefined,
-        isLoading: false,
-        isFetching: false,
-        error: new Error('API Error'),
-        refetch: vi.fn(),
-      });
-      (vi.mocked(useCodexLensMutations) as any).mockReturnValue(mockMutations);
-
-      render(<CodexLensManagerPage />);
-
-      // Page should still render even with error
-      expect(screen.getByText(/CodexLens/i)).toBeInTheDocument();
+      // Page title from zh codexlens.json
+      expect(screen.getByRole('heading', { level: 1 })).toBeInTheDocument();
     });
   });
 });
diff --git a/ccw/frontend/src/pages/CodexLensManagerPage.tsx b/ccw/frontend/src/pages/CodexLensManagerPage.tsx
index 8d54193a..ce67d799 100644
--- a/ccw/frontend/src/pages/CodexLensManagerPage.tsx
+++ b/ccw/frontend/src/pages/CodexLensManagerPage.tsx
@@ -1,85 +1,67 @@
 // ========================================
-// CodexLens Manager Page
+// CodexLens Manager Page (v2)
 // ========================================
-// Manage CodexLens semantic code search with tabbed interface
-// Supports Overview, Settings, Models, and Advanced tabs
+// V2 search management interface with index status, search test, and configuration
 
 import { useState } from 'react';
 import { useIntl } from 'react-intl';
 import {
-  Sparkles,
+  Search,
   RefreshCw,
-  Download,
-  Trash2,
+  Database,
   Zap,
+  AlertCircle,
+  CheckCircle2,
+  Clock,
+  FileText,
+  HardDrive,
 } from 'lucide-react';
 import { Card } from '@/components/ui/Card';
 import { Button } from '@/components/ui/Button';
-import { TabsNavigation } from '@/components/ui/TabsNavigation';
-import {
-  AlertDialog,
-  AlertDialogTrigger,
-  AlertDialogContent,
-  AlertDialogHeader,
-  AlertDialogFooter,
-  AlertDialogTitle,
-  AlertDialogDescription,
-  AlertDialogAction,
-  AlertDialogCancel,
-} from '@/components/ui/AlertDialog';
-import { OverviewTab } from '@/components/codexlens/OverviewTab';
-import { SettingsTab } from '@/components/codexlens/SettingsTab';
-import { AdvancedTab } from '@/components/codexlens/AdvancedTab';
-import { ModelsTab } from '@/components/codexlens/ModelsTab';
-import { SearchTab } from '@/components/codexlens/SearchTab';
-import { SemanticInstallDialog } from '@/components/codexlens/SemanticInstallDialog';
-import { InstallProgressOverlay } from '@/components/codexlens/InstallProgressOverlay';
-import { useCodexLensDashboard, useCodexLensMutations } from '@/hooks';
+import { useV2SearchManager } from '@/hooks';
 import { cn } from '@/lib/utils';
 
+function formatBytes(bytes: number): string {
+  if (bytes === 0) return '0 B';
+  const units = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  return `${(bytes / Math.pow(1024, i)).toFixed(1)} ${units[i]}`;
+}
+
+function formatDate(dateStr: string | null): string {
+  if (!dateStr) return '-';
+  try {
+    return new Date(dateStr).toLocaleString();
+  } catch {
+    return dateStr;
+  }
+}
+
 export function CodexLensManagerPage() {
   const { formatMessage } = useIntl();
-  const [activeTab, setActiveTab] = useState('overview');
-  const [isUninstallDialogOpen, setIsUninstallDialogOpen] = useState(false);
-  const [isSemanticInstallOpen, setIsSemanticInstallOpen] = useState(false);
-  const [isInstallOverlayOpen, setIsInstallOverlayOpen] = useState(false);
+  const [searchQuery, setSearchQuery] = useState('');
 
   const {
-    installed,
     status,
-    config,
-    semantic,
-    isLoading,
-    isFetching,
-    refetch,
-  } = useCodexLensDashboard();
+    isLoadingStatus,
+    statusError,
+    refetchStatus,
+    search,
+    isSearching,
+    searchResult,
+    reindex,
+    isReindexing,
+  } = useV2SearchManager();
 
-  const {
-    bootstrap,
-    isBootstrapping,
-    uninstall,
-    isUninstalling,
-  } = useCodexLensMutations();
-
-  const handleRefresh = () => {
-    refetch();
+  const handleSearch = async () => {
+    if (!searchQuery.trim()) return;
+    await search(searchQuery.trim());
   };
 
-  const handleBootstrap = () => {
-    setIsInstallOverlayOpen(true);
-  };
-
-  const handleBootstrapInstall = async () => {
-    const result = await bootstrap();
-    return result;
-  };
-
-  const handleUninstall = async () => {
-    const result = await uninstall();
-    if (result.success) {
-      refetch();
+  const handleKeyDown = (e: React.KeyboardEvent) => {
+    if (e.key === 'Enter') {
+      handleSearch();
     }
-    setIsUninstallDialogOpen(false);
   };
 
   return (
@@ -88,7 +70,7 @@ export function CodexLensManagerPage() {
       <div className="flex flex-col sm:flex-row sm:items-center sm:justify-between gap-4">
         <div>
           <h1 className="text-2xl font-bold text-foreground flex items-center gap-2">
-            <Sparkles className="w-6 h-6 text-primary" />
+            <Search className="w-6 h-6 text-primary" />
             {formatMessage({ id: 'codexlens.title' })}
           </h1>
           <p className="text-muted-foreground mt-1">
@@ -98,150 +80,196 @@ export function CodexLensManagerPage() {
         <div className="flex gap-2">
           <Button
             variant="outline"
-            onClick={handleRefresh}
-            disabled={isFetching}
+            onClick={refetchStatus}
+            disabled={isLoadingStatus}
           >
-            <RefreshCw className={cn('w-4 h-4 mr-2', isFetching && 'animate-spin')} />
+            <RefreshCw className={cn('w-4 h-4 mr-2', isLoadingStatus && 'animate-spin')} />
             {formatMessage({ id: 'common.actions.refresh' })}
           </Button>
-          {!installed ? (
-            <Button
-              onClick={handleBootstrap}
-              disabled={isBootstrapping}
-            >
-              <Download className={cn('w-4 h-4 mr-2', isBootstrapping && 'animate-spin')} />
-              {isBootstrapping
-                ? formatMessage({ id: 'codexlens.bootstrapping' })
-                : formatMessage({ id: 'codexlens.bootstrap' })
-              }
-            </Button>
-          ) : (
-            <>
-              <Button
-                variant="outline"
-                onClick={() => setIsSemanticInstallOpen(true)}
-                disabled={!semantic?.available}
-              >
-                <Zap className="w-4 h-4 mr-2" />
-                {formatMessage({ id: 'codexlens.semantic.install' })}
-              </Button>
-              <AlertDialog open={isUninstallDialogOpen} onOpenChange={setIsUninstallDialogOpen}>
-                <AlertDialogTrigger asChild>
-                  <Button
-                    variant="destructive"
-                    disabled={isUninstalling}
-                  >
-                    <Trash2 className={cn('w-4 h-4 mr-2', isUninstalling && 'animate-spin')} />
-                    {isUninstalling
-                      ? formatMessage({ id: 'codexlens.uninstalling' })
-                      : formatMessage({ id: 'codexlens.uninstall' })
-                    }
-                  </Button>
-                </AlertDialogTrigger>
-                <AlertDialogContent>
-                  <AlertDialogHeader>
-                    <AlertDialogTitle>
-                      {formatMessage({ id: 'codexlens.confirmUninstallTitle' })}
-                    </AlertDialogTitle>
-                    <AlertDialogDescription>
-                      {formatMessage({ id: 'codexlens.confirmUninstall' })}
-                    </AlertDialogDescription>
-                  </AlertDialogHeader>
-                  <AlertDialogFooter>
-                    <AlertDialogCancel disabled={isUninstalling}>
-                      {formatMessage({ id: 'common.actions.cancel' })}
-                    </AlertDialogCancel>
-                    <AlertDialogAction
-                      onClick={handleUninstall}
-                      disabled={isUninstalling}
-                      className="bg-destructive text-destructive-foreground hover:bg-destructive/90"
-                    >
-                      {isUninstalling
-                        ? formatMessage({ id: 'codexlens.uninstalling' })
-                        : formatMessage({ id: 'common.actions.confirm' })
-                      }
-                    </AlertDialogAction>
-                  </AlertDialogFooter>
-                </AlertDialogContent>
-              </AlertDialog>
-            </>
-          )}
+          <Button
+            onClick={() => reindex()}
+            disabled={isReindexing}
+          >
+            <Zap className={cn('w-4 h-4 mr-2', isReindexing && 'animate-spin')} />
+            {isReindexing
+              ? formatMessage({ id: 'codexlens.reindexing' })
+              : formatMessage({ id: 'codexlens.reindex' })
+            }
+          </Button>
         </div>
       </div>
 
-      {/* Installation Status Alert */}
-      {!installed && !isLoading && (
-        <Card className="p-4 bg-warning/10 border-warning/20">
-          <p className="text-sm text-warning-foreground">
-            {formatMessage({ id: 'codexlens.notInstalled' })}
-          </p>
+      {/* Error Alert */}
+      {statusError && (
+        <Card className="p-4 bg-destructive/10 border-destructive/20">
+          <div className="flex items-center gap-2">
+            <AlertCircle className="w-4 h-4 text-destructive" />
+            <p className="text-sm text-destructive">
+              {formatMessage({ id: 'codexlens.statusError' })}
+            </p>
+          </div>
         </Card>
       )}
 
-      {/* Tabbed Interface */}
-      <TabsNavigation
-        value={activeTab}
-        onValueChange={setActiveTab}
-        tabs={[
-          { value: 'overview', label: formatMessage({ id: 'codexlens.tabs.overview' }) },
-          { value: 'settings', label: formatMessage({ id: 'codexlens.tabs.settings' }) },
-          { value: 'models', label: formatMessage({ id: 'codexlens.tabs.models' }) },
-          { value: 'search', label: formatMessage({ id: 'codexlens.tabs.search' }) },
-          { value: 'advanced', label: formatMessage({ id: 'codexlens.tabs.advanced' }) },
-        ]}
-      />
+      {/* Index Status Section */}
+      <Card className="p-6">
+        <h2 className="text-lg font-semibold mb-4 flex items-center gap-2">
+          <Database className="w-5 h-5 text-primary" />
+          {formatMessage({ id: 'codexlens.indexStatus.title' })}
+        </h2>
 
-      {/* Tab Content */}
-      {activeTab === 'overview' && (
-        <div className="mt-4">
-          <OverviewTab
-            installed={installed}
-            status={status}
-            config={config}
-            isLoading={isLoading}
-            onRefresh={handleRefresh}
+        {isLoadingStatus ? (
+          <div className="grid grid-cols-2 md:grid-cols-4 gap-4">
+            {[1, 2, 3, 4].map((i) => (
+              <div key={i} className="h-16 bg-muted/50 rounded-lg animate-pulse" />
+            ))}
+          </div>
+        ) : status ? (
+          <div className="grid grid-cols-2 md:grid-cols-4 gap-4">
+            <div className="flex items-start gap-3 p-3 rounded-lg bg-muted/30">
+              {status.indexed ? (
+                <CheckCircle2 className="w-5 h-5 text-green-500 mt-0.5" />
+              ) : (
+                <AlertCircle className="w-5 h-5 text-yellow-500 mt-0.5" />
+              )}
+              <div>
+                <p className="text-xs text-muted-foreground">
+                  {formatMessage({ id: 'codexlens.indexStatus.status' })}
+                </p>
+                <p className="text-sm font-medium">
+                  {status.indexed
+                    ? formatMessage({ id: 'codexlens.indexStatus.ready' })
+                    : formatMessage({ id: 'codexlens.indexStatus.notIndexed' })
+                  }
+                </p>
+              </div>
+            </div>
+
+            <div className="flex items-start gap-3 p-3 rounded-lg bg-muted/30">
+              <FileText className="w-5 h-5 text-blue-500 mt-0.5" />
+              <div>
+                <p className="text-xs text-muted-foreground">
+                  {formatMessage({ id: 'codexlens.indexStatus.files' })}
+                </p>
+                <p className="text-sm font-medium">{status.totalFiles.toLocaleString()}</p>
+              </div>
+            </div>
+
+            <div className="flex items-start gap-3 p-3 rounded-lg bg-muted/30">
+              <HardDrive className="w-5 h-5 text-purple-500 mt-0.5" />
+              <div>
+                <p className="text-xs text-muted-foreground">
+                  {formatMessage({ id: 'codexlens.indexStatus.dbSize' })}
+                </p>
+                <p className="text-sm font-medium">{formatBytes(status.dbSizeBytes)}</p>
+              </div>
+            </div>
+
+            <div className="flex items-start gap-3 p-3 rounded-lg bg-muted/30">
+              <Clock className="w-5 h-5 text-orange-500 mt-0.5" />
+              <div>
+                <p className="text-xs text-muted-foreground">
+                  {formatMessage({ id: 'codexlens.indexStatus.lastIndexed' })}
+                </p>
+                <p className="text-sm font-medium">{formatDate(status.lastIndexedAt)}</p>
+              </div>
+            </div>
+          </div>
+        ) : (
+          <p className="text-sm text-muted-foreground">
+            {formatMessage({ id: 'codexlens.indexStatus.unavailable' })}
+          </p>
+        )}
+
+        {status && (
+          <div className="mt-4 flex gap-4 text-xs text-muted-foreground">
+            <span>
+              {formatMessage({ id: 'codexlens.indexStatus.chunks' })}: {status.totalChunks.toLocaleString()}
+            </span>
+            {status.vectorDimension && (
+              <span>
+                {formatMessage({ id: 'codexlens.indexStatus.vectorDim' })}: {status.vectorDimension}
+              </span>
+            )}
+            <span>
+              FTS: {status.ftsEnabled
+                ? formatMessage({ id: 'codexlens.indexStatus.enabled' })
+                : formatMessage({ id: 'codexlens.indexStatus.disabled' })
+              }
+            </span>
+          </div>
+        )}
+      </Card>
+
+      {/* Search Test Section */}
+      <Card className="p-6">
+        <h2 className="text-lg font-semibold mb-4 flex items-center gap-2">
+          <Search className="w-5 h-5 text-primary" />
+          {formatMessage({ id: 'codexlens.searchTest.title' })}
+        </h2>
+
+        <div className="flex gap-2 mb-4">
+          <input
+            type="text"
+            value={searchQuery}
+            onChange={(e) => setSearchQuery(e.target.value)}
+            onKeyDown={handleKeyDown}
+            placeholder={formatMessage({ id: 'codexlens.searchTest.placeholder' })}
+            className="flex-1 px-3 py-2 border border-input rounded-md bg-background text-sm focus:outline-none focus:ring-2 focus:ring-ring"
           />
+          <Button
+            onClick={handleSearch}
+            disabled={isSearching || !searchQuery.trim()}
+          >
+            {isSearching ? (
+              <RefreshCw className="w-4 h-4 mr-2 animate-spin" />
+            ) : (
+              <Search className="w-4 h-4 mr-2" />
+            )}
+            {formatMessage({ id: 'codexlens.searchTest.button' })}
+          </Button>
         </div>
-      )}
 
-      {activeTab === 'settings' && (
-        <div className="mt-4">
-          <SettingsTab enabled={installed} />
-        </div>
-      )}
+        {searchResult && (
+          <div>
+            <div className="flex items-center justify-between mb-2">
+              <p className="text-sm text-muted-foreground">
+                {searchResult.totalResults} {formatMessage({ id: 'codexlens.searchTest.results' })}
+              </p>
+              <p className="text-xs text-muted-foreground">
+                {searchResult.timingMs.toFixed(1)}ms
+              </p>
+            </div>
 
-      {activeTab === 'models' && (
-        <div className="mt-4">
-          <ModelsTab installed={installed} />
-        </div>
-      )}
-
-      {activeTab === 'search' && (
-        <div className="mt-4">
-          <SearchTab enabled={installed} />
-        </div>
-      )}
-
-      {activeTab === 'advanced' && (
-        <div className="mt-4">
-          <AdvancedTab enabled={installed} />
-        </div>
-      )}
-
-      {/* Semantic Install Dialog */}
-      <SemanticInstallDialog
-        open={isSemanticInstallOpen}
-        onOpenChange={setIsSemanticInstallOpen}
-        onSuccess={() => refetch()}
-      />
-
-      {/* Install Progress Overlay */}
-      <InstallProgressOverlay
-        open={isInstallOverlayOpen}
-        onOpenChange={setIsInstallOverlayOpen}
-        onInstall={handleBootstrapInstall}
-        onSuccess={() => refetch()}
-      />
+            {searchResult.results.length > 0 ? (
+              <div className="space-y-2 max-h-96 overflow-y-auto">
+                {searchResult.results.map((result, idx) => (
+                  <div
+                    key={idx}
+                    className="p-3 rounded-lg border border-border bg-muted/20 hover:bg-muted/40 transition-colors"
+                  >
+                    <div className="flex items-center justify-between mb-1">
+                      <span className="text-sm font-mono text-primary truncate">
+                        {result.file}
+                      </span>
+                      <span className="text-xs text-muted-foreground ml-2 shrink-0">
+                        {(result.score * 100).toFixed(1)}%
+                      </span>
+                    </div>
+                    <pre className="text-xs text-muted-foreground whitespace-pre-wrap line-clamp-3">
+                      {result.snippet}
+                    </pre>
+                  </div>
+                ))}
+              </div>
+            ) : (
+              <p className="text-sm text-muted-foreground text-center py-4">
+                {formatMessage({ id: 'codexlens.searchTest.noResults' })}
+              </p>
+            )}
+          </div>
+        )}
+      </Card>
     </div>
   );
 }
diff --git a/ccw/frontend/src/test/i18n.tsx b/ccw/frontend/src/test/i18n.tsx
index e48ade88..9ff9b018 100644
--- a/ccw/frontend/src/test/i18n.tsx
+++ b/ccw/frontend/src/test/i18n.tsx
@@ -118,173 +118,29 @@ const mockMessages: Record<Locale, Record<string, string>> = {
     'issues.discovery.status.failed': 'Failed',
     'issues.discovery.progress': 'Progress',
     'issues.discovery.findings': 'Findings',
-    // CodexLens
-    'codexlens.title': 'CodexLens',
-    'codexlens.description': 'Semantic code search engine',
-    'codexlens.bootstrap': 'Bootstrap',
-    'codexlens.bootstrapping': 'Bootstrapping...',
-    'codexlens.uninstall': 'Uninstall',
-    'codexlens.uninstalling': 'Uninstalling...',
-    'codexlens.confirmUninstall': 'Are you sure you want to uninstall CodexLens?',
-    'codexlens.notInstalled': 'CodexLens is not installed',
-    'codexlens.comingSoon': 'Coming Soon',
-    'codexlens.tabs.overview': 'Overview',
-    'codexlens.tabs.settings': 'Settings',
-    'codexlens.tabs.models': 'Models',
-    'codexlens.tabs.advanced': 'Advanced',
-    'codexlens.overview.status.installation': 'Installation Status',
-    'codexlens.overview.status.ready': 'Ready',
-    'codexlens.overview.status.notReady': 'Not Ready',
-    'codexlens.overview.status.version': 'Version',
-    'codexlens.overview.status.indexPath': 'Index Path',
-    'codexlens.overview.status.indexCount': 'Index Count',
-    'codexlens.overview.notInstalled.title': 'CodexLens Not Installed',
-    'codexlens.overview.notInstalled.message': 'Please install CodexLens to use semantic code search features.',
-    'codexlens.overview.actions.title': 'Quick Actions',
-    'codexlens.overview.actions.ftsFull': 'FTS Full',
-    'codexlens.overview.actions.ftsFullDesc': 'Rebuild full-text index',
-    'codexlens.overview.actions.ftsIncremental': 'FTS Incremental',
-    'codexlens.overview.actions.ftsIncrementalDesc': 'Incremental update full-text index',
-    'codexlens.overview.actions.vectorFull': 'Vector Full',
-    'codexlens.overview.actions.vectorFullDesc': 'Rebuild vector index',
-    'codexlens.overview.actions.vectorIncremental': 'Vector Incremental',
-    'codexlens.overview.actions.vectorIncrementalDesc': 'Incremental update vector index',
-    'codexlens.overview.venv.title': 'Python Virtual Environment Details',
-    'codexlens.overview.venv.pythonVersion': 'Python Version',
-    'codexlens.overview.venv.venvPath': 'Virtual Environment Path',
-    'codexlens.overview.venv.lastCheck': 'Last Check Time',
-    'codexlens.install.title': 'Install CodexLens',
-    // Env Groups & Fields
-    'codexlens.envGroup.embedding': 'Embedding',
-    'codexlens.envGroup.reranker': 'Reranker',
-    'codexlens.envGroup.concurrency': 'Concurrency',
-    'codexlens.envGroup.cascade': 'Cascade Search',
-    'codexlens.envGroup.indexing': 'Indexing',
-    'codexlens.envGroup.chunking': 'Chunking',
-    'codexlens.envField.backend': 'Backend',
-    'codexlens.envField.model': 'Model',
-    'codexlens.envField.useGpu': 'Use GPU',
-    'codexlens.envField.highAvailability': 'High Availability',
-    'codexlens.envField.loadBalanceStrategy': 'Load Balance Strategy',
-    'codexlens.envField.rateLimitCooldown': 'Rate Limit Cooldown',
-    'codexlens.envField.enabled': 'Enabled',
-    'codexlens.envField.topKResults': 'Top K Results',
-    'codexlens.envField.maxWorkers': 'Max Workers',
-    'codexlens.envField.batchSize': 'Batch Size',
-    'codexlens.envField.dynamicBatchSize': 'Dynamic Batch Size',
-    'codexlens.envField.batchSizeUtilization': 'Utilization Factor',
-    'codexlens.envField.batchSizeMax': 'Max Batch Size',
-    'codexlens.envField.charsPerToken': 'Chars Per Token',
-    'codexlens.envField.searchStrategy': 'Search Strategy',
-    'codexlens.envField.coarseK': 'Coarse K',
-    'codexlens.envField.fineK': 'Fine K',
-    'codexlens.envField.stagedStage2Mode': 'Stage-2 Mode',
-    'codexlens.envField.stagedClusteringStrategy': 'Clustering Strategy',
-    'codexlens.envField.stagedClusteringMinSize': 'Cluster Min Size',
-    'codexlens.envField.enableStagedRerank': 'Enable Rerank',
-    'codexlens.envField.useAstGrep': 'Use ast-grep',
-    'codexlens.envField.staticGraphEnabled': 'Static Graph',
-    'codexlens.envField.staticGraphRelationshipTypes': 'Relationship Types',
-    'codexlens.envField.stripComments': 'Strip Comments',
-    'codexlens.envField.stripDocstrings': 'Strip Docstrings',
-    'codexlens.envField.testFilePenalty': 'Test File Penalty',
-    'codexlens.envField.docstringWeight': 'Docstring Weight',
-    'codexlens.install.description': 'Set up Python virtual environment and install CodexLens package.',
-    'codexlens.install.checklist': 'What will be installed',
-    'codexlens.install.pythonVenv': 'Python Virtual Environment',
-    'codexlens.install.pythonVenvDesc': 'Isolated Python environment for CodexLens',
-    'codexlens.install.codexlensPackage': 'CodexLens Package',
-    'codexlens.install.codexlensPackageDesc': 'Core semantic code search engine',
-    'codexlens.install.sqliteFts': 'SQLite FTS5',
-    'codexlens.install.sqliteFtsDesc': 'Full-text search extension for fast code lookup',
-    'codexlens.install.location': 'Install Location',
-    'codexlens.install.locationPath': '~/.codexlens/venv',
-    'codexlens.install.timeEstimate': 'Installation may take 1-3 minutes depending on network speed.',
-    'codexlens.install.stage.creatingVenv': 'Creating Python virtual environment...',
-    'codexlens.install.stage.installingPip': 'Installing pip dependencies...',
-    'codexlens.install.stage.installingPackage': 'Installing CodexLens package...',
-    'codexlens.install.stage.settingUpDeps': 'Setting up dependencies...',
-    'codexlens.install.stage.finalizing': 'Finalizing installation...',
-    'codexlens.install.stage.complete': 'Installation complete!',
-    'codexlens.install.installNow': 'Install Now',
-    'codexlens.install.installing': 'Installing...',
-    'codexlens.watcher.title': 'File Watcher',
-    'codexlens.watcher.status.running': 'Running',
-    'codexlens.watcher.status.stopped': 'Stopped',
-    'codexlens.watcher.eventsProcessed': 'Events Processed',
-    'codexlens.watcher.uptime': 'Uptime',
-    'codexlens.watcher.start': 'Start Watcher',
-    'codexlens.watcher.starting': 'Starting...',
-    'codexlens.watcher.stop': 'Stop Watcher',
-    'codexlens.watcher.stopping': 'Stopping...',
-    'codexlens.watcher.started': 'File watcher started',
-    'codexlens.watcher.stopped': 'File watcher stopped',
-    'codexlens.settings.currentCount': 'Current Index Count',
-    'codexlens.settings.currentWorkers': 'Current Workers',
-    'codexlens.settings.currentBatchSize': 'Current Batch Size',
-    'codexlens.settings.configTitle': 'Basic Configuration',
-    'codexlens.settings.indexDir.label': 'Index Directory',
-    'codexlens.settings.indexDir.placeholder': '~/.codexlens/indexes',
-    'codexlens.settings.indexDir.hint': 'Directory path for storing code indexes',
-    'codexlens.settings.maxWorkers.label': 'Max Workers',
-    'codexlens.settings.maxWorkers.hint': 'API concurrent processing threads (1-32)',
-    'codexlens.settings.batchSize.label': 'Batch Size',
-    'codexlens.settings.batchSize.hint': 'Number of files processed per batch (1-64)',
-    'codexlens.settings.validation.indexDirRequired': 'Index directory is required',
-    'codexlens.settings.validation.maxWorkersRange': 'Workers must be between 1 and 32',
-    'codexlens.settings.validation.batchSizeRange': 'Batch size must be between 1 and 64',
-    'codexlens.settings.save': 'Save',
-    'codexlens.settings.saving': 'Saving...',
-    'codexlens.settings.reset': 'Reset',
-    'codexlens.settings.saveSuccess': 'Configuration saved',
-    'codexlens.settings.saveFailed': 'Save failed',
-    'codexlens.settings.configUpdated': 'Configuration updated successfully',
-    'codexlens.settings.saveError': 'Error saving configuration',
-    'codexlens.settings.unknownError': 'An unknown error occurred',
-    'codexlens.models.title': 'Model Management',
-    'codexlens.models.searchPlaceholder': 'Search models...',
-    'codexlens.models.downloading': 'Downloading...',
-    'codexlens.models.status.downloaded': 'Downloaded',
-    'codexlens.models.status.available': 'Available',
-    'codexlens.models.types.embedding': 'Embedding Models',
-    'codexlens.models.types.reranker': 'Reranker Models',
-    'codexlens.models.filters.label': 'Filter',
-    'codexlens.models.filters.all': 'All',
-    'codexlens.models.actions.download': 'Download',
-    'codexlens.models.actions.delete': 'Delete',
-    'codexlens.models.actions.cancel': 'Cancel',
-    'codexlens.models.custom.title': 'Custom Model',
-    'codexlens.models.custom.placeholder': 'HuggingFace model name (e.g., BAAI/bge-small-zh-v1.5)',
-    'codexlens.models.custom.description': 'Download custom models from HuggingFace. Ensure the model name is correct.',
-    'codexlens.models.deleteConfirm': 'Are you sure you want to delete model {modelName}?',
-    'codexlens.models.notInstalled.title': 'CodexLens Not Installed',
-    'codexlens.models.notInstalled.description': 'Please install CodexLens to use model management features.',
-    'codexlens.models.empty.title': 'No models found',
-    'codexlens.models.empty.description': 'Try adjusting your search or filter criteria',
-    // Reranker
-    'codexlens.reranker.title': 'Reranker Configuration',
-    'codexlens.reranker.description': 'Configure the reranker backend, model, and provider for search result ranking.',
-    'codexlens.reranker.backend': 'Backend',
-    'codexlens.reranker.backendHint': 'Inference backend for reranking',
-    'codexlens.reranker.model': 'Model',
-    'codexlens.reranker.modelHint': 'Reranker model name or LiteLLM endpoint',
-    'codexlens.reranker.provider': 'API Provider',
-    'codexlens.reranker.providerHint': 'API provider for reranker service',
-    'codexlens.reranker.apiKeyStatus': 'API Key',
-    'codexlens.reranker.apiKeySet': 'Configured',
-    'codexlens.reranker.apiKeyNotSet': 'Not configured',
-    'codexlens.reranker.configSource': 'Config Source',
-    'codexlens.reranker.save': 'Save Reranker Config',
-    'codexlens.reranker.saving': 'Saving...',
-    'codexlens.reranker.saveSuccess': 'Reranker configuration saved',
-    'codexlens.reranker.saveFailed': 'Failed to save reranker configuration',
-    'codexlens.reranker.noBackends': 'No backends available',
-    'codexlens.reranker.noModels': 'No models available',
-    'codexlens.reranker.noProviders': 'No providers available',
-    'codexlens.reranker.litellmModels': 'LiteLLM Models',
-    'codexlens.reranker.selectBackend': 'Select backend...',
-    'codexlens.reranker.selectModel': 'Select model...',
-    'codexlens.reranker.selectProvider': 'Select provider...',
+    // CodexLens (v2)
+    'codexlens.title': 'Search Manager',
+    'codexlens.description': 'V2 semantic search index management',
+    'codexlens.reindex': 'Reindex',
+    'codexlens.reindexing': 'Reindexing...',
+    'codexlens.statusError': 'Failed to load search index status',
+    'codexlens.indexStatus.title': 'Index Status',
+    'codexlens.indexStatus.status': 'Status',
+    'codexlens.indexStatus.ready': 'Ready',
+    'codexlens.indexStatus.notIndexed': 'Not Indexed',
+    'codexlens.indexStatus.files': 'Files',
+    'codexlens.indexStatus.dbSize': 'DB Size',
+    'codexlens.indexStatus.lastIndexed': 'Last Indexed',
+    'codexlens.indexStatus.chunks': 'Chunks',
+    'codexlens.indexStatus.vectorDim': 'Vector Dim',
+    'codexlens.indexStatus.enabled': 'Enabled',
+    'codexlens.indexStatus.disabled': 'Disabled',
+    'codexlens.indexStatus.unavailable': 'Index status unavailable',
+    'codexlens.searchTest.title': 'Search Test',
+    'codexlens.searchTest.placeholder': 'Enter search query...',
+    'codexlens.searchTest.button': 'Search',
+    'codexlens.searchTest.results': 'results',
+    'codexlens.searchTest.noResults': 'No results found',
     // MCP - CCW Tools
     'mcp.ccw.title': 'CCW MCP Server',
     'mcp.ccw.description': 'Configure CCW MCP tools and paths',
@@ -438,173 +294,29 @@ const mockMessages: Record<Locale, Record<string, string>> = {
     'issues.discovery.status.failed': '失败',
     'issues.discovery.progress': '进度',
     'issues.discovery.findings': '发现',
-    // CodexLens
-    'codexlens.title': 'CodexLens',
-    'codexlens.description': '语义代码搜索引擎',
-    'codexlens.bootstrap': '引导安装',
-    'codexlens.bootstrapping': '安装中...',
-    'codexlens.uninstall': '卸载',
-    'codexlens.uninstalling': '卸载中...',
-    'codexlens.confirmUninstall': '确定要卸载 CodexLens 吗？',
-    'codexlens.notInstalled': 'CodexLens 尚未安装',
-    'codexlens.comingSoon': '即将推出',
-    'codexlens.tabs.overview': '概览',
-    'codexlens.tabs.settings': '设置',
-    'codexlens.tabs.models': '模型',
-    'codexlens.tabs.advanced': '高级',
-    'codexlens.overview.status.installation': '安装状态',
-    'codexlens.overview.status.ready': '就绪',
-    'codexlens.overview.status.notReady': '未就绪',
-    'codexlens.overview.status.version': '版本',
-    'codexlens.overview.status.indexPath': '索引路径',
-    'codexlens.overview.status.indexCount': '索引数量',
-    'codexlens.overview.notInstalled.title': 'CodexLens 未安装',
-    'codexlens.overview.notInstalled.message': '请先安装 CodexLens 以使用语义代码搜索功能。',
-    'codexlens.overview.actions.title': '快速操作',
-    'codexlens.overview.actions.ftsFull': 'FTS 全量',
-    'codexlens.overview.actions.ftsFullDesc': '重建全文索引',
-    'codexlens.overview.actions.ftsIncremental': 'FTS 增量',
-    'codexlens.overview.actions.ftsIncrementalDesc': '增量更新全文索引',
-    'codexlens.overview.actions.vectorFull': '向量全量',
-    'codexlens.overview.actions.vectorFullDesc': '重建向量索引',
-    'codexlens.overview.actions.vectorIncremental': '向量增量',
-    'codexlens.overview.actions.vectorIncrementalDesc': '增量更新向量索引',
-    'codexlens.overview.venv.title': 'Python 虚拟环境详情',
-    'codexlens.overview.venv.pythonVersion': 'Python 版本',
-    'codexlens.overview.venv.venvPath': '虚拟环境路径',
-    'codexlens.overview.venv.lastCheck': '最后检查时间',
-    'codexlens.install.title': '安装 CodexLens',
-    // Env Groups & Fields
-    'codexlens.envGroup.embedding': '嵌入模型',
-    'codexlens.envGroup.reranker': '重排序',
-    'codexlens.envGroup.concurrency': '并发',
-    'codexlens.envGroup.cascade': '级联搜索',
-    'codexlens.envGroup.indexing': '索引与解析',
-    'codexlens.envGroup.chunking': '分块',
-    'codexlens.envField.backend': '后端',
-    'codexlens.envField.model': '模型',
-    'codexlens.envField.useGpu': '使用 GPU',
-    'codexlens.envField.highAvailability': '高可用',
-    'codexlens.envField.loadBalanceStrategy': '负载均衡策略',
-    'codexlens.envField.rateLimitCooldown': '限流冷却时间',
-    'codexlens.envField.enabled': '启用',
-    'codexlens.envField.topKResults': 'Top K 结果数',
-    'codexlens.envField.maxWorkers': '最大工作线程',
-    'codexlens.envField.batchSize': '批次大小',
-    'codexlens.envField.dynamicBatchSize': '动态批次大小',
-    'codexlens.envField.batchSizeUtilization': '利用率因子',
-    'codexlens.envField.batchSizeMax': '最大批次大小',
-    'codexlens.envField.charsPerToken': '每 Token 字符数',
-    'codexlens.envField.searchStrategy': '搜索策略',
-    'codexlens.envField.coarseK': '粗筛 K 值',
-    'codexlens.envField.fineK': '精筛 K 值',
-    'codexlens.envField.stagedStage2Mode': 'Stage-2 模式',
-    'codexlens.envField.stagedClusteringStrategy': '聚类策略',
-    'codexlens.envField.stagedClusteringMinSize': '最小聚类大小',
-    'codexlens.envField.enableStagedRerank': '启用重排序',
-    'codexlens.envField.useAstGrep': '使用 ast-grep',
-    'codexlens.envField.staticGraphEnabled': '启用静态图',
-    'codexlens.envField.staticGraphRelationshipTypes': '关系类型',
-    'codexlens.envField.stripComments': '去除注释',
-    'codexlens.envField.stripDocstrings': '去除文档字符串',
-    'codexlens.envField.testFilePenalty': '测试文件惩罚',
-    'codexlens.envField.docstringWeight': '文档字符串权重',
-    'codexlens.install.description': '设置 Python 虚拟环境并安装 CodexLens 包。',
-    'codexlens.install.checklist': '将要安装的内容',
-    'codexlens.install.pythonVenv': 'Python 虚拟环境',
-    'codexlens.install.pythonVenvDesc': 'CodexLens 的隔离 Python 环境',
-    'codexlens.install.codexlensPackage': 'CodexLens 包',
-    'codexlens.install.codexlensPackageDesc': '核心语义代码搜索引擎',
-    'codexlens.install.sqliteFts': 'SQLite FTS5',
-    'codexlens.install.sqliteFtsDesc': '用于快速代码查找的全文搜索扩展',
-    'codexlens.install.location': '安装位置',
-    'codexlens.install.locationPath': '~/.codexlens/venv',
-    'codexlens.install.timeEstimate': '安装可能需要 1-3 分钟，取决于网络速度。',
-    'codexlens.install.stage.creatingVenv': '正在创建 Python 虚拟环境...',
-    'codexlens.install.stage.installingPip': '正在安装 pip 依赖...',
-    'codexlens.install.stage.installingPackage': '正在安装 CodexLens 包...',
-    'codexlens.install.stage.settingUpDeps': '正在设置依赖项...',
-    'codexlens.install.stage.finalizing': '正在完成安装...',
-    'codexlens.install.stage.complete': '安装完成！',
-    'codexlens.install.installNow': '立即安装',
-    'codexlens.install.installing': '安装中...',
-    'codexlens.watcher.title': '文件监听器',
-    'codexlens.watcher.status.running': '运行中',
-    'codexlens.watcher.status.stopped': '已停止',
-    'codexlens.watcher.eventsProcessed': '已处理事件',
-    'codexlens.watcher.uptime': '运行时间',
-    'codexlens.watcher.start': '启动监听',
-    'codexlens.watcher.starting': '启动中...',
-    'codexlens.watcher.stop': '停止监听',
-    'codexlens.watcher.stopping': '停止中...',
-    'codexlens.watcher.started': '文件监听器已启动',
-    'codexlens.watcher.stopped': '文件监听器已停止',
-    'codexlens.settings.currentCount': '当前索引数量',
-    'codexlens.settings.currentWorkers': '当前工作线程',
-    'codexlens.settings.currentBatchSize': '当前批次大小',
-    'codexlens.settings.configTitle': '基本配置',
-    'codexlens.settings.indexDir.label': '索引目录',
-    'codexlens.settings.indexDir.placeholder': '~/.codexlens/indexes',
-    'codexlens.settings.indexDir.hint': '存储代码索引的目录路径',
-    'codexlens.settings.maxWorkers.label': '最大工作线程',
-    'codexlens.settings.maxWorkers.hint': 'API 并发处理线程数 (1-32)',
-    'codexlens.settings.batchSize.label': '批次大小',
-    'codexlens.settings.batchSize.hint': '每次批量处理的文件数量 (1-64)',
-    'codexlens.settings.validation.indexDirRequired': '索引目录不能为空',
-    'codexlens.settings.validation.maxWorkersRange': '工作线程数必须在 1-32 之间',
-    'codexlens.settings.validation.batchSizeRange': '批次大小必须在 1-64 之间',
-    'codexlens.settings.save': '保存',
-    'codexlens.settings.saving': '保存中...',
-    'codexlens.settings.reset': '重置',
-    'codexlens.settings.saveSuccess': '配置已保存',
-    'codexlens.settings.saveFailed': '保存失败',
-    'codexlens.settings.configUpdated': '配置更新成功',
-    'codexlens.settings.saveError': '保存配置时出错',
-    'codexlens.settings.unknownError': '发生未知错误',
-    'codexlens.models.title': '模型管理',
-    'codexlens.models.searchPlaceholder': '搜索模型...',
-    'codexlens.models.downloading': '下载中...',
-    'codexlens.models.status.downloaded': '已下载',
-    'codexlens.models.status.available': '可用',
-    'codexlens.models.types.embedding': '嵌入模型',
-    'codexlens.models.types.reranker': '重排序模型',
-    'codexlens.models.filters.label': '筛选',
-    'codexlens.models.filters.all': '全部',
-    'codexlens.models.actions.download': '下载',
-    'codexlens.models.actions.delete': '删除',
-    'codexlens.models.actions.cancel': '取消',
-    'codexlens.models.custom.title': '自定义模型',
-    'codexlens.models.custom.placeholder': 'HuggingFace 模型名称 (如: BAAI/bge-small-zh-v1.5)',
-    'codexlens.models.custom.description': '从 HuggingFace 下载自定义模型。请确保模型名称正确。',
-    'codexlens.models.deleteConfirm': '确定要删除模型 {modelName} 吗？',
-    'codexlens.models.notInstalled.title': 'CodexLens 未安装',
-    'codexlens.models.notInstalled.description': '请先安装 CodexLens 以使用模型管理功能。',
-    'codexlens.models.empty.title': '没有找到模型',
-    'codexlens.models.empty.description': '尝试调整搜索或筛选条件',
-    // Reranker
-    'codexlens.reranker.title': '重排序配置',
-    'codexlens.reranker.description': '配置重排序后端、模型和提供商，用于搜索结果排序。',
-    'codexlens.reranker.backend': '后端',
-    'codexlens.reranker.backendHint': '重排序推理后端',
-    'codexlens.reranker.model': '模型',
-    'codexlens.reranker.modelHint': '重排序模型名称或 LiteLLM 端点',
-    'codexlens.reranker.provider': 'API 提供商',
-    'codexlens.reranker.providerHint': '重排序服务的 API 提供商',
-    'codexlens.reranker.apiKeyStatus': 'API 密钥',
-    'codexlens.reranker.apiKeySet': '已配置',
-    'codexlens.reranker.apiKeyNotSet': '未配置',
-    'codexlens.reranker.configSource': '配置来源',
-    'codexlens.reranker.save': '保存重排序配置',
-    'codexlens.reranker.saving': '保存中...',
-    'codexlens.reranker.saveSuccess': '重排序配置已保存',
-    'codexlens.reranker.saveFailed': '保存重排序配置失败',
-    'codexlens.reranker.noBackends': '无可用后端',
-    'codexlens.reranker.noModels': '无可用模型',
-    'codexlens.reranker.noProviders': '无可用提供商',
-    'codexlens.reranker.litellmModels': 'LiteLLM 模型',
-    'codexlens.reranker.selectBackend': '选择后端...',
-    'codexlens.reranker.selectModel': '选择模型...',
-    'codexlens.reranker.selectProvider': '选择提供商...',
+    // CodexLens (v2)
+    'codexlens.title': '搜索管理',
+    'codexlens.description': 'V2 语义搜索索引管理',
+    'codexlens.reindex': '重建索引',
+    'codexlens.reindexing': '重建中...',
+    'codexlens.statusError': '加载搜索索引状态失败',
+    'codexlens.indexStatus.title': '索引状态',
+    'codexlens.indexStatus.status': '状态',
+    'codexlens.indexStatus.ready': '就绪',
+    'codexlens.indexStatus.notIndexed': '未索引',
+    'codexlens.indexStatus.files': '文件数',
+    'codexlens.indexStatus.dbSize': '数据库大小',
+    'codexlens.indexStatus.lastIndexed': '上次索引',
+    'codexlens.indexStatus.chunks': '分块数',
+    'codexlens.indexStatus.vectorDim': '向量维度',
+    'codexlens.indexStatus.enabled': '已启用',
+    'codexlens.indexStatus.disabled': '已禁用',
+    'codexlens.indexStatus.unavailable': '索引状态不可用',
+    'codexlens.searchTest.title': '搜索测试',
+    'codexlens.searchTest.placeholder': '输入搜索查询...',
+    'codexlens.searchTest.button': '搜索',
+    'codexlens.searchTest.results': '个结果',
+    'codexlens.searchTest.noResults': '未找到结果',
     // MCP - CCW Tools
     'mcp.ccw.title': 'CCW MCP 服务器',
     'mcp.ccw.description': '配置 CCW MCP 工具与路径',
diff --git a/ccw/frontend/src/types/codexlens.ts b/ccw/frontend/src/types/codexlens.ts
deleted file mode 100644
index 470e4894..00000000
--- a/ccw/frontend/src/types/codexlens.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-// ========================================
-// CodexLens Type Definitions
-// ========================================
-// TypeScript interfaces for structured env var form schema
-
-/**
- * Model group definition for model-select fields
- */
-export interface ModelGroup {
-  group: string;
-  items: string[];
-}
-
-/**
- * Schema for a single environment variable field
- */
-export interface EnvVarFieldSchema {
-  /** Environment variable key (e.g. CODEXLENS_EMBEDDING_BACKEND) */
-  key: string;
-  /** i18n label key */
-  labelKey: string;
-  /** Field type determines which control to render */
-  type: 'select' | 'model-select' | 'number' | 'checkbox' | 'text' | 'password';
-  /** Options for select type */
-  options?: string[];
-  /** Default value */
-  default?: string;
-  /** Placeholder text */
-  placeholder?: string;
-  /** Conditional visibility based on current env values */
-  showWhen?: (env: Record<string, string>) => boolean;
-  /** Mapped path in settings.json (e.g. embedding.backend) */
-  settingsPath?: string;
-  /** Min value for number type */
-  min?: number;
-  /** Max value for number type */
-  max?: number;
-  /** Step value for number type */
-  step?: number;
-  /** Preset local models for model-select */
-  localModels?: ModelGroup[];
-  /** Preset API models for model-select */
-  apiModels?: ModelGroup[];
-}
-
-/**
- * Schema for a group of related environment variables
- */
-export interface EnvVarGroup {
-  /** Unique group identifier */
-  id: string;
-  /** i18n label key for group title */
-  labelKey: string;
-  /** Lucide icon name */
-  icon: string;
-  /** Ordered map of env var key to field schema */
-  vars: Record<string, EnvVarFieldSchema>;
-}
-
-/**
- * Complete schema for all env var groups
- */
-export type EnvVarGroupsSchema = Record<string, EnvVarGroup>;
diff --git a/ccw/src/core/memory-embedder-bridge.ts b/ccw/src/core/memory-embedder-bridge.ts
index 0b733041..19b0db4d 100644
--- a/ccw/src/core/memory-embedder-bridge.ts
+++ b/ccw/src/core/memory-embedder-bridge.ts
@@ -1,37 +1,13 @@
 /**
- * Memory Embedder Bridge - TypeScript interface to Python memory embedder
+ * Memory Embedder Bridge - STUB (v1 Python bridge removed)
  *
- * This module provides a TypeScript bridge to the Python memory_embedder.py script,
- * which generates and searches embeddings for memory chunks using CodexLens's embedder.
- *
- * Features:
- * - Reuses CodexLens venv at ~/.codexlens/venv
- * - JSON protocol communication
- * - Three commands: embed, search, status
- * - Automatic availability checking
- * - Stage1 output embedding for V2 pipeline
+ * The Python memory_embedder.py bridge has been removed. This module provides
+ * no-op stubs so that existing consumers compile without errors.
  */
 
-import { spawn } from 'child_process';
-import { join, dirname } from 'path';
-import { existsSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { getCodexLensHiddenPython } from '../utils/codexlens-path.js';
-import { getCoreMemoryStore } from './core-memory-store.js';
-import type { Stage1Output } from './core-memory-store.js';
-import { StoragePaths } from '../config/storage-paths.js';
+const V1_REMOVED = 'Memory embedder Python bridge has been removed (v1 cleanup).';
 
-// Get directory of this module
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// Venv paths (reuse CodexLens venv)
-const VENV_PYTHON = getCodexLensHiddenPython();
-
-// Script path
-const EMBEDDER_SCRIPT = join(__dirname, '..', '..', 'scripts', 'memory_embedder.py');
-
-// Types
+// Types (kept for backward compatibility)
 export interface EmbedResult {
   success: boolean;
   chunks_processed: number;
@@ -78,197 +54,6 @@ export interface SearchOptions {
   sourceType?: 'core_memory' | 'workflow' | 'cli_history';
 }
 
-/**
- * Check if embedder is available (venv and script exist)
- * @returns True if embedder is available
- */
-export function isEmbedderAvailable(): boolean {
-  // Check venv python exists
-  if (!existsSync(VENV_PYTHON)) {
-    return false;
-  }
-
-  // Check script exists
-  if (!existsSync(EMBEDDER_SCRIPT)) {
-    return false;
-  }
-
-  return true;
-}
-
-/**
- * Run Python script with arguments
- * @param args - Command line arguments
- * @param timeout - Timeout in milliseconds
- * @returns JSON output from script
- */
-function runPython(args: string[], timeout: number = 300000): Promise<string> {
-  return new Promise((resolve, reject) => {
-    // Check availability
-    if (!isEmbedderAvailable()) {
-      reject(
-        new Error(
-          'Memory embedder not available. Ensure CodexLens venv exists at ~/.codexlens/venv'
-        )
-      );
-      return;
-    }
-
-    // Spawn Python process
-    const child = spawn(VENV_PYTHON, [EMBEDDER_SCRIPT, ...args], {
-      shell: false,
-      stdio: ['ignore', 'pipe', 'pipe'],
-      timeout,
-      windowsHide: true,
-      env: { ...process.env, PYTHONIOENCODING: 'utf-8' },
-    });
-
-    let stdout = '';
-    let stderr = '';
-
-    child.stdout.on('data', (data) => {
-      stdout += data.toString();
-    });
-
-    child.stderr.on('data', (data) => {
-      stderr += data.toString();
-    });
-
-    child.on('close', (code) => {
-      if (code === 0) {
-        resolve(stdout.trim());
-      } else {
-        reject(new Error(`Python script failed (exit code ${code}): ${stderr || stdout}`));
-      }
-    });
-
-    child.on('error', (err) => {
-      if ((err as NodeJS.ErrnoException).code === 'ETIMEDOUT') {
-        reject(new Error('Python script timed out'));
-      } else {
-        reject(new Error(`Failed to spawn Python: ${err.message}`));
-      }
-    });
-  });
-}
-
-/**
- * Generate embeddings for memory chunks
- * @param dbPath - Path to SQLite database
- * @param options - Embedding options
- * @returns Embedding result
- */
-export async function generateEmbeddings(
-  dbPath: string,
-  options: EmbedOptions = {}
-): Promise<EmbedResult> {
-  const { sourceId, batchSize = 8, force = false } = options;
-
-  // Build arguments
-  const args = ['embed', dbPath];
-
-  if (sourceId) {
-    args.push('--source-id', sourceId);
-  }
-
-  if (batchSize !== 8) {
-    args.push('--batch-size', batchSize.toString());
-  }
-
-  if (force) {
-    args.push('--force');
-  }
-
-  try {
-    // Default timeout: 5 minutes
-    const output = await runPython(args, 300000);
-    const result = JSON.parse(output) as EmbedResult;
-    return result;
-  } catch (err) {
-    return {
-      success: false,
-      chunks_processed: 0,
-      chunks_failed: 0,
-      elapsed_time: 0,
-      error: (err as Error).message,
-    };
-  }
-}
-
-/**
- * Search memory chunks using semantic search
- * @param dbPath - Path to SQLite database
- * @param query - Search query text
- * @param options - Search options
- * @returns Search results
- */
-export async function searchMemories(
-  dbPath: string,
-  query: string,
-  options: SearchOptions = {}
-): Promise<SearchResult> {
-  const { topK = 10, minScore = 0.3, sourceType } = options;
-
-  // Build arguments
-  const args = ['search', dbPath, query];
-
-  if (topK !== 10) {
-    args.push('--top-k', topK.toString());
-  }
-
-  if (minScore !== 0.3) {
-    args.push('--min-score', minScore.toString());
-  }
-
-  if (sourceType) {
-    args.push('--type', sourceType);
-  }
-
-  try {
-    // Default timeout: 30 seconds
-    const output = await runPython(args, 30000);
-    const result = JSON.parse(output) as SearchResult;
-    return result;
-  } catch (err) {
-    return {
-      success: false,
-      matches: [],
-      error: (err as Error).message,
-    };
-  }
-}
-
-/**
- * Get embedding status statistics
- * @param dbPath - Path to SQLite database
- * @returns Embedding status
- */
-export async function getEmbeddingStatus(dbPath: string): Promise<EmbeddingStatus> {
-  // Build arguments
-  const args = ['status', dbPath];
-
-  try {
-    // Default timeout: 30 seconds
-    const output = await runPython(args, 30000);
-    const result = JSON.parse(output) as EmbeddingStatus;
-    return { ...result, success: true };
-  } catch (err) {
-    return {
-      success: false,
-      total_chunks: 0,
-      embedded_chunks: 0,
-      pending_chunks: 0,
-      by_type: {},
-      error: (err as Error).message,
-    };
-  }
-}
-
-// ============================================================================
-// Memory V2: Stage1 Output Embedding
-// ============================================================================
-
-/** Result of stage1 embedding operation */
 export interface Stage1EmbedResult {
   success: boolean;
   chunksCreated: number;
@@ -276,98 +61,54 @@ export interface Stage1EmbedResult {
   error?: string;
 }
 
-/**
- * Chunk and embed stage1_outputs (raw_memory + rollout_summary) for semantic search.
- *
- * Reads all stage1_outputs from the DB, chunks their raw_memory and rollout_summary
- * content, inserts chunks into memory_chunks with source_type='cli_history' and
- * metadata indicating the V2 origin, then triggers embedding generation.
- *
- * Uses source_id format: "s1:{thread_id}" to differentiate from regular cli_history chunks.
- *
- * @param projectPath - Project root path
- * @param force - Force re-chunking even if chunks exist
- * @returns Embedding result
- */
-export async function embedStage1Outputs(
-  projectPath: string,
-  force: boolean = false
-): Promise<Stage1EmbedResult> {
-  try {
-    const store = getCoreMemoryStore(projectPath);
-    const stage1Outputs = store.listStage1Outputs();
-
-    if (stage1Outputs.length === 0) {
-      return { success: true, chunksCreated: 0, chunksEmbedded: 0 };
-    }
-
-    let totalChunksCreated = 0;
-
-    for (const output of stage1Outputs) {
-      const sourceId = `s1:${output.thread_id}`;
-
-      // Check if already chunked
-      const existingChunks = store.getChunks(sourceId);
-      if (existingChunks.length > 0 && !force) continue;
-
-      // Delete old chunks if force
-      if (force && existingChunks.length > 0) {
-        store.deleteChunks(sourceId);
-      }
-
-      // Combine raw_memory and rollout_summary for richer semantic content
-      const combinedContent = [
-        output.rollout_summary ? `## Summary\n${output.rollout_summary}` : '',
-        output.raw_memory ? `## Raw Memory\n${output.raw_memory}` : '',
-      ].filter(Boolean).join('\n\n');
-
-      if (!combinedContent.trim()) continue;
-
-      // Chunk using the store's built-in chunking
-      const chunks = store.chunkContent(combinedContent, sourceId, 'cli_history');
-
-      // Insert chunks with V2 metadata
-      for (let i = 0; i < chunks.length; i++) {
-        store.insertChunk({
-          source_id: sourceId,
-          source_type: 'cli_history',
-          chunk_index: i,
-          content: chunks[i],
-          metadata: JSON.stringify({
-            v2_source: 'stage1_output',
-            thread_id: output.thread_id,
-            generated_at: output.generated_at,
-          }),
-          created_at: new Date().toISOString(),
-        });
-        totalChunksCreated++;
-      }
-    }
-
-    // If we created chunks, generate embeddings
-    let chunksEmbedded = 0;
-    if (totalChunksCreated > 0) {
-      const paths = StoragePaths.project(projectPath);
-      const dbPath = join(paths.root, 'core-memory', 'core_memory.db');
-
-      const embedResult = await generateEmbeddings(dbPath, { force: false });
-      if (embedResult.success) {
-        chunksEmbedded = embedResult.chunks_processed;
-      }
-    }
-
-    return {
-      success: true,
-      chunksCreated: totalChunksCreated,
-      chunksEmbedded,
-    };
-  } catch (err) {
-    return {
-      success: false,
-      chunksCreated: 0,
-      chunksEmbedded: 0,
-      error: (err as Error).message,
-    };
-  }
+export function isEmbedderAvailable(): boolean {
+  return false;
 }
 
+export async function generateEmbeddings(
+  _dbPath: string,
+  _options: EmbedOptions = {}
+): Promise<EmbedResult> {
+  return {
+    success: false,
+    chunks_processed: 0,
+    chunks_failed: 0,
+    elapsed_time: 0,
+    error: V1_REMOVED,
+  };
+}
+
+export async function searchMemories(
+  _dbPath: string,
+  _query: string,
+  _options: SearchOptions = {}
+): Promise<SearchResult> {
+  return {
+    success: false,
+    matches: [],
+    error: V1_REMOVED,
+  };
+}
+
+export async function getEmbeddingStatus(_dbPath: string): Promise<EmbeddingStatus> {
+  return {
+    success: false,
+    total_chunks: 0,
+    embedded_chunks: 0,
+    pending_chunks: 0,
+    by_type: {},
+    error: V1_REMOVED,
+  };
+}
+
+export async function embedStage1Outputs(
+  _projectPath: string,
+  _force: boolean = false
+): Promise<Stage1EmbedResult> {
+  return {
+    success: false,
+    chunksCreated: 0,
+    chunksEmbedded: 0,
+    error: V1_REMOVED,
+  };
+}
diff --git a/ccw/src/core/routes/codexlens-routes.ts b/ccw/src/core/routes/codexlens-routes.ts
deleted file mode 100644
index fc066f54..00000000
--- a/ccw/src/core/routes/codexlens-routes.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-/**
- * CodexLens Routes Module
- * Handles all CodexLens-related API endpoints.
- */
-
-import type { RouteContext } from './types.js';
-import { handleCodexLensConfigRoutes } from './codexlens/config-handlers.js';
-import { handleCodexLensIndexRoutes } from './codexlens/index-handlers.js';
-import { handleCodexLensSemanticRoutes } from './codexlens/semantic-handlers.js';
-import { handleCodexLensWatcherRoutes } from './codexlens/watcher-handlers.js';
-
-/**
- * Handle CodexLens routes
- * @returns true if route was handled, false otherwise
- */
-export async function handleCodexLensRoutes(ctx: RouteContext): Promise<boolean> {
-  if (await handleCodexLensIndexRoutes(ctx)) return true;
-  if (await handleCodexLensConfigRoutes(ctx)) return true;
-  if (await handleCodexLensSemanticRoutes(ctx)) return true;
-  if (await handleCodexLensWatcherRoutes(ctx)) return true;
-  return false;
-}
-
diff --git a/ccw/src/core/routes/codexlens/README.md b/ccw/src/core/routes/codexlens/README.md
deleted file mode 100644
index 0c2ea75c..00000000
--- a/ccw/src/core/routes/codexlens/README.md
+++ /dev/null
@@ -1,37 +0,0 @@
-# CodexLens Routes
-
-CodexLens-related HTTP endpoints are handled by `ccw/src/core/routes/codexlens-routes.ts`, which delegates to handler modules in this directory. Each handler returns `true` when it handles the current request.
-
-## File Map
-
-- `ccw/src/core/routes/codexlens/utils.ts` – shared helpers (ANSI stripping + robust JSON extraction from CLI output).
-- `ccw/src/core/routes/codexlens/index-handlers.ts` – index/project management endpoints:
-  - `GET /api/codexlens/indexes`
-  - `POST /api/codexlens/clean`
-  - `POST /api/codexlens/init`
-  - `POST /api/codexlens/cancel`
-  - `GET /api/codexlens/indexing-status`
-- `ccw/src/core/routes/codexlens/config-handlers.ts` – install/config/environment endpoints:
-  - `GET /api/codexlens/status`
-  - `GET /api/codexlens/dashboard-init`
-  - `POST /api/codexlens/bootstrap`
-  - `POST /api/codexlens/uninstall`
-  - `GET /api/codexlens/config`
-  - `POST /api/codexlens/config`
-  - GPU: `GET /api/codexlens/gpu/detect`, `GET /api/codexlens/gpu/list`, `POST /api/codexlens/gpu/select`, `POST /api/codexlens/gpu/reset`
-  - Models: `GET /api/codexlens/models`, `POST /api/codexlens/models/download`, `POST /api/codexlens/models/delete`, `GET /api/codexlens/models/info`
-  - Env: `GET /api/codexlens/env`, `POST /api/codexlens/env`
-- `ccw/src/core/routes/codexlens/semantic-handlers.ts` – semantic search + reranker + SPLADE endpoints:
-  - Semantic: `GET /api/codexlens/semantic/status`, `GET /api/codexlens/semantic/metadata`, `POST /api/codexlens/semantic/install`
-  - Search: `GET /api/codexlens/search`, `GET /api/codexlens/search_files`, `GET /api/codexlens/symbol`, `POST /api/codexlens/enhance`
-  - Reranker: `GET /api/codexlens/reranker/config`, `POST /api/codexlens/reranker/config`, `GET /api/codexlens/reranker/models`, `POST /api/codexlens/reranker/models/download`, `POST /api/codexlens/reranker/models/delete`, `GET /api/codexlens/reranker/models/info`
-  - SPLADE: `GET /api/codexlens/splade/status`, `POST /api/codexlens/splade/install`, `GET /api/codexlens/splade/index-status`, `POST /api/codexlens/splade/rebuild`
-- `ccw/src/core/routes/codexlens/watcher-handlers.ts` – file watcher endpoints:
-  - `GET /api/codexlens/watch/status`
-  - `POST /api/codexlens/watch/start`
-  - `POST /api/codexlens/watch/stop`
-  - Also exports `stopWatcherForUninstall()` used during uninstall flow.
-
-## Notes
-
-- CodexLens CLI output may include logging + ANSI escapes even with `--json`; handlers use `extractJSON()` from `utils.ts` to parse reliably.
diff --git a/ccw/src/core/routes/codexlens/config-handlers.ts b/ccw/src/core/routes/codexlens/config-handlers.ts
deleted file mode 100644
index af9dc08d..00000000
--- a/ccw/src/core/routes/codexlens/config-handlers.ts
+++ /dev/null
@@ -1,1448 +0,0 @@
-/**
- * CodexLens configuration + environment handlers.
- */
-
-import {
-  bootstrapVenv,
-  cancelIndexing,
-  checkSemanticStatus,
-  checkVenvStatus,
-  detectGpuSupport,
-  executeCodexLens,
-  isIndexingInProgress,
-  uninstallCodexLens,
-  useCodexLensV2,
-} from '../../../tools/codex-lens.js';
-import {
-  executeV2ListModels,
-  executeV2DownloadModel,
-  executeV2DeleteModel,
-} from '../../../tools/smart-search.js';
-import type { RouteContext } from '../types.js';
-import { EXEC_TIMEOUTS } from '../../../utils/exec-constants.js';
-import { extractJSON } from './utils.js';
-import { stopWatcherForUninstall } from './watcher-handlers.js';
-import { getCodexLensDataDir } from '../../../utils/codexlens-path.js';
-
-export async function handleCodexLensConfigRoutes(ctx: RouteContext): Promise<boolean> {
-  const { pathname, url, req, res, initialPath, handlePostRequest, broadcastToClients } = ctx;
-
-  // API: CodexLens Status
-  if (pathname === '/api/codexlens/status') {
-    const status = await checkVenvStatus();
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify(status));
-    return true;
-  }
-
-  // API: CodexLens Dashboard Init - Aggregated endpoint for page initialization
-  if (pathname === '/api/codexlens/dashboard-init') {
-    try {
-      const venvStatus = await checkVenvStatus();
-
-      if (!venvStatus.ready) {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-          installed: false,
-          status: venvStatus,
-          config: { index_dir: '~/.codexlens/indexes', index_count: 0 },
-          semantic: { available: false }
-        }));
-        return true;
-      }
-
-      // Parallel fetch all initialization data
-      const [configResult, statusResult, semanticStatus] = await Promise.all([
-        executeCodexLens(['config', '--json']),
-        executeCodexLens(['status', '--json']),
-        checkSemanticStatus()
-      ]);
-
-      // Parse config
-      let config = { index_dir: '~/.codexlens/indexes', index_count: 0 };
-      if (configResult.success) {
-        try {
-          const configData = extractJSON(configResult.output ?? '');
-          if (configData.success && configData.result) {
-            config.index_dir = configData.result.index_dir || configData.result.index_root || config.index_dir;
-          }
-        } catch (e: unknown) {
-          console.error('[CodexLens] Failed to parse config for dashboard init:', e instanceof Error ? e.message : String(e));
-        }
-      }
-
-      // Parse status
-      let statusData: any = {};
-      if (statusResult.success) {
-        try {
-          const status = extractJSON(statusResult.output ?? '');
-          if (status.success && status.result) {
-            config.index_count = status.result.projects_count || 0;
-            statusData = status.result;
-          }
-        } catch (e: unknown) {
-          console.error('[CodexLens] Failed to parse status for dashboard init:', e instanceof Error ? e.message : String(e));
-        }
-      }
-
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        installed: true,
-        status: venvStatus,
-        config,
-        semantic: semanticStatus,
-        statusData
-      }));
-    } catch (err: unknown) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: false, error: err instanceof Error ? err.message : String(err) }));
-    }
-    return true;
-  }
-
-  // API: CodexLens Workspace Status - Get FTS and Vector index status for current workspace
-  if (pathname === '/api/codexlens/workspace-status') {
-    try {
-      const venvStatus = await checkVenvStatus();
-
-      // Default response when not installed
-      if (!venvStatus.ready) {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-          success: true,
-          hasIndex: false,
-          fts: { percent: 0, indexedFiles: 0, totalFiles: 0 },
-          vector: { percent: 0, filesWithEmbeddings: 0, totalFiles: 0, totalChunks: 0 }
-        }));
-        return true;
-      }
-
-      // Use path from query param, fallback to initialPath
-      const projectPath = url.searchParams.get('path') || initialPath;
-
-      // Get project info using 'projects show' command
-      const projectResult = await executeCodexLens(['projects', 'show', projectPath, '--json']);
-
-      if (!projectResult.success) {
-        // No index for this workspace
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-          success: true,
-          hasIndex: false,
-          fts: { percent: 0, indexedFiles: 0, totalFiles: 0 },
-          vector: { percent: 0, filesWithEmbeddings: 0, totalFiles: 0, totalChunks: 0 }
-        }));
-        return true;
-      }
-
-      // Parse project data
-      let projectData: any = null;
-      try {
-        const parsed = extractJSON(projectResult.output ?? '');
-        if (parsed.success && parsed.result) {
-          projectData = parsed.result;
-        }
-      } catch (e: unknown) {
-        console.error('[CodexLens] Failed to parse project data:', e instanceof Error ? e.message : String(e));
-      }
-
-      if (!projectData) {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-          success: true,
-          hasIndex: false,
-          fts: { percent: 0, indexedFiles: 0, totalFiles: 0 },
-          vector: { percent: 0, filesWithEmbeddings: 0, totalFiles: 0, totalChunks: 0 }
-        }));
-        return true;
-      }
-
-      // Get index status for embeddings coverage using 'index status' command
-      const indexStatusResult = await executeCodexLens(['index', 'status', projectPath, '--json']);
-
-      let embeddingsData: any = null;
-      if (indexStatusResult.success && indexStatusResult.output) {
-        try {
-          const parsed = extractJSON(indexStatusResult.output);
-          if (parsed.success && parsed.result?.embeddings) {
-            embeddingsData = parsed.result.embeddings;
-          }
-        } catch (e: unknown) {
-          console.error('[CodexLens] Failed to parse index status:', e instanceof Error ? e.message : String(e));
-        }
-      }
-
-      // Calculate FTS and Vector percentages
-      const totalFiles = projectData.total_files || 0;
-      const indexedFiles = projectData.total_files || 0; // All indexed files have FTS
-
-      // Get embeddings data from index status
-      // The response structure is: { total_indexes, indexes_with_embeddings, total_chunks, indexes: [{coverage_percent, total_files, ...}] }
-      const indexesWithEmbeddings = embeddingsData?.indexes_with_embeddings || 0;
-      const totalChunks = embeddingsData?.total_chunks || 0;
-      // coverage_percent is in the indexes array - get the first one (for single project query)
-      const indexEntry = embeddingsData?.indexes?.[0];
-      const vectorPercent = indexEntry?.coverage_percent || 0;
-      const filesWithEmbeddings = indexEntry?.total_files || 0;
-
-      // FTS percentage (all indexed files have FTS, so it's always 100% if indexed)
-      const ftsPercent = totalFiles > 0 ? 100 : 0;
-
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        success: true,
-        hasIndex: true,
-        path: projectPath,
-        fts: {
-          percent: ftsPercent,
-          indexedFiles,
-          totalFiles
-        },
-        vector: {
-          percent: vectorPercent,
-          filesWithEmbeddings,
-          totalFiles,
-          totalChunks
-        }
-      }));
-    } catch (err: unknown) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: false, error: err instanceof Error ? err.message : String(err) }));
-    }
-    return true;
-  }
-
-  // API: CodexLens Bootstrap (Install)
-  if (pathname === '/api/codexlens/bootstrap' && req.method === 'POST') {
-    handlePostRequest(req, res, async () => {
-      try {
-        const result = await bootstrapVenv();
-        if (result.success) {
-          const status = await checkVenvStatus();
-          broadcastToClients({
-            type: 'CODEXLENS_INSTALLED',
-            payload: { version: status.version, timestamp: new Date().toISOString() }
-          });
-          return { success: true, message: 'CodexLens installed successfully', version: status.version };
-        } else {
-          return { success: false, error: result.error, status: 500 };
-        }
-      } catch (err) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  // API: CodexLens Uninstall
-  if (pathname === '/api/codexlens/uninstall' && req.method === 'POST') {
-    handlePostRequest(req, res, async () => {
-      try {
-        // Stop watcher if running (to release file handles)
-        await stopWatcherForUninstall();
-
-        if (isIndexingInProgress()) {
-          console.log('[CodexLens] Cancelling indexing before uninstall...');
-          try {
-            cancelIndexing();
-          } catch {
-            // Ignore errors
-          }
-        }
-
-        // Wait a moment for processes to fully exit and release handles
-        await new Promise(resolve => setTimeout(resolve, 1000));
-
-        const result = await uninstallCodexLens();
-        if (result.success) {
-          broadcastToClients({
-            type: 'CODEXLENS_UNINSTALLED',
-            payload: { timestamp: new Date().toISOString() }
-          });
-          return { success: true, message: 'CodexLens uninstalled successfully' };
-        } else {
-          return { success: false, error: result.error, status: 500 };
-        }
-      } catch (err) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  // API: CodexLens Config - GET (Get current configuration with index count)
-  if (pathname === '/api/codexlens/config' && req.method === 'GET') {
-    try {
-      const venvStatus = await checkVenvStatus();
-      let responseData = { index_dir: '~/.codexlens/indexes', index_count: 0 };
-
-      // If not installed, return default config without executing CodexLens
-      if (!venvStatus.ready) {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify(responseData));
-        return true;
-      }
-
-      // Use projects list for accurate index_count (same source as /api/codexlens/indexes)
-      const [configResult, projectsResult] = await Promise.all([
-        executeCodexLens(['config', '--json']),
-        executeCodexLens(['projects', 'list', '--json'])
-      ]);
-
-      // Parse config (extract JSON from output that may contain log messages)
-      if (configResult.success) {
-        try {
-          const config = extractJSON(configResult.output ?? '');
-          if (config.success && config.result) {
-            // CLI returns index_dir (not index_root)
-            responseData.index_dir = config.result.index_dir || config.result.index_root || responseData.index_dir;
-          }
-        } catch (e: unknown) {
-          console.error('[CodexLens] Failed to parse config:', e instanceof Error ? e.message : String(e));
-          console.error('[CodexLens] Config output:', (configResult.output ?? '').substring(0, 200));
-        }
-      }
-
-      // Parse projects list to get index_count (consistent with /api/codexlens/indexes)
-      if (projectsResult.success) {
-        try {
-          const projectsData = extractJSON(projectsResult.output ?? '');
-          if (projectsData.success && Array.isArray(projectsData.result)) {
-            // Filter out test/temp projects (same logic as /api/codexlens/indexes)
-            const validProjects = projectsData.result.filter((project: any) => {
-              if (project.source_root && (
-                project.source_root.includes('\\Temp\\') ||
-                project.source_root.includes('/tmp/') ||
-                project.total_files === 0
-              )) {
-                return false;
-              }
-              return true;
-            });
-            responseData.index_count = validProjects.length;
-          }
-        } catch (e: unknown) {
-          console.error('[CodexLens] Failed to parse projects list:', e instanceof Error ? e.message : String(e));
-          console.error('[CodexLens] Projects output:', (projectsResult.output ?? '').substring(0, 200));
-        }
-      }
-
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify(responseData));
-    } catch (err: unknown) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
-    }
-    return true;
-  }
-
-  // API: CodexLens Config - POST (Set configuration)
-  if (pathname === '/api/codexlens/config' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body: unknown) => {
-      const { index_dir } = body as {
-        index_dir?: unknown;
-      };
-
-      if (!index_dir) {
-        return { success: false, error: 'index_dir is required', status: 400 };
-      }
-
-      // Validate index_dir path
-      const indexDirStr = String(index_dir).trim();
-
-      // Check for dangerous patterns
-      if (indexDirStr.includes('\0')) {
-        return { success: false, error: 'Invalid path: contains null bytes', status: 400 };
-      }
-
-      // Prevent system root paths and their subdirectories (Windows and Unix)
-      const dangerousPaths = ['/', 'C:\\', 'C:/', '/etc', '/usr', '/bin', '/sys', '/proc', '/var',
-                              'C:\\Windows', 'C:\\Program Files', 'C:\\Program Files (x86)', 'C:\\System32'];
-      const normalizedPath = indexDirStr.replace(/\\/g, '/').toLowerCase();
-      for (const dangerous of dangerousPaths) {
-        const dangerousLower = dangerous.replace(/\\/g, '/').toLowerCase();
-        // Block exact match OR any subdirectory (using startsWith)
-        if (normalizedPath === dangerousLower ||
-            normalizedPath === dangerousLower + '/' ||
-            normalizedPath.startsWith(dangerousLower + '/')) {
-          return { success: false, error: 'Invalid path: cannot use system directories or their subdirectories', status: 400 };
-        }
-      }
-
-      // Additional check: prevent path traversal attempts
-      if (normalizedPath.includes('../') || normalizedPath.includes('/..')) {
-        return { success: false, error: 'Invalid path: path traversal not allowed', status: 400 };
-      }
-
-      try {
-        // Set index_dir
-        const result = await executeCodexLens(['config', 'set', 'index_dir', indexDirStr, '--json']);
-        if (!result.success) {
-          return { success: false, error: result.error || 'Failed to update index_dir', status: 500 };
-        }
-
-        return { success: true, message: 'Configuration updated successfully' };
-      } catch (err: unknown) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  // API: Detect GPU support for semantic search
-  if (pathname === '/api/codexlens/gpu/detect' && req.method === 'GET') {
-    try {
-      const gpuInfo = await detectGpuSupport();
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: true, ...gpuInfo }));
-    } catch (err: unknown) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: false, error: err instanceof Error ? err.message : String(err) }));
-    }
-    return true;
-  }
-
-  // API: List available GPU devices for selection
-  if (pathname === '/api/codexlens/gpu/list' && req.method === 'GET') {
-    try {
-      // Try CodexLens gpu-list first if available
-      const venvStatus = await checkVenvStatus();
-      if (venvStatus.ready) {
-        const result = await executeCodexLens(['gpu-list', '--json']);
-        if (result.success) {
-          try {
-            const parsed = extractJSON(result.output ?? '');
-            if (parsed.devices && parsed.devices.length > 0) {
-              res.writeHead(200, { 'Content-Type': 'application/json' });
-              res.end(JSON.stringify(parsed));
-              return true;
-            }
-          } catch {
-            // Fall through to system detection
-          }
-        }
-      }
-
-      // Fallback: Use system commands to detect GPUs
-      const devices: Array<{ name: string; type: string; index: number }> = [];
-
-      if (process.platform === 'win32') {
-        // Windows: Use PowerShell Get-CimInstance (wmic is deprecated in Windows 11)
-        try {
-          const { execSync } = await import('child_process');
-          const psOutput = execSync(
-            'powershell -NoProfile -Command "(Get-CimInstance Win32_VideoController).Name"',
-            {
-              encoding: 'utf-8',
-              timeout: EXEC_TIMEOUTS.SYSTEM_INFO,
-              stdio: ['pipe', 'pipe', 'pipe']
-            }
-          );
-
-          const lines = psOutput.split('\n')
-            .map(line => line.trim())
-            .filter(line => line);
-
-          lines.forEach((name, index) => {
-            if (name) {
-              const isIntegrated = name.toLowerCase().includes('intel') ||
-                                   name.toLowerCase().includes('integrated');
-              devices.push({
-                name: name,
-                type: isIntegrated ? 'integrated' : 'discrete',
-                index: index
-              });
-            }
-          });
-        } catch (e) {
-          console.warn('[CodexLens] PowerShell GPU detection failed:', (e as Error).message);
-        }
-      } else {
-        // Linux/Mac: Try nvidia-smi for NVIDIA GPUs
-        try {
-          const { execSync } = await import('child_process');
-          const nvidiaOutput = execSync('nvidia-smi --query-gpu=name --format=csv,noheader', {
-            encoding: 'utf-8',
-            timeout: EXEC_TIMEOUTS.SYSTEM_INFO,
-            stdio: ['pipe', 'pipe', 'pipe']
-          });
-
-          const lines = nvidiaOutput.split('\n').filter(line => line.trim());
-          lines.forEach((name, index) => {
-            devices.push({
-              name: name.trim(),
-              type: 'discrete',
-              index: index
-            });
-          });
-        } catch {
-          // NVIDIA not available, that's fine
-        }
-      }
-
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: true, devices: devices, selected_device_id: null }));
-    } catch (err: unknown) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: false, error: err instanceof Error ? err.message : String(err) }));
-    }
-    return true;
-  }
-
-  // API: Select GPU device for embedding
-  if (pathname === '/api/codexlens/gpu/select' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body) => {
-      const { device_id } = body as { device_id?: unknown };
-      const resolvedDeviceId = typeof device_id === 'string' || typeof device_id === 'number' ? device_id : undefined;
-
-      if (resolvedDeviceId === undefined) {
-        return { success: false, error: 'device_id is required', status: 400 };
-      }
-
-      try {
-        const result = await executeCodexLens(['gpu-select', String(resolvedDeviceId), '--json']);
-        if (result.success) {
-          try {
-            const parsed = extractJSON(result.output ?? '');
-            return parsed;
-          } catch {
-            return { success: true, message: 'GPU selected', output: result.output };
-          }
-        } else {
-          return { success: false, error: result.error, status: 500 };
-        }
-      } catch (err: unknown) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  // API: Reset GPU selection to auto-detection
-  if (pathname === '/api/codexlens/gpu/reset' && req.method === 'POST') {
-    handlePostRequest(req, res, async () => {
-      try {
-        const result = await executeCodexLens(['gpu-reset', '--json']);
-        if (result.success) {
-          try {
-            const parsed = extractJSON(result.output ?? '');
-            return parsed;
-          } catch {
-            return { success: true, message: 'GPU selection reset', output: result.output };
-          }
-        } else {
-          return { success: false, error: result.error, status: 500 };
-        }
-      } catch (err: unknown) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  // API: CodexLens Model List (list available embedding AND reranker models)
-  if (pathname === '/api/codexlens/models' && req.method === 'GET') {
-    try {
-      // v2 bridge: single list-models command returns all models with type
-      if (useCodexLensV2()) {
-        const result = await executeV2ListModels();
-        if (result.success && result.status) {
-          // v2 bridge returns array directly as status
-          const models = Array.isArray(result.status) ? result.status : [];
-          res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ success: true, result: { models } }));
-        } else {
-          res.writeHead(500, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ success: false, error: result.error || 'Failed to list models' }));
-        }
-        return true;
-      }
-
-      // v1 fallback: fetch embedding and reranker models separately
-      // Check if CodexLens is installed first (without auto-installing)
-      const venvStatus = await checkVenvStatus();
-      if (!venvStatus.ready) {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ success: false, error: 'CodexLens not installed' }));
-        return true;
-      }
-
-      // Fetch both embedding and reranker models in parallel
-      const [embeddingResult, rerankerResult] = await Promise.all([
-        executeCodexLens(['model-list', '--json']),
-        executeCodexLens(['reranker-model-list', '--json'])
-      ]);
-
-      const allModels: any[] = [];
-
-      // Parse embedding models and add type field
-      if (embeddingResult.success) {
-        try {
-          const parsed = extractJSON(embeddingResult.output ?? '');
-          const models = parsed?.result?.models ?? parsed?.models ?? [];
-          for (const model of models) {
-            allModels.push({ ...model, type: 'embedding' });
-          }
-        } catch {
-          // Ignore parsing errors for embedding models
-        }
-      }
-
-      // Parse reranker models and add type field
-      if (rerankerResult.success) {
-        try {
-          const parsed = extractJSON(rerankerResult.output ?? '');
-          const models = parsed?.result?.models ?? parsed?.models ?? [];
-          for (const model of models) {
-            allModels.push({ ...model, type: 'reranker' });
-          }
-        } catch {
-          // Ignore parsing errors for reranker models
-        }
-      }
-
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        success: true,
-        result: { models: allModels }
-      }));
-    } catch (err: unknown) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: false, error: err instanceof Error ? err.message : String(err) }));
-    }
-    return true;
-  }
-
-  // API: CodexLens Model Download (download embedding or reranker model by profile)
-  if (pathname === '/api/codexlens/models/download' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body) => {
-      const { profile, model_type, model_name } = body as { profile?: unknown; model_type?: unknown; model_name?: unknown };
-      // v2 bridge: accepts model_name (HF name) directly; v1 uses profile names
-      const resolvedProfile = typeof profile === 'string' && profile.trim().length > 0 ? profile.trim() : undefined;
-      const resolvedModelName = typeof model_name === 'string' && model_name.trim().length > 0 ? model_name.trim() : undefined;
-      const resolvedModelType = typeof model_type === 'string' ? model_type.trim() : undefined;
-
-      // v2 bridge: download by model name
-      if (useCodexLensV2()) {
-        const nameToDownload = resolvedModelName || resolvedProfile;
-        if (!nameToDownload) {
-          return { success: false, error: 'model_name or profile is required', status: 400 };
-        }
-        const result = await executeV2DownloadModel(nameToDownload);
-        if (result.success) {
-          const data = (result.status && typeof result.status === 'object') ? result.status as Record<string, unknown> : {};
-          return { success: true, ...data };
-        }
-        return { success: false, error: result.error, status: 500 };
-      }
-
-      // v1 fallback
-      if (!resolvedProfile) {
-        return { success: false, error: 'profile is required', status: 400 };
-      }
-
-      try {
-        // If model_type is specified, use it directly
-        if (resolvedModelType === 'reranker') {
-          const result = await executeCodexLens(['reranker-model-download', resolvedProfile, '--json'], { timeout: 600000 });
-          if (result.success) {
-            try {
-              const parsed = extractJSON(result.output ?? '');
-              return { success: true, ...parsed };
-            } catch {
-              return { success: true, output: result.output };
-            }
-          } else {
-            return { success: false, error: result.error, status: 500 };
-          }
-        }
-
-        // Try embedding model first, then reranker if profile not found
-        const embeddingResult = await executeCodexLens(['model-download', resolvedProfile, '--json'], { timeout: 600000 });
-
-        // Check if the error indicates unknown profile
-        const outputStr = embeddingResult.output ?? '';
-        const isUnknownProfile = !embeddingResult.success &&
-          (outputStr.includes('Unknown profile') || outputStr.includes('unknown profile'));
-
-        if (isUnknownProfile) {
-          // Try reranker model
-          const rerankerResult = await executeCodexLens(['reranker-model-download', resolvedProfile, '--json'], { timeout: 600000 });
-          if (rerankerResult.success) {
-            try {
-              const parsed = extractJSON(rerankerResult.output ?? '');
-              return { success: true, ...parsed };
-            } catch {
-              return { success: true, output: rerankerResult.output };
-            }
-          } else {
-            return { success: false, error: rerankerResult.error, status: 500 };
-          }
-        }
-
-        if (embeddingResult.success) {
-          try {
-            const parsed = extractJSON(embeddingResult.output ?? '');
-            return { success: true, ...parsed };
-          } catch {
-            return { success: true, output: embeddingResult.output };
-          }
-        } else {
-          return { success: false, error: embeddingResult.error, status: 500 };
-        }
-      } catch (err: unknown) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  // API: CodexLens Model Download Custom (download any HuggingFace model)
-  if (pathname === '/api/codexlens/models/download-custom' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body) => {
-      const { model_name, model_type } = body as { model_name?: unknown; model_type?: unknown };
-      const resolvedModelName = typeof model_name === 'string' && model_name.trim().length > 0 ? model_name.trim() : undefined;
-      const resolvedModelType = typeof model_type === 'string' ? model_type.trim() : 'embedding';
-
-      if (!resolvedModelName) {
-        return { success: false, error: 'model_name is required', status: 400 };
-      }
-
-      // Validate model name format
-      if (!resolvedModelName.includes('/')) {
-        return { success: false, error: 'Invalid model_name format. Expected: org/model-name', status: 400 };
-      }
-
-      // v2 bridge: download-model handles any HF model name directly
-      if (useCodexLensV2()) {
-        const result = await executeV2DownloadModel(resolvedModelName);
-        if (result.success) {
-          const data = (result.status && typeof result.status === 'object') ? result.status as Record<string, unknown> : {};
-          return { success: true, ...data };
-        }
-        return { success: false, error: result.error, status: 500 };
-      }
-
-      // v1 fallback
-      try {
-        const result = await executeCodexLens([
-          'model-download-custom', resolvedModelName,
-          '--type', resolvedModelType,
-          '--json'
-        ], { timeout: 600000 }); // 10 min for download
-
-        if (result.success) {
-          try {
-            const parsed = extractJSON(result.output ?? '');
-            return { success: true, ...parsed };
-          } catch {
-            return { success: true, output: result.output };
-          }
-        } else {
-          return { success: false, error: result.error, status: 500 };
-        }
-      } catch (err: unknown) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  // API: CodexLens Model Delete (delete embedding or reranker model by profile)
-  if (pathname === '/api/codexlens/models/delete' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body) => {
-      const { profile, model_type, model_name } = body as { profile?: unknown; model_type?: unknown; model_name?: unknown };
-      const resolvedProfile = typeof profile === 'string' && profile.trim().length > 0 ? profile.trim() : undefined;
-      const resolvedModelName = typeof model_name === 'string' && model_name.trim().length > 0 ? model_name.trim() : undefined;
-      const resolvedModelType = typeof model_type === 'string' ? model_type.trim() : undefined;
-
-      // v2 bridge: delete by model name
-      if (useCodexLensV2()) {
-        const nameToDelete = resolvedModelName || resolvedProfile;
-        if (!nameToDelete) {
-          return { success: false, error: 'model_name or profile is required', status: 400 };
-        }
-        const result = await executeV2DeleteModel(nameToDelete);
-        if (result.success) {
-          const data = (result.status && typeof result.status === 'object') ? result.status as Record<string, unknown> : {};
-          return { success: true, ...data };
-        }
-        return { success: false, error: result.error, status: 500 };
-      }
-
-      // v1 fallback
-      if (!resolvedProfile) {
-        return { success: false, error: 'profile is required', status: 400 };
-      }
-
-      try {
-        // If model_type is specified, use it directly
-        if (resolvedModelType === 'reranker') {
-          const result = await executeCodexLens(['reranker-model-delete', resolvedProfile, '--json']);
-          if (result.success) {
-            try {
-              const parsed = extractJSON(result.output ?? '');
-              return { success: true, ...parsed };
-            } catch {
-              return { success: true, output: result.output };
-            }
-          } else {
-            return { success: false, error: result.error, status: 500 };
-          }
-        }
-
-        // Try embedding model first, then reranker if profile not found
-        const embeddingResult = await executeCodexLens(['model-delete', resolvedProfile, '--json']);
-
-        // Check if the error indicates unknown profile
-        const outputStr = embeddingResult.output ?? '';
-        const isUnknownProfile = !embeddingResult.success &&
-          (outputStr.includes('Unknown profile') || outputStr.includes('unknown profile'));
-
-        if (isUnknownProfile) {
-          // Try reranker model
-          const rerankerResult = await executeCodexLens(['reranker-model-delete', resolvedProfile, '--json']);
-          if (rerankerResult.success) {
-            try {
-              const parsed = extractJSON(rerankerResult.output ?? '');
-              return { success: true, ...parsed };
-            } catch {
-              return { success: true, output: rerankerResult.output };
-            }
-          } else {
-            return { success: false, error: rerankerResult.error, status: 500 };
-          }
-        }
-
-        if (embeddingResult.success) {
-          try {
-            const parsed = extractJSON(embeddingResult.output ?? '');
-            return { success: true, ...parsed };
-          } catch {
-            return { success: true, output: embeddingResult.output };
-          }
-        } else {
-          return { success: false, error: embeddingResult.error, status: 500 };
-        }
-      } catch (err: unknown) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  // API: CodexLens Model Delete by Path (delete discovered/manually placed model)
-  if (pathname === '/api/codexlens/models/delete-path' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body) => {
-      const { cache_path } = body as { cache_path?: unknown };
-      const resolvedPath = typeof cache_path === 'string' && cache_path.trim().length > 0 ? cache_path.trim() : undefined;
-
-      if (!resolvedPath) {
-        return { success: false, error: 'cache_path is required', status: 400 };
-      }
-
-      // Security: Validate that the path is within the HuggingFace cache directory
-      const { homedir } = await import('os');
-      const { join, resolve, normalize } = await import('path');
-      const { rm } = await import('fs/promises');
-
-      const hfCacheDir = process.env.HF_HOME || join(homedir(), '.cache', 'huggingface');
-      const normalizedCachePath = normalize(resolve(resolvedPath));
-      const normalizedHfCacheDir = normalize(resolve(hfCacheDir));
-
-      // Ensure the path is within the HuggingFace cache directory
-      if (!normalizedCachePath.startsWith(normalizedHfCacheDir)) {
-        return { success: false, error: 'Path must be within the HuggingFace cache directory', status: 400 };
-      }
-
-      // Ensure it's a models-- directory
-      const pathParts = normalizedCachePath.split(/[/\\]/);
-      const lastPart = pathParts[pathParts.length - 1];
-      if (!lastPart.startsWith('models--')) {
-        return { success: false, error: 'Path must be a model cache directory (models--*)', status: 400 };
-      }
-
-      try {
-        await rm(normalizedCachePath, { recursive: true, force: true });
-        return { success: true, message: 'Model deleted successfully', cache_path: normalizedCachePath };
-      } catch (err: unknown) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  // API: CodexLens Model Info (get model info by profile)
-  if (pathname === '/api/codexlens/models/info' && req.method === 'GET') {
-    const profile = url.searchParams.get('profile');
-
-    if (!profile) {
-      res.writeHead(400, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: false, error: 'profile parameter is required' }));
-      return true;
-    }
-
-    try {
-      const result = await executeCodexLens(['model-info', profile, '--json']);
-      if (result.success) {
-        try {
-          const parsed = extractJSON(result.output ?? '');
-          res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify(parsed));
-        } catch {
-          res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ success: false, error: 'Failed to parse response' }));
-        }
-      } else {
-        res.writeHead(500, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ success: false, error: result.error }));
-      }
-    } catch (err: unknown) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: false, error: err instanceof Error ? err.message : String(err) }));
-    }
-    return true;
-  }
-
-  // ============================================================
-  // ENV FILE MANAGEMENT ENDPOINTS
-  // ============================================================
-
-  // API: Get global env file content
-  if (pathname === '/api/codexlens/env' && req.method === 'GET') {
-    try {
-      const { homedir } = await import('os');
-      const { join } = await import('path');
-      const { readFile } = await import('fs/promises');
-
-      const envPath = join(getCodexLensDataDir(), '.env');
-      let content = '';
-      try {
-        content = await readFile(envPath, 'utf-8');
-      } catch {
-        // File doesn't exist, return empty
-      }
-
-      // Parse env file into key-value pairs (robust parsing)
-      const envVars: Record<string, string> = {};
-      const lines = content.split('\n');
-      for (const line of lines) {
-        const trimmed = line.trim();
-        // Skip empty lines and comments
-        if (!trimmed || trimmed.startsWith('#')) continue;
-
-        // Find first = that's part of key=value (not in a quote)
-        const eqIndex = trimmed.indexOf('=');
-        if (eqIndex <= 0) continue;
-
-        const key = trimmed.substring(0, eqIndex).trim();
-        // Validate key format (alphanumeric + underscore)
-        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) continue;
-
-        let value = trimmed.substring(eqIndex + 1);
-
-        // Handle quoted values (preserves = inside quotes)
-        if (value.startsWith('"')) {
-          // Find matching closing quote (handle escaped quotes)
-          let end = 1;
-          while (end < value.length) {
-            if (value[end] === '"' && value[end - 1] !== '\\') break;
-            end++;
-          }
-          value = value.substring(1, end).replace(/\\"/g, '"');
-        } else if (value.startsWith("'")) {
-          // Single quotes don't support escaping
-          const end = value.indexOf("'", 1);
-          value = end > 0 ? value.substring(1, end) : value.substring(1);
-        } else {
-          // Unquoted: trim and take until comment or end
-          const commentIndex = value.indexOf(' #');
-          if (commentIndex > 0) {
-            value = value.substring(0, commentIndex);
-          }
-          value = value.trim();
-        }
-
-        envVars[key] = value;
-      }
-
-      // Also read settings.json for current configuration
-      const settingsPath = join(getCodexLensDataDir(), 'settings.json');
-      let settings: Record<string, any> = {};
-      try {
-        const settingsContent = await readFile(settingsPath, 'utf-8');
-        settings = JSON.parse(settingsContent);
-      } catch {
-        // Settings file doesn't exist or is invalid, use empty
-      }
-
-      // Map settings to env var format for defaults (v2 schema)
-      const settingsDefaults: Record<string, string> = {};
-
-      // Embedding settings
-      if (settings.embedding?.backend) {
-        settingsDefaults['CODEXLENS_EMBEDDING_BACKEND'] = settings.embedding.backend;
-      }
-      if (settings.embedding?.model) {
-        settingsDefaults['CODEXLENS_EMBEDDING_MODEL'] = settings.embedding.model;
-      }
-      if (settings.embedding?.device) {
-        settingsDefaults['CODEXLENS_USE_GPU'] = settings.embedding.device;
-      }
-      if (settings.embedding?.batch_size !== undefined) {
-        settingsDefaults['CODEXLENS_EMBED_BATCH_SIZE'] = String(settings.embedding.batch_size);
-      }
-      // Embedding API settings
-      if (settings.embedding?.api_url) {
-        settingsDefaults['CODEXLENS_EMBED_API_URL'] = settings.embedding.api_url;
-      }
-      if (settings.embedding?.api_key) {
-        settingsDefaults['CODEXLENS_EMBED_API_KEY'] = settings.embedding.api_key;
-      }
-      if (settings.embedding?.api_model) {
-        settingsDefaults['CODEXLENS_EMBED_API_MODEL'] = settings.embedding.api_model;
-      }
-      if (settings.embedding?.api_endpoints) {
-        settingsDefaults['CODEXLENS_EMBED_API_ENDPOINTS'] = settings.embedding.api_endpoints;
-      }
-      if (settings.embedding?.dim !== undefined) {
-        settingsDefaults['CODEXLENS_EMBED_DIM'] = String(settings.embedding.dim);
-      }
-      if (settings.embedding?.api_concurrency !== undefined) {
-        settingsDefaults['CODEXLENS_EMBED_API_CONCURRENCY'] = String(settings.embedding.api_concurrency);
-      }
-      if (settings.embedding?.api_max_tokens_per_batch !== undefined) {
-        settingsDefaults['CODEXLENS_EMBED_API_MAX_TOKENS'] = String(settings.embedding.api_max_tokens_per_batch);
-      }
-
-      // Reranker settings
-      if (settings.reranker?.backend) {
-        settingsDefaults['CODEXLENS_RERANKER_BACKEND'] = settings.reranker.backend;
-      }
-      if (settings.reranker?.model) {
-        settingsDefaults['CODEXLENS_RERANKER_MODEL'] = settings.reranker.model;
-      }
-      if (settings.reranker?.top_k !== undefined) {
-        settingsDefaults['CODEXLENS_RERANKER_TOP_K'] = String(settings.reranker.top_k);
-      }
-      if (settings.reranker?.batch_size !== undefined) {
-        settingsDefaults['CODEXLENS_RERANKER_BATCH_SIZE'] = String(settings.reranker.batch_size);
-      }
-      // Reranker API settings
-      if (settings.reranker?.api_url) {
-        settingsDefaults['CODEXLENS_RERANKER_API_URL'] = settings.reranker.api_url;
-      }
-      if (settings.reranker?.api_key) {
-        settingsDefaults['CODEXLENS_RERANKER_API_KEY'] = settings.reranker.api_key;
-      }
-      if (settings.reranker?.api_model) {
-        settingsDefaults['CODEXLENS_RERANKER_API_MODEL'] = settings.reranker.api_model;
-      }
-
-      // Search pipeline settings
-      if (settings.search?.binary_top_k !== undefined) {
-        settingsDefaults['CODEXLENS_BINARY_TOP_K'] = String(settings.search.binary_top_k);
-      }
-      if (settings.search?.ann_top_k !== undefined) {
-        settingsDefaults['CODEXLENS_ANN_TOP_K'] = String(settings.search.ann_top_k);
-      }
-      if (settings.search?.fts_top_k !== undefined) {
-        settingsDefaults['CODEXLENS_FTS_TOP_K'] = String(settings.search.fts_top_k);
-      }
-      if (settings.search?.fusion_k !== undefined) {
-        settingsDefaults['CODEXLENS_FUSION_K'] = String(settings.search.fusion_k);
-      }
-
-      // Indexing settings
-      if (settings.indexing?.code_aware_chunking !== undefined) {
-        settingsDefaults['CODEXLENS_CODE_AWARE_CHUNKING'] = String(settings.indexing.code_aware_chunking);
-      }
-      if (settings.indexing?.workers !== undefined) {
-        settingsDefaults['CODEXLENS_INDEX_WORKERS'] = String(settings.indexing.workers);
-      }
-      if (settings.indexing?.max_file_size_bytes !== undefined) {
-        settingsDefaults['CODEXLENS_MAX_FILE_SIZE'] = String(settings.indexing.max_file_size_bytes);
-      }
-      if (settings.indexing?.hnsw_ef !== undefined) {
-        settingsDefaults['CODEXLENS_HNSW_EF'] = String(settings.indexing.hnsw_ef);
-      }
-      if (settings.indexing?.hnsw_M !== undefined) {
-        settingsDefaults['CODEXLENS_HNSW_M'] = String(settings.indexing.hnsw_M);
-      }
-
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        success: true,
-        path: envPath,
-        env: envVars,
-        raw: content,
-        settings: settingsDefaults
-      }));
-    } catch (err: unknown) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: false, error: err instanceof Error ? err.message : String(err) }));
-    }
-    return true;
-  }
-
-  // API: Save global env file content (merge mode - preserves existing values)
-  if (pathname === '/api/codexlens/env' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body) => {
-      const { env } = body as { env: Record<string, string> };
-
-      if (!env || typeof env !== 'object') {
-        return { success: false, error: 'env object is required', status: 400 };
-      }
-
-      try {
-        const { homedir } = await import('os');
-        const { join, dirname } = await import('path');
-        const { writeFile, mkdir, readFile } = await import('fs/promises');
-
-        const envPath = join(getCodexLensDataDir(), '.env');
-        await mkdir(dirname(envPath), { recursive: true });
-
-        // Read existing env file to preserve custom variables
-        let existingEnv: Record<string, string> = {};
-        let existingComments: string[] = [];
-        try {
-          const content = await readFile(envPath, 'utf-8');
-          const lines = content.split('\n');
-          for (const line of lines) {
-            const trimmed = line.trim();
-            // Preserve comment lines that aren't our headers
-            if (trimmed.startsWith('#') && !trimmed.includes('Managed by CCW')) {
-              if (!trimmed.includes('Reranker Configuration') && !trimmed.includes('Embedding Configuration') &&
-                  !trimmed.includes('Search Pipeline') && !trimmed.includes('Indexing Settings') &&
-                  !trimmed.includes('Other Settings') && !trimmed.includes('CodexLens Environment')) {
-                existingComments.push(line);
-              }
-            }
-            if (!trimmed || trimmed.startsWith('#')) continue;
-
-            // Robust parsing (same as GET handler)
-            const eqIndex = trimmed.indexOf('=');
-            if (eqIndex <= 0) continue;
-
-            const key = trimmed.substring(0, eqIndex).trim();
-            if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) continue;
-
-            let value = trimmed.substring(eqIndex + 1);
-            if (value.startsWith('"')) {
-              let end = 1;
-              while (end < value.length) {
-                if (value[end] === '"' && value[end - 1] !== '\\') break;
-                end++;
-              }
-              value = value.substring(1, end).replace(/\\"/g, '"');
-            } else if (value.startsWith("'")) {
-              const end = value.indexOf("'", 1);
-              value = end > 0 ? value.substring(1, end) : value.substring(1);
-            } else {
-              const commentIndex = value.indexOf(' #');
-              if (commentIndex > 0) value = value.substring(0, commentIndex);
-              value = value.trim();
-            }
-            existingEnv[key] = value;
-          }
-        } catch {
-          // File doesn't exist, start fresh
-        }
-
-        // Merge: update known keys from payload, preserve unknown keys
-        const knownKeys = new Set([
-          // v2 embedding
-          'CODEXLENS_EMBEDDING_BACKEND', 'CODEXLENS_EMBEDDING_MODEL', 'CODEXLENS_USE_GPU',
-          'CODEXLENS_EMBED_BATCH_SIZE', 'CODEXLENS_EMBED_API_URL', 'CODEXLENS_EMBED_API_KEY',
-          'CODEXLENS_EMBED_API_MODEL', 'CODEXLENS_EMBED_API_ENDPOINTS', 'CODEXLENS_EMBED_DIM',
-          'CODEXLENS_EMBED_API_CONCURRENCY', 'CODEXLENS_EMBED_API_MAX_TOKENS',
-          // v2 reranker
-          'CODEXLENS_RERANKER_BACKEND', 'CODEXLENS_RERANKER_MODEL', 'CODEXLENS_RERANKER_TOP_K',
-          'CODEXLENS_RERANKER_BATCH_SIZE', 'CODEXLENS_RERANKER_API_URL',
-          'CODEXLENS_RERANKER_API_KEY', 'CODEXLENS_RERANKER_API_MODEL',
-          // v2 search pipeline
-          'CODEXLENS_BINARY_TOP_K', 'CODEXLENS_ANN_TOP_K', 'CODEXLENS_FTS_TOP_K', 'CODEXLENS_FUSION_K',
-          // v2 indexing
-          'CODEXLENS_CODE_AWARE_CHUNKING', 'CODEXLENS_INDEX_WORKERS', 'CODEXLENS_MAX_FILE_SIZE',
-          'CODEXLENS_HNSW_EF', 'CODEXLENS_HNSW_M',
-        ]);
-
-        // Apply updates from payload
-        for (const [key, value] of Object.entries(env)) {
-          if (value) {
-            existingEnv[key] = value;
-          } else if (knownKeys.has(key)) {
-            // Remove known key if value is empty
-            delete existingEnv[key];
-          }
-        }
-
-        // Build env file content
-        const lines = [
-          '# CodexLens Environment Configuration',
-          '# Managed by CCW Dashboard',
-          ''
-        ];
-
-        // Add preserved custom comments
-        if (existingComments.length > 0) {
-          lines.push(...existingComments, '');
-        }
-
-        // Group by semantic category (v2 env var naming)
-        const groups: Record<string, string[]> = {
-          'EMBED': [],
-          'RERANKER': [],
-          'SEARCH': [],
-          'INDEX': [],
-          'OTHER': []
-        };
-
-        for (const [key, value] of Object.entries(existingEnv)) {
-          if (!value) continue;
-          // SECURITY: Escape special characters to prevent .env injection
-          const escapedValue = value
-            .replace(/\\/g, '\\\\')  // Escape backslashes first
-            .replace(/"/g, '\\"')    // Escape double quotes
-            .replace(/\n/g, '\\n')   // Escape newlines
-            .replace(/\r/g, '\\r');  // Escape carriage returns
-          const line = `${key}="${escapedValue}"`;
-          if (key.includes('EMBED') || key === 'CODEXLENS_USE_GPU') groups['EMBED'].push(line);
-          else if (key.includes('RERANKER')) groups['RERANKER'].push(line);
-          else if (key.includes('BINARY_TOP_K') || key.includes('ANN_TOP_K') || key.includes('FTS_TOP_K') || key.includes('FUSION_K')) groups['SEARCH'].push(line);
-          else if (key.includes('INDEX') || key.includes('HNSW') || key.includes('MAX_FILE_SIZE') || key.includes('CODE_AWARE')) groups['INDEX'].push(line);
-          else groups['OTHER'].push(line);
-        }
-
-        // Add grouped content
-        if (groups['EMBED'].length) {
-          lines.push('# Embedding Configuration');
-          lines.push(...groups['EMBED'], '');
-        }
-        if (groups['RERANKER'].length) {
-          lines.push('# Reranker Configuration');
-          lines.push(...groups['RERANKER'], '');
-        }
-        if (groups['SEARCH'].length) {
-          lines.push('# Search Pipeline');
-          lines.push(...groups['SEARCH'], '');
-        }
-        if (groups['INDEX'].length) {
-          lines.push('# Indexing Settings');
-          lines.push(...groups['INDEX'], '');
-        }
-        if (groups['OTHER'].length) {
-          lines.push('# Other Settings');
-          lines.push(...groups['OTHER'], '');
-        }
-
-        await writeFile(envPath, lines.join('\n'), 'utf-8');
-
-        // Also update settings.json with mapped values
-        const settingsPath = join(getCodexLensDataDir(), 'settings.json');
-        let settings: Record<string, any> = {};
-        try {
-          const settingsContent = await readFile(settingsPath, 'utf-8');
-          settings = JSON.parse(settingsContent);
-        } catch {
-          // File doesn't exist, create default structure (v2 sections)
-          settings = { embedding: {}, reranker: {}, search: {}, indexing: {} };
-        }
-
-        // Map env vars to settings.json structure (v2 schema)
-        const envToSettings: Record<string, { path: string[], transform?: (v: string) => any }> = {
-          // Embedding
-          'CODEXLENS_EMBEDDING_BACKEND': { path: ['embedding', 'backend'] },
-          'CODEXLENS_EMBEDDING_MODEL': { path: ['embedding', 'model'] },
-          'CODEXLENS_USE_GPU': { path: ['embedding', 'device'] },
-          'CODEXLENS_EMBED_BATCH_SIZE': { path: ['embedding', 'batch_size'], transform: v => parseInt(v, 10) },
-          'CODEXLENS_EMBED_API_URL': { path: ['embedding', 'api_url'] },
-          'CODEXLENS_EMBED_API_KEY': { path: ['embedding', 'api_key'] },
-          'CODEXLENS_EMBED_API_MODEL': { path: ['embedding', 'api_model'] },
-          'CODEXLENS_EMBED_API_ENDPOINTS': { path: ['embedding', 'api_endpoints'] },
-          'CODEXLENS_EMBED_DIM': { path: ['embedding', 'dim'], transform: v => parseInt(v, 10) },
-          'CODEXLENS_EMBED_API_CONCURRENCY': { path: ['embedding', 'api_concurrency'], transform: v => parseInt(v, 10) },
-          'CODEXLENS_EMBED_API_MAX_TOKENS': { path: ['embedding', 'api_max_tokens_per_batch'], transform: v => parseInt(v, 10) },
-          // Reranker
-          'CODEXLENS_RERANKER_BACKEND': { path: ['reranker', 'backend'] },
-          'CODEXLENS_RERANKER_MODEL': { path: ['reranker', 'model'] },
-          'CODEXLENS_RERANKER_TOP_K': { path: ['reranker', 'top_k'], transform: v => parseInt(v, 10) },
-          'CODEXLENS_RERANKER_BATCH_SIZE': { path: ['reranker', 'batch_size'], transform: v => parseInt(v, 10) },
-          'CODEXLENS_RERANKER_API_URL': { path: ['reranker', 'api_url'] },
-          'CODEXLENS_RERANKER_API_KEY': { path: ['reranker', 'api_key'] },
-          'CODEXLENS_RERANKER_API_MODEL': { path: ['reranker', 'api_model'] },
-          // Search pipeline
-          'CODEXLENS_BINARY_TOP_K': { path: ['search', 'binary_top_k'], transform: v => parseInt(v, 10) },
-          'CODEXLENS_ANN_TOP_K': { path: ['search', 'ann_top_k'], transform: v => parseInt(v, 10) },
-          'CODEXLENS_FTS_TOP_K': { path: ['search', 'fts_top_k'], transform: v => parseInt(v, 10) },
-          'CODEXLENS_FUSION_K': { path: ['search', 'fusion_k'], transform: v => parseInt(v, 10) },
-          // Indexing
-          'CODEXLENS_CODE_AWARE_CHUNKING': { path: ['indexing', 'code_aware_chunking'], transform: v => v === 'true' },
-          'CODEXLENS_INDEX_WORKERS': { path: ['indexing', 'workers'], transform: v => parseInt(v, 10) },
-          'CODEXLENS_MAX_FILE_SIZE': { path: ['indexing', 'max_file_size_bytes'], transform: v => parseInt(v, 10) },
-          'CODEXLENS_HNSW_EF': { path: ['indexing', 'hnsw_ef'], transform: v => parseInt(v, 10) },
-          'CODEXLENS_HNSW_M': { path: ['indexing', 'hnsw_M'], transform: v => parseInt(v, 10) },
-        };
-
-        // Apply env vars to settings
-        for (const [envKey, value] of Object.entries(env)) {
-          const mapping = envToSettings[envKey];
-          if (mapping && value) {
-            const [section, key] = mapping.path;
-            if (!settings[section]) settings[section] = {};
-            settings[section][key] = mapping.transform ? mapping.transform(value) : value;
-          }
-        }
-
-        // Write updated settings
-        await writeFile(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
-
-        return {
-          success: true,
-          message: 'Environment and settings configuration saved',
-          path: envPath,
-          settingsPath
-        };
-      } catch (err: unknown) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  // ============================================================
-  // IGNORE PATTERNS CONFIGURATION ENDPOINTS
-  // ============================================================
-
-  // API: Get ignore patterns configuration
-  if (pathname === '/api/codexlens/ignore-patterns' && req.method === 'GET') {
-    try {
-      const { homedir } = await import('os');
-      const { join } = await import('path');
-      const { readFile } = await import('fs/promises');
-
-      const settingsPath = join(getCodexLensDataDir(), 'settings.json');
-      let settings: Record<string, any> = {};
-      try {
-        const content = await readFile(settingsPath, 'utf-8');
-        settings = JSON.parse(content);
-      } catch {
-        // File doesn't exist
-      }
-
-      // Default ignore patterns (matching WatcherConfig defaults in events.py)
-      const defaultPatterns = [
-        // Version control
-        '.git', '.svn', '.hg',
-        // Python environments & cache
-        '.venv', 'venv', 'env', '__pycache__', '.pytest_cache', '.mypy_cache', '.ruff_cache',
-        // Node.js
-        'node_modules', 'bower_components', '.npm', '.yarn',
-        // Build artifacts
-        'dist', 'build', 'out', 'target', 'bin', 'obj', '_build', 'coverage', 'htmlcov',
-        // IDE & Editor
-        '.idea', '.vscode', '.vs', '.eclipse',
-        // CodexLens internal
-        '.codexlens',
-        // Package manager caches
-        '.cache', '.parcel-cache', '.turbo', '.next', '.nuxt',
-        // Logs & temp
-        'logs', 'tmp', 'temp',
-      ];
-
-      // Default extension filters for embeddings (files skipped for vector index)
-      const defaultExtensionFilters = [
-        // Lock files (large, repetitive)
-        'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'composer.lock', 'Gemfile.lock', 'poetry.lock',
-        // Generated/minified
-        '*.min.js', '*.min.css', '*.bundle.js',
-        // Binary-like text
-        '*.svg', '*.map',
-      ];
-
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        success: true,
-        patterns: settings.ignore_patterns || defaultPatterns,
-        extensionFilters: settings.extension_filters || defaultExtensionFilters,
-        defaults: {
-          patterns: defaultPatterns,
-          extensionFilters: defaultExtensionFilters
-        }
-      }));
-    } catch (err: unknown) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: false, error: err instanceof Error ? err.message : String(err) }));
-    }
-    return true;
-  }
-
-  // API: Save ignore patterns configuration
-  if (pathname === '/api/codexlens/ignore-patterns' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body) => {
-      const { patterns, extensionFilters } = body as {
-        patterns?: string[];
-        extensionFilters?: string[];
-      };
-
-      try {
-        const { homedir } = await import('os');
-        const { join, dirname } = await import('path');
-        const { writeFile, mkdir, readFile } = await import('fs/promises');
-
-        const settingsPath = join(getCodexLensDataDir(), 'settings.json');
-        await mkdir(dirname(settingsPath), { recursive: true });
-
-        // Read existing settings
-        let settings: Record<string, any> = {};
-        try {
-          const content = await readFile(settingsPath, 'utf-8');
-          settings = JSON.parse(content);
-        } catch {
-          // File doesn't exist, start fresh
-        }
-
-        // Validate patterns (alphanumeric, dots, underscores, dashes, asterisks)
-        const validPatternRegex = /^[\w.*\-/]+$/;
-        if (patterns) {
-          const invalidPatterns = patterns.filter(p => !validPatternRegex.test(p));
-          if (invalidPatterns.length > 0) {
-            return {
-              success: false,
-              error: `Invalid patterns: ${invalidPatterns.join(', ')}`,
-              status: 400
-            };
-          }
-          settings.ignore_patterns = patterns;
-        }
-
-        if (extensionFilters) {
-          const invalidFilters = extensionFilters.filter(p => !validPatternRegex.test(p));
-          if (invalidFilters.length > 0) {
-            return {
-              success: false,
-              error: `Invalid extension filters: ${invalidFilters.join(', ')}`,
-              status: 400
-            };
-          }
-          settings.extension_filters = extensionFilters;
-        }
-
-        // Write updated settings
-        await writeFile(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
-
-        return {
-          success: true,
-          message: 'Ignore patterns saved successfully',
-          patterns: settings.ignore_patterns,
-          extensionFilters: settings.extension_filters
-        };
-      } catch (err: unknown) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  return false;
-}
diff --git a/ccw/src/core/routes/codexlens/index-handlers.ts b/ccw/src/core/routes/codexlens/index-handlers.ts
deleted file mode 100644
index 923a2f7b..00000000
--- a/ccw/src/core/routes/codexlens/index-handlers.ts
+++ /dev/null
@@ -1,459 +0,0 @@
-/**
- * CodexLens index management handlers.
- */
-
-import {
-  cancelIndexing,
-  checkVenvStatus,
-  checkSemanticStatus,
-  ensureLiteLLMEmbedderReady,
-  executeCodexLens,
-  isIndexingInProgress,
-} from '../../../tools/codex-lens.js';
-import type { ProgressInfo } from '../../../tools/codex-lens.js';
-import type { RouteContext } from '../types.js';
-import { extractJSON, formatSize } from './utils.js';
-
-/**
- * Handle CodexLens index routes
- * @returns true if route was handled, false otherwise
- */
-export async function handleCodexLensIndexRoutes(ctx: RouteContext): Promise<boolean> {
-  const { pathname, url, req, res, initialPath, handlePostRequest, broadcastToClients } = ctx;
-
-  // API: CodexLens Index List - Get all indexed projects with details
-  if (pathname === '/api/codexlens/indexes') {
-    try {
-      // Check if CodexLens is installed first (without auto-installing)
-      const venvStatus = await checkVenvStatus();
-      if (!venvStatus.ready) {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ success: true, indexes: [], totalSize: 0, totalSizeFormatted: '0 B' }));
-        return true;
-      }
-
-      // Execute all CLI commands in parallel
-      const [configResult, projectsResult, statusResult] = await Promise.all([
-        executeCodexLens(['config', '--json']),
-        executeCodexLens(['projects', 'list', '--json']),
-        executeCodexLens(['status', '--json'])
-      ]);
-
-      let indexDir = '';
-      if (configResult.success) {
-        try {
-          const config = extractJSON(configResult.output ?? '');
-          if (config.success && config.result) {
-            // CLI returns index_dir (not index_root)
-            indexDir = config.result.index_dir || config.result.index_root || '';
-          }
-        } catch (e: unknown) {
-          console.error('[CodexLens] Failed to parse config for index list:', e instanceof Error ? e.message : String(e));
-        }
-      }
-
-      let indexes: any[] = [];
-      let totalSize = 0;
-      let vectorIndexCount = 0;
-      let normalIndexCount = 0;
-
-      if (projectsResult.success) {
-        try {
-          const projectsData = extractJSON(projectsResult.output ?? '');
-          if (projectsData.success && Array.isArray(projectsData.result)) {
-            const { stat, readdir } = await import('fs/promises');
-            const { existsSync } = await import('fs');
-            const { basename, join } = await import('path');
-
-            for (const project of projectsData.result) {
-              // Skip test/temp projects
-              if (project.source_root && (
-                project.source_root.includes('\\Temp\\') ||
-                project.source_root.includes('/tmp/') ||
-                project.total_files === 0
-              )) {
-                continue;
-              }
-
-              let projectSize = 0;
-              let hasVectorIndex = false;
-              let hasNormalIndex = true; // All projects have FTS index
-              let lastModified = null;
-
-              // Try to get actual index size from index_root
-              if (project.index_root && existsSync(project.index_root)) {
-                try {
-                  const files = await readdir(project.index_root);
-                  for (const file of files) {
-                    try {
-                      const filePath = join(project.index_root, file);
-                      const fileStat = await stat(filePath);
-                      projectSize += fileStat.size;
-                      if (!lastModified || fileStat.mtime > lastModified) {
-                        lastModified = fileStat.mtime;
-                      }
-                      // Check for vector/embedding files
-                      if (file.includes('vector') || file.includes('embedding') ||
-                          file.endsWith('.faiss') || file.endsWith('.npy') ||
-                          file.includes('semantic_chunks')) {
-                        hasVectorIndex = true;
-                      }
-                    } catch {
-                      // Skip files we can't stat
-                    }
-                  }
-                } catch {
-                  // Can't read index directory
-                }
-              }
-
-              if (hasVectorIndex) vectorIndexCount++;
-              if (hasNormalIndex) normalIndexCount++;
-              totalSize += projectSize;
-
-              // Use source_root as the display name
-              const displayName = project.source_root ? basename(project.source_root) : `project_${project.id}`;
-
-              indexes.push({
-                id: displayName,
-                path: project.source_root || '',
-                indexPath: project.index_root || '',
-                size: projectSize,
-                sizeFormatted: formatSize(projectSize),
-                fileCount: project.total_files || 0,
-                dirCount: project.total_dirs || 0,
-                hasVectorIndex,
-                hasNormalIndex,
-                status: project.status || 'active',
-                lastModified: lastModified ? lastModified.toISOString() : null
-              });
-            }
-
-            // Sort by file count (most files first), then by name
-            indexes.sort((a, b) => {
-              if (b.fileCount !== a.fileCount) return b.fileCount - a.fileCount;
-              return a.id.localeCompare(b.id);
-            });
-          }
-        } catch (e: unknown) {
-          console.error('[CodexLens] Failed to parse projects list:', e instanceof Error ? e.message : String(e));
-        }
-      }
-
-      // Parse summary stats from status command (already fetched in parallel)
-      let statusSummary: any = {};
-
-      if (statusResult.success) {
-        try {
-          const status = extractJSON(statusResult.output ?? '');
-          if (status.success && status.result) {
-            statusSummary = {
-              totalProjects: status.result.projects_count || indexes.length,
-              totalFiles: status.result.total_files || 0,
-              totalDirs: status.result.total_dirs || 0,
-              // Keep calculated totalSize for consistency with per-project sizes
-              // status.index_size_bytes includes shared resources (models, cache)
-              indexSizeBytes: totalSize,
-              indexSizeMb: totalSize / (1024 * 1024),
-              embeddings: status.result.embeddings || {},
-              // Store full index dir size separately for reference
-              fullIndexDirSize: status.result.index_size_bytes || 0,
-              fullIndexDirSizeFormatted: formatSize(status.result.index_size_bytes || 0)
-            };
-          }
-        } catch (e: unknown) {
-          console.error('[CodexLens] Failed to parse status:', e instanceof Error ? e.message : String(e));
-        }
-      }
-
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        success: true,
-        indexDir,
-        indexes,
-        summary: {
-          totalProjects: indexes.length,
-          totalSize,
-          totalSizeFormatted: formatSize(totalSize),
-          vectorIndexCount,
-          normalIndexCount,
-          ...statusSummary
-        }
-      }));
-    } catch (err: unknown) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: false, error: err instanceof Error ? err.message : String(err) }));
-    }
-    return true;
-  }
-
-  // API: CodexLens Clean (Clean indexes)
-  if (pathname === '/api/codexlens/clean' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body) => {
-      const { all = false, path } = body as { all?: unknown; path?: unknown };
-
-      try {
-        const args = ['clean'];
-        if (all === true) {
-          args.push('--all');
-        } else if (typeof path === 'string' && path.trim().length > 0) {
-          // Path is passed as a positional argument, not as a flag
-          args.push(path);
-        }
-        args.push('--json');
-
-        const result = await executeCodexLens(args);
-        if (result.success) {
-          return { success: true, message: 'Indexes cleaned successfully' };
-        } else {
-          return { success: false, error: result.error || 'Failed to clean indexes', status: 500 };
-        }
-      } catch (err: unknown) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  // API: CodexLens Init (Initialize workspace index)
-  if (pathname === '/api/codexlens/init' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body) => {
-      const { path: projectPath, indexType = 'vector', embeddingModel = 'code', embeddingBackend = 'fastembed', maxWorkers = 1 } = body as {
-        path?: unknown;
-        indexType?: unknown;
-        embeddingModel?: unknown;
-        embeddingBackend?: unknown;
-        maxWorkers?: unknown;
-      };
-      const targetPath = typeof projectPath === 'string' && projectPath.trim().length > 0 ? projectPath : initialPath;
-      const resolvedIndexType = indexType === 'normal' ? 'normal' : 'vector';
-      const resolvedEmbeddingModel = typeof embeddingModel === 'string' && embeddingModel.trim().length > 0 ? embeddingModel : 'code';
-      const resolvedEmbeddingBackend = typeof embeddingBackend === 'string' && embeddingBackend.trim().length > 0 ? embeddingBackend : 'fastembed';
-      const resolvedMaxWorkers = typeof maxWorkers === 'number' ? maxWorkers : Number(maxWorkers);
-
-      // Pre-check: Verify embedding backend availability before proceeding with vector indexing
-      // This prevents silent degradation where vector indexing is skipped without error
-      if (resolvedIndexType !== 'normal') {
-        if (resolvedEmbeddingBackend === 'litellm') {
-          // For litellm backend, ensure ccw-litellm is installed
-          const installResult = await ensureLiteLLMEmbedderReady();
-          if (!installResult.success) {
-            return {
-              success: false,
-              error: installResult.error || 'LiteLLM embedding backend is not available. Please install ccw-litellm first.',
-              status: 500
-            };
-          }
-        } else {
-          // For fastembed backend (default), check semantic dependencies
-          const semanticStatus = await checkSemanticStatus();
-          if (!semanticStatus.available) {
-            return {
-              success: false,
-              error: semanticStatus.error || 'FastEmbed semantic backend is not available. Please install semantic dependencies first (CodeLens Settings → Install Semantic).',
-              status: 500
-            };
-          }
-        }
-      }
-
-      // Build CLI arguments based on index type
-      // Use 'index init' subcommand (new CLI structure)
-      // --force flag ensures full reindex (not incremental)
-      const args = ['index', 'init', targetPath, '--force', '--json'];
-      if (resolvedIndexType === 'normal') {
-        args.push('--no-embeddings');
-      } else {
-        // Add embedding model selection for vector index (use --model, not --embedding-model)
-        args.push('--model', resolvedEmbeddingModel);
-        // Add embedding backend if not using default fastembed (use --backend, not --embedding-backend)
-        if (resolvedEmbeddingBackend && resolvedEmbeddingBackend !== 'fastembed') {
-          args.push('--backend', resolvedEmbeddingBackend);
-        }
-        // Add max workers for concurrent API calls (useful for litellm backend)
-        if (!Number.isNaN(resolvedMaxWorkers) && resolvedMaxWorkers > 1) {
-          args.push('--max-workers', String(resolvedMaxWorkers));
-        }
-      }
-
-      // Broadcast start event
-      broadcastToClients({
-        type: 'CODEXLENS_INDEX_PROGRESS',
-        payload: { stage: 'start', message: 'Starting index...', percent: 0, path: targetPath, indexType: resolvedIndexType }
-      });
-
-      try {
-        const result = await executeCodexLens(args, {
-          cwd: targetPath,
-          timeout: 1800000, // 30 minutes for large codebases
-          onProgress: (progress: ProgressInfo) => {
-            broadcastToClients({
-              type: 'CODEXLENS_INDEX_PROGRESS',
-              payload: { ...progress, path: targetPath }
-            });
-          }
-        });
-
-        if (result.success) {
-          broadcastToClients({
-            type: 'CODEXLENS_INDEX_PROGRESS',
-            payload: { stage: 'complete', message: 'Index complete', percent: 100, path: targetPath }
-          });
-
-          try {
-            const parsed = extractJSON(result.output ?? '');
-            return { success: true, result: parsed };
-          } catch {
-            return { success: true, output: result.output ?? '' };
-          }
-        } else {
-          broadcastToClients({
-            type: 'CODEXLENS_INDEX_PROGRESS',
-            payload: { stage: 'error', message: result.error || 'Unknown error', percent: 0, path: targetPath }
-          });
-          return { success: false, error: result.error, status: 500 };
-        }
-      } catch (err: unknown) {
-        const message = err instanceof Error ? err.message : String(err);
-        broadcastToClients({
-          type: 'CODEXLENS_INDEX_PROGRESS',
-          payload: { stage: 'error', message, percent: 0, path: targetPath }
-        });
-        return { success: false, error: message, status: 500 };
-      }
-    });
-    return true;
-  }
-
-  // API: Cancel CodexLens Indexing
-  if (pathname === '/api/codexlens/cancel' && req.method === 'POST') {
-    const result = cancelIndexing();
-
-    // Broadcast cancellation event
-    if (result.success) {
-      broadcastToClients({
-        type: 'CODEXLENS_INDEX_PROGRESS',
-        payload: { stage: 'cancelled', message: 'Indexing cancelled by user', percent: 0 }
-      });
-    }
-
-    res.writeHead(result.success ? 200 : 400, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify(result));
-    return true;
-  }
-
-  // API: CodexLens Update (Incremental index update)
-  if (pathname === '/api/codexlens/update' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body) => {
-      const { path: projectPath, indexType = 'vector', embeddingModel = 'code', embeddingBackend = 'fastembed', maxWorkers = 1 } = body as {
-        path?: unknown;
-        indexType?: unknown;
-        embeddingModel?: unknown;
-        embeddingBackend?: unknown;
-        maxWorkers?: unknown;
-      };
-      const targetPath = typeof projectPath === 'string' && projectPath.trim().length > 0 ? projectPath : initialPath;
-      const resolvedIndexType = indexType === 'normal' ? 'normal' : 'vector';
-      const resolvedEmbeddingModel = typeof embeddingModel === 'string' && embeddingModel.trim().length > 0 ? embeddingModel : 'code';
-      const resolvedEmbeddingBackend = typeof embeddingBackend === 'string' && embeddingBackend.trim().length > 0 ? embeddingBackend : 'fastembed';
-      const resolvedMaxWorkers = typeof maxWorkers === 'number' ? maxWorkers : Number(maxWorkers);
-
-      // Pre-check: Verify embedding backend availability before proceeding with vector indexing
-      if (resolvedIndexType !== 'normal') {
-        if (resolvedEmbeddingBackend === 'litellm') {
-          const installResult = await ensureLiteLLMEmbedderReady();
-          if (!installResult.success) {
-            return {
-              success: false,
-              error: installResult.error || 'LiteLLM embedding backend is not available. Please install ccw-litellm first.',
-              status: 500
-            };
-          }
-        } else {
-          const semanticStatus = await checkSemanticStatus();
-          if (!semanticStatus.available) {
-            return {
-              success: false,
-              error: semanticStatus.error || 'FastEmbed semantic backend is not available. Please install semantic dependencies first.',
-              status: 500
-            };
-          }
-        }
-      }
-
-      // Build CLI arguments for incremental update using 'index init' without --force
-      // 'index init' defaults to incremental mode (skip unchanged files)
-      // 'index update' is only for single-file updates in hooks
-      const args = ['index', 'init', targetPath, '--json'];
-      if (resolvedIndexType === 'normal') {
-        args.push('--no-embeddings');
-      } else {
-        args.push('--model', resolvedEmbeddingModel);
-        if (resolvedEmbeddingBackend && resolvedEmbeddingBackend !== 'fastembed') {
-          args.push('--backend', resolvedEmbeddingBackend);
-        }
-        if (!Number.isNaN(resolvedMaxWorkers) && resolvedMaxWorkers > 1) {
-          args.push('--max-workers', String(resolvedMaxWorkers));
-        }
-      }
-
-      // Broadcast start event
-      broadcastToClients({
-        type: 'CODEXLENS_INDEX_PROGRESS',
-        payload: { stage: 'start', message: 'Starting incremental index update...', percent: 0, path: targetPath, indexType: resolvedIndexType }
-      });
-
-      try {
-        const result = await executeCodexLens(args, {
-          cwd: targetPath,
-          timeout: 1800000,
-          onProgress: (progress: ProgressInfo) => {
-            broadcastToClients({
-              type: 'CODEXLENS_INDEX_PROGRESS',
-              payload: { ...progress, path: targetPath }
-            });
-          }
-        });
-
-        if (result.success) {
-          broadcastToClients({
-            type: 'CODEXLENS_INDEX_PROGRESS',
-            payload: { stage: 'complete', message: 'Incremental update complete', percent: 100, path: targetPath }
-          });
-
-          try {
-            const parsed = extractJSON(result.output ?? '');
-            return { success: true, result: parsed };
-          } catch {
-            return { success: true, output: result.output ?? '' };
-          }
-        } else {
-          broadcastToClients({
-            type: 'CODEXLENS_INDEX_PROGRESS',
-            payload: { stage: 'error', message: result.error || 'Unknown error', percent: 0, path: targetPath }
-          });
-          return { success: false, error: result.error, status: 500 };
-        }
-      } catch (err: unknown) {
-        const message = err instanceof Error ? err.message : String(err);
-        broadcastToClients({
-          type: 'CODEXLENS_INDEX_PROGRESS',
-          payload: { stage: 'error', message, percent: 0, path: targetPath }
-        });
-        return { success: false, error: message, status: 500 };
-      }
-    });
-    return true;
-  }
-
-  // API: Check if indexing is in progress
-  if (pathname === '/api/codexlens/indexing-status') {
-    const inProgress = isIndexingInProgress();
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ success: true, inProgress }));
-    return true;
-  }
-
-  return false;
-}
-
diff --git a/ccw/src/core/routes/codexlens/semantic-handlers.ts b/ccw/src/core/routes/codexlens/semantic-handlers.ts
deleted file mode 100644
index 76d56f1b..00000000
--- a/ccw/src/core/routes/codexlens/semantic-handlers.ts
+++ /dev/null
@@ -1,1289 +0,0 @@
-/**
- * CodexLens semantic search + reranker + SPLADE handlers.
- */
-
-import {
-  checkSemanticStatus,
-  checkVenvStatus,
-  executeCodexLens,
-  installSemantic,
-} from '../../../tools/codex-lens.js';
-import { getCodexLensHiddenPython } from '../../../utils/codexlens-path.js';
-import { spawn } from 'child_process';
-import type { GpuMode } from '../../../tools/codex-lens.js';
-import { loadLiteLLMApiConfig, getAvailableModelsForType, getProvider, getAllProviders } from '../../../config/litellm-api-config-manager.js';
-import {
-  isUvAvailable,
-  createCodexLensUvManager,
-} from '../../../utils/uv-manager.js';
-import type { RouteContext } from '../types.js';
-import { extractJSON } from './utils.js';
-import { getDefaultTool } from '../../../tools/claude-cli-tools.js';
-import { getCodexLensDataDir } from '../../../utils/codexlens-path.js';
-
-/**
- * Execute CodexLens Python API call directly (bypasses CLI for richer API access).
- */
-async function executeCodexLensPythonAPI(
-  apiFunction: string,
-  args: Record<string, unknown>,
-  timeout: number = 60000
-): Promise<{ success: boolean; results?: unknown; error?: string }> {
-  return new Promise((resolve) => {
-    const pythonScript = `
-import json
-import sys
-from dataclasses import is_dataclass, asdict
-from codexlens.api import ${apiFunction}
-
-def to_serializable(obj):
-    if obj is None:
-        return None
-    if is_dataclass(obj) and not isinstance(obj, type):
-        return asdict(obj)
-    if isinstance(obj, list):
-        return [to_serializable(item) for item in obj]
-    if isinstance(obj, dict):
-        return {key: to_serializable(value) for key, value in obj.items()}
-    if isinstance(obj, tuple):
-        return tuple(to_serializable(item) for item in obj)
-    return obj
-
-try:
-    args = ${JSON.stringify(args)}
-    result = ${apiFunction}(**args)
-    output = to_serializable(result)
-    print(json.dumps({"success": True, "result": output}))
-except Exception as e:
-    print(json.dumps({"success": False, "error": str(e)}))
-    sys.exit(1)
-`;
-
-    const pythonPath = getCodexLensHiddenPython();
-    const child = spawn(pythonPath, ['-c', pythonScript], {
-      shell: false,
-      stdio: ['ignore', 'pipe', 'pipe'],
-      timeout,
-      windowsHide: true,
-      env: { ...process.env, PYTHONIOENCODING: 'utf-8' },
-    });
-
-    let stdout = '';
-    let stderr = '';
-
-    child.stdout.on('data', (data: Buffer) => {
-      stdout += data.toString();
-    });
-
-    child.stderr.on('data', (data: Buffer) => {
-      stderr += data.toString();
-    });
-
-    child.on('close', (code) => {
-      if (code !== 0) {
-        try {
-          const errorData = JSON.parse(stderr || stdout);
-          resolve({ success: false, error: errorData.error || 'Unknown error' });
-        } catch {
-          resolve({ success: false, error: stderr || stdout || `Process exited with code ${code}` });
-        }
-        return;
-      }
-
-      try {
-        const data = JSON.parse(stdout);
-        resolve({ success: data.success, results: data.result, error: data.error });
-      } catch (err) {
-        resolve({ success: false, error: `Failed to parse output: ${(err as Error).message}` });
-      }
-    });
-
-    child.on('error', (err) => {
-      resolve({ success: false, error: `Failed to execute: ${err.message}` });
-    });
-  });
-}
-
-export async function handleCodexLensSemanticRoutes(ctx: RouteContext): Promise<boolean> {
-  const { pathname, url, req, res, initialPath, handlePostRequest } = ctx;
-
-  // API: CodexLens Semantic Search Status
-  if (pathname === '/api/codexlens/semantic/status') {
-    const status = await checkSemanticStatus();
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify(status));
-    return true;
-  }
-
-  // API: CodexLens Semantic Metadata List
-  if (pathname === '/api/codexlens/semantic/metadata') {
-    const offset = parseInt(url.searchParams.get('offset') || '0', 10);
-    const limit = parseInt(url.searchParams.get('limit') || '50', 10);
-    const tool = url.searchParams.get('tool') || '';
-    const projectPath = url.searchParams.get('path') || initialPath;
-
-    try {
-      const args = [
-        'semantic-list',
-        '--path', projectPath,
-        '--offset', offset.toString(),
-        '--limit', limit.toString(),
-        '--json'
-      ];
-      if (tool) {
-        args.push('--tool', tool);
-      }
-
-      const result = await executeCodexLens(args, { cwd: projectPath });
-
-      if (result.success) {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(result.output ?? '');
-      } else {
-        res.writeHead(500, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ success: false, error: result.error }));
-      }
-    } catch (err: unknown) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: false, error: err instanceof Error ? err.message : String(err) }));
-    }
-    return true;
-  }
-
-  // API: CodexLens LLM Enhancement (run enhance command)
-  if (pathname === '/api/codexlens/enhance' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body) => {
-      const { path: projectPath, tool, batchSize = 5, timeoutMs = 300000 } = body as {
-        path?: unknown;
-        tool?: unknown;
-        batchSize?: unknown;
-        timeoutMs?: unknown;
-      };
-      const targetPath = typeof projectPath === 'string' && projectPath.trim().length > 0 ? projectPath : initialPath;
-      const resolvedTool = typeof tool === 'string' && tool.trim().length > 0 ? tool : getDefaultTool(targetPath);
-      const resolvedBatchSize = typeof batchSize === 'number' ? batchSize : Number(batchSize);
-      const resolvedTimeoutMs = typeof timeoutMs === 'number' ? timeoutMs : Number(timeoutMs);
-
-      try {
-        const args = ['enhance', targetPath, '--tool', resolvedTool, '--batch-size', String(resolvedBatchSize)];
-        const timeout = !Number.isNaN(resolvedTimeoutMs) ? resolvedTimeoutMs + 30000 : 330000;
-        const result = await executeCodexLens(args, { cwd: targetPath, timeout });
-        if (result.success) {
-          try {
-            const parsed = extractJSON(result.output ?? '');
-            return { success: true, result: parsed };
-          } catch {
-            return { success: true, output: result.output ?? '' };
-          }
-        } else {
-          return { success: false, error: result.error, status: 500 };
-        }
-      } catch (err: unknown) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  // API: CodexLens Search (FTS5 text search with mode support)
-  if (pathname === '/api/codexlens/search') {
-    const query = url.searchParams.get('query') || '';
-    const limit = parseInt(url.searchParams.get('limit') || '20', 10);
-    const mode = url.searchParams.get('mode') || 'exact';  // exact, fuzzy, hybrid, vector
-    const maxContentLength = parseInt(url.searchParams.get('max_content_length') || '200', 10);
-    const extraFilesCount = parseInt(url.searchParams.get('extra_files_count') || '10', 10);
-    const projectPath = url.searchParams.get('path') || initialPath;
-
-    if (!query) {
-      res.writeHead(400, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: false, error: 'Query parameter is required' }));
-      return true;
-    }
-
-    try {
-      // Request more results to support split (full content + extra files)
-      const totalToFetch = limit + extraFilesCount;
-      // Use --method instead of deprecated --mode
-      const args = ['search', query, '--path', projectPath, '--limit', totalToFetch.toString(), '--method', mode, '--json'];
-
-      const result = await executeCodexLens(args, { cwd: projectPath });
-
-      if (result.success) {
-        try {
-          const parsed = extractJSON(result.output ?? '');
-          const allResults = parsed.result?.results || [];
-
-          // Truncate content and split results
-          const truncateContent = (content: string | null | undefined): string => {
-            if (!content) return '';
-            if (content.length <= maxContentLength) return content;
-            return content.slice(0, maxContentLength) + '...';
-          };
-
-          // Split results: first N with full content, rest as file paths only
-          const resultsWithContent = allResults.slice(0, limit).map((r: any) => ({
-            ...r,
-            content: truncateContent(r.content || r.excerpt),
-            excerpt: truncateContent(r.excerpt || r.content),
-          }));
-
-          const extraResults = allResults.slice(limit, limit + extraFilesCount);
-          const extraFiles = [...new Set(extraResults.map((r: any) => r.path || r.file))];
-
-          res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({
-            success: true,
-            results: resultsWithContent,
-            extra_files: extraFiles.length > 0 ? extraFiles : undefined,
-            metadata: {
-              total: allResults.length,
-              limit,
-              max_content_length: maxContentLength,
-              extra_files_count: extraFilesCount,
-            },
-          }));
-        } catch {
-          res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ success: true, results: [], output: result.output }));
-        }
-      } else {
-        res.writeHead(500, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ success: false, error: result.error }));
-      }
-    } catch (err: unknown) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: false, error: err instanceof Error ? err.message : String(err) }));
-    }
-    return true;
-  }
-
-  // API: CodexLens Search Files Only (return file paths only, with mode support)
-  if (pathname === '/api/codexlens/search_files') {
-    const query = url.searchParams.get('query') || '';
-    const limit = parseInt(url.searchParams.get('limit') || '20', 10);
-    const mode = url.searchParams.get('mode') || 'exact';  // exact, fuzzy, hybrid, vector
-    const projectPath = url.searchParams.get('path') || initialPath;
-
-    if (!query) {
-      res.writeHead(400, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: false, error: 'Query parameter is required' }));
-      return true;
-    }
-
-    try {
-      // Use --method instead of deprecated --mode
-      const args = ['search', query, '--path', projectPath, '--limit', limit.toString(), '--method', mode, '--files-only', '--json'];
-
-      const result = await executeCodexLens(args, { cwd: projectPath });
-
-      if (result.success) {
-        try {
-          const parsed = extractJSON(result.output ?? '');
-          res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ success: true, ...parsed.result }));
-        } catch {
-          res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ success: true, files: [], output: result.output }));
-        }
-      } else {
-        res.writeHead(500, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ success: false, error: result.error }));
-      }
-    } catch (err: unknown) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: false, error: err instanceof Error ? err.message : String(err) }));
-    }
-    return true;
-  }
-
-  // API: CodexLens Symbol Search (search for symbols by name)
-  if (pathname === '/api/codexlens/symbol') {
-    const query = url.searchParams.get('query') || '';
-    const file = url.searchParams.get('file');
-    const limit = parseInt(url.searchParams.get('limit') || '20', 10);
-    const projectPath = url.searchParams.get('path') || initialPath;
-
-    if (!query && !file) {
-      res.writeHead(400, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: false, error: 'Either query or file parameter is required' }));
-      return true;
-    }
-
-    try {
-      let args;
-      if (file) {
-        // Get symbols from a specific file
-        args = ['symbol', '--file', file, '--json'];
-      } else {
-        // Search for symbols by name
-        args = ['symbol', query, '--path', projectPath, '--limit', limit.toString(), '--json'];
-      }
-
-      const result = await executeCodexLens(args, { cwd: projectPath });
-
-      if (result.success) {
-        try {
-          const parsed = extractJSON(result.output ?? '');
-          res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ success: true, ...parsed.result }));
-        } catch {
-          res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ success: true, symbols: [], output: result.output }));
-        }
-      } else {
-        res.writeHead(500, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ success: false, error: result.error }));
-      }
-    } catch (err: unknown) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: false, error: err instanceof Error ? err.message : String(err) }));
-    }
-    return true;
-  }
-
-  // API: CodexLens Semantic Search Install (with GPU mode support)
-  if (pathname === '/api/codexlens/semantic/install' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body) => {
-      try {
-        // Get GPU mode from request body, default to 'cpu'
-        const { gpuMode } = body as { gpuMode?: unknown };
-        const resolvedGpuModeCandidate = typeof gpuMode === 'string' && gpuMode.trim().length > 0 ? gpuMode : 'cpu';
-        const validModes: GpuMode[] = ['cpu', 'cuda', 'directml'];
-
-        if (!validModes.includes(resolvedGpuModeCandidate as GpuMode)) {
-          return {
-            success: false,
-            error: `Invalid GPU mode: ${resolvedGpuModeCandidate}. Valid modes: ${validModes.join(', ')}`,
-            status: 400
-          };
-        }
-
-        const resolvedGpuMode = resolvedGpuModeCandidate as GpuMode;
-        const result = await installSemantic(resolvedGpuMode);
-        if (result.success) {
-          const status = await checkSemanticStatus();
-          const modeDescriptions = {
-            cpu: 'CPU (ONNX Runtime)',
-            cuda: 'NVIDIA CUDA GPU',
-            directml: 'Windows DirectML GPU'
-          };
-          return {
-            success: true,
-            message: `Semantic search installed successfully with ${modeDescriptions[resolvedGpuMode]}`,
-            gpuMode: resolvedGpuMode,
-            ...status
-          };
-        } else {
-          return { success: false, error: result.error, status: 500 };
-        }
-      } catch (err: unknown) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  // ============================================================
-  // RERANKER CONFIGURATION ENDPOINTS
-  // ============================================================
-
-  // API: Get Reranker Configuration
-  if (pathname === '/api/codexlens/reranker/config' && req.method === 'GET') {
-    try {
-      const venvStatus = await checkVenvStatus();
-
-      // Default reranker config (matches fastembed default)
-      const rerankerConfig = {
-        backend: 'fastembed',
-        model_name: 'Xenova/ms-marco-MiniLM-L-6-v2',
-        api_provider: 'siliconflow',
-        api_key_set: false,
-        available_backends: ['onnx', 'api', 'litellm', 'legacy'],
-        api_providers: ['siliconflow', 'cohere', 'jina'],
-        litellm_endpoints: [] as string[],
-        config_source: 'default'
-      };
-
-      // Load LiteLLM reranker models for dropdown (from litellm-api-config providers)
-      try {
-        const availableRerankerModels = getAvailableModelsForType(initialPath, 'reranker');
-        if (availableRerankerModels && Array.isArray(availableRerankerModels)) {
-          // Return full model info for frontend to use
-          (rerankerConfig as any).litellm_models = availableRerankerModels.map((m: any) => ({
-            modelId: m.modelId,
-            modelName: m.modelName,
-            providers: m.providers
-          }));
-          // Keep litellm_endpoints for backward compatibility (just model IDs)
-          rerankerConfig.litellm_endpoints = availableRerankerModels.map((m: any) => m.modelId);
-        }
-      } catch {
-        // LiteLLM config not available, continue with empty models
-      }
-
-      // If CodexLens is installed, try to get actual config
-      if (venvStatus.ready) {
-        try {
-          const result = await executeCodexLens(['config', '--json']);
-          if (result.success) {
-            const config = extractJSON(result.output ?? '');
-            if (config.success && config.result) {
-              // Map config values
-              if (config.result.reranker_backend) {
-                rerankerConfig.backend = config.result.reranker_backend;
-                rerankerConfig.config_source = 'codexlens';
-              }
-              if (config.result.reranker_model) {
-                rerankerConfig.model_name = config.result.reranker_model;
-              }
-              if (config.result.reranker_api_provider) {
-                rerankerConfig.api_provider = config.result.reranker_api_provider;
-              }
-              // Check if API key is set (from env)
-              if (process.env.RERANKER_API_KEY) {
-                rerankerConfig.api_key_set = true;
-              }
-            }
-          }
-        } catch (e) {
-          console.error('[CodexLens] Failed to get reranker config:', e);
-        }
-      }
-
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: true, ...rerankerConfig }));
-    } catch (err: unknown) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: false, error: err instanceof Error ? err.message : String(err) }));
-    }
-    return true;
-  }
-
-  // API: Set Reranker Configuration
-  if (pathname === '/api/codexlens/reranker/config' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body) => {
-      const { backend, model_name, api_provider, api_key, litellm_endpoint } = body as {
-        backend?: unknown;
-        model_name?: unknown;
-        api_provider?: unknown;
-        api_key?: unknown;
-        litellm_endpoint?: unknown;
-      };
-      const resolvedBackend = typeof backend === 'string' && backend.trim().length > 0 ? backend : undefined;
-      const resolvedModelName = typeof model_name === 'string' && model_name.trim().length > 0 ? model_name : undefined;
-      const resolvedApiProvider = typeof api_provider === 'string' && api_provider.trim().length > 0 ? api_provider : undefined;
-      const resolvedApiKey = typeof api_key === 'string' && api_key.trim().length > 0 ? api_key : undefined;
-      const resolvedLiteLLMEndpoint =
-        typeof litellm_endpoint === 'string' && litellm_endpoint.trim().length > 0 ? litellm_endpoint : undefined;
-
-      // Validate backend
-      const validBackends = ['onnx', 'api', 'litellm', 'legacy', 'fastembed'];
-      if (resolvedBackend && !validBackends.includes(resolvedBackend)) {
-        return {
-          success: false,
-          error: `Invalid backend: ${resolvedBackend}. Valid options: ${validBackends.join(', ')}`,
-          status: 400
-        };
-      }
-
-      // Validate api_provider
-      const validProviders = ['siliconflow', 'cohere', 'jina'];
-      if (resolvedApiProvider && !validProviders.includes(resolvedApiProvider)) {
-        return {
-          success: false,
-          error: `Invalid api_provider: ${resolvedApiProvider}. Valid options: ${validProviders.join(', ')}`,
-          status: 400
-        };
-      }
-
-      try {
-        const updates: string[] = [];
-
-        // Special handling for litellm backend - auto-configure from litellm-api-config
-        if (resolvedBackend === 'litellm' && (resolvedModelName || resolvedLiteLLMEndpoint)) {
-          const selectedModel = (resolvedModelName || resolvedLiteLLMEndpoint) as string;
-
-          // Find the provider that has this model
-          const providers = getAllProviders(initialPath);
-          let providerWithModel: any = null;
-          let foundModel: any = null;
-
-          for (const provider of providers) {
-            if (!provider.enabled || !provider.rerankerModels) continue;
-            const model = provider.rerankerModels.find((m: any) => m.id === selectedModel && m.enabled);
-            if (model) {
-              providerWithModel = provider;
-              foundModel = model;
-              break;
-            }
-          }
-
-          if (providerWithModel) {
-            // Set backend to litellm
-            const backendResult = await executeCodexLens(['config', 'set', 'reranker_backend', 'litellm', '--json']);
-            if (backendResult.success) updates.push('backend');
-
-            // Set model
-            const modelResult = await executeCodexLens(['config', 'set', 'reranker_model', selectedModel, '--json']);
-            if (modelResult.success) updates.push('model_name');
-
-            // Auto-configure API credentials from provider
-            // Write to CodexLens .env file for persistence
-            const { writeFileSync, existsSync, readFileSync } = await import('fs');
-            const { join } = await import('path');
-
-            const codexlensDir = getCodexLensDataDir();
-            const envFile = join(codexlensDir, '.env');
-
-            // Read existing .env content
-            let envContent = '';
-            if (existsSync(envFile)) {
-              envContent = readFileSync(envFile, 'utf-8');
-            }
-
-            // Update or add RERANKER_API_KEY and RERANKER_API_BASE
-            const apiKey = providerWithModel.apiKey;
-            const apiBase = providerWithModel.apiBase;
-
-            // Helper to update env var in content
-            const updateEnvVar = (content: string, key: string, value: string): string => {
-              const regex = new RegExp(`^${key}=.*$`, 'm');
-              const newLine = `${key}="${value}"`;
-              if (regex.test(content)) {
-                return content.replace(regex, newLine);
-              } else {
-                return content.trim() + '\n' + newLine;
-              }
-            };
-
-            if (apiKey) {
-              envContent = updateEnvVar(envContent, 'RERANKER_API_KEY', apiKey);
-              envContent = updateEnvVar(envContent, 'CODEXLENS_RERANKER_API_KEY', apiKey);
-              process.env.RERANKER_API_KEY = apiKey;
-              updates.push('api_key (auto-configured)');
-            }
-            if (apiBase) {
-              envContent = updateEnvVar(envContent, 'RERANKER_API_BASE', apiBase);
-              envContent = updateEnvVar(envContent, 'CODEXLENS_RERANKER_API_BASE', apiBase);
-              process.env.RERANKER_API_BASE = apiBase;
-              updates.push('api_base (auto-configured)');
-            }
-
-            // Write updated .env
-            writeFileSync(envFile, envContent.trim() + '\n', 'utf-8');
-
-            return {
-              success: true,
-              message: `LiteLLM backend configured with model: ${selectedModel}`,
-              updated_fields: updates,
-              provider: providerWithModel.name,
-              auto_configured: true
-            };
-          } else {
-            return {
-              success: false,
-              error: `Model "${selectedModel}" not found in any enabled LiteLLM provider. Please configure it in API Settings first.`,
-              status: 400
-            };
-          }
-        }
-
-        // Standard handling for non-litellm backends
-        // Set backend
-        if (resolvedBackend) {
-          const result = await executeCodexLens(['config', 'set', 'reranker_backend', resolvedBackend, '--json']);
-          if (result.success) updates.push('backend');
-        }
-
-        // Set model
-        if (resolvedModelName) {
-          const result = await executeCodexLens(['config', 'set', 'reranker_model', resolvedModelName, '--json']);
-          if (result.success) updates.push('model_name');
-        }
-
-        // Set API provider
-        if (resolvedApiProvider) {
-          const result = await executeCodexLens(['config', 'set', 'reranker_api_provider', resolvedApiProvider, '--json']);
-          if (result.success) updates.push('api_provider');
-        }
-
-        // Set LiteLLM endpoint (for backward compatibility)
-        if (resolvedLiteLLMEndpoint && resolvedBackend !== 'litellm') {
-          const result = await executeCodexLens([
-            'config',
-            'set',
-            'reranker_litellm_endpoint',
-            resolvedLiteLLMEndpoint,
-            '--json'
-          ]);
-          if (result.success) updates.push('litellm_endpoint');
-        }
-
-        // Handle API key - write to .env file or environment
-        if (resolvedApiKey) {
-          // For security, we store in process.env for the current session
-          // In production, this should be written to a secure .env file
-          process.env.RERANKER_API_KEY = resolvedApiKey;
-          updates.push('api_key');
-        }
-
-        return {
-          success: true,
-          message: `Updated: ${updates.join(', ')}`,
-          updated_fields: updates
-        };
-      } catch (err: unknown) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  // ============================================================
-  // RERANKER MODEL MANAGEMENT ENDPOINTS
-  // ============================================================
-
-  // API: List Reranker Models (list available reranker models)
-  if (pathname === '/api/codexlens/reranker/models' && req.method === 'GET') {
-    try {
-      // Check if CodexLens is installed first
-      const venvStatus = await checkVenvStatus();
-      if (!venvStatus.ready) {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ success: false, error: 'CodexLens not installed' }));
-        return true;
-      }
-      const result = await executeCodexLens(['reranker-model-list', '--json']);
-      if (result.success) {
-        try {
-          const parsed = extractJSON(result.output ?? '');
-          res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify(parsed));
-        } catch {
-          res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ success: true, result: { models: [] }, output: result.output }));
-        }
-      } else {
-        res.writeHead(500, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ success: false, error: result.error }));
-      }
-    } catch (err: unknown) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: false, error: err instanceof Error ? err.message : String(err) }));
-    }
-    return true;
-  }
-
-  // API: Download Reranker Model (download reranker model by profile)
-  if (pathname === '/api/codexlens/reranker/models/download' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body) => {
-      const { profile } = body as { profile?: unknown };
-      const resolvedProfile = typeof profile === 'string' && profile.trim().length > 0 ? profile.trim() : undefined;
-
-      if (!resolvedProfile) {
-        return { success: false, error: 'profile is required', status: 400 };
-      }
-
-      try {
-        const result = await executeCodexLens(['reranker-model-download', resolvedProfile, '--json'], { timeout: 600000 }); // 10 min for download
-        if (result.success) {
-          try {
-            const parsed = extractJSON(result.output ?? '');
-            return { success: true, ...parsed };
-          } catch {
-            return { success: true, output: result.output };
-          }
-        } else {
-          return { success: false, error: result.error, status: 500 };
-        }
-      } catch (err: unknown) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  // API: Delete Reranker Model (delete reranker model by profile)
-  if (pathname === '/api/codexlens/reranker/models/delete' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body) => {
-      const { profile } = body as { profile?: unknown };
-      const resolvedProfile = typeof profile === 'string' && profile.trim().length > 0 ? profile.trim() : undefined;
-
-      if (!resolvedProfile) {
-        return { success: false, error: 'profile is required', status: 400 };
-      }
-
-      try {
-        const result = await executeCodexLens(['reranker-model-delete', resolvedProfile, '--json']);
-        if (result.success) {
-          try {
-            const parsed = extractJSON(result.output ?? '');
-            return { success: true, ...parsed };
-          } catch {
-            return { success: true, output: result.output };
-          }
-        } else {
-          return { success: false, error: result.error, status: 500 };
-        }
-      } catch (err: unknown) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  // API: Reranker Model Info (get reranker model info by profile)
-  if (pathname === '/api/codexlens/reranker/models/info' && req.method === 'GET') {
-    const profile = url.searchParams.get('profile');
-
-    if (!profile) {
-      res.writeHead(400, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: false, error: 'profile parameter is required' }));
-      return true;
-    }
-
-    try {
-      const result = await executeCodexLens(['reranker-model-info', profile, '--json']);
-      if (result.success) {
-        try {
-          const parsed = extractJSON(result.output ?? '');
-          res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify(parsed));
-        } catch {
-          res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ success: false, error: 'Failed to parse response' }));
-        }
-      } else {
-        res.writeHead(500, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ success: false, error: result.error }));
-      }
-    } catch (err: unknown) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: false, error: err instanceof Error ? err.message : String(err) }));
-    }
-    return true;
-  }
-
-  // ============================================================
-  // SPLADE ENDPOINTS
-  // ============================================================
-
-  // API: SPLADE Status - Check if SPLADE is available and installed
-  if (pathname === '/api/codexlens/splade/status') {
-    try {
-      // Check if CodexLens is installed first
-      const venvStatus = await checkVenvStatus();
-      if (!venvStatus.ready) {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-          available: false,
-          installed: false,
-          model: 'naver/splade-cocondenser-ensembledistil',
-          error: 'CodexLens not installed'
-        }));
-        return true;
-      }
-
-      // Check SPLADE availability using Python check
-      const result = await executeCodexLens(['python', '-c',
-        'from codexlens.semantic.splade_encoder import check_splade_available; ok, err = check_splade_available(); print(\"OK\" if ok else err)'
-      ]);
-
-      const output = result.output ?? '';
-      const available = output.includes('OK');
-
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        available,
-        installed: available,
-        model: 'naver/splade-cocondenser-ensembledistil',
-        error: available ? null : output.trim()
-      }));
-    } catch (err: unknown) {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        available: false,
-        installed: false,
-        model: 'naver/splade-cocondenser-ensembledistil',
-        error: err instanceof Error ? err.message : String(err)
-      }));
-    }
-    return true;
-  }
-
-  // API: SPLADE Install - Install SPLADE dependencies
-  if (pathname === '/api/codexlens/splade/install' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body) => {
-      try {
-        const { gpu } = body as { gpu?: unknown };
-        const useGpu = typeof gpu === 'boolean' ? gpu : false;
-        const extras = useGpu ? ['splade-gpu'] : ['splade'];
-
-        // Priority: Use UV if available (faster, better dependency resolution)
-        if (await isUvAvailable()) {
-          console.log('[SPLADE Install] Using UV for installation...');
-          const uv = createCodexLensUvManager();
-
-          // Ensure venv exists
-          if (!uv.isVenvValid()) {
-            console.log('[SPLADE Install] Venv not valid, creating...');
-            const venvResult = await uv.createVenv();
-            if (!venvResult.success) {
-              throw new Error(`Failed to create venv: ${venvResult.error}`);
-            }
-          }
-
-          // Find local codex-lens package
-          const { existsSync } = await import('fs');
-          const { join, dirname } = await import('path');
-          const { fileURLToPath } = await import('url');
-          const __filename = fileURLToPath(import.meta.url);
-          const __dirname = dirname(__filename);
-
-          // Look for local codex-lens package
-          const possiblePaths = [
-            join(__dirname, '..', '..', '..', '..', '..', 'codex-lens'),
-            join(__dirname, '..', '..', '..', '..', '..', '..', 'codex-lens'),
-            join(process.cwd(), 'codex-lens'),
-          ];
-
-          let codexLensPath: string | null = null;
-          for (const p of possiblePaths) {
-            if (existsSync(join(p, 'pyproject.toml'))) {
-              codexLensPath = p;
-              break;
-            }
-          }
-
-          if (codexLensPath) {
-            // Install from local project with extras
-            const result = await uv.installFromProject(codexLensPath, extras);
-            if (result.success) {
-              return {
-                success: true,
-                message: `SPLADE installed successfully via UV (${useGpu ? 'GPU' : 'CPU'} mode)`,
-                duration: result.duration
-              };
-            }
-            console.log('[SPLADE Install] UV install failed, falling back to pip:', result.error);
-          } else {
-            // Install from PyPI with extras
-            const packageSpec = `codex-lens[${extras.join(',')}]`;
-            const result = await uv.install([packageSpec]);
-            if (result.success) {
-              return {
-                success: true,
-                message: `SPLADE installed successfully via UV from PyPI (${useGpu ? 'GPU' : 'CPU'} mode)`,
-                duration: result.duration
-              };
-            }
-            console.log('[SPLADE Install] UV install failed, falling back to pip:', result.error);
-          }
-        }
-
-        // Fallback: Use pip for installation
-        console.log('[SPLADE Install] Using pip fallback...');
-        const packageName = useGpu ? 'codex-lens[splade-gpu]' : 'codex-lens[splade]';
-        const { promisify } = await import('util');
-        const execFilePromise = promisify(require('child_process').execFile);
-
-        const result = await execFilePromise('pip', ['install', packageName], {
-          timeout: 600000 // 10 minutes
-        });
-
-        return {
-          success: true,
-          message: `SPLADE installed successfully via pip (${useGpu ? 'GPU' : 'CPU'} mode)`,
-          output: result.stdout
-        };
-      } catch (err: unknown) {
-        const message = err instanceof Error ? err.message : String(err);
-        const stderr = (err as { stderr?: unknown })?.stderr;
-        return {
-          success: false,
-          error: message,
-          stderr: typeof stderr === 'string' ? stderr : undefined,
-          status: 500
-        };
-      }
-    });
-    return true;
-  }
-
-  // API: SPLADE Index Status - Check if SPLADE index exists for a project
-  if (pathname === '/api/codexlens/splade/index-status') {
-    try {
-      const projectPath = url.searchParams.get('path');
-      if (!projectPath) {
-        res.writeHead(400, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ success: false, error: 'Missing path parameter' }));
-        return true;
-      }
-
-      // Check if CodexLens is installed first
-      const venvStatus = await checkVenvStatus();
-      if (!venvStatus.ready) {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ exists: false, error: 'CodexLens not installed' }));
-        return true;
-      }
-
-      const { join } = await import('path');
-      const indexDb = join(projectPath, '.codexlens', '_index.db');
-
-      // Use Python to check SPLADE index status
-      const pythonCode = `
-from codexlens.storage.splade_index import SpladeIndex
-from pathlib import Path
-try:
-    idx = SpladeIndex(Path(\"${indexDb.replace(/\\\\/g, '\\\\\\\\')}\"))
-    if idx.has_index():
-        stats = idx.get_stats()
-        meta = idx.get_metadata()
-        model = meta.get('model_name', '') if meta else ''
-        print(f\"OK|{stats['unique_chunks']}|{stats['total_postings']}|{model}\")
-    else:
-        print(\"NO_INDEX\")
-except Exception as e:
-    print(f\"ERROR|{str(e)}\")
-`;
-
-      const result = await executeCodexLens(['python', '-c', pythonCode]);
-
-      const output = result.output ?? '';
-      if (output.startsWith('OK|')) {
-        const parts = output.trim().split('|');
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-          exists: true,
-          chunks: parseInt(parts[1]),
-          postings: parseInt(parts[2]),
-          model: parts[3]
-        }));
-      } else if (output.startsWith('ERROR|')) {
-        const errorMsg = output.substring(6).trim();
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ exists: false, error: errorMsg }));
-      } else {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ exists: false }));
-      }
-    } catch (err: unknown) {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ exists: false, error: err instanceof Error ? err.message : String(err) }));
-    }
-    return true;
-  }
-
-  // API: SPLADE Index Rebuild - Rebuild SPLADE index for a project
-  if (pathname === '/api/codexlens/splade/rebuild' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body) => {
-      const { path: projectPath } = body as { path?: unknown };
-      const resolvedProjectPath = typeof projectPath === 'string' && projectPath.trim().length > 0 ? projectPath : undefined;
-
-      if (!resolvedProjectPath) {
-        return { success: false, error: 'Missing path parameter', status: 400 };
-      }
-
-      try {
-        // Use 'index splade' instead of deprecated 'splade-index'
-        const result = await executeCodexLens(['index', 'splade', resolvedProjectPath, '--rebuild'], {
-          cwd: resolvedProjectPath,
-          timeout: 1800000 // 30 minutes for large codebases
-        });
-
-        if (result.success) {
-          return {
-            success: true,
-            message: 'SPLADE index rebuilt successfully',
-            output: result.output
-          };
-        } else {
-          return {
-            success: false,
-            error: result.error || 'Failed to rebuild SPLADE index',
-            output: result.output,
-            status: 500
-          };
-        }
-      } catch (err: unknown) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  // ============================================================
-  // LSP / SEMANTIC SEARCH API ENDPOINTS
-  // ============================================================
-
-  // API: LSP Status - Check if LSP/semantic search capabilities are available
-  if (pathname === '/api/codexlens/lsp/status') {
-    try {
-      const venvStatus = await checkVenvStatus();
-      if (!venvStatus.ready) {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-          available: false,
-          semantic_available: false,
-          vector_index: false,
-          error: 'CodexLens not installed'
-        }));
-        return true;
-      }
-
-      // Check semantic deps and vector index availability in parallel
-      const [semanticStatus, workspaceResult] = await Promise.all([
-        checkSemanticStatus(),
-        executeCodexLens(['status', '--json'])
-      ]);
-
-      let hasVectorIndex = false;
-      let projectCount = 0;
-      let embeddingsInfo: Record<string, unknown> = {};
-
-      if (workspaceResult.success) {
-        try {
-          const status = extractJSON(workspaceResult.output ?? '');
-          if (status.success !== false && status.result) {
-            projectCount = status.result.projects_count || 0;
-            embeddingsInfo = status.result.embeddings || {};
-            // Check if any projects have embeddings
-            hasVectorIndex = projectCount > 0 && Object.keys(embeddingsInfo).length > 0;
-          } else if (status.projects_count !== undefined) {
-            projectCount = status.projects_count || 0;
-            embeddingsInfo = status.embeddings || {};
-            hasVectorIndex = projectCount > 0 && Object.keys(embeddingsInfo).length > 0;
-          }
-        } catch {
-          // Parse failed
-        }
-      }
-
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        available: semanticStatus.available && hasVectorIndex,
-        semantic_available: semanticStatus.available,
-        vector_index: hasVectorIndex,
-        project_count: projectCount,
-        embeddings: embeddingsInfo,
-        modes: ['fusion', 'vector', 'structural'],
-        strategies: ['rrf', 'staged', 'binary', 'hybrid', 'dense_rerank'],
-      }));
-    } catch (err: unknown) {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        available: false,
-        semantic_available: false,
-        vector_index: false,
-        error: err instanceof Error ? err.message : String(err)
-      }));
-    }
-    return true;
-  }
-
-  // API: LSP Start - Start the standalone LSP manager
-  if (pathname === '/api/codexlens/lsp/start' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body) => {
-      const { path: workspacePath } = body as { path?: unknown };
-      const targetPath = typeof workspacePath === 'string' && workspacePath.trim().length > 0
-        ? workspacePath : initialPath;
-
-      try {
-        const venvStatus = await checkVenvStatus();
-        if (!venvStatus.ready) {
-          return { success: false, error: 'CodexLens not installed', status: 400 };
-        }
-
-        const result = await executeCodexLensPythonAPI('lsp_start', {
-          workspace_root: targetPath,
-        }, 30000);
-
-        if (result.success) {
-          return {
-            success: true,
-            message: 'LSP server started',
-            workspace_root: targetPath,
-            ...((result.results && typeof result.results === 'object') ? result.results : {}),
-          };
-        } else {
-          return { success: false, error: result.error || 'Failed to start LSP server', status: 500 };
-        }
-      } catch (err: unknown) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  // API: LSP Stop - Stop the standalone LSP manager
-  if (pathname === '/api/codexlens/lsp/stop' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body) => {
-      const { path: workspacePath } = body as { path?: unknown };
-      const targetPath = typeof workspacePath === 'string' && workspacePath.trim().length > 0
-        ? workspacePath : initialPath;
-
-      try {
-        const venvStatus = await checkVenvStatus();
-        if (!venvStatus.ready) {
-          return { success: false, error: 'CodexLens not installed', status: 400 };
-        }
-
-        const result = await executeCodexLensPythonAPI('lsp_stop', {
-          workspace_root: targetPath,
-        }, 15000);
-
-        if (result.success) {
-          return {
-            success: true,
-            message: 'LSP server stopped',
-          };
-        } else {
-          return { success: false, error: result.error || 'Failed to stop LSP server', status: 500 };
-        }
-      } catch (err: unknown) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  // API: LSP Restart - Stop then start the standalone LSP manager
-  if (pathname === '/api/codexlens/lsp/restart' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body) => {
-      const { path: workspacePath } = body as { path?: unknown };
-      const targetPath = typeof workspacePath === 'string' && workspacePath.trim().length > 0
-        ? workspacePath : initialPath;
-
-      try {
-        const venvStatus = await checkVenvStatus();
-        if (!venvStatus.ready) {
-          return { success: false, error: 'CodexLens not installed', status: 400 };
-        }
-
-        const result = await executeCodexLensPythonAPI('lsp_restart', {
-          workspace_root: targetPath,
-        }, 45000);
-
-        if (result.success) {
-          return {
-            success: true,
-            message: 'LSP server restarted',
-            workspace_root: targetPath,
-            ...((result.results && typeof result.results === 'object') ? result.results : {}),
-          };
-        } else {
-          return { success: false, error: result.error || 'Failed to restart LSP server', status: 500 };
-        }
-      } catch (err: unknown) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  // API: LSP Semantic Search - Advanced semantic search via Python API
-  if (pathname === '/api/codexlens/lsp/search' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body) => {
-      const {
-        query,
-        path: projectPath,
-        mode = 'fusion',
-        fusion_strategy = 'rrf',
-        staged_stage2_mode,
-        vector_weight = 0.5,
-        structural_weight = 0.3,
-        keyword_weight = 0.2,
-        kind_filter,
-        limit = 20,
-        include_match_reason = false,
-      } = body as {
-        query?: unknown;
-        path?: unknown;
-        mode?: unknown;
-        fusion_strategy?: unknown;
-        staged_stage2_mode?: unknown;
-        vector_weight?: unknown;
-        structural_weight?: unknown;
-        keyword_weight?: unknown;
-        kind_filter?: unknown;
-        limit?: unknown;
-        include_match_reason?: unknown;
-      };
-
-      const resolvedQuery = typeof query === 'string' ? query.trim() : '';
-      if (!resolvedQuery) {
-        return { success: false, error: 'Query parameter is required', status: 400 };
-      }
-
-      const targetPath = typeof projectPath === 'string' && projectPath.trim().length > 0 ? projectPath : initialPath;
-      const resolvedMode = typeof mode === 'string' && ['fusion', 'vector', 'structural'].includes(mode) ? mode : 'fusion';
-      const resolvedStrategy = typeof fusion_strategy === 'string' &&
-        ['rrf', 'staged', 'binary', 'hybrid', 'dense_rerank'].includes(fusion_strategy) ? fusion_strategy : 'rrf';
-      let resolvedStage2Mode: 'precomputed' | 'realtime' | 'static_global_graph' | undefined;
-      if (resolvedStrategy === 'staged' && typeof staged_stage2_mode === 'string') {
-        const stage2 = staged_stage2_mode.trim().toLowerCase();
-        if (stage2.length > 0) {
-          if (stage2 === 'live') {
-            resolvedStage2Mode = 'realtime';
-          } else if (stage2 === 'precomputed' || stage2 === 'realtime' || stage2 === 'static_global_graph') {
-            resolvedStage2Mode = stage2;
-          } else {
-            return {
-              success: false,
-              error: `Invalid staged_stage2_mode: ${stage2}. Must be one of: precomputed, realtime, static_global_graph`,
-              status: 400,
-            };
-          }
-        }
-      }
-      const resolvedVectorWeight = typeof vector_weight === 'number' ? vector_weight : 0.5;
-      const resolvedStructuralWeight = typeof structural_weight === 'number' ? structural_weight : 0.3;
-      const resolvedKeywordWeight = typeof keyword_weight === 'number' ? keyword_weight : 0.2;
-      const resolvedLimit = typeof limit === 'number' ? limit : 20;
-      const resolvedIncludeReason = typeof include_match_reason === 'boolean' ? include_match_reason : false;
-
-      // Build Python API call args
-      const apiArgs: Record<string, unknown> = {
-        project_root: targetPath,
-        query: resolvedQuery,
-        mode: resolvedMode,
-        vector_weight: resolvedVectorWeight,
-        structural_weight: resolvedStructuralWeight,
-        keyword_weight: resolvedKeywordWeight,
-        fusion_strategy: resolvedStrategy,
-        limit: resolvedLimit,
-        include_match_reason: resolvedIncludeReason,
-      };
-
-      if (resolvedStage2Mode) {
-        apiArgs.staged_stage2_mode = resolvedStage2Mode;
-      }
-
-      if (Array.isArray(kind_filter) && kind_filter.length > 0) {
-        apiArgs.kind_filter = kind_filter;
-      }
-
-      try {
-        const result = await executeCodexLensPythonAPI('semantic_search', apiArgs);
-        if (result.success) {
-          return {
-            success: true,
-            results: result.results,
-            query: resolvedQuery,
-            mode: resolvedMode,
-            fusion_strategy: resolvedStrategy,
-            count: Array.isArray(result.results) ? result.results.length : 0,
-          };
-        } else {
-          return { success: false, error: result.error || 'Semantic search failed', status: 500 };
-        }
-      } catch (err: unknown) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  return false;
-}
diff --git a/ccw/src/core/routes/codexlens/utils.ts b/ccw/src/core/routes/codexlens/utils.ts
deleted file mode 100644
index f2bd14c0..00000000
--- a/ccw/src/core/routes/codexlens/utils.ts
+++ /dev/null
@@ -1,96 +0,0 @@
-/**
- * CodexLens route utilities.
- *
- * CodexLens CLI can emit logging + ANSI escapes even with --json, so helpers
- * here normalize output for reliable JSON parsing.
- */
-
-/**
- * Strip ANSI color codes from string.
- * Rich library adds color codes even with --json flag.
- */
-export function stripAnsiCodes(str: string): string {
-  // ANSI escape code pattern: \x1b[...m or \x1b]...
-  return str.replace(/\x1b\[[0-9;]*m/g, '')
-            .replace(/\x1b\][0-9;]*\x07/g, '')
-            .replace(/\x1b\][^\x07]*\x07/g, '');
-}
-
-/**
- * Format file size to human readable string.
- */
-export function formatSize(bytes: number): string {
-  if (bytes === 0) return '0 B';
-  const units = ['B', 'KB', 'MB', 'GB', 'TB'];
-  const k = 1024;
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  const size = parseFloat((bytes / Math.pow(k, i)).toFixed(i < 2 ? 0 : 1));
-  return size + ' ' + units[i];
-}
-
-/**
- * Extract JSON from CLI output that may contain logging messages.
- * CodexLens CLI outputs logs like "INFO ..." before the JSON.
- * Also strips ANSI color codes that Rich library adds.
- * Handles trailing content after JSON (e.g., "INFO: Done" messages).
- */
-export function extractJSON(output: string): any {
-  // Strip ANSI color codes first
-  const cleanOutput = stripAnsiCodes(output);
-
-  // Find the first { or [ character (start of JSON)
-  const jsonStart = cleanOutput.search(/[{\[]/);
-  if (jsonStart === -1) {
-    throw new Error('No JSON found in output');
-  }
-
-  const startChar = cleanOutput[jsonStart];
-  const endChar = startChar === '{' ? '}' : ']';
-
-  // Find matching closing brace/bracket using a simple counter
-  let depth = 0;
-  let inString = false;
-  let escapeNext = false;
-  let jsonEnd = -1;
-
-  for (let i = jsonStart; i < cleanOutput.length; i++) {
-    const char = cleanOutput[i];
-
-    if (escapeNext) {
-      escapeNext = false;
-      continue;
-    }
-
-    if (char === '\\' && inString) {
-      escapeNext = true;
-      continue;
-    }
-
-    if (char === '"') {
-      inString = !inString;
-      continue;
-    }
-
-    if (!inString) {
-      if (char === startChar) {
-        depth++;
-      } else if (char === endChar) {
-        depth--;
-        if (depth === 0) {
-          jsonEnd = i + 1;
-          break;
-        }
-      }
-    }
-  }
-
-  if (jsonEnd === -1) {
-    // Fallback: try to parse from start to end (original behavior)
-    const jsonString = cleanOutput.substring(jsonStart);
-    return JSON.parse(jsonString);
-  }
-
-  const jsonString = cleanOutput.substring(jsonStart, jsonEnd);
-  return JSON.parse(jsonString);
-}
-
diff --git a/ccw/src/core/routes/codexlens/watcher-handlers.ts b/ccw/src/core/routes/codexlens/watcher-handlers.ts
deleted file mode 100644
index 36e31e13..00000000
--- a/ccw/src/core/routes/codexlens/watcher-handlers.ts
+++ /dev/null
@@ -1,322 +0,0 @@
-/**
- * CodexLens file watcher handlers.
- *
- * Maintains watcher process state across requests to support dashboard controls.
- */
-
-import {
-  checkVenvStatus,
-  executeCodexLens,
-  getVenvPythonPath,
-  useCodexLensV2,
-} from '../../../tools/codex-lens.js';
-import type { RouteContext } from '../types.js';
-import { extractJSON, stripAnsiCodes } from './utils.js';
-import type { ChildProcess } from 'child_process';
-
-// File watcher state (persisted across requests)
-let watcherProcess: any = null;
-let watcherStats = {
-  running: false,
-  root_path: '',
-  events_processed: 0,
-  start_time: null as Date | null
-};
-
-export async function stopWatcherForUninstall(): Promise<void> {
-  if (!watcherStats.running || !watcherProcess) return;
-
-  try {
-    watcherProcess.kill('SIGTERM');
-    await new Promise(resolve => setTimeout(resolve, 500));
-    if (watcherProcess && !watcherProcess.killed) {
-      watcherProcess.kill('SIGKILL');
-    }
-  } catch {
-    // Ignore errors stopping watcher
-  }
-
-  watcherStats = {
-    running: false,
-    root_path: '',
-    events_processed: 0,
-    start_time: null
-  };
-  watcherProcess = null;
-}
-
-/**
- * Spawn v2 bridge watcher subprocess.
- * Runs 'codexlens-search watch --root X --debounce-ms Y' and reads JSONL stdout.
- * @param root - Root directory to watch
- * @param debounceMs - Debounce interval in milliseconds
- * @returns Spawned child process
- */
-function spawnV2Watcher(root: string, debounceMs: number): ChildProcess {
-  const { spawn } = require('child_process') as typeof import('child_process');
-  return spawn('codexlens-search', [
-    'watch',
-    '--root', root,
-    '--debounce-ms', String(debounceMs),
-    '--db-path', require('path').join(root, '.codexlens'),
-  ], {
-    cwd: root,
-    shell: false,
-    stdio: ['ignore', 'pipe', 'pipe'],
-    windowsHide: true,
-    env: { ...process.env, PYTHONIOENCODING: 'utf-8' },
-  });
-}
-
-/**
- * Handle CodexLens watcher routes
- * @returns true if route was handled, false otherwise
- */
-export async function handleCodexLensWatcherRoutes(ctx: RouteContext): Promise<boolean> {
-  const { pathname, req, res, initialPath, handlePostRequest, broadcastToClients } = ctx;
-
-  // API: Get File Watcher Status
-  if (pathname === '/api/codexlens/watch/status') {
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({
-      success: true,
-      running: watcherStats.running,
-      root_path: watcherStats.root_path,
-      events_processed: watcherStats.events_processed,
-      start_time: watcherStats.start_time?.toISOString() || null,
-      uptime_seconds: watcherStats.start_time
-        ? Math.floor((Date.now() - watcherStats.start_time.getTime()) / 1000)
-        : 0
-    }));
-    return true;
-  }
-
-  // API: Start File Watcher
-  if (pathname === '/api/codexlens/watch/start' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body) => {
-      const { path: watchPath, debounce_ms = 1000 } = body as { path?: unknown; debounce_ms?: unknown };
-      const targetPath = typeof watchPath === 'string' && watchPath.trim().length > 0 ? watchPath : initialPath;
-      const resolvedDebounceMs = typeof debounce_ms === 'number' ? debounce_ms : Number(debounce_ms);
-      const debounceMs = !Number.isNaN(resolvedDebounceMs) && resolvedDebounceMs > 0 ? resolvedDebounceMs : 1000;
-
-      if (watcherStats.running) {
-        return { success: false, error: 'Watcher already running', status: 400 };
-      }
-
-      try {
-        const { spawn } = await import('child_process');
-        const { existsSync, statSync } = await import('fs');
-
-        // Validate path exists and is a directory
-        if (!existsSync(targetPath)) {
-          return { success: false, error: `Path does not exist: ${targetPath}`, status: 400 };
-        }
-        const pathStat = statSync(targetPath);
-        if (!pathStat.isDirectory()) {
-          return { success: false, error: `Path is not a directory: ${targetPath}`, status: 400 };
-        }
-
-        // Route to v2 or v1 watcher based on feature flag
-        if (useCodexLensV2()) {
-          // v2 bridge watcher: codexlens-search watch
-          console.log('[CodexLens] Using v2 bridge watcher');
-          watcherProcess = spawnV2Watcher(targetPath, debounceMs);
-        } else {
-          // v1 watcher: python -m codexlens watch
-          const venvStatus = await checkVenvStatus();
-          if (!venvStatus.ready) {
-            return { success: false, error: 'CodexLens not installed', status: 400 };
-          }
-
-          // Verify directory is indexed before starting watcher
-          try {
-            const statusResult = await executeCodexLens(['projects', 'list', '--json']);
-            if (statusResult.success && statusResult.output) {
-              const parsed = extractJSON(statusResult.output);
-              const projects = parsed.result || parsed || [];
-              const normalizedTarget = targetPath.toLowerCase().replace(/\\/g, '/');
-              const isIndexed = Array.isArray(projects) && projects.some((p: { source_root?: string }) =>
-                p.source_root && p.source_root.toLowerCase().replace(/\\/g, '/') === normalizedTarget
-              );
-              if (!isIndexed) {
-                return {
-                  success: false,
-                  error: `Directory is not indexed: ${targetPath}. Run 'codexlens init' first.`,
-                  status: 400
-                };
-              }
-            }
-          } catch (err) {
-            console.warn('[CodexLens] Could not verify index status:', err);
-            // Continue anyway - watcher will fail with proper error if not indexed
-          }
-
-          // Spawn watch process using Python (no shell: true for security)
-          const pythonPath = getVenvPythonPath();
-          const args = ['-m', 'codexlens', 'watch', targetPath, '--debounce', String(debounceMs)];
-          watcherProcess = spawn(pythonPath, args, {
-            cwd: targetPath,
-            shell: false,
-            stdio: ['ignore', 'pipe', 'pipe'],
-            windowsHide: true,
-            env: { ...process.env, PYTHONIOENCODING: 'utf-8' }
-          });
-        }
-
-        watcherStats = {
-          running: true,
-          root_path: targetPath,
-          events_processed: 0,
-          start_time: new Date()
-        };
-
-        // Capture stderr for error messages (capped at 4KB to prevent memory leak)
-        const MAX_STDERR_SIZE = 4096;
-        let stderrBuffer = '';
-        if (watcherProcess.stderr) {
-          watcherProcess.stderr.on('data', (data: Buffer) => {
-            stderrBuffer += data.toString();
-            // Cap buffer size to prevent memory leak in long-running watchers
-            if (stderrBuffer.length > MAX_STDERR_SIZE) {
-              stderrBuffer = stderrBuffer.slice(-MAX_STDERR_SIZE);
-            }
-          });
-        }
-
-        // Handle process output for event counting
-        const isV2Watcher = useCodexLensV2();
-        let stdoutLineBuffer = '';
-        if (watcherProcess.stdout) {
-          watcherProcess.stdout.on('data', (data: Buffer) => {
-            const output = data.toString();
-
-            if (isV2Watcher) {
-              // v2 bridge outputs JSONL - parse line by line
-              stdoutLineBuffer += output;
-              const lines = stdoutLineBuffer.split('\n');
-              // Keep incomplete last line in buffer
-              stdoutLineBuffer = lines.pop() || '';
-              for (const line of lines) {
-                const trimmed = line.trim();
-                if (!trimmed) continue;
-                try {
-                  const event = JSON.parse(trimmed);
-                  // Count file change events (created, modified, deleted, moved)
-                  if (event.event && event.event !== 'watching') {
-                    watcherStats.events_processed += 1;
-                  }
-                } catch {
-                  // Not valid JSON, skip
-                }
-              }
-            } else {
-              // v1 watcher: count text-based event messages
-              const matches = output.match(/Processed \d+ events?/g);
-              if (matches) {
-                watcherStats.events_processed += matches.length;
-              }
-            }
-          });
-        }
-
-        // Handle spawn errors (e.g., ENOENT)
-        watcherProcess.on('error', (err: Error) => {
-          console.error(`[CodexLens] Watcher spawn error: ${err.message}`);
-          watcherStats.running = false;
-          watcherProcess = null;
-          broadcastToClients({
-            type: 'CODEXLENS_WATCHER_STATUS',
-            payload: { running: false, error: `Spawn error: ${err.message}` }
-          });
-        });
-
-        // Handle process exit
-        watcherProcess.on('exit', (code: number) => {
-          watcherStats.running = false;
-          watcherProcess = null;
-          console.log(`[CodexLens] Watcher exited with code ${code}`);
-
-          // Broadcast error if exited with non-zero code
-          if (code !== 0) {
-            const errorMsg = stderrBuffer.trim() || `Exited with code ${code}`;
-            const cleanError = stripAnsiCodes(errorMsg);
-            broadcastToClients({
-              type: 'CODEXLENS_WATCHER_STATUS',
-              payload: { running: false, error: cleanError }
-            });
-          } else {
-            broadcastToClients({
-              type: 'CODEXLENS_WATCHER_STATUS',
-              payload: { running: false }
-            });
-          }
-        });
-
-        // Broadcast watcher started
-        broadcastToClients({
-          type: 'CODEXLENS_WATCHER_STATUS',
-          payload: { running: true, path: targetPath }
-        });
-
-        return {
-          success: true,
-          message: 'Watcher started',
-          path: targetPath,
-          pid: watcherProcess.pid
-        };
-      } catch (err: unknown) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  // API: Stop File Watcher
-  if (pathname === '/api/codexlens/watch/stop' && req.method === 'POST') {
-    handlePostRequest(req, res, async () => {
-      if (!watcherStats.running || !watcherProcess) {
-        return { success: false, error: 'Watcher not running', status: 400 };
-      }
-
-      try {
-        watcherProcess.kill('SIGTERM');
-        await new Promise(resolve => setTimeout(resolve, 500));
-        if (watcherProcess && !watcherProcess.killed) {
-          watcherProcess.kill('SIGKILL');
-        }
-
-        const finalStats = {
-          events_processed: watcherStats.events_processed,
-          uptime_seconds: watcherStats.start_time
-            ? Math.floor((Date.now() - watcherStats.start_time.getTime()) / 1000)
-            : 0
-        };
-
-        watcherStats = {
-          running: false,
-          root_path: '',
-          events_processed: 0,
-          start_time: null
-        };
-        watcherProcess = null;
-
-        broadcastToClients({
-          type: 'CODEXLENS_WATCHER_STATUS',
-          payload: { running: false }
-        });
-
-        return {
-          success: true,
-          message: 'Watcher stopped',
-          ...finalStats
-        };
-      } catch (err: unknown) {
-        return { success: false, error: err instanceof Error ? err.message : String(err), status: 500 };
-      }
-    });
-    return true;
-  }
-
-  return false;
-}
-
diff --git a/ccw/src/core/routes/litellm-api-routes.ts b/ccw/src/core/routes/litellm-api-routes.ts
index 2a50901e..536c4549 100644
--- a/ccw/src/core/routes/litellm-api-routes.ts
+++ b/ccw/src/core/routes/litellm-api-routes.ts
@@ -3,17 +3,6 @@
  * Handles LiteLLM provider management, endpoint configuration, and cache management
  */
 import { z } from 'zod';
-import { spawn } from 'child_process';
-import {
-  getSystemPythonCommand,
-  parsePythonCommandSpec,
-  type PythonCommandSpec,
-} from '../../utils/python-utils.js';
-import {
-  isUvAvailable,
-  createCodexLensUvManager
-} from '../../utils/uv-manager.js';
-import { ensureLiteLLMEmbedderReady } from '../../tools/codex-lens.js';
 import type { RouteContext } from './types.js';
 
 // ========== Input Validation Schemas ==========
@@ -81,106 +70,13 @@ import {
   type EmbeddingPoolConfig,
 } from '../../config/litellm-api-config-manager.js';
 import { getContextCacheStore } from '../../tools/context-cache-store.js';
-import { getLiteLLMClient } from '../../tools/litellm-client.js';
 import { testApiKeyConnection, getDefaultApiBase } from '../services/api-key-tester.js';
 
-interface CcwLitellmEnvCheck {
-  python: string;
-  installed: boolean;
-  version?: string;
-  error?: string;
-}
+const V1_REMOVED = 'Python bridge has been removed (v1 cleanup).';
 
-interface CcwLitellmStatusResponse {
-  /**
-   * Whether ccw-litellm is installed in the CodexLens venv.
-   * This is the environment used for the LiteLLM embedding backend.
-   */
-  installed: boolean;
-  version?: string;
-  error?: string;
-  checks?: {
-    codexLensVenv: CcwLitellmEnvCheck;
-    systemPython?: CcwLitellmEnvCheck;
-  };
-}
-
-function checkCcwLitellmImport(
-  pythonCmd: string | PythonCommandSpec,
-  options: { timeout: number }
-): Promise<CcwLitellmEnvCheck> {
-  const { timeout } = options;
-  const pythonSpec = typeof pythonCmd === 'string' ? parsePythonCommandSpec(pythonCmd) : pythonCmd;
-
-  const sanitizePythonError = (stderrText: string): string | undefined => {
-    const trimmed = stderrText.trim();
-    if (!trimmed) return undefined;
-    const lines = trimmed
-      .split(/\r?\n/g)
-      .map((line) => line.trim())
-      .filter(Boolean);
-    // Prefer the final exception line (avoids leaking full traceback + file paths)
-    return lines[lines.length - 1] || undefined;
-  };
-
-  return new Promise((resolve) => {
-    const child = spawn(pythonSpec.command, [...pythonSpec.args, '-c', 'import ccw_litellm; print(ccw_litellm.__version__)'], {
-      stdio: ['ignore', 'pipe', 'pipe'],
-      timeout,
-      windowsHide: true,
-      shell: false,
-      env: { ...process.env, PYTHONIOENCODING: 'utf-8' },
-    });
-
-    let stdout = '';
-    let stderr = '';
-
-    child.stdout?.on('data', (data: Buffer) => {
-      stdout += data.toString();
-    });
-
-    child.stderr?.on('data', (data: Buffer) => {
-      stderr += data.toString();
-    });
-
-    child.on('close', (code: number | null) => {
-      const version = stdout.trim();
-      const error = sanitizePythonError(stderr);
-
-      if (code === 0 && version) {
-        resolve({ python: pythonSpec.display, installed: true, version });
-        return;
-      }
-
-      if (code === null) {
-        resolve({ python: pythonSpec.display, installed: false, error: `Timed out after ${timeout}ms` });
-        return;
-      }
-
-      resolve({ python: pythonSpec.display, installed: false, error: error || undefined });
-    });
-
-    child.on('error', (err) => {
-      resolve({ python: pythonSpec.display, installed: false, error: err.message });
-    });
-  });
-}
-
-// Cache for ccw-litellm status check
-let ccwLitellmStatusCache: {
-  data: CcwLitellmStatusResponse | null;
-  timestamp: number;
-  ttl: number;
-} = {
-  data: null,
-  timestamp: 0,
-  ttl: 5 * 60 * 1000, // 5 minutes
-};
-
-// Clear cache (call after install)
+// Clear cache (no-op stub, kept for backward compatibility)
 export function clearCcwLitellmStatusCache() {
-  ccwLitellmStatusCache.data = null;
-  ccwLitellmStatusCache.timestamp = 0;
+  // no-op: Python bridge removed
 }
 
 function sanitizeProviderForResponse(provider: any): any {
@@ -922,57 +818,10 @@ export async function handleLiteLLMApiRoutes(ctx: RouteContext): Promise<boolean
   // CCW-LiteLLM Package Management
   // ===========================
 
-  // GET /api/litellm-api/ccw-litellm/status - Check ccw-litellm installation status
-  // Supports ?refresh=true to bypass cache
+  // GET /api/litellm-api/ccw-litellm/status - Stub (v1 Python bridge removed)
   if (pathname === '/api/litellm-api/ccw-litellm/status' && req.method === 'GET') {
-    const forceRefresh = url.searchParams.get('refresh') === 'true';
-
-    // Check cache first (unless force refresh)
-    if (!forceRefresh && ccwLitellmStatusCache.data &&
-        Date.now() - ccwLitellmStatusCache.timestamp < ccwLitellmStatusCache.ttl) {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify(ccwLitellmStatusCache.data));
-      return true;
-    }
-
-    try {
-      const uv = createCodexLensUvManager();
-      const venvPython = uv.getVenvPython();
-      const statusTimeout = process.platform === 'win32' ? 15000 : 10000;
-      const codexLensVenv = uv.isVenvValid()
-        ? await checkCcwLitellmImport(venvPython, { timeout: statusTimeout })
-        : { python: venvPython, installed: false, error: 'CodexLens venv not valid' };
-
-      // Diagnostics only: if not installed in venv, also check system python so users understand mismatches.
-      // NOTE: `installed` flag remains the CodexLens venv status (we want isolated venv dependencies).
-      const systemPython = !codexLensVenv.installed
-        ? await checkCcwLitellmImport(getSystemPythonCommand(), { timeout: statusTimeout })
-        : undefined;
-
-      const result: CcwLitellmStatusResponse = {
-        installed: codexLensVenv.installed,
-        version: codexLensVenv.version,
-        error: codexLensVenv.error,
-        checks: {
-          codexLensVenv,
-          ...(systemPython ? { systemPython } : {}),
-        },
-      };
-
-      // Update cache
-      ccwLitellmStatusCache = {
-        data: result,
-        timestamp: Date.now(),
-        ttl: 5 * 60 * 1000,
-      };
-
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify(result));
-    } catch (err) {
-      const errorResult = { installed: false, error: (err as Error).message };
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify(errorResult));
-    }
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ installed: false, error: V1_REMOVED }));
     return true;
   }
 
@@ -1367,96 +1216,18 @@ export async function handleLiteLLMApiRoutes(ctx: RouteContext): Promise<boolean
     return true;
   }
 
-  // POST /api/litellm-api/ccw-litellm/install - Install ccw-litellm package
+  // POST /api/litellm-api/ccw-litellm/install - Stub (v1 Python bridge removed)
   if (pathname === '/api/litellm-api/ccw-litellm/install' && req.method === 'POST') {
     handlePostRequest(req, res, async () => {
-      try {
-        // Delegate entirely to ensureLiteLLMEmbedderReady for consistent installation
-        // This uses unified package discovery and handles UV → pip fallback
-        const result = await ensureLiteLLMEmbedderReady();
-
-        if (result.success) {
-          clearCcwLitellmStatusCache();
-          broadcastToClients({
-            type: 'CCW_LITELLM_INSTALLED',
-            payload: { timestamp: new Date().toISOString(), method: 'unified' }
-          });
-        }
-
-        return result;
-      } catch (err) {
-        return { success: false, error: (err as Error).message };
-      }
+      return { success: false, error: V1_REMOVED };
     });
     return true;
   }
 
-  // POST /api/litellm-api/ccw-litellm/uninstall - Uninstall ccw-litellm package
+  // POST /api/litellm-api/ccw-litellm/uninstall - Stub (v1 Python bridge removed)
   if (pathname === '/api/litellm-api/ccw-litellm/uninstall' && req.method === 'POST') {
     handlePostRequest(req, res, async () => {
-      try {
-        // Priority 1: Use UV to uninstall from CodexLens venv
-        if (await isUvAvailable()) {
-          const uv = createCodexLensUvManager();
-          if (uv.isVenvValid()) {
-            console.log('[ccw-litellm uninstall] Using UV to uninstall from CodexLens venv...');
-            const uvResult = await uv.uninstall(['ccw-litellm']);
-            clearCcwLitellmStatusCache();
-
-            if (uvResult.success) {
-              broadcastToClients({
-                type: 'CCW_LITELLM_UNINSTALLED',
-                payload: { timestamp: new Date().toISOString() }
-              });
-              return { success: true, message: 'ccw-litellm uninstalled successfully via UV' };
-            }
-            console.log('[ccw-litellm uninstall] UV uninstall failed, falling back to pip:', uvResult.error);
-          }
-        }
-
-        // Priority 2: Fallback to system pip uninstall
-        console.log('[ccw-litellm uninstall] Using pip fallback...');
-        const pythonCmd = getSystemPythonCommand();
-
-        return new Promise((resolve) => {
-          const proc = spawn(
-            pythonCmd.command,
-            [...pythonCmd.args, '-m', 'pip', 'uninstall', '-y', 'ccw-litellm'],
-            {
-              shell: false,
-              timeout: 120000,
-              windowsHide: true,
-              env: { ...process.env, PYTHONIOENCODING: 'utf-8' },
-            },
-          );
-          let output = '';
-          let error = '';
-          proc.stdout?.on('data', (data) => { output += data.toString(); });
-          proc.stderr?.on('data', (data) => { error += data.toString(); });
-          proc.on('close', (code) => {
-            // Clear status cache after uninstallation attempt
-            clearCcwLitellmStatusCache();
-
-            if (code === 0) {
-              broadcastToClients({
-                type: 'CCW_LITELLM_UNINSTALLED',
-                payload: { timestamp: new Date().toISOString() }
-              });
-              resolve({ success: true, message: 'ccw-litellm uninstalled successfully' });
-            } else {
-              // Check if package was not installed
-              if (error.includes('not installed') || output.includes('not installed')) {
-                resolve({ success: true, message: 'ccw-litellm was not installed' });
-              } else {
-                resolve({ success: false, error: error || output || 'Uninstallation failed' });
-              }
-            }
-          });
-          proc.on('error', (err) => resolve({ success: false, error: err.message }));
-        });
-      } catch (err) {
-        return { success: false, error: (err as Error).message };
-      }
+      return { success: false, error: V1_REMOVED };
     });
     return true;
   }
diff --git a/ccw/src/core/routes/status-routes.ts b/ccw/src/core/routes/status-routes.ts
index abd39312..a92d79b7 100644
--- a/ccw/src/core/routes/status-routes.ts
+++ b/ccw/src/core/routes/status-routes.ts
@@ -6,7 +6,6 @@ import { existsSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { getCliToolsStatus } from '../../tools/cli-executor.js';
-import { checkVenvStatus, checkSemanticStatus } from '../../tools/codex-lens.js';
 import type { RouteContext } from './types.js';
 
 // Performance logging helper
@@ -80,36 +79,14 @@ export async function handleStatusRoutes(ctx: RouteContext): Promise<boolean> {
       const ccwInstallStatus = checkCcwInstallStatus();
       perfLog('checkCcwInstallStatus', ccwStart);
 
-      // Execute all status checks in parallel with individual timing
+      // Execute async status checks
       const cliStart = Date.now();
-      const codexStart = Date.now();
-      const semanticStart = Date.now();
 
-      const [cliStatus, codexLensStatus, semanticStatus] = await Promise.all([
-        getCliToolsStatus().then(result => {
-          perfLog('getCliToolsStatus', cliStart, { toolCount: Object.keys(result).length });
-          return result;
-        }),
-        checkVenvStatus().then(result => {
-          perfLog('checkVenvStatus', codexStart, { ready: result.ready });
-          return result;
-        }),
-        // Always check semantic status (will return available: false if CodexLens not ready)
-        checkSemanticStatus()
-          .then(result => {
-            perfLog('checkSemanticStatus', semanticStart, { available: result.available });
-            return result;
-          })
-          .catch(() => {
-            perfLog('checkSemanticStatus (error)', semanticStart);
-            return { available: false, backend: null };
-          })
-      ]);
+      const cliStatus = await getCliToolsStatus();
+      perfLog('getCliToolsStatus', cliStart, { toolCount: Object.keys(cliStatus).length });
 
       const response = {
         cli: cliStatus,
-        codexLens: codexLensStatus,
-        semantic: semanticStatus,
         ccwInstall: ccwInstallStatus,
         timestamp: new Date().toISOString()
       };
diff --git a/ccw/src/core/server.ts b/ccw/src/core/server.ts
index fcf6c104..1210c357 100644
--- a/ccw/src/core/server.ts
+++ b/ccw/src/core/server.ts
@@ -16,7 +16,6 @@ import { handleUnifiedMemoryRoutes } from './routes/unified-memory-routes.js';
 import { handleMcpRoutes } from './routes/mcp-routes.js';
 import { handleHooksRoutes } from './routes/hooks-routes.js';
 import { handleUnsplashRoutes, handleBackgroundRoutes } from './routes/unsplash-routes.js';
-import { handleCodexLensRoutes } from './routes/codexlens-routes.js';
 import { handleGraphRoutes } from './routes/graph-routes.js';
 import { handleSystemRoutes } from './routes/system-routes.js';
 import { handleFilesRoutes } from './routes/files-routes.js';
@@ -66,7 +65,6 @@ import { getCliSessionManager } from './services/cli-session-manager.js';
 import { QueueSchedulerService } from './services/queue-scheduler-service.js';
 
 // Import status check functions for warmup
-import { checkSemanticStatus, checkVenvStatus } from '../tools/codex-lens.js';
 import { getCliToolsStatus } from '../tools/cli-executor.js';
 
 import type { ServerConfig } from '../types/config.js';
@@ -302,28 +300,6 @@ async function warmupCaches(initialPath: string): Promise<void> {
 
   // Run all warmup tasks in parallel for faster startup
   const warmupTasks = [
-    // Warmup semantic status cache (Python process startup - can be slow first time)
-    (async () => {
-      const taskStart = Date.now();
-      try {
-        const semanticStatus = await checkSemanticStatus();
-        console.log(`[WARMUP] Semantic status: ${semanticStatus.available ? 'available' : 'not available'} (${Date.now() - taskStart}ms)`);
-      } catch (err) {
-        console.warn(`[WARMUP] Semantic status check failed: ${(err as Error).message}`);
-      }
-    })(),
-
-    // Warmup venv status cache
-    (async () => {
-      const taskStart = Date.now();
-      try {
-        const venvStatus = await checkVenvStatus();
-        console.log(`[WARMUP] Venv status: ${venvStatus.ready ? 'ready' : 'not ready'} (${Date.now() - taskStart}ms)`);
-      } catch (err) {
-        console.warn(`[WARMUP] Venv status check failed: ${(err as Error).message}`);
-      }
-    })(),
-
     // Warmup CLI tools status cache
     (async () => {
       const taskStart = Date.now();
@@ -598,11 +574,6 @@ export async function startServer(options: ServerOptions = {}): Promise<http.Ser
         if (await handleUnsplashRoutes(routeContext)) return;
       }
 
-      // CodexLens routes (/api/codexlens/*)
-      if (pathname.startsWith('/api/codexlens/')) {
-        if (await handleCodexLensRoutes(routeContext)) return;
-      }
-
       // LiteLLM routes (/api/litellm/*)
       if (pathname.startsWith('/api/litellm/')) {
         if (await handleLiteLLMRoutes(routeContext)) return;
diff --git a/ccw/src/core/unified-vector-index.ts b/ccw/src/core/unified-vector-index.ts
index d35405c6..eea10366 100644
--- a/ccw/src/core/unified-vector-index.ts
+++ b/ccw/src/core/unified-vector-index.ts
@@ -1,79 +1,37 @@
 /**
- * Unified Vector Index - TypeScript bridge to unified_memory_embedder.py
+ * Unified Vector Index - STUB (v1 Python bridge removed)
  *
- * Provides HNSW-backed vector indexing and search for all memory content
- * (core_memory, cli_history, workflow, entity, pattern) via CodexLens VectorStore.
- *
- * Features:
- * - JSON stdin/stdout protocol to Python embedder
- * - Content chunking (paragraph -> sentence splitting, CHUNK_SIZE=1500, OVERLAP=200)
- * - Batch embedding via CodexLens EmbedderFactory
- * - HNSW approximate nearest neighbor search (sub-10ms for 1000 chunks)
- * - Category-based filtering
+ * The Python unified_memory_embedder.py bridge has been removed. This module
+ * provides no-op stubs so that existing consumers compile without errors.
  */
 
-import { spawn } from 'child_process';
-import { join, dirname } from 'path';
-import { existsSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { getCodexLensHiddenPython } from '../utils/codexlens-path.js';
-import { StoragePaths, ensureStorageDir } from '../config/storage-paths.js';
+const V1_REMOVED = 'Unified vector index Python bridge has been removed (v1 cleanup).';
 
-// Get directory of this module
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+// ---------------------------------------------------------------------------
+// Types (kept for backward compatibility)
+// ---------------------------------------------------------------------------
 
-// Venv python path (reuse CodexLens venv)
-const VENV_PYTHON = getCodexLensHiddenPython();
-
-// Script path
-const EMBEDDER_SCRIPT = join(__dirname, '..', '..', 'scripts', 'unified_memory_embedder.py');
-
-// Chunking constants (match existing core-memory-store.ts)
-const CHUNK_SIZE = 1500;
-const OVERLAP = 200;
-
-// =============================================================================
-// Types
-// =============================================================================
-
-/** Valid source types for vector content */
 export type SourceType = 'core_memory' | 'workflow' | 'cli_history';
 
-/** Valid category values for vector filtering */
 export type VectorCategory = 'core_memory' | 'cli_history' | 'workflow' | 'entity' | 'pattern';
 
-/** Metadata attached to each chunk in the vector store */
 export interface ChunkMetadata {
-  /** Source identifier (e.g., memory ID, session ID) */
   source_id: string;
-  /** Source type */
   source_type: SourceType;
-  /** Category for filtering */
   category: VectorCategory;
-  /** Chunk index within the source */
   chunk_index?: number;
-  /** Additional metadata */
   [key: string]: unknown;
 }
 
-/** A chunk to be embedded and indexed */
 export interface VectorChunk {
-  /** Text content */
   content: string;
-  /** Source identifier */
   source_id: string;
-  /** Source type */
   source_type: SourceType;
-  /** Category for filtering */
   category: VectorCategory;
-  /** Chunk index */
   chunk_index: number;
-  /** Additional metadata */
   metadata?: Record<string, unknown>;
 }
 
-/** Result of an embed operation */
 export interface EmbedResult {
   success: boolean;
   chunks_processed: number;
@@ -82,7 +40,6 @@ export interface EmbedResult {
   error?: string;
 }
 
-/** A single search match */
 export interface VectorSearchMatch {
   content: string;
   score: number;
@@ -93,7 +50,6 @@ export interface VectorSearchMatch {
   metadata: Record<string, unknown>;
 }
 
-/** Result of a search operation */
 export interface VectorSearchResult {
   success: boolean;
   matches: VectorSearchMatch[];
@@ -102,14 +58,12 @@ export interface VectorSearchResult {
   error?: string;
 }
 
-/** Search options */
 export interface VectorSearchOptions {
   topK?: number;
   minScore?: number;
   category?: VectorCategory;
 }
 
-/** Index status information */
 export interface VectorIndexStatus {
   success: boolean;
   total_chunks: number;
@@ -126,7 +80,6 @@ export interface VectorIndexStatus {
   error?: string;
 }
 
-/** Reindex result */
 export interface ReindexResult {
   success: boolean;
   hnsw_count?: number;
@@ -134,344 +87,73 @@ export interface ReindexResult {
   error?: string;
 }
 
-// =============================================================================
-// Python Bridge
-// =============================================================================
+// ---------------------------------------------------------------------------
+// No-op implementations
+// ---------------------------------------------------------------------------
 
-/**
- * Check if the unified embedder is available (venv and script exist)
- */
 export function isUnifiedEmbedderAvailable(): boolean {
-  if (!existsSync(VENV_PYTHON)) {
-    return false;
-  }
-  if (!existsSync(EMBEDDER_SCRIPT)) {
-    return false;
-  }
-  return true;
+  return false;
 }
 
-/**
- * Run Python script with JSON stdin/stdout protocol.
- *
- * @param request - JSON request object to send via stdin
- * @param timeout - Timeout in milliseconds (default: 5 minutes)
- * @returns Parsed JSON response
- */
-function runPython<T>(request: Record<string, unknown>, timeout: number = 300000): Promise<T> {
-  return new Promise((resolve, reject) => {
-    if (!isUnifiedEmbedderAvailable()) {
-      reject(
-        new Error(
-          'Unified embedder not available. Ensure CodexLens venv exists at ~/.codexlens/venv'
-        )
-      );
-      return;
-    }
-
-    const child = spawn(VENV_PYTHON, [EMBEDDER_SCRIPT], {
-      shell: false,
-      stdio: ['pipe', 'pipe', 'pipe'],
-      timeout,
-      windowsHide: true,
-      env: { ...process.env, PYTHONIOENCODING: 'utf-8' },
-    });
-
-    let stdout = '';
-    let stderr = '';
-
-    child.stdout.on('data', (data) => {
-      stdout += data.toString();
-    });
-
-    child.stderr.on('data', (data) => {
-      stderr += data.toString();
-    });
-
-    child.on('close', (code) => {
-      if (code === 0 && stdout.trim()) {
-        try {
-          resolve(JSON.parse(stdout.trim()) as T);
-        } catch {
-          reject(new Error(`Failed to parse Python output: ${stdout.substring(0, 500)}`));
-        }
-      } else {
-        reject(new Error(`Python script failed (exit code ${code}): ${stderr || stdout}`));
-      }
-    });
-
-    child.on('error', (err) => {
-      if ((err as NodeJS.ErrnoException).code === 'ETIMEDOUT') {
-        reject(new Error('Python script timed out'));
-      } else {
-        reject(new Error(`Failed to spawn Python: ${err.message}`));
-      }
-    });
-
-    // Write JSON request to stdin and close
-    const jsonInput = JSON.stringify(request);
-    child.stdin.write(jsonInput);
-    child.stdin.end();
-  });
-}
-
-// =============================================================================
-// Content Chunking
-// =============================================================================
-
-/**
- * Chunk content into smaller pieces for embedding.
- * Uses paragraph-first, sentence-fallback strategy with overlap.
- *
- * Matches the chunking logic in core-memory-store.ts:
- * - CHUNK_SIZE = 1500 characters
- * - OVERLAP = 200 characters
- * - Split by paragraph boundaries (\n\n) first
- * - Fall back to sentence boundaries (. ) for oversized paragraphs
- *
- * @param content - Text content to chunk
- * @returns Array of chunk strings
- */
 export function chunkContent(content: string): string[] {
-  const chunks: string[] = [];
-
-  // Split by paragraph boundaries first
-  const paragraphs = content.split(/\n\n+/);
-  let currentChunk = '';
-
-  for (const paragraph of paragraphs) {
-    // If adding this paragraph would exceed chunk size
-    if (currentChunk.length + paragraph.length > CHUNK_SIZE && currentChunk.length > 0) {
-      chunks.push(currentChunk.trim());
-
-      // Start new chunk with overlap
-      const overlapText = currentChunk.slice(-OVERLAP);
-      currentChunk = overlapText + '\n\n' + paragraph;
-    } else {
-      currentChunk += (currentChunk ? '\n\n' : '') + paragraph;
-    }
-  }
-
-  // Add remaining chunk
-  if (currentChunk.trim()) {
-    chunks.push(currentChunk.trim());
-  }
-
-  // If chunks are still too large, split by sentences
-  const finalChunks: string[] = [];
-  for (const chunk of chunks) {
-    if (chunk.length <= CHUNK_SIZE) {
-      finalChunks.push(chunk);
-    } else {
-      // Split by sentence boundaries
-      const sentences = chunk.split(/\. +/);
-      let sentenceChunk = '';
-
-      for (const sentence of sentences) {
-        const sentenceWithPeriod = sentence + '. ';
-        if (
-          sentenceChunk.length + sentenceWithPeriod.length > CHUNK_SIZE &&
-          sentenceChunk.length > 0
-        ) {
-          finalChunks.push(sentenceChunk.trim());
-          const overlapText = sentenceChunk.slice(-OVERLAP);
-          sentenceChunk = overlapText + sentenceWithPeriod;
-        } else {
-          sentenceChunk += sentenceWithPeriod;
-        }
-      }
-
-      if (sentenceChunk.trim()) {
-        finalChunks.push(sentenceChunk.trim());
-      }
-    }
-  }
-
-  return finalChunks.length > 0 ? finalChunks : [content];
+  // Minimal chunking for backward compat - just return the content as-is
+  if (!content.trim()) return [];
+  return [content];
 }
 
-// =============================================================================
-// UnifiedVectorIndex Class
-// =============================================================================
-
-/**
- * Unified vector index backed by CodexLens VectorStore (HNSW).
- *
- * Provides content chunking, embedding, storage, and search for all
- * memory content types through a single interface.
- */
 export class UnifiedVectorIndex {
-  private storePath: string;
+  constructor(_projectPath: string) {}
 
-  /**
-   * Create a UnifiedVectorIndex for a project.
-   *
-   * @param projectPath - Project root path (used to resolve storage location)
-   */
-  constructor(projectPath: string) {
-    const paths = StoragePaths.project(projectPath);
-    this.storePath = paths.unifiedVectors.root;
-    ensureStorageDir(this.storePath);
-  }
-
-  /**
-   * Index content by chunking, embedding, and storing in VectorStore.
-   *
-   * @param content - Text content to index
-   * @param metadata - Metadata for all chunks (source_id, source_type, category)
-   * @returns Embed result
-   */
   async indexContent(
-    content: string,
-    metadata: ChunkMetadata
+    _content: string,
+    _metadata: ChunkMetadata
   ): Promise<EmbedResult> {
-    if (!content.trim()) {
-      return {
-        success: true,
-        chunks_processed: 0,
-        chunks_failed: 0,
-        elapsed_time: 0,
-      };
-    }
-
-    // Chunk content
-    const textChunks = chunkContent(content);
-
-    // Build chunk objects for Python
-    const chunks: VectorChunk[] = textChunks.map((text, index) => ({
-      content: text,
-      source_id: metadata.source_id,
-      source_type: metadata.source_type,
-      category: metadata.category,
-      chunk_index: metadata.chunk_index != null ? metadata.chunk_index + index : index,
-      metadata: { ...metadata },
-    }));
-
-    try {
-      const result = await runPython<EmbedResult>({
-        operation: 'embed',
-        store_path: this.storePath,
-        chunks,
-        batch_size: 8,
-      });
-      return result;
-    } catch (err) {
-      return {
-        success: false,
-        chunks_processed: 0,
-        chunks_failed: textChunks.length,
-        elapsed_time: 0,
-        error: (err as Error).message,
-      };
-    }
+    return {
+      success: false,
+      chunks_processed: 0,
+      chunks_failed: 0,
+      elapsed_time: 0,
+      error: V1_REMOVED,
+    };
   }
 
-  /**
-   * Search the vector index using semantic similarity.
-   *
-   * @param query - Natural language search query
-   * @param options - Search options (topK, minScore, category)
-   * @returns Search results sorted by relevance
-   */
   async search(
-    query: string,
-    options: VectorSearchOptions = {}
+    _query: string,
+    _options: VectorSearchOptions = {}
   ): Promise<VectorSearchResult> {
-    const { topK = 10, minScore = 0.3, category } = options;
-
-    try {
-      const result = await runPython<VectorSearchResult>({
-        operation: 'search',
-        store_path: this.storePath,
-        query,
-        top_k: topK,
-        min_score: minScore,
-        category: category || null,
-      });
-      return result;
-    } catch (err) {
-      return {
-        success: false,
-        matches: [],
-        error: (err as Error).message,
-      };
-    }
+    return {
+      success: false,
+      matches: [],
+      error: V1_REMOVED,
+    };
   }
 
-  /**
-   * Search the vector index using a pre-computed embedding vector.
-   * Bypasses text embedding, directly querying HNSW with a raw vector.
-   *
-   * @param vector - Pre-computed embedding vector (array of floats)
-   * @param options - Search options (topK, minScore, category)
-   * @returns Search results sorted by relevance
-   */
   async searchByVector(
-    vector: number[],
-    options: VectorSearchOptions = {}
+    _vector: number[],
+    _options: VectorSearchOptions = {}
   ): Promise<VectorSearchResult> {
-    const { topK = 10, minScore = 0.3, category } = options;
-
-    try {
-      const result = await runPython<VectorSearchResult>({
-        operation: 'search_by_vector',
-        store_path: this.storePath,
-        vector,
-        top_k: topK,
-        min_score: minScore,
-        category: category || null,
-      });
-      return result;
-    } catch (err) {
-      return {
-        success: false,
-        matches: [],
-        error: (err as Error).message,
-      };
-    }
+    return {
+      success: false,
+      matches: [],
+      error: V1_REMOVED,
+    };
   }
 
-  /**
-   * Rebuild the HNSW index from scratch.
-   *
-   * @returns Reindex result
-   */
   async reindexAll(): Promise<ReindexResult> {
-    try {
-      const result = await runPython<ReindexResult>({
-        operation: 'reindex',
-        store_path: this.storePath,
-      });
-      return result;
-    } catch (err) {
-      return {
-        success: false,
-        error: (err as Error).message,
-      };
-    }
+    return {
+      success: false,
+      error: V1_REMOVED,
+    };
   }
 
-  /**
-   * Get the current status of the vector index.
-   *
-   * @returns Index status including chunk counts, HNSW availability, dimension
-   */
   async getStatus(): Promise<VectorIndexStatus> {
-    try {
-      const result = await runPython<VectorIndexStatus>({
-        operation: 'status',
-        store_path: this.storePath,
-      });
-      return result;
-    } catch (err) {
-      return {
-        success: false,
-        total_chunks: 0,
-        hnsw_available: false,
-        hnsw_count: 0,
-        dimension: 0,
-        error: (err as Error).message,
-      };
-    }
+    return {
+      success: false,
+      total_chunks: 0,
+      hnsw_available: false,
+      hnsw_count: 0,
+      dimension: 0,
+      error: V1_REMOVED,
+    };
   }
 }
diff --git a/ccw/src/tools/codex-lens-lsp.ts b/ccw/src/tools/codex-lens-lsp.ts
deleted file mode 100644
index 14f77ce4..00000000
--- a/ccw/src/tools/codex-lens-lsp.ts
+++ /dev/null
@@ -1,405 +0,0 @@
-/**
- * CodexLens LSP Tool - Provides LSP-like code intelligence via CodexLens Python API
- *
- * Features:
- * - symbol_search: Search symbols across workspace
- * - find_definition: Go to symbol definition
- * - find_references: Find all symbol references
- * - get_hover: Get hover information for symbols
- */
-
-import { z } from 'zod';
-import type { ToolSchema, ToolResult } from '../types/tool.js';
-import { spawn } from 'child_process';
-import { join } from 'path';
-import { getProjectRoot } from '../utils/path-validator.js';
-import { getCodexLensHiddenPython } from '../utils/codexlens-path.js';
-
-// CodexLens venv configuration
-const CODEXLENS_VENV = getCodexLensHiddenPython();
-
-// Define Zod schema for validation
-const ParamsSchema = z.object({
-  action: z.enum(['symbol_search', 'find_definition', 'find_references', 'get_hover']),
-  project_root: z.string().optional().describe('Project root directory (auto-detected if not provided)'),
-  symbol_name: z.string().describe('Symbol name to search/query'),
-  symbol_kind: z.string().optional().describe('Symbol kind filter (class, function, method, etc.)'),
-  file_context: z.string().optional().describe('Current file path for proximity ranking'),
-  limit: z.number().default(50).describe('Maximum number of results to return'),
-  kind_filter: z.array(z.string()).optional().describe('List of symbol kinds to filter (for symbol_search)'),
-  file_pattern: z.string().optional().describe('Glob pattern to filter files (for symbol_search)'),
-});
-
-type Params = z.infer<typeof ParamsSchema>;
-
-/**
- * Result types
- */
-interface SymbolInfo {
-  name: string;
-  kind: string;
-  file_path: string;
-  range: {
-    start_line: number;
-    end_line: number;
-  };
-  score?: number;
-}
-
-interface DefinitionResult {
-  name: string;
-  kind: string;
-  file_path: string;
-  range: {
-    start_line: number;
-    end_line: number;
-  };
-}
-
-interface ReferenceResult {
-  file_path: string;
-  line: number;
-  column: number;
-}
-
-interface HoverInfo {
-  name: string;
-  kind: string;
-  signature: string;
-  file_path: string;
-  start_line: number;
-}
-
-type LSPResult = {
-  success: boolean;
-  results?: SymbolInfo[] | DefinitionResult[] | ReferenceResult[] | HoverInfo;
-  error?: string;
-  action: string;
-  metadata?: Record<string, unknown>;
-};
-
-/**
- * Execute CodexLens Python API call
- */
-async function executeCodexLensAPI(
-  apiFunction: string,
-  args: Record<string, unknown>,
-  timeout: number = 30000
-): Promise<LSPResult> {
-  return new Promise((resolve) => {
-    // Build Python script to call API function
-    const pythonScript = `
-import json
-import sys
-from dataclasses import is_dataclass, asdict
-from codexlens.api import ${apiFunction}
-
-def to_serializable(obj):
-    """Recursively convert dataclasses to dicts for JSON serialization."""
-    if obj is None:
-        return None
-    if is_dataclass(obj) and not isinstance(obj, type):
-        return asdict(obj)
-    if isinstance(obj, list):
-        return [to_serializable(item) for item in obj]
-    if isinstance(obj, dict):
-        return {key: to_serializable(value) for key, value in obj.items()}
-    if isinstance(obj, tuple):
-        return tuple(to_serializable(item) for item in obj)
-    return obj
-
-try:
-    args = ${JSON.stringify(args)}
-    result = ${apiFunction}(**args)
-
-    # Convert result to JSON-serializable format
-    output = to_serializable(result)
-
-    print(json.dumps({"success": True, "result": output}))
-except Exception as e:
-    print(json.dumps({"success": False, "error": str(e)}), file=sys.stderr)
-    sys.exit(1)
-`;
-
-    const child = spawn(CODEXLENS_VENV, ['-c', pythonScript], {
-      shell: false,
-      stdio: ['ignore', 'pipe', 'pipe'],
-      timeout,
-      windowsHide: true,
-      env: { ...process.env, PYTHONIOENCODING: 'utf-8' },
-    });
-
-    let stdout = '';
-    let stderr = '';
-
-    child.stdout.on('data', (data) => {
-      stdout += data.toString();
-    });
-
-    child.stderr.on('data', (data) => {
-      stderr += data.toString();
-    });
-
-    child.on('close', (code) => {
-      if (code !== 0) {
-        try {
-          const errorData = JSON.parse(stderr);
-          resolve({
-            success: false,
-            error: errorData.error || 'Unknown error',
-            action: apiFunction,
-          });
-        } catch {
-          resolve({
-            success: false,
-            error: stderr || `Process exited with code ${code}`,
-            action: apiFunction,
-          });
-        }
-        return;
-      }
-
-      try {
-        const data = JSON.parse(stdout);
-        resolve({
-          success: data.success,
-          results: data.result,
-          action: apiFunction,
-        });
-      } catch (err) {
-        resolve({
-          success: false,
-          error: `Failed to parse output: ${(err as Error).message}`,
-          action: apiFunction,
-        });
-      }
-    });
-
-    child.on('error', (err) => {
-      resolve({
-        success: false,
-        error: `Failed to execute: ${err.message}`,
-        action: apiFunction,
-      });
-    });
-  });
-}
-
-/**
- * Handler: symbol_search
- */
-async function handleSymbolSearch(params: Params): Promise<LSPResult> {
-  const projectRoot = params.project_root || getProjectRoot();
-
-  const args: Record<string, unknown> = {
-    project_root: projectRoot,
-    query: params.symbol_name,
-    limit: params.limit,
-  };
-
-  if (params.kind_filter) {
-    args.kind_filter = params.kind_filter;
-  }
-
-  if (params.file_pattern) {
-    args.file_pattern = params.file_pattern;
-  }
-
-  return executeCodexLensAPI('workspace_symbols', args);
-}
-
-/**
- * Handler: find_definition
- */
-async function handleFindDefinition(params: Params): Promise<LSPResult> {
-  const projectRoot = params.project_root || getProjectRoot();
-
-  const args: Record<string, unknown> = {
-    project_root: projectRoot,
-    symbol_name: params.symbol_name,
-    limit: params.limit,
-  };
-
-  if (params.symbol_kind) {
-    args.symbol_kind = params.symbol_kind;
-  }
-
-  if (params.file_context) {
-    args.file_context = params.file_context;
-  }
-
-  return executeCodexLensAPI('find_definition', args);
-}
-
-/**
- * Handler: find_references
- */
-async function handleFindReferences(params: Params): Promise<LSPResult> {
-  const projectRoot = params.project_root || getProjectRoot();
-
-  const args: Record<string, unknown> = {
-    project_root: projectRoot,
-    symbol_name: params.symbol_name,
-    limit: params.limit,
-  };
-
-  if (params.symbol_kind) {
-    args.symbol_kind = params.symbol_kind;
-  }
-
-  return executeCodexLensAPI('find_references', args);
-}
-
-/**
- * Handler: get_hover
- */
-async function handleGetHover(params: Params): Promise<LSPResult> {
-  const projectRoot = params.project_root || getProjectRoot();
-
-  const args: Record<string, unknown> = {
-    project_root: projectRoot,
-    symbol_name: params.symbol_name,
-  };
-
-  if (params.file_context) {
-    args.file_path = params.file_context;
-  }
-
-  return executeCodexLensAPI('get_hover', args);
-}
-
-/**
- * Main handler function
- */
-export async function handler(params: Record<string, unknown>): Promise<ToolResult<LSPResult>> {
-  try {
-    // Validate parameters
-    const validatedParams = ParamsSchema.parse(params);
-
-    // Route to appropriate handler based on action
-    let result: LSPResult;
-    switch (validatedParams.action) {
-      case 'symbol_search':
-        result = await handleSymbolSearch(validatedParams);
-        break;
-      case 'find_definition':
-        result = await handleFindDefinition(validatedParams);
-        break;
-      case 'find_references':
-        result = await handleFindReferences(validatedParams);
-        break;
-      case 'get_hover':
-        result = await handleGetHover(validatedParams);
-        break;
-      default:
-        return {
-          success: false,
-          error: `Unknown action: ${(validatedParams as any).action}`,
-          result: null as any,
-        };
-    }
-
-    if (!result.success) {
-      return {
-        success: false,
-        error: result.error || 'Unknown error',
-        result: null as any,
-      };
-    }
-
-    return {
-      success: true,
-      result,
-    };
-  } catch (err) {
-    if (err instanceof z.ZodError) {
-      return {
-        success: false,
-        error: `Parameter validation failed: ${err.issues.map((e: z.ZodIssue) => `${e.path.join('.')}: ${e.message}`).join(', ')}`,
-        result: null as any,
-      };
-    }
-
-    return {
-      success: false,
-      error: `Execution failed: ${(err as Error).message}`,
-      result: null as any,
-    };
-  }
-}
-
-/**
- * Tool schema for MCP
- */
-export const schema: ToolSchema = {
-  name: 'codex_lens_lsp',
-  description: `LSP-like code intelligence tool powered by CodexLens indexing.
-
-**Actions:**
-- symbol_search: Search for symbols across the workspace
-- find_definition: Find the definition of a symbol
-- find_references: Find all references to a symbol
-- get_hover: Get hover information for a symbol
-
-**Usage Examples:**
-
-Search symbols:
-  codex_lens_lsp(action="symbol_search", symbol_name="MyClass")
-  codex_lens_lsp(action="symbol_search", symbol_name="auth", kind_filter=["function", "method"])
-  codex_lens_lsp(action="symbol_search", symbol_name="User", file_pattern="*.py")
-
-Find definition:
-  codex_lens_lsp(action="find_definition", symbol_name="authenticate")
-  codex_lens_lsp(action="find_definition", symbol_name="User", symbol_kind="class")
-
-Find references:
-  codex_lens_lsp(action="find_references", symbol_name="login")
-
-Get hover info:
-  codex_lens_lsp(action="get_hover", symbol_name="processPayment")
-
-**Requirements:**
-- CodexLens must be installed and indexed: run smart_search(action="init") first
-- Python environment with codex-lens package available`,
-  inputSchema: {
-    type: 'object',
-    properties: {
-      action: {
-        type: 'string',
-        enum: ['symbol_search', 'find_definition', 'find_references', 'get_hover'],
-        description: 'LSP action to perform',
-      },
-      symbol_name: {
-        type: 'string',
-        description: 'Symbol name to search/query (required)',
-      },
-      project_root: {
-        type: 'string',
-        description: 'Project root directory (auto-detected if not provided)',
-      },
-      symbol_kind: {
-        type: 'string',
-        description: 'Symbol kind filter: class, function, method, variable, etc. (optional)',
-      },
-      file_context: {
-        type: 'string',
-        description: 'Current file path for proximity ranking (optional)',
-      },
-      limit: {
-        type: 'number',
-        description: 'Maximum number of results to return (default: 50)',
-        default: 50,
-      },
-      kind_filter: {
-        type: 'array',
-        items: { type: 'string' },
-        description: 'List of symbol kinds to include (for symbol_search)',
-      },
-      file_pattern: {
-        type: 'string',
-        description: 'Glob pattern to filter files (for symbol_search)',
-      },
-    },
-    required: ['action', 'symbol_name'],
-  },
-};
diff --git a/ccw/src/tools/codex-lens.ts b/ccw/src/tools/codex-lens.ts
index 372f5a34..ffff12f1 100644
--- a/ccw/src/tools/codex-lens.ts
+++ b/ccw/src/tools/codex-lens.ts
@@ -1,182 +1,16 @@
 /**
- * CodexLens Tool - Bridge between CCW and CodexLens Python package
- * Provides code indexing and semantic search via spawned Python process
+ * CodexLens Tool - STUB (v1 removed)
  *
- * Features:
- * - Automatic venv bootstrap at ~/.codexlens/venv
- * - JSON protocol communication
- * - Symbol extraction and semantic search
- * - FTS5 full-text search
+ * The v1 Python bridge has been removed. This module provides no-op stubs
+ * so that existing consumers compile without errors.
+ * Semantic search is now handled entirely by codexlens-search v2.
  */
 
-import { z } from 'zod';
 import type { ToolSchema, ToolResult } from '../types/tool.js';
-import { spawn, spawnSync, execSync, exec, type SpawnOptions, type SpawnSyncOptionsWithStringEncoding } from 'child_process';
-import { existsSync, mkdirSync, rmSync, statSync } from 'fs';
-import { join, resolve } from 'path';
-import {
-  getSystemPythonCommand,
-  parsePythonVersion,
-  isPythonVersionCompatible,
-  type PythonCommandSpec,
-} from '../utils/python-utils.js';
-import { EXEC_TIMEOUTS } from '../utils/exec-constants.js';
-import {
-  UvManager,
-  ensureUvInstalled,
-  isUvAvailable,
-  createCodexLensUvManager,
-} from '../utils/uv-manager.js';
-import {
-  getCodexLensDataDir,
-  getCodexLensVenvDir,
-  getCodexLensPython,
-  getCodexLensHiddenPython,
-  getCodexLensPip,
-} from '../utils/codexlens-path.js';
-import {
-  findCodexLensPath,
-  findCcwLitellmPath,
-  formatSearchResults,
-  isDevEnvironment,
-  isInsideNodeModules,
-  type PackageDiscoveryResult,
-  type SearchAttempt,
-} from '../utils/package-discovery.js';
 
-// Bootstrap status cache
-let bootstrapChecked = false;
-let bootstrapReady = false;
-
-// Venv status cache with TTL
-interface VenvStatusCache {
-  status: ReadyStatus;
-  timestamp: number;
-}
-let venvStatusCache: VenvStatusCache | null = null;
-const VENV_STATUS_TTL = 5 * 60 * 1000; // 5 minutes TTL
-
-// Semantic status cache with TTL (same as venv cache)
-interface SemanticStatusCache {
-  status: SemanticStatus;
-  timestamp: number;
-}
-let semanticStatusCache: SemanticStatusCache | null = null;
-const SEMANTIC_STATUS_TTL = 5 * 60 * 1000; // 5 minutes TTL
-
-type HiddenCodexLensSpawnSyncOptions = Omit<SpawnSyncOptionsWithStringEncoding, 'encoding'> & {
-  encoding?: BufferEncoding;
-};
-
-// Track running indexing process for cancellation
-let currentIndexingProcess: ReturnType<typeof spawn> | null = null;
-let currentIndexingAborted = false;
-
-// Spawn timeout for checkVenvStatus (Windows cold start is slower)
-const VENV_CHECK_TIMEOUT = process.platform === 'win32' ? 15000 : 10000;
-
-/**
- * Pre-flight check: verify Python 3.9+ is available before attempting bootstrap.
- * Returns an error message if Python is not suitable, or null if OK.
- */
-function probePythonVersion(
-  pythonCommand: PythonCommandSpec,
-  runner: typeof spawnSync = spawnSync,
-): string {
-  const result = runner(
-    pythonCommand.command,
-    [...pythonCommand.args, '--version'],
-    buildCodexLensSpawnSyncOptions({
-      timeout: EXEC_TIMEOUTS.PYTHON_VERSION,
-    }),
-  );
-
-  if (result.error) {
-    throw result.error;
-  }
-
-  const versionOutput = `${result.stdout ?? ''}${result.stderr ?? ''}`.trim();
-  if (result.status !== 0) {
-    throw new Error(versionOutput || `Python version probe exited with code ${String(result.status)}`);
-  }
-
-  return versionOutput;
-}
-
-function preFlightCheck(): string | null {
-  try {
-    const pythonCommand = getSystemPythonCommand();
-    const version = probePythonVersion(pythonCommand);
-    const parsed = parsePythonVersion(version);
-    if (!parsed) {
-      return `Cannot parse Python version from: "${version}". Ensure Python 3.9+ is installed.`;
-    }
-    if (parsed.major !== 3 || parsed.minor < 9) {
-      return `Python ${parsed.major}.${parsed.minor} found, but 3.9+ is required. Install Python 3.9-3.12 or set CCW_PYTHON.`;
-    }
-    return null;
-  } catch (err) {
-    return `Python not found: ${(err as Error).message}. Install Python 3.9-3.12 and ensure it is in PATH.`;
-  }
-}
-
-/**
- * Detect and repair a corrupted venv.
- * A venv is considered corrupted if the directory exists but the Python executable is missing.
- * @returns true if venv was repaired (deleted), false if no repair needed
- */
-function repairVenvIfCorrupted(): boolean {
-  const venvPath = getCodexLensVenvDir();
-  if (!existsSync(venvPath)) {
-    return false; // No venv at all — nothing to repair
-  }
-
-  const pythonPath = getCodexLensPython();
-  if (existsSync(pythonPath)) {
-    return false; // Venv looks healthy
-  }
-
-  // Venv dir exists but python is missing — corrupted
-  console.warn(`[CodexLens] Corrupted venv detected: ${venvPath} exists but Python executable missing. Removing for recreation...`);
-  try {
-    rmSync(venvPath, { recursive: true, force: true });
-    clearVenvStatusCache();
-    console.log('[CodexLens] Corrupted venv removed successfully.');
-    return true;
-  } catch (err) {
-    console.error(`[CodexLens] Failed to remove corrupted venv: ${(err as Error).message}`);
-    return false;
-  }
-}
-
-// Define Zod schema for validation
-const ParamsSchema = z.object({
-  action: z.enum([
-    'init',
-    'search',
-    'search_files',
-    'status',
-    'symbol',
-    'check',
-    'update',
-    'bootstrap',
-  ]),
-  path: z.string().optional(),
-  query: z.string().optional(),
-  mode: z.enum(['auto', 'text', 'semantic', 'exact', 'fuzzy', 'hybrid', 'vector', 'pure-vector']).default('auto'),
-  format: z.enum(['json', 'text', 'pretty']).default('json'),
-  languages: z.array(z.string()).optional(),
-  limit: z.number().default(20),
-  enrich: z.boolean().default(false),
-  // Additional fields for internal functions
-  file: z.string().optional(),
-  key: z.string().optional(),
-  value: z.string().optional(),
-  newPath: z.string().optional(),
-  all: z.boolean().optional(),
-});
-
-type Params = z.infer<typeof ParamsSchema>;
+// ---------------------------------------------------------------------------
+// Types (kept for backward compatibility)
+// ---------------------------------------------------------------------------
 
 interface ReadyStatus {
   ready: boolean;
@@ -198,16 +32,14 @@ interface SemanticStatus {
 
 interface BootstrapResult {
   success: boolean;
-  error?: string;
   message?: string;
-  warnings?: string[];
-  diagnostics?: {
+  error?: string;
+  details?: {
     pythonVersion?: string;
     venvPath?: string;
     packagePath?: string;
     installer?: 'uv' | 'pip';
     editable?: boolean;
-    searchedPaths?: SearchAttempt[];
   };
 }
 
@@ -220,11 +52,6 @@ interface ExecuteResult {
   results?: unknown;
   files?: unknown;
   symbols?: unknown;
-  status?: unknown;
-  config?: unknown;
-  cleanResult?: unknown;
-  ready?: boolean;
-  version?: string;
 }
 
 interface ExecuteOptions {
@@ -241,2366 +68,119 @@ interface ProgressInfo {
   totalFiles?: number;
 }
 
-/**
- * Clear venv status cache (call after install/uninstall operations)
- */
-function clearVenvStatusCache(): void {
-  venvStatusCache = null;
-}
-
-// Python detection functions imported from ../utils/python-utils.js
-
-/**
- * Check if CodexLens venv exists and has required packages
- * @param force - Force refresh cache (default: false)
- * @returns Ready status
- */
-async function checkVenvStatus(force = false): Promise<ReadyStatus> {
-  const funcStart = Date.now();
-  console.log('[PERF][CodexLens] checkVenvStatus START');
-
-  // Use cached result if available and not expired
-  if (!force && venvStatusCache && (Date.now() - venvStatusCache.timestamp < VENV_STATUS_TTL)) {
-    console.log(`[PERF][CodexLens] checkVenvStatus CACHE HIT: ${Date.now() - funcStart}ms`);
-    return venvStatusCache.status;
-  }
-
-  const venvPath = getCodexLensVenvDir();
-
-  // Check venv exists
-  if (!existsSync(venvPath)) {
-    const result = { ready: false, installed: false, error: 'Venv not found', venvPath };
-    venvStatusCache = { status: result, timestamp: Date.now() };
-    console.log(`[PERF][CodexLens] checkVenvStatus (no venv): ${Date.now() - funcStart}ms`);
-    return result;
-  }
-
-  const pythonPath = getCodexLensHiddenPython();
-
-  // Check python executable exists
-  if (!existsSync(pythonPath)) {
-    const result = { ready: false, installed: false, error: 'Python executable not found in venv', venvPath };
-    venvStatusCache = { status: result, timestamp: Date.now() };
-    console.log(`[PERF][CodexLens] checkVenvStatus (no python): ${Date.now() - funcStart}ms`);
-    return result;
-  }
-
-  // Check codexlens and core dependencies are importable, and get Python version
-  const spawnStart = Date.now();
-  console.log('[PERF][CodexLens] checkVenvStatus spawning Python...');
-
-  return new Promise((resolve) => {
-    const child = spawn(
-      pythonPath,
-      ['-c', 'import sys; import codexlens; import watchdog; print(f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"); print(codexlens.__version__)'],
-      buildCodexLensSpawnOptions(venvPath, VENV_CHECK_TIMEOUT, {
-        stdio: ['ignore', 'pipe', 'pipe'],
-      }),
-    );
-
-    let stdout = '';
-    let stderr = '';
-
-    child.stdout?.on('data', (data) => {
-      stdout += data.toString();
-    });
-    child.stderr?.on('data', (data) => {
-      stderr += data.toString();
-    });
-
-    child.on('close', (code) => {
-      let result: ReadyStatus;
-      if (code === 0) {
-        const lines = stdout.trim().split('\n');
-        const pythonVersion = lines[0]?.trim() || '';
-        const codexlensVersion = lines[1]?.trim() || '';
-        result = {
-          ready: true,
-          installed: true,
-          version: codexlensVersion,
-          pythonVersion,
-          venvPath
-        };
-      } else {
-        result = { ready: false, installed: false, error: `CodexLens not installed: ${stderr}`, venvPath };
-      }
-      // Cache the result
-      venvStatusCache = { status: result, timestamp: Date.now() };
-      console.log(`[PERF][CodexLens] checkVenvStatus Python spawn: ${Date.now() - spawnStart}ms | TOTAL: ${Date.now() - funcStart}ms | ready: ${result.ready}`);
-      resolve(result);
-    });
-
-    child.on('error', (err) => {
-      const result = { ready: false, installed: false, error: `Failed to check venv: ${err.message}`, venvPath };
-      venvStatusCache = { status: result, timestamp: Date.now() };
-      console.log(`[PERF][CodexLens] checkVenvStatus ERROR: ${Date.now() - funcStart}ms`);
-      resolve(result);
-    });
-  });
-}
-
-/**
- * Clear semantic status cache (call after install/uninstall operations)
- */
-function clearSemanticStatusCache(): void {
-  semanticStatusCache = null;
-}
-
-/**
- * Check if semantic search dependencies are installed
- * @param force - Force refresh cache (default: false)
- * @returns Semantic status
- */
-async function checkSemanticStatus(force = false): Promise<SemanticStatus> {
-  const funcStart = Date.now();
-  console.log('[PERF][CodexLens] checkSemanticStatus START');
-
-  // Use cached result if available and not expired
-  if (!force && semanticStatusCache && (Date.now() - semanticStatusCache.timestamp < SEMANTIC_STATUS_TTL)) {
-    console.log(`[PERF][CodexLens] checkSemanticStatus CACHE HIT: ${Date.now() - funcStart}ms`);
-    return semanticStatusCache.status;
-  }
-
-  // First check if CodexLens is installed
-  const venvStatus = await checkVenvStatus();
-  if (!venvStatus.ready) {
-    const result: SemanticStatus = { available: false, error: 'CodexLens not installed' };
-    semanticStatusCache = { status: result, timestamp: Date.now() };
-    console.log(`[PERF][CodexLens] checkSemanticStatus (no venv): ${Date.now() - funcStart}ms`);
-    return result;
-  }
-
-  // Check semantic module availability and accelerator info
-  const spawnStart = Date.now();
-  console.log('[PERF][CodexLens] checkSemanticStatus spawning Python...');
-
-  return new Promise((resolve) => {
-    const checkCode = `
-import sys
-import json
-try:
-    import codexlens.semantic as semantic
-    SEMANTIC_AVAILABLE = bool(getattr(semantic, "SEMANTIC_AVAILABLE", False))
-    SEMANTIC_BACKEND = getattr(semantic, "SEMANTIC_BACKEND", None)
-    LITELLM_AVAILABLE = bool(getattr(semantic, "LITELLM_AVAILABLE", False))
-    result = {
-        "available": SEMANTIC_AVAILABLE,
-        "backend": SEMANTIC_BACKEND if SEMANTIC_AVAILABLE else None,
-        "litellm_available": LITELLM_AVAILABLE,
-    }
-
-    # Get ONNX providers for accelerator info
-    try:
-        import onnxruntime
-        providers = onnxruntime.get_available_providers()
-        result["providers"] = providers
-
-        # Determine accelerator type
-        if "CUDAExecutionProvider" in providers or "TensorrtExecutionProvider" in providers:
-            result["accelerator"] = "CUDA"
-        elif "DmlExecutionProvider" in providers:
-            result["accelerator"] = "DirectML"
-        elif "CoreMLExecutionProvider" in providers:
-            result["accelerator"] = "CoreML"
-        elif "ROCMExecutionProvider" in providers:
-            result["accelerator"] = "ROCm"
-        else:
-            result["accelerator"] = "CPU"
-    except:
-        result["providers"] = []
-        result["accelerator"] = "CPU"
-
-    print(json.dumps(result))
-except Exception as e:
-    print(json.dumps({"available": False, "error": str(e)}))
-`;
-    const child = spawn(
-      getCodexLensHiddenPython(),
-      ['-c', checkCode],
-      buildCodexLensSpawnOptions(getCodexLensVenvDir(), 15000, {
-        stdio: ['ignore', 'pipe', 'pipe'],
-      }),
-    );
-
-    let stdout = '';
-    let stderr = '';
-
-    child.stdout?.on('data', (data) => {
-      stdout += data.toString();
-    });
-    child.stderr?.on('data', (data) => {
-      stderr += data.toString();
-    });
-
-    child.on('close', (code) => {
-      const output = stdout.trim();
-      try {
-        const result = JSON.parse(output);
-        console.log(`[PERF][CodexLens] checkSemanticStatus Python spawn: ${Date.now() - spawnStart}ms | TOTAL: ${Date.now() - funcStart}ms | available: ${result.available}`);
-        const status: SemanticStatus = {
-          available: result.available || false,
-          backend: result.backend,
-          accelerator: result.accelerator || 'CPU',
-          providers: result.providers || [],
-          litellmAvailable: result.litellm_available || false,
-          error: result.error
-        };
-        // Cache the result
-        semanticStatusCache = { status, timestamp: Date.now() };
-        resolve(status);
-      } catch {
-        console.log(`[PERF][CodexLens] checkSemanticStatus PARSE ERROR: ${Date.now() - funcStart}ms`);
-        const errorStatus: SemanticStatus = { available: false, error: output || stderr || 'Unknown error' };
-        semanticStatusCache = { status: errorStatus, timestamp: Date.now() };
-        resolve(errorStatus);
-      }
-    });
-
-    child.on('error', (err) => {
-      console.log(`[PERF][CodexLens] checkSemanticStatus ERROR: ${Date.now() - funcStart}ms`);
-      const errorStatus: SemanticStatus = { available: false, error: `Check failed: ${err.message}` };
-      semanticStatusCache = { status: errorStatus, timestamp: Date.now() };
-      resolve(errorStatus);
-    });
-  });
-}
-
-/**
- * Ensure LiteLLM embedder dependencies are available in the CodexLens venv.
- * Installs ccw-litellm into the venv if needed.
- */
-async function ensureLiteLLMEmbedderReady(): Promise<BootstrapResult> {
-  // Ensure CodexLens venv exists and CodexLens is installed.
-  const readyStatus = await ensureReady();
-  if (!readyStatus.ready) {
-    return { success: false, error: readyStatus.error || 'CodexLens not ready' };
-  }
-
-  // Check if ccw_litellm can be imported
-  const importStatus = await new Promise<{ ok: boolean; error?: string }>((resolve) => {
-    const child = spawn(
-      getCodexLensHiddenPython(),
-      ['-c', 'import ccw_litellm; print("OK")'],
-      buildCodexLensSpawnOptions(getCodexLensVenvDir(), 15000, {
-        stdio: ['ignore', 'pipe', 'pipe'],
-      }),
-    );
-
-    let stderr = '';
-    child.stderr?.on('data', (data) => {
-      stderr += data.toString();
-    });
-
-    child.on('close', (code) => {
-      resolve({ ok: code === 0, error: stderr.trim() || undefined });
-    });
-
-    child.on('error', (err) => {
-      resolve({ ok: false, error: err.message });
-    });
-  });
-
-  if (importStatus.ok) {
-    return { success: true, diagnostics: { venvPath: getCodexLensVenvDir() } };
-  }
-
-  console.log('[CodexLens] Installing ccw-litellm for LiteLLM embedding backend...');
-
-  // Find local ccw-litellm package path using unified discovery
-  const discovery = findCcwLitellmPath();
-  const localPath = discovery.path;
-  const editable = localPath ? (isDevEnvironment() && !discovery.insideNodeModules) : false;
-  const warnings: string[] = [];
-
-  // Priority: Use UV if available (faster, better dependency resolution)
-  if (await isUvAvailable()) {
-    console.log('[CodexLens] Using UV for ccw-litellm installation...');
-    try {
-      const uv = createCodexLensUvManager();
-
-      // Ensure venv exists
-      if (!uv.isVenvValid()) {
-        const venvResult = await uv.createVenv();
-        if (!venvResult.success) {
-          console.log('[CodexLens] UV venv creation failed, falling back to pip:', venvResult.error);
-          warnings.push(`UV venv creation failed: ${venvResult.error}`);
-          // Fall through to pip fallback
-        }
-      }
-
-      if (uv.isVenvValid()) {
-        let uvResult;
-        if (localPath) {
-          console.log(`[CodexLens] Installing ccw-litellm from local path with UV: ${localPath} (editable: ${editable})`);
-          uvResult = await uv.installFromProject(localPath, undefined, editable);
-        } else {
-          console.log('[CodexLens] Installing ccw-litellm from PyPI with UV...');
-          uvResult = await uv.install(['ccw-litellm']);
-        }
-
-        if (uvResult.success) {
-          return {
-            success: true,
-            diagnostics: { packagePath: localPath || undefined, venvPath: getCodexLensVenvDir(), installer: 'uv', editable },
-            warnings: warnings.length > 0 ? warnings : undefined,
-          };
-        }
-        console.log('[CodexLens] UV install failed, falling back to pip:', uvResult.error);
-        warnings.push(`UV install failed: ${uvResult.error}`);
-      }
-    } catch (uvErr) {
-      console.log('[CodexLens] UV error, falling back to pip:', (uvErr as Error).message);
-      warnings.push(`UV error: ${(uvErr as Error).message}`);
-    }
-  }
-
-  // Fallback: Use pip for installation
-  const pipPath = getCodexLensPip();
-
-  // UV-created venvs may not ship with pip.exe. Ensure pip exists before using pip fallback.
-  if (!existsSync(pipPath)) {
-    const venvPython = getCodexLensPython();
-    console.warn(`[CodexLens] pip not found at: ${pipPath}. Attempting to bootstrap pip with ensurepip...`);
-    try {
-      const ensurePipResult = spawnSync(
-        venvPython,
-        ['-m', 'ensurepip', '--upgrade'],
-        buildCodexLensSpawnSyncOptions({
-          timeout: EXEC_TIMEOUTS.PACKAGE_INSTALL,
-        }),
-      );
-      if (ensurePipResult.error) {
-        throw ensurePipResult.error;
-      }
-      if (ensurePipResult.status !== 0) {
-        throw new Error(`ensurepip exited with code ${String(ensurePipResult.status)}`);
-      }
-    } catch (err) {
-      console.warn(`[CodexLens] ensurepip failed: ${(err as Error).message}`);
-    }
-  }
-
-  if (!existsSync(pipPath)) {
-    return {
-      success: false,
-      error: `pip not found at ${pipPath}. Delete ${getCodexLensVenvDir()} and retry, or reinstall using UV.`,
-      diagnostics: {
-        packagePath: localPath || undefined,
-        venvPath: getCodexLensVenvDir(),
-        installer: 'pip',
-        editable,
-        searchedPaths: !localPath ? discovery.searchedPaths : undefined,
-      },
-      warnings: warnings.length > 0 ? warnings : undefined,
-    };
-  }
-
-
-  try {
-    if (localPath) {
-      const pipArgs = editable ? ['install', '-e', localPath] : ['install', localPath];
-      console.log(`[CodexLens] Installing ccw-litellm from local path with pip: ${localPath} (editable: ${editable})`);
-      const installResult = spawnSync(
-        pipPath,
-        pipArgs,
-        buildCodexLensSpawnSyncOptions({
-          timeout: EXEC_TIMEOUTS.PACKAGE_INSTALL,
-        }),
-      );
-      if (installResult.error) {
-        throw installResult.error;
-      }
-      if (installResult.status !== 0) {
-        throw new Error(`pip install exited with code ${String(installResult.status)}`);
-      }
-    } else {
-      console.log('[CodexLens] Installing ccw-litellm from PyPI with pip...');
-      const installResult = spawnSync(
-        pipPath,
-        ['install', 'ccw-litellm'],
-        buildCodexLensSpawnSyncOptions({
-          timeout: EXEC_TIMEOUTS.PACKAGE_INSTALL,
-        }),
-      );
-      if (installResult.error) {
-        throw installResult.error;
-      }
-      if (installResult.status !== 0) {
-        throw new Error(`pip install exited with code ${String(installResult.status)}`);
-      }
-    }
-
-    return {
-      success: true,
-      diagnostics: { packagePath: localPath || undefined, venvPath: getCodexLensVenvDir(), installer: 'pip', editable },
-      warnings: warnings.length > 0 ? warnings : undefined,
-    };
-  } catch (err) {
-    return {
-      success: false,
-      error: `Failed to install ccw-litellm: ${(err as Error).message}`,
-      diagnostics: {
-        packagePath: localPath || undefined,
-        venvPath: getCodexLensVenvDir(),
-        installer: 'pip',
-        editable,
-        searchedPaths: !localPath ? discovery.searchedPaths : undefined,
-      },
-      warnings: warnings.length > 0 ? warnings : undefined,
-    };
-  }
-}
-
-/**
- * GPU acceleration mode for semantic search
- */
 type GpuMode = 'cpu' | 'cuda' | 'directml';
 
-/**
- * Mapping from GPU mode to codexlens extras for UV installation
- */
-const GPU_MODE_EXTRAS: Record<GpuMode, string[]> = {
-  cpu: ['semantic'],
-  cuda: ['semantic-gpu'],
-  directml: ['semantic-directml'],
-};
-
-/**
- * Python environment info for compatibility checks
- */
 interface PythonEnvInfo {
-  version: string;        // e.g., "3.11.5"
-  majorMinor: string;     // e.g., "3.11"
-  architecture: number;   // 32 or 64
-  compatible: boolean;    // true if 64-bit and Python 3.8-3.12
+  version: string;
+  majorMinor: string;
+  architecture: number;
+  compatible: boolean;
   error?: string;
 }
 
-/**
- * Check Python environment in venv for DirectML compatibility
- * DirectML requires: 64-bit Python, version 3.8-3.12
- */
-async function checkPythonEnvForDirectML(): Promise<PythonEnvInfo> {
-  const pythonPath = getCodexLensHiddenPython();
+// ---------------------------------------------------------------------------
+// No-op implementations
+// ---------------------------------------------------------------------------
 
-  if (!existsSync(pythonPath)) {
-    return { version: '', majorMinor: '', architecture: 0, compatible: false, error: 'Python not found in venv' };
-  }
+const V1_REMOVED = 'CodexLens v1 has been removed. Use codexlens-search v2.';
 
-  try {
-    // Get Python version and architecture in one call
-    // Use % formatting instead of f-string to avoid Windows shell escaping issues with curly braces
-    const checkScript = `import sys, struct; print('%d.%d.%d|%d' % (sys.version_info.major, sys.version_info.minor, sys.version_info.micro, struct.calcsize('P') * 8))`;
-    const result = spawnSync(
-      pythonPath,
-      ['-c', checkScript],
-      buildCodexLensSpawnSyncOptions({ timeout: 10000 }),
-    );
-    if (result.error) {
-      throw result.error;
-    }
-    const output = `${result.stdout ?? ''}${result.stderr ?? ''}`.trim();
-    if (result.status !== 0) {
-      throw new Error(output || `Python probe exited with code ${String(result.status)}`);
-    }
-    const [version, archStr] = output.split('|');
-    const architecture = parseInt(archStr, 10);
-    const [major, minor] = version.split('.').map(Number);
-    const majorMinor = `${major}.${minor}`;
-
-    // DirectML wheels available for Python 3.8-3.12, 64-bit only
-    const versionCompatible = major === 3 && minor >= 8 && minor <= 12;
-    const archCompatible = architecture === 64;
-    const compatible = versionCompatible && archCompatible;
-
-    let error: string | undefined;
-    if (!archCompatible) {
-      error = `Python is ${architecture}-bit. onnxruntime-directml requires 64-bit Python. Please reinstall Python as 64-bit.`;
-    } else if (!versionCompatible) {
-      error = `Python ${majorMinor} is not supported. onnxruntime-directml requires Python 3.8-3.12.`;
-    }
-
-    return { version, majorMinor, architecture, compatible, error };
-  } catch (e) {
-    return { version: '', majorMinor: '', architecture: 0, compatible: false, error: `Failed to check Python: ${(e as Error).message}` };
-  }
-}
-
-/**
- * Detect available GPU acceleration
- * @returns Detected GPU mode and info
- */
-async function detectGpuSupport(): Promise<{ mode: GpuMode; available: GpuMode[]; info: string; pythonEnv?: PythonEnvInfo }> {
-  const available: GpuMode[] = ['cpu'];
-  let detectedInfo = 'CPU only';
-
-  // Check for NVIDIA GPU (CUDA)
-  try {
-    if (process.platform === 'win32') {
-      execSync('nvidia-smi', { stdio: 'pipe', timeout: EXEC_TIMEOUTS.SYSTEM_INFO });
-      available.push('cuda');
-      detectedInfo = 'NVIDIA GPU detected (CUDA available)';
-    } else {
-      execSync('which nvidia-smi', { stdio: 'pipe', timeout: EXEC_TIMEOUTS.SYSTEM_INFO });
-      available.push('cuda');
-      detectedInfo = 'NVIDIA GPU detected (CUDA available)';
-    }
-  } catch {
-    // NVIDIA not available
-  }
-
-  // On Windows, DirectML requires 64-bit Python 3.8-3.12
-  let pythonEnv: PythonEnvInfo | undefined;
-  if (process.platform === 'win32') {
-    pythonEnv = await checkPythonEnvForDirectML();
-    if (pythonEnv.compatible) {
-      available.push('directml');
-      if (available.includes('cuda')) {
-        detectedInfo = 'NVIDIA GPU detected (CUDA & DirectML available)';
-      } else {
-        detectedInfo = 'DirectML available (Windows GPU acceleration)';
-      }
-    } else if (pythonEnv.error) {
-      // DirectML not available due to Python environment
-      console.log(`[CodexLens] DirectML unavailable: ${pythonEnv.error}`);
-    }
-  }
-
-  // Recommend best available mode
-  let recommendedMode: GpuMode = 'cpu';
-  if (process.platform === 'win32' && available.includes('directml')) {
-    recommendedMode = 'directml'; // DirectML is easier on Windows (no CUDA toolkit needed)
-  } else if (available.includes('cuda')) {
-    recommendedMode = 'cuda';
-  }
-
-  return { mode: recommendedMode, available, info: detectedInfo, pythonEnv };
-}
-
-/**
- * Bootstrap CodexLens venv using UV (fast package manager)
- * @param gpuMode - GPU acceleration mode for semantic search
- * @returns Bootstrap result
- */
-async function bootstrapWithUv(gpuMode: GpuMode = 'cpu'): Promise<BootstrapResult> {
-  console.log('[CodexLens] Bootstrapping with UV package manager...');
-
-  // Pre-flight: verify Python is available and compatible
-  const preFlightError = preFlightCheck();
-  if (preFlightError) {
-    return { success: false, error: `Pre-flight failed: ${preFlightError}` };
-  }
-
-  // Auto-repair corrupted venv before proceeding
-  repairVenvIfCorrupted();
-
-  // Ensure UV is installed
-  const uvInstalled = await ensureUvInstalled();
-  if (!uvInstalled) {
-    return { success: false, error: 'Failed to install UV package manager' };
-  }
-
-  // Create UV manager for CodexLens
-  const uv = createCodexLensUvManager();
-
-  // Create venv if not exists
-  if (!uv.isVenvValid()) {
-    console.log('[CodexLens] Creating virtual environment with UV...');
-    const createResult = await uv.createVenv();
-    if (!createResult.success) {
-      return { success: false, error: `Failed to create venv: ${createResult.error}` };
-    }
-  }
-
-  // Find local codex-lens package using unified discovery
-  const discovery = findCodexLensPath();
-
-  // Determine extras based on GPU mode
-  const extras = GPU_MODE_EXTRAS[gpuMode];
-
-  if (!discovery.path) {
-    return {
-      success: false,
-      error: formatSearchResults(discovery, 'codex-lens'),
-      diagnostics: { searchedPaths: discovery.searchedPaths, venvPath: getCodexLensVenvDir(), installer: 'uv' },
-    };
-  }
-
-  // Use non-editable install for production stability (editable only in dev)
-  const editable = isDevEnvironment() && !discovery.insideNodeModules;
-  console.log(`[CodexLens] Installing from local path with UV: ${discovery.path} (editable: ${editable})`);
-  console.log(`[CodexLens] Extras: ${extras.join(', ')}`);
-  const installResult = await uv.installFromProject(discovery.path, extras, editable);
-  if (!installResult.success) {
-    return {
-      success: false,
-      error: `Failed to install codex-lens: ${installResult.error}`,
-      diagnostics: { packagePath: discovery.path, venvPath: getCodexLensVenvDir(), installer: 'uv', editable },
-    };
-  }
-
-  // Clear cache after successful installation
-  clearVenvStatusCache();
-  clearSemanticStatusCache();
-  console.log(`[CodexLens] Bootstrap with UV complete (${gpuMode} mode)`);
-  return {
-    success: true,
-    message: `Installed with UV (${gpuMode} mode)`,
-    diagnostics: { packagePath: discovery.path, venvPath: getCodexLensVenvDir(), installer: 'uv', editable },
-  };
-}
-
-/**
- * Install semantic search dependencies using UV (fast package manager)
- * UV automatically handles ONNX Runtime conflicts
- * @param gpuMode - GPU acceleration mode: 'cpu', 'cuda', or 'directml'
- * @returns Bootstrap result
- */
-async function installSemanticWithUv(gpuMode: GpuMode = 'cpu'): Promise<BootstrapResult> {
-  console.log('[CodexLens] Installing semantic dependencies with UV...');
-
-  // First check if CodexLens is installed
-  const venvStatus = await checkVenvStatus();
-  if (!venvStatus.ready) {
-    return { success: false, error: 'CodexLens not installed. Install CodexLens first.' };
-  }
-
-  // Check Python environment compatibility for DirectML
-  if (gpuMode === 'directml') {
-    const pythonEnv = await checkPythonEnvForDirectML();
-    if (!pythonEnv.compatible) {
-      const errorDetails = pythonEnv.error || 'Unknown compatibility issue';
-      return {
-        success: false,
-        error: `DirectML installation failed: ${errorDetails}\n\nTo fix this:\n1. Uninstall current Python\n2. Install 64-bit Python 3.10, 3.11, or 3.12 from python.org\n3. Delete ~/.codexlens/venv folder\n4. Reinstall CodexLens`,
-      };
-    }
-    console.log(`[CodexLens] Python ${pythonEnv.version} (${pythonEnv.architecture}-bit) - DirectML compatible`);
-  }
-
-  // Create UV manager
-  const uv = createCodexLensUvManager();
-
-  // Find local codex-lens package using unified discovery
-  const discovery = findCodexLensPath();
-
-  // Determine extras based on GPU mode
-  const extras = GPU_MODE_EXTRAS[gpuMode];
-  const modeDescription =
-    gpuMode === 'cuda'
-      ? 'NVIDIA CUDA GPU acceleration'
-      : gpuMode === 'directml'
-        ? 'Windows DirectML GPU acceleration'
-        : 'CPU (ONNX Runtime)';
-
-  console.log(`[CodexLens] Mode: ${modeDescription}`);
-  console.log(`[CodexLens] Extras: ${extras.join(', ')}`);
-
-  // Install with extras - UV handles dependency conflicts automatically
-  if (!discovery.path) {
-    return { success: false, error: formatSearchResults(discovery, 'codex-lens') };
-  }
-
-  const editable = isDevEnvironment() && !discovery.insideNodeModules;
-  console.log(`[CodexLens] Reinstalling from local path with semantic extras (editable: ${editable})...`);
-  const installResult = await uv.installFromProject(discovery.path, extras, editable);
-  if (!installResult.success) {
-    return { success: false, error: `Installation failed: ${installResult.error}` };
-  }
-
-  console.log(`[CodexLens] Semantic dependencies installed successfully (${gpuMode} mode)`);
-  return { success: true, message: `Installed with ${modeDescription}` };
-}
-
-/**
- * Install semantic search dependencies with optional GPU acceleration
- * @param gpuMode - GPU acceleration mode: 'cpu', 'cuda', or 'directml'
- * @returns Bootstrap result
- */
-async function installSemantic(gpuMode: GpuMode = 'cpu'): Promise<BootstrapResult> {
-  // Prefer UV if available
-  if (await isUvAvailable()) {
-    console.log('[CodexLens] Using UV for semantic installation...');
-    return installSemanticWithUv(gpuMode);
-  }
-
-  // Fall back to pip logic...
-  // First ensure CodexLens is installed
-  const venvStatus = await checkVenvStatus();
-  if (!venvStatus.ready) {
-    return { success: false, error: 'CodexLens not installed. Install CodexLens first.' };
-  }
-
-  // Check Python environment compatibility for DirectML
-  if (gpuMode === 'directml') {
-    const pythonEnv = await checkPythonEnvForDirectML();
-    if (!pythonEnv.compatible) {
-      const errorDetails = pythonEnv.error || 'Unknown compatibility issue';
-      return {
-        success: false,
-        error: `DirectML installation failed: ${errorDetails}\n\nTo fix this:\n1. Uninstall current Python\n2. Install 64-bit Python 3.10, 3.11, or 3.12 from python.org\n3. Delete ~/.codexlens/venv folder\n4. Reinstall CodexLens`
-      };
-    }
-    console.log(`[CodexLens] Python ${pythonEnv.version} (${pythonEnv.architecture}-bit) - DirectML compatible`);
-  }
-
-  const pipPath = getCodexLensPip();
-
-  // IMPORTANT: Uninstall all onnxruntime variants first to prevent conflicts
-  // Having multiple onnxruntime packages causes provider detection issues
-  const onnxVariants = ['onnxruntime', 'onnxruntime-gpu', 'onnxruntime-directml'];
-  console.log(`[CodexLens] Cleaning up existing ONNX Runtime packages...`);
-
-  for (const pkg of onnxVariants) {
-    try {
-      execSync(`"${pipPath}" uninstall ${pkg} -y`, { stdio: 'pipe', timeout: EXEC_TIMEOUTS.PACKAGE_INSTALL });
-      console.log(`[CodexLens] Removed ${pkg}`);
-    } catch {
-      // Package not installed, ignore
-    }
-  }
-
-  // Build package list based on GPU mode
-  const packages = ['numpy>=1.24', 'fastembed>=0.5', 'hnswlib>=0.8.0'];
-
-  let modeDescription = 'CPU (ONNX Runtime)';
-  let onnxPackage = 'onnxruntime>=1.18.0'; // Default CPU
-
-  if (gpuMode === 'cuda') {
-    onnxPackage = 'onnxruntime-gpu>=1.18.0';
-    modeDescription = 'NVIDIA CUDA GPU acceleration';
-  } else if (gpuMode === 'directml') {
-    onnxPackage = 'onnxruntime-directml>=1.18.0';
-    modeDescription = 'Windows DirectML GPU acceleration';
-  }
-
-  return new Promise((resolve) => {
-    console.log(`[CodexLens] Installing semantic search dependencies...`);
-    console.log(`[CodexLens] Mode: ${modeDescription}`);
-    console.log(`[CodexLens] ONNX Runtime: ${onnxPackage}`);
-    console.log(`[CodexLens] Packages: ${packages.join(', ')}`);
-
-    // Install ONNX Runtime first with force-reinstall to ensure clean state
-    const installOnnx = spawn(
-      pipPath,
-      ['install', '--force-reinstall', onnxPackage],
-      buildCodexLensSpawnOptions(getCodexLensVenvDir(), 600000, {
-        stdio: ['ignore', 'pipe', 'pipe'],
-      }),
-    );
-
-    let onnxStdout = '';
-    let onnxStderr = '';
-
-    installOnnx.stdout?.on('data', (data) => {
-      onnxStdout += data.toString();
-      const line = data.toString().trim();
-      if (line.includes('Downloading') || line.includes('Installing')) {
-        console.log(`[CodexLens] ${line}`);
-      }
-    });
-
-    installOnnx.stderr?.on('data', (data) => {
-      onnxStderr += data.toString();
-    });
-
-    installOnnx.on('close', (onnxCode) => {
-      if (onnxCode !== 0) {
-        resolve({ success: false, error: `Failed to install ${onnxPackage}: ${onnxStderr || onnxStdout}` });
-        return;
-      }
-
-      console.log(`[CodexLens] ${onnxPackage} installed successfully`);
-
-      // Now install remaining packages
-      const child = spawn(
-        pipPath,
-        ['install', ...packages],
-        buildCodexLensSpawnOptions(getCodexLensVenvDir(), 600000, {
-          stdio: ['ignore', 'pipe', 'pipe'],
-        }),
-      );
-
-      let stdout = '';
-      let stderr = '';
-
-      child.stdout?.on('data', (data) => {
-        stdout += data.toString();
-        const line = data.toString().trim();
-        if (line.includes('Downloading') || line.includes('Installing') || line.includes('Collecting')) {
-          console.log(`[CodexLens] ${line}`);
-        }
-      });
-
-      child.stderr?.on('data', (data) => {
-        stderr += data.toString();
-      });
-
-      child.on('close', (code) => {
-        if (code === 0) {
-          // IMPORTANT: fastembed installs onnxruntime (CPU) as dependency, which conflicts
-          // with onnxruntime-directml/gpu. Reinstall the GPU version to ensure it takes precedence.
-          if (gpuMode !== 'cpu') {
-            try {
-              console.log(`[CodexLens] Reinstalling ${onnxPackage} to ensure GPU provider works...`);
-              execSync(`"${pipPath}" install --force-reinstall ${onnxPackage}`, { stdio: 'pipe', timeout: EXEC_TIMEOUTS.PACKAGE_INSTALL });
-              console.log(`[CodexLens] ${onnxPackage} reinstalled successfully`);
-            } catch (e) {
-              console.warn(`[CodexLens] Warning: Failed to reinstall ${onnxPackage}: ${(e as Error).message}`);
-            }
-          }
-          console.log(`[CodexLens] Semantic dependencies installed successfully (${gpuMode} mode)`);
-          resolve({ success: true, message: `Installed with ${modeDescription}` });
-        } else {
-          resolve({ success: false, error: `Installation failed: ${stderr || stdout}` });
-        }
-      });
-
-      child.on('error', (err) => {
-        resolve({ success: false, error: `Failed to run pip: ${err.message}` });
-      });
-    });
-
-    installOnnx.on('error', (err) => {
-      resolve({ success: false, error: `Failed to install ONNX Runtime: ${err.message}` });
-    });
-  });
-}
-
-/**
- * Check if codexlens-search (v2) bridge CLI is installed and functional.
- * Runs 'codexlens-search status' and checks exit code.
- * @returns true if the v2 bridge CLI is available
- */
-function isCodexLensV2Installed(): boolean {
-  try {
-    const result = spawnSync('codexlens-search', ['status', '--db-path', '.codexlens'], {
-      encoding: 'utf-8',
-      timeout: EXEC_TIMEOUTS.PYTHON_VERSION,
-      stdio: ['pipe', 'pipe', 'pipe'],
-      windowsHide: true,
-    });
-    // Exit code 0 or valid JSON output means it's installed
-    return result.status === 0 || (result.stdout != null && result.stdout.includes('"status"'));
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Bootstrap codexlens-search (v2) package using UV.
- * Installs 'codexlens-search[semantic]' into the shared CodexLens venv.
- * @returns Bootstrap result
- */
-async function bootstrapV2WithUv(): Promise<BootstrapResult> {
-  console.log('[CodexLens] Bootstrapping codexlens-search (v2) with UV...');
-
-  const preFlightError = preFlightCheck();
-  if (preFlightError) {
-    return { success: false, error: `Pre-flight failed: ${preFlightError}` };
-  }
-
-  repairVenvIfCorrupted();
-
-  const uvInstalled = await ensureUvInstalled();
-  if (!uvInstalled) {
-    return { success: false, error: 'Failed to install UV package manager' };
-  }
-
-  const uv = createCodexLensUvManager();
-
-  if (!uv.isVenvValid()) {
-    console.log('[CodexLens] Creating virtual environment with UV for v2...');
-    const createResult = await uv.createVenv();
-    if (!createResult.success) {
-      return { success: false, error: `Failed to create venv: ${createResult.error}` };
-    }
-  }
-
-  // Find local codexlens-search package using unified discovery
-  const { findCodexLensSearchPath } = await import('../utils/package-discovery.js');
-  const discovery = findCodexLensSearchPath();
-
-  const extras = ['semantic'];
-  const editable = isDevEnvironment() && !discovery.insideNodeModules;
-
-  if (!discovery.path) {
-    // Fallback: try installing from PyPI
-    console.log('[CodexLens] Local codexlens-search not found, trying PyPI install...');
-    const pipResult = await uv.install(['codexlens-search[semantic]']);
-    if (!pipResult.success) {
-      return {
-        success: false,
-        error: `Failed to install codexlens-search from PyPI: ${pipResult.error}`,
-        diagnostics: { venvPath: getCodexLensVenvDir(), installer: 'uv' },
-      };
-    }
-  } else {
-    console.log(`[CodexLens] Installing codexlens-search from local path with UV: ${discovery.path} (editable: ${editable})`);
-    const installResult = await uv.installFromProject(discovery.path, extras, editable);
-    if (!installResult.success) {
-      return {
-        success: false,
-        error: `Failed to install codexlens-search: ${installResult.error}`,
-        diagnostics: { packagePath: discovery.path, venvPath: getCodexLensVenvDir(), installer: 'uv', editable },
-      };
-    }
-  }
-
-  clearVenvStatusCache();
-  console.log('[CodexLens] codexlens-search (v2) bootstrap complete');
-  return {
-    success: true,
-    message: 'Installed codexlens-search (v2) with UV',
-    diagnostics: { packagePath: discovery.path ?? undefined, venvPath: getCodexLensVenvDir(), installer: 'uv', editable },
-  };
-}
-
-/**
- * Check if v2 bridge should be used based on CCW_USE_CODEXLENS_V2 env var.
- */
-function useCodexLensV2(): boolean {
-  const flag = process.env.CCW_USE_CODEXLENS_V2;
-  return flag === '1' || flag === 'true';
-}
-
-/**
- * Bootstrap CodexLens venv with required packages
- * @returns Bootstrap result
- */
-async function bootstrapVenv(): Promise<BootstrapResult> {
-  const warnings: string[] = [];
-
-  // If v2 flag is set, also bootstrap codexlens-search alongside v1
-  if (useCodexLensV2() && await isUvAvailable()) {
-    try {
-      const v2Result = await bootstrapV2WithUv();
-      if (v2Result.success) {
-        console.log('[CodexLens] codexlens-search (v2) installed successfully');
-      } else {
-        console.warn(`[CodexLens] codexlens-search (v2) bootstrap failed: ${v2Result.error}`);
-        warnings.push(`v2 bootstrap failed: ${v2Result.error || 'Unknown error'}`);
-      }
-    } catch (v2Err) {
-      const msg = v2Err instanceof Error ? v2Err.message : String(v2Err);
-      console.warn(`[CodexLens] codexlens-search (v2) bootstrap error: ${msg}`);
-      warnings.push(`v2 bootstrap error: ${msg}`);
-    }
-  }
-
-  // Prefer UV if available (faster package resolution and installation)
-  if (await isUvAvailable()) {
-    console.log('[CodexLens] Using UV for bootstrap...');
-    try {
-      const uvResult = await bootstrapWithUv();
-      if (uvResult.success) {
-        return uvResult;
-      }
-
-      console.log('[CodexLens] UV bootstrap failed, falling back to pip:', uvResult.error);
-      warnings.push(`UV bootstrap failed: ${uvResult.error || 'Unknown error'}`);
-    } catch (uvErr) {
-      const message = uvErr instanceof Error ? uvErr.message : String(uvErr);
-      console.log('[CodexLens] UV bootstrap error, falling back to pip:', message);
-      warnings.push(`UV bootstrap error: ${message}`);
-    }
-  }
-
-  // Pre-flight: verify Python is available and compatible
-  const preFlightError = preFlightCheck();
-  if (preFlightError) {
-    return {
-      success: false,
-      error: `Pre-flight failed: ${preFlightError}`,
-      warnings: warnings.length > 0 ? warnings : undefined,
-    };
-  }
-
-  // Auto-repair corrupted venv before proceeding
-  repairVenvIfCorrupted();
-
-  // Fall back to pip logic...
-  // Ensure data directory exists
-  const dataDir = getCodexLensDataDir();
-  const venvDir = getCodexLensVenvDir();
-  if (!existsSync(dataDir)) {
-    mkdirSync(dataDir, { recursive: true });
-  }
-
-  // Create venv if not exists
-    if (!existsSync(venvDir)) {
-      try {
-        console.log('[CodexLens] Creating virtual environment...');
-        const pythonCmd = getSystemPythonCommand();
-        const createResult = spawnSync(
-          pythonCmd.command,
-          [...pythonCmd.args, '-m', 'venv', venvDir],
-          buildCodexLensSpawnSyncOptions({
-            timeout: EXEC_TIMEOUTS.PROCESS_SPAWN,
-          }),
-        );
-        if (createResult.error) {
-          throw createResult.error;
-        }
-        if (createResult.status !== 0) {
-          throw new Error(`venv creation exited with code ${String(createResult.status)}`);
-        }
-      } catch (err) {
-        return {
-          success: false,
-          error: `Failed to create venv: ${(err as Error).message}`,
-          warnings: warnings.length > 0 ? warnings : undefined,
-        };
-      }
-    }
-
-    // Install codex-lens
-    try {
-      console.log('[CodexLens] Installing codex-lens package...');
-      const pipPath = getCodexLensPip();
-
-      // UV-created venvs may not ship with pip.exe. Ensure pip exists before using pip fallback.
-      if (!existsSync(pipPath)) {
-        const venvPython = getCodexLensPython();
-        console.warn(`[CodexLens] pip not found at: ${pipPath}. Attempting to bootstrap pip with ensurepip...`);
-        try {
-          const ensurePipResult = spawnSync(
-            venvPython,
-            ['-m', 'ensurepip', '--upgrade'],
-            buildCodexLensSpawnSyncOptions({
-              timeout: EXEC_TIMEOUTS.PACKAGE_INSTALL,
-            }),
-          );
-          if (ensurePipResult.error) {
-            throw ensurePipResult.error;
-          }
-          if (ensurePipResult.status !== 0) {
-            throw new Error(`ensurepip exited with code ${String(ensurePipResult.status)}`);
-          }
-        } catch (err) {
-          console.warn(`[CodexLens] ensurepip failed: ${(err as Error).message}`);
-        }
-      }
-
-      // If pip is still missing, recreate the venv using system Python (guarantees pip).
-      if (!existsSync(pipPath)) {
-        console.warn('[CodexLens] pip still missing after ensurepip; recreating venv with system Python...');
-        try {
-          rmSync(venvDir, { recursive: true, force: true });
-          const pythonCmd = getSystemPythonCommand();
-          const recreateResult = spawnSync(
-            pythonCmd.command,
-            [...pythonCmd.args, '-m', 'venv', venvDir],
-            buildCodexLensSpawnSyncOptions({
-              timeout: EXEC_TIMEOUTS.PROCESS_SPAWN,
-            }),
-          );
-          if (recreateResult.error) {
-            throw recreateResult.error;
-          }
-          if (recreateResult.status !== 0) {
-            throw new Error(`venv recreation exited with code ${String(recreateResult.status)}`);
-          }
-        } catch (err) {
-          return {
-            success: false,
-            error: `Failed to recreate venv for pip fallback: ${(err as Error).message}`,
-            warnings: warnings.length > 0 ? warnings : undefined,
-          };
-        }
-
-        if (!existsSync(pipPath)) {
-          return {
-            success: false,
-            error: `pip not found at ${pipPath} after venv recreation. Ensure your Python installation includes ensurepip/pip.`,
-            warnings: warnings.length > 0 ? warnings : undefined,
-          };
-        }
-      }
-
-    // Try local path using unified discovery
-    const discovery = findCodexLensPath();
-
-    if (!discovery.path) {
-      throw new Error(formatSearchResults(discovery, 'codex-lens'));
-    }
-
-    const editable = isDevEnvironment() && !discovery.insideNodeModules;
-    const pipArgs = editable ? ['install', '-e', discovery.path] : ['install', discovery.path];
-    console.log(`[CodexLens] Installing from local path: ${discovery.path} (editable: ${editable})`);
-    const installResult = spawnSync(
-      pipPath,
-      pipArgs,
-      buildCodexLensSpawnSyncOptions({
-        timeout: EXEC_TIMEOUTS.PACKAGE_INSTALL,
-      }),
-    );
-    if (installResult.error) {
-      throw installResult.error;
-    }
-    if (installResult.status !== 0) {
-      throw new Error(`pip install exited with code ${String(installResult.status)}`);
-    }
-
-    // Clear cache after successful installation
-    clearVenvStatusCache();
-    clearSemanticStatusCache();
-    return { success: true, warnings: warnings.length > 0 ? warnings : undefined };
-  } catch (err) {
-    return {
-      success: false,
-      error: `Failed to install codex-lens: ${(err as Error).message}`,
-      warnings: warnings.length > 0 ? warnings : undefined,
-    };
-  }
-}
-
-/**
- * Ensure CodexLens is ready to use
- * @returns Ready status
- */
 async function ensureReady(): Promise<ReadyStatus> {
-  // Use cached result if already checked
-  if (bootstrapChecked && bootstrapReady) {
-    return { ready: true, installed: true };
-  }
-
-  // Check current status
-  const status = await checkVenvStatus();
-  if (status.ready) {
-    bootstrapChecked = true;
-    bootstrapReady = true;
-    return { ready: true, installed: true, version: status.version };
-  }
-
-  // Attempt bootstrap
-  const bootstrap = await bootstrapVenv();
-  if (!bootstrap.success) {
-    return { ready: false, installed: false, error: bootstrap.error };
-  }
-
-  // Verify after bootstrap
-  const recheck = await checkVenvStatus();
-  bootstrapChecked = true;
-  bootstrapReady = recheck.ready;
-
-  return { ...recheck, installed: recheck.ready };
+  return { ready: false, installed: false, error: V1_REMOVED };
 }
 
-/**
- * Parse progress info from CodexLens output
- * @param line - Output line to parse
- * @returns Progress info or null
- */
-function parseProgressLine(line: string): ProgressInfo | null {
-  // Parse file processing progress: "Processing file X/Y: path"
-  const fileMatch = line.match(/Processing file (\d+)\/(\d+):\s*(.+)/i);
-  if (fileMatch) {
-    const current = parseInt(fileMatch[1], 10);
-    const total = parseInt(fileMatch[2], 10);
-    return {
-      stage: 'indexing',
-      message: `Processing ${fileMatch[3]}`,
-      percent: Math.round((current / total) * 80) + 10, // 10-90%
-      filesProcessed: current,
-      totalFiles: total,
-    };
-  }
-
-  // Parse stage messages
-  if (line.includes('Discovering files')) {
-    return { stage: 'discover', message: 'Discovering files...', percent: 5 };
-  }
-  if (line.includes('Building index')) {
-    return { stage: 'build', message: 'Building index...', percent: 10 };
-  }
-  if (line.includes('Extracting symbols')) {
-    return { stage: 'symbols', message: 'Extracting symbols...', percent: 50 };
-  }
-  if (line.includes('Generating embeddings') || line.includes('Creating embeddings')) {
-    return { stage: 'embeddings', message: 'Generating embeddings...', percent: 70 };
-  }
-  // Note: "Finalizing index" and "Building ANN" are handled separately below
-  // Only match generic "Complete" here (not "Finalizing" which has specific handlers)
-
-  // Parse indexed count: "Indexed X files" - FTS complete, but embeddings may follow
-  const indexedMatch = line.match(/Indexed (\d+) files/i);
-  if (indexedMatch) {
-    return {
-      stage: 'fts_complete',  // Not 'complete' - embeddings generation may still be pending
-      message: `Indexed ${indexedMatch[1]} files, generating embeddings...`,
-      percent: 60,  // FTS done, embeddings starting
-      filesProcessed: parseInt(indexedMatch[1], 10),
-    };
-  }
-
-  // Parse embedding batch progress: "Batch X: N files, M chunks"
-  const batchMatch = line.match(/Batch (\d+):\s*(\d+) files,\s*(\d+) chunks/i);
-  if (batchMatch) {
-    return {
-      stage: 'embeddings',
-      message: `Embedding batch ${batchMatch[1]}: ${batchMatch[3]} chunks`,
-      percent: 70,  // Stay at 70% during embedding batches
-    };
-  }
-
-  // Parse embedding progress with file count
-  const embedProgressMatch = line.match(/Processing (\d+) files/i);
-  if (embedProgressMatch && line.toLowerCase().includes('embed')) {
-    return {
-      stage: 'embeddings',
-      message: `Processing ${embedProgressMatch[1]} files for embeddings`,
-      percent: 75,
-    };
-  }
-
-  // Parse finalizing ANN index
-  if (line.includes('Finalizing index') || line.includes('Building ANN')) {
-    return { stage: 'finalizing', message: 'Finalizing vector index...', percent: 90 };
-  }
-
-  // Parse embeddings complete message
-  const embedCompleteMatch = line.match(/Embeddings complete:\s*(\d+)\s*chunks/i);
-  if (embedCompleteMatch) {
-    return {
-      stage: 'embeddings_complete',
-      message: `Embeddings complete: ${embedCompleteMatch[1]} chunks`,
-      percent: 95,
-    };
-  }
-
-  // Parse generic completion (but not "Embeddings complete" which is handled above)
-  if (line.includes('Complete') && !line.toLowerCase().includes('embeddings complete')) {
-    return { stage: 'complete', message: 'Complete', percent: 98 };
-  }
-
-  return null;
+async function executeCodexLens(_args: string[], _options: ExecuteOptions = {}): Promise<ExecuteResult> {
+  return { success: false, error: V1_REMOVED };
 }
 
-function shouldRetryWithoutEnrich(args: string[], error?: string): boolean {
-  return args.includes('--enrich') && Boolean(error && /No such option:\s+--enrich/i.test(error));
+async function checkVenvStatus(_force?: boolean): Promise<ReadyStatus> {
+  return { ready: false, installed: false, error: V1_REMOVED };
 }
 
-function shouldRetryWithoutLanguageFilters(args: string[], error?: string): boolean {
-  return args.includes('--language') && Boolean(error && /Got unexpected extra arguments?\b/i.test(error));
+async function bootstrapVenv(): Promise<BootstrapResult> {
+  return { success: false, error: V1_REMOVED };
 }
 
-function shouldRetryWithLegacySearchArgs(args: string[], error?: string): boolean {
-  return args[0] === 'search'
-    && (args.includes('--limit') || args.includes('--mode') || args.includes('--offset'))
-    && Boolean(error && /Got unexpected extra arguments?\b/i.test(error));
+async function checkSemanticStatus(_force?: boolean): Promise<SemanticStatus> {
+  return { available: false, error: V1_REMOVED };
 }
 
-function stripFlag(args: string[], flag: string): string[] {
-  return args.filter((arg) => arg !== flag);
+async function ensureLiteLLMEmbedderReady(): Promise<BootstrapResult> {
+  return { success: false, error: V1_REMOVED };
 }
 
-function stripOptionWithValues(args: string[], option: string): string[] {
-  const nextArgs: string[] = [];
-  for (let index = 0; index < args.length; index += 1) {
-    if (args[index] === option) {
-      index += 1;
-      continue;
-    }
-    nextArgs.push(args[index]);
-  }
-  return nextArgs;
+async function installSemantic(_gpuMode: GpuMode = 'cpu'): Promise<BootstrapResult> {
+  return { success: false, error: V1_REMOVED };
 }
 
-function stripSearchCompatibilityOptions(args: string[]): string[] {
-  return stripOptionWithValues(
-    stripOptionWithValues(
-      stripOptionWithValues(args, '--offset'),
-      '--mode',
-    ),
-    '--limit',
-  );
+async function detectGpuSupport(): Promise<{ mode: GpuMode; available: GpuMode[]; info: string; pythonEnv?: PythonEnvInfo }> {
+  return { mode: 'cpu', available: ['cpu'], info: V1_REMOVED };
 }
 
-function appendWarning(existing: string | undefined, next: string | undefined): string | undefined {
-  if (!next) {
-    return existing;
-  }
-  if (!existing) {
-    return next;
-  }
-  if (existing.includes(next)) {
-    return existing;
-  }
-  return `${existing} ${next}`;
+async function uninstallCodexLens(): Promise<BootstrapResult> {
+  return { success: false, error: V1_REMOVED };
 }
 
-function shouldRetryWithAstGrepPreference(args: string[], error?: string): boolean {
-  return !args.includes('--use-astgrep')
-    && !args.includes('--no-use-astgrep')
-    && Boolean(error && /Options --use-astgrep and --no-use-astgrep are mutually exclusive/i.test(error));
+function cancelIndexing(): { success: boolean; message?: string; error?: string } {
+  return { success: false, error: V1_REMOVED };
 }
 
-function shouldRetryWithStaticGraphPreference(args: string[], error?: string): boolean {
-  return !args.includes('--static-graph')
-    && !args.includes('--no-static-graph')
-    && Boolean(error && /Options --static-graph and --no-static-graph are mutually exclusive/i.test(error));
+function isIndexingInProgress(): boolean {
+  return false;
 }
 
-function shouldRetryWithCentralizedPreference(args: string[], error?: string): boolean {
-  return !args.includes('--centralized')
-    && !args.includes('--distributed')
-    && Boolean(error && /Options --centralized and --distributed are mutually exclusive/i.test(error));
+async function bootstrapWithUv(_gpuMode: GpuMode = 'cpu'): Promise<BootstrapResult> {
+  return { success: false, error: V1_REMOVED };
 }
 
-function stripAnsiCodes(value: string): string {
-  return value
-    .replace(/\x1b\[[0-9;]*m/g, '')
-    .replace(/\x1b\][0-9;]*\x07/g, '')
-    .replace(/\x1b\][^\x07]*\x07/g, '');
+async function installSemanticWithUv(_gpuMode: GpuMode = 'cpu'): Promise<BootstrapResult> {
+  return { success: false, error: V1_REMOVED };
 }
 
-function tryExtractJsonPayload(raw: string): unknown | null {
-  const cleanOutput = stripAnsiCodes(raw).trim();
-  const jsonStart = cleanOutput.search(/[\[{]/);
-  if (jsonStart === -1) {
-    return null;
-  }
-
-  const startChar = cleanOutput[jsonStart];
-  const endChar = startChar === '{' ? '}' : ']';
-  let depth = 0;
-  let inString = false;
-  let escapeNext = false;
-  let jsonEnd = -1;
-
-  for (let index = jsonStart; index < cleanOutput.length; index += 1) {
-    const char = cleanOutput[index];
-
-    if (escapeNext) {
-      escapeNext = false;
-      continue;
-    }
-
-    if (char === '\\' && inString) {
-      escapeNext = true;
-      continue;
-    }
-
-    if (char === '"') {
-      inString = !inString;
-      continue;
-    }
-
-    if (!inString) {
-      if (char === startChar) {
-        depth += 1;
-      } else if (char === endChar) {
-        depth -= 1;
-        if (depth === 0) {
-          jsonEnd = index + 1;
-          break;
-        }
-      }
-    }
-  }
-
-  if (jsonEnd === -1) {
-    return null;
-  }
-
-  try {
-    return JSON.parse(cleanOutput.slice(jsonStart, jsonEnd));
-  } catch {
-    return null;
-  }
+function useCodexLensV2(): boolean {
+  return true; // v2 is now the only option
 }
 
-function parseLegacySearchPaths(output: string | undefined, cwd: string): string[] {
-  const lines = stripAnsiCodes(output || '')
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter(Boolean);
-
-  const filePaths: string[] = [];
-  for (const line of lines) {
-    if (line.includes('RuntimeWarning:') || line.startsWith('warn(') || line.startsWith('Warning:')) {
-      continue;
-    }
-
-    const candidate = /^[a-zA-Z]:[\\/]|^\//.test(line)
-      ? line
-      : resolve(cwd, line);
-
-    try {
-      if (statSync(candidate).isFile()) {
-        filePaths.push(candidate);
-      }
-    } catch {
-      continue;
-    }
-  }
-
-  return [...new Set(filePaths)];
+function isCodexLensV2Installed(): boolean {
+  return false;
 }
 
-function buildLegacySearchPayload(query: string, filePaths: string[], limit: number): Record<string, unknown> {
-  const results = filePaths.slice(0, limit).map((path, index) => ({
-    path,
-    score: Math.max(0.1, 1 - index * 0.05),
-    excerpt: '',
-    content: '',
-    source: 'legacy_text_output',
-    symbol: null,
-  }));
-
-  return {
-    success: true,
-    result: {
-      query,
-      count: filePaths.length,
-      results,
-    },
-  };
+async function bootstrapV2WithUv(): Promise<BootstrapResult> {
+  return { success: false, error: V1_REMOVED };
 }
 
-function buildLegacySearchFilesPayload(query: string, filePaths: string[], limit: number): Record<string, unknown> {
-  return {
-    success: true,
-    result: {
-      query,
-      count: filePaths.length,
-      files: filePaths.slice(0, limit),
-    },
-  };
+function getVenvPythonPath(): string {
+  return 'python';
 }
 
-function buildEmptySearchPayload(query: string, filesOnly: boolean): Record<string, unknown> {
-  return filesOnly
-    ? {
-        success: true,
-        result: {
-          query,
-          count: 0,
-          files: [],
-        },
-      }
-    : {
-        success: true,
-        result: {
-          query,
-          count: 0,
-          results: [],
-        },
-      };
-}
+// ---------------------------------------------------------------------------
+// Tool schema / handler (no-op)
+// ---------------------------------------------------------------------------
 
-function normalizeSearchCommandResult(
-  result: ExecuteResult,
-  options: { query: string; cwd: string; limit: number; filesOnly: boolean },
-): ExecuteResult {
-  if (!result.success) {
-    return result;
-  }
-
-  const { query, cwd, limit, filesOnly } = options;
-  const rawOutput = typeof result.output === 'string' ? result.output : '';
-  const parsedPayload = rawOutput ? tryExtractJsonPayload(rawOutput) : null;
-  if (parsedPayload !== null) {
-    if (filesOnly) {
-      result.files = parsedPayload;
-    } else {
-      result.results = parsedPayload;
-    }
-    delete result.output;
-    return result;
-  }
-
-  const legacyPaths = parseLegacySearchPaths(rawOutput, cwd);
-  if (legacyPaths.length > 0) {
-    const warning = filesOnly
-      ? 'CodexLens CLI returned legacy plain-text file output; synthesized JSON-compatible search_files results.'
-      : 'CodexLens CLI returned legacy plain-text search output; synthesized JSON-compatible search results.';
-
-    if (filesOnly) {
-      result.files = buildLegacySearchFilesPayload(query, legacyPaths, limit);
-    } else {
-      result.results = buildLegacySearchPayload(query, legacyPaths, limit);
-    }
-    delete result.output;
-    result.warning = appendWarning(result.warning, warning);
-    result.message = appendWarning(result.message, warning);
-    return result;
-  }
-
-  const warning = rawOutput.trim()
-    ? (filesOnly
-        ? 'CodexLens CLI returned non-JSON search_files output; synthesized an empty JSON-compatible fallback payload.'
-        : 'CodexLens CLI returned non-JSON search output; synthesized an empty JSON-compatible fallback payload.')
-    : (filesOnly
-        ? 'CodexLens CLI returned empty stdout in JSON mode for search_files; synthesized an empty JSON-compatible fallback payload.'
-        : 'CodexLens CLI returned empty stdout in JSON mode for search; synthesized an empty JSON-compatible fallback payload.');
-
-  if (filesOnly) {
-    result.files = buildEmptySearchPayload(query, true);
-  } else {
-    result.results = buildEmptySearchPayload(query, false);
-  }
-  delete result.output;
-  result.warning = appendWarning(result.warning, warning);
-  result.message = appendWarning(result.message, warning);
-  return result;
-}
-
-function extractStructuredError(payload: unknown): string | null {
-  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
-    return null;
-  }
-
-  const record = payload as Record<string, unknown>;
-  if (typeof record.error === 'string' && record.error.trim()) {
-    return record.error.trim();
-  }
-  if (typeof record.message === 'string' && record.message.trim()) {
-    return record.message.trim();
-  }
-
-  return null;
-}
-
-function extractCodexLensFailure(stdout: string, stderr: string, code: number | null): string {
-  const structuredStdout = extractStructuredError(tryExtractJsonPayload(stdout));
-  if (structuredStdout) {
-    return structuredStdout;
-  }
-
-  const structuredStderr = extractStructuredError(tryExtractJsonPayload(stderr));
-  if (structuredStderr) {
-    return structuredStderr;
-  }
-
-  const cleanStdout = stripAnsiCodes(stdout).trim();
-  const cleanStderr = stripAnsiCodes(stderr)
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter((line) => line && !/^DEBUG\b/i.test(line))
-    .join('\n')
-    .trim();
-
-  return cleanStderr || cleanStdout || stripAnsiCodes(stderr).trim() || `Process exited with code ${code ?? 'unknown'}`;
-}
-
-/**
- * Execute CodexLens CLI command with real-time progress updates
- * @param args - CLI arguments
- * @param options - Execution options
- * @returns Execution result
- */
-async function executeCodexLens(args: string[], options: ExecuteOptions = {}): Promise<ExecuteResult> {
-  let attemptArgs = [...args];
-  let result = await executeCodexLensOnce(attemptArgs, options);
-  const compatibilityWarnings: string[] = [];
-
-  const compatibilityRetries = [
-    {
-      shouldRetry: shouldRetryWithoutEnrich,
-      transform: (currentArgs: string[]) => stripFlag(currentArgs, '--enrich'),
-      warning: 'CodexLens CLI does not support --enrich; retried without it.',
-    },
-    {
-      shouldRetry: shouldRetryWithoutLanguageFilters,
-      transform: (currentArgs: string[]) => stripOptionWithValues(currentArgs, '--language'),
-      warning: 'CodexLens CLI rejected --language filters; retried without language scoping.',
-    },
-    {
-      shouldRetry: shouldRetryWithLegacySearchArgs,
-      transform: stripSearchCompatibilityOptions,
-      warning: 'CodexLens CLI rejected search --limit/--mode compatibility flags; retried with minimal legacy search args.',
-    },
-    {
-      shouldRetry: shouldRetryWithAstGrepPreference,
-      transform: (currentArgs: string[]) => [...currentArgs, '--use-astgrep'],
-      warning: 'CodexLens CLI hit a Typer ast-grep option conflict; retried with explicit --use-astgrep.',
-    },
-    {
-      shouldRetry: shouldRetryWithStaticGraphPreference,
-      transform: (currentArgs: string[]) => [...currentArgs, '--static-graph'],
-      warning: 'CodexLens CLI hit a Typer static-graph option conflict; retried with explicit --static-graph.',
-    },
-    {
-      shouldRetry: shouldRetryWithCentralizedPreference,
-      transform: (currentArgs: string[]) => [...currentArgs, '--centralized'],
-      warning: 'CodexLens CLI hit a Typer centralized/distributed option conflict; retried with explicit --centralized.',
-    },
-  ];
-
-  for (const retry of compatibilityRetries) {
-    if (result.success || !retry.shouldRetry(attemptArgs, result.error)) {
-      continue;
-    }
-
-    compatibilityWarnings.push(retry.warning);
-    attemptArgs = retry.transform(attemptArgs);
-    const retryResult = await executeCodexLensOnce(attemptArgs, options);
-    result = retryResult.success
-      ? retryResult
-      : {
-          ...retryResult,
-          error: retryResult.error
-            ? `${retryResult.error} (after compatibility retry; initial error: ${result.error})`
-            : result.error,
-        };
-  }
-
-  if (compatibilityWarnings.length === 0) {
-    return result;
-  }
-
-  const warning = compatibilityWarnings.join(' ');
-  return {
-    ...result,
-    warning,
-    message: result.message ? `${result.message} ${warning}` : warning,
-  };
-}
-
-function buildCodexLensSpawnOptions(cwd: string, timeout: number, overrides: SpawnOptions = {}): SpawnOptions {
-  const { env, ...rest } = overrides;
-  return {
-    cwd,
-    shell: false,
-    timeout,
-    windowsHide: true,
-    env: { ...process.env, PYTHONIOENCODING: 'utf-8', ...env },
-    ...rest,
-  };
-}
-
-function buildCodexLensSpawnSyncOptions(
-  overrides: HiddenCodexLensSpawnSyncOptions = {},
-): SpawnSyncOptionsWithStringEncoding {
-  const { env, encoding, ...rest } = overrides;
-  return {
-    shell: false,
-    windowsHide: true,
-    stdio: ['ignore', 'pipe', 'pipe'],
-    env: { ...process.env, PYTHONIOENCODING: 'utf-8', ...env },
-    ...rest,
-    encoding: encoding ?? 'utf8',
-  };
-}
-
-async function executeCodexLensOnce(args: string[], options: ExecuteOptions = {}): Promise<ExecuteResult> {
-  const { timeout = 300000, cwd = process.cwd(), onProgress } = options; // Default 5 min
-
-  // Ensure ready
-  const readyStatus = await ensureReady();
-  if (!readyStatus.ready) {
-    return { success: false, error: readyStatus.error };
-  }
-
-  return new Promise((resolve) => {
-    // SECURITY: Use spawn without shell to prevent command injection
-    // Pass arguments directly - no manual quoting needed
-    // spawn's cwd option handles drive changes correctly on Windows
-    const spawnArgs = ['-m', 'codexlens', ...args];
-
-    const child = spawn(getCodexLensHiddenPython(), spawnArgs, buildCodexLensSpawnOptions(cwd, timeout));
-
-    // Track indexing process for cancellation (only for init commands)
-    const isIndexingCommand = args.includes('init');
-    if (isIndexingCommand) {
-      currentIndexingProcess = child;
-      currentIndexingAborted = false;
-    }
-
-    let stdout = '';
-    let stderr = '';
-    let stdoutLineBuffer = '';
-    let stderrLineBuffer = '';
-    let timeoutHandle: NodeJS.Timeout | null = null;
-    let resolved = false;
-
-    // Helper to safely resolve only once
-    const safeResolve = (result: ExecuteResult) => {
-      if (resolved) return;
-      resolved = true;
-      if (timeoutHandle) {
-        clearTimeout(timeoutHandle);
-        timeoutHandle = null;
-      }
-      // Clear indexing process tracking
-      if (isIndexingCommand) {
-        currentIndexingProcess = null;
-      }
-      resolve(result);
-    };
-
-    // Set up timeout handler
-    if (timeout > 0) {
-      timeoutHandle = setTimeout(() => {
-        if (!resolved) {
-          child.kill('SIGTERM');
-          // Give it a moment to die gracefully, then force kill
-          setTimeout(() => {
-            if (!resolved) {
-              child.kill('SIGKILL');
-            }
-          }, 5000);
-          safeResolve({ success: false, error: 'Command timed out' });
-        }
-      }, timeout);
-    }
-
-    // Process stdout line by line for real-time progress
-    child.stdout?.on('data', (data: Buffer) => {
-      const chunk = data.toString();
-      stdoutLineBuffer += chunk;
-      stdout += chunk;
-
-      // Process complete lines
-      const lines = stdoutLineBuffer.split('\n');
-      stdoutLineBuffer = lines.pop() || ''; // Keep incomplete line in buffer
-
-      for (const line of lines) {
-        const trimmedLine = line.trim();
-        if (trimmedLine && onProgress) {
-          const progress = parseProgressLine(trimmedLine);
-          if (progress) {
-            onProgress(progress);
-          }
-        }
-      }
-    });
-
-    // Collect stderr
-    child.stderr?.on('data', (data: Buffer) => {
-      const chunk = data.toString();
-      stderrLineBuffer += chunk;
-      stderr += chunk;
-
-      // Also check stderr for progress (some tools output progress to stderr)
-      const lines = stderrLineBuffer.split('\n');
-      stderrLineBuffer = lines.pop() || '';
-
-      for (const line of lines) {
-        const trimmedLine = line.trim();
-        if (trimmedLine && onProgress) {
-          const progress = parseProgressLine(trimmedLine);
-          if (progress) {
-            onProgress(progress);
-          }
-        }
-      }
-    });
-
-    // Handle process errors (spawn failure)
-    child.on('error', (err) => {
-      safeResolve({ success: false, error: `Failed to start process: ${err.message}` });
-    });
-
-    // Handle process completion
-    child.on('close', (code) => {
-      // Process any remaining buffered content
-      if (stdoutLineBuffer.trim() && onProgress) {
-        const progress = parseProgressLine(stdoutLineBuffer.trim());
-        if (progress) {
-          onProgress(progress);
-        }
-      }
-
-      const trimmedStdout = stdout.trim();
-      if (code === 0) {
-        const warning = args.includes('--json') && trimmedStdout.length === 0
-          ? `CodexLens CLI exited successfully but produced empty stdout in JSON mode for ${args[0] ?? 'command'}.`
-          : undefined;
-        safeResolve({
-          success: true,
-          output: trimmedStdout || undefined,
-          warning,
-          message: warning,
-        });
-      } else {
-        safeResolve({
-          success: false,
-          error: extractCodexLensFailure(stdout, stderr, code),
-          output: trimmedStdout || undefined,
-        });
-      }
-    });
-  });
-}
-
-/**
- * Initialize CodexLens index for a directory
- * @param params - Parameters
- * @returns Execution result
- */
-async function initIndex(params: Params): Promise<ExecuteResult> {
-  const { path = '.', languages } = params;
-
-  // Use 'index init' subcommand (new CLI structure)
-  const args = ['index', 'init', path];
-  if (languages && languages.length > 0) {
-    args.push(...languages.flatMap((language) => ['--language', language]));
-  }
-
-  return executeCodexLens(args, { cwd: path });
-}
-
-/**
- * Search code using CodexLens
- * @param params - Search parameters
- * @returns Execution result
- */
-async function searchCode(params: Params): Promise<ExecuteResult> {
-  const { query, path = '.', limit = 20, mode = 'auto', enrich = false } = params;
-
-  if (!query) {
-    return { success: false, error: 'Query is required for search action' };
-  }
-
-  // Map MCP mode names to CLI mode names
-  const modeMap: Record<string, string> = {
-    'text': 'exact',
-    'semantic': 'pure-vector',
-    'auto': 'auto',
-    'exact': 'exact',
-    'fuzzy': 'fuzzy',
-    'hybrid': 'hybrid',
-    'vector': 'vector',
-    'pure-vector': 'pure-vector',
-  };
-
-  const cliMode = modeMap[mode] || 'auto';
-  const args = ['search', query, '--limit', limit.toString(), '--mode', cliMode, '--json'];
-
-  if (enrich) {
-    args.push('--enrich');
-  }
-
-  return normalizeSearchCommandResult(await executeCodexLens(args, { cwd: path }), {
-    query,
-    cwd: path,
-    limit,
-    filesOnly: false,
-  });
-}
-
-/**
- * Search code and return only file paths
- * @param params - Search parameters
- * @returns Execution result
- */
-async function searchFiles(params: Params): Promise<ExecuteResult> {
-  const { query, path = '.', limit = 20, mode = 'auto', enrich = false } = params;
-
-  if (!query) {
-    return { success: false, error: 'Query is required for search_files action' };
-  }
-
-  // Map MCP mode names to CLI mode names
-  const modeMap: Record<string, string> = {
-    'text': 'exact',
-    'semantic': 'pure-vector',
-    'auto': 'auto',
-    'exact': 'exact',
-    'fuzzy': 'fuzzy',
-    'hybrid': 'hybrid',
-    'vector': 'vector',
-    'pure-vector': 'pure-vector',
-  };
-
-  const cliMode = modeMap[mode] || 'auto';
-  const args = ['search', query, '--files-only', '--limit', limit.toString(), '--mode', cliMode, '--json'];
-
-  if (enrich) {
-    args.push('--enrich');
-  }
-
-  return normalizeSearchCommandResult(await executeCodexLens(args, { cwd: path }), {
-    query,
-    cwd: path,
-    limit,
-    filesOnly: true,
-  });
-}
-
-/**
- * Extract symbols from a file
- * @param params - Parameters
- * @returns Execution result
- */
-async function extractSymbols(params: Params): Promise<ExecuteResult> {
-  const { file } = params;
-
-  if (!file) {
-    return { success: false, error: 'File is required for symbol action' };
-  }
-
-  const args = ['symbol', file, '--json'];
-
-  const result = await executeCodexLens(args);
-
-  if (result.success && result.output) {
-    try {
-      result.symbols = JSON.parse(result.output);
-      delete result.output;
-    } catch {
-      // Keep raw output if JSON parse fails
-    }
-  }
-
-  return result;
-}
-
-/**
- * Get index status
- * @param params - Parameters
- * @returns Execution result
- */
-async function getStatus(params: Params): Promise<ExecuteResult> {
-  const { path = '.' } = params;
-
-  const args = ['status', '--json'];
-
-  const result = await executeCodexLens(args, { cwd: path });
-
-  if (result.success && result.output) {
-    try {
-      result.status = JSON.parse(result.output);
-      delete result.output;
-    } catch {
-      // Keep raw output if JSON parse fails
-    }
-  }
-
-  return result;
-}
-
-/**
- * Show configuration
- * @param params - Parameters
- * @returns Execution result
- */
-async function configShow(): Promise<ExecuteResult> {
-  const args = ['config', 'show', '--json'];
-  const result = await executeCodexLens(args);
-
-  if (result.success && result.output) {
-    try {
-      result.config = JSON.parse(result.output);
-      delete result.output;
-    } catch {
-      // Keep raw output if JSON parse fails
-    }
-  }
-
-  return result;
-}
-
-/**
- * Set configuration value
- * @param params - Parameters
- * @returns Execution result
- */
-async function configSet(params: Params): Promise<ExecuteResult> {
-  const { key, value } = params;
-
-  if (!key) {
-    return { success: false, error: 'key is required for config_set action' };
-  }
-  if (!value) {
-    return { success: false, error: 'value is required for config_set action' };
-  }
-
-  const args = ['config', 'set', key, value, '--json'];
-  const result = await executeCodexLens(args);
-
-  if (result.success && result.output) {
-    try {
-      result.config = JSON.parse(result.output);
-      delete result.output;
-    } catch {
-      // Keep raw output if JSON parse fails
-    }
-  }
-
-  return result;
-}
-
-/**
- * Migrate indexes to new location
- * @param params - Parameters
- * @returns Execution result
- */
-async function configMigrate(params: Params): Promise<ExecuteResult> {
-  const { newPath } = params;
-
-  if (!newPath) {
-    return { success: false, error: 'newPath is required for config_migrate action' };
-  }
-
-  const args = ['config', 'migrate', newPath, '--json'];
-  const result = await executeCodexLens(args, { timeout: 300000 }); // 5 min for migration
-
-  if (result.success && result.output) {
-    try {
-      result.config = JSON.parse(result.output);
-      delete result.output;
-    } catch {
-      // Keep raw output if JSON parse fails
-    }
-  }
-
-  return result;
-}
-
-/**
- * Clean indexes
- * @param params - Parameters
- * @returns Execution result
- */
-async function cleanIndexes(params: Params): Promise<ExecuteResult> {
-  const { path, all } = params;
-
-  const args = ['clean'];
-
-  if (all) {
-    args.push('--all');
-  } else if (path) {
-    args.push(path);
-  }
-
-  args.push('--json');
-  const result = await executeCodexLens(args);
-
-  if (result.success && result.output) {
-    try {
-      result.cleanResult = JSON.parse(result.output);
-      delete result.output;
-    } catch {
-      // Keep raw output if JSON parse fails
-    }
-  }
-
-  return result;
-}
-
-// Tool schema for MCP
 export const schema: ToolSchema = {
   name: 'codex_lens',
-  description: `CodexLens - Code indexing and semantic search. Choose an action and provide its required parameters.
-
-**Actions & Required Parameters:**
-
-*   **init**: Index directory (auto-generates embeddings if available).
-    *   *path* (string): Directory to index (default: current).
-    *   *languages* (array): Languages to index (e.g., ["javascript", "typescript", "python"]).
-
-*   **search**: Search code content.
-    *   **query** (string, **REQUIRED**): Search query text.
-    *   *path* (string): Directory to search (default: current).
-    *   *mode* (string): Search mode (default: "auto").
-        - "auto": Auto-detect (hybrid if embeddings exist, exact otherwise).
-        - "exact"/"text": Exact FTS for code identifiers.
-        - "hybrid": Exact + Fuzzy + Vector fusion (best results, requires embeddings).
-        - "fuzzy": Typo-tolerant search.
-        - "vector": Semantic + keyword.
-        - "semantic"/"pure-vector": Pure semantic search.
-    *   *limit* (number): Max results (default: 20).
-    *   *enrich* (boolean): Enrich with code relationships (default: false).
-    *   *format* (string): Output format - "json" | "text" | "pretty" (default: "json").
-
-*   **search_files**: Search and return file paths only.
-    *   **query** (string, **REQUIRED**): Search query text.
-    *   *path* (string): Directory to search (default: current).
-    *   *limit* (number): Max results (default: 20).
-
-*   **status**: Check index status.
-    *   *path* (string): Directory to check (default: current).
-
-*   **symbol**: Extract symbols from code.
-    *   *path* (string): Directory to analyze (default: current).
-
-*   **check**: Check if CodexLens is ready.
-    *   *path* (string): Directory to check (default: current).
-
-*   **update**: Incremental index update.
-    *   *path* (string): Directory to update (default: current).
-
-*   **bootstrap**: Setup Python virtual environment.
-
-**Examples:**
-  codex_lens(action="init", path=".")
-  codex_lens(action="search", query="authentication")
-  codex_lens(action="search", query="func", mode="hybrid", enrich=true)
-  codex_lens(action="search_files", query="MyClass")
-
-**Note:** For advanced operations (config, clean), use CLI: codexlens --help`,
+  description: '[REMOVED] CodexLens v1 tool has been removed. Use smart_search instead.',
   inputSchema: {
     type: 'object',
     properties: {
-      action: {
-        type: 'string',
-        enum: [
-          'init',
-          'search',
-          'search_files',
-          'status',
-          'symbol',
-          'check',
-          'update',
-          'bootstrap',
-        ],
-        description: 'Action to perform: init/update (index directory), search (search code), search_files (search files only), status (index status), symbol (extract symbols), check (check if ready), bootstrap (setup venv)',
-      },
-      path: {
-        type: 'string',
-        description: 'Target directory path (for init, search, search_files). Defaults to current directory.',
-      },
-      query: {
-        type: 'string',
-        description: 'Search query (required for search and search_files actions)',
-      },
-      mode: {
-        type: 'string',
-        enum: ['auto', 'text', 'semantic', 'exact', 'fuzzy', 'hybrid', 'vector', 'pure-vector'],
-        description: 'Search mode: auto (default, hybrid if embeddings exist), text/exact (FTS), hybrid (best), fuzzy, vector, semantic/pure-vector',
-        default: 'auto',
-      },
-      format: {
-        type: 'string',
-        enum: ['json', 'text', 'pretty'],
-        description: 'Output format: json (default), text, pretty',
-        default: 'json',
-      },
-      languages: {
-        type: 'array',
-        items: { type: 'string' },
-        description: 'Languages to index (for init action). Example: ["javascript", "typescript", "python"]',
-      },
-      limit: {
-        type: 'number',
-        description: 'Maximum number of search results (for search and search_files actions)',
-        default: 20,
-      },
-      enrich: {
-        type: 'boolean',
-        description: 'Enrich search results with code graph relationships (calls, imports)',
-        default: false,
-      },
+      action: { type: 'string', description: 'Action (v1 removed)' },
     },
-    required: ['action'],
   },
 };
 
-// Handler function
-export async function handler(params: Record<string, unknown>): Promise<ToolResult<ExecuteResult>> {
-  const parsed = ParamsSchema.safeParse(params);
-  if (!parsed.success) {
-    return { success: false, error: `Invalid params: ${parsed.error.message}` };
-  }
-
-  const { action } = parsed.data;
-
-  try {
-    let result: ExecuteResult;
-
-    switch (action) {
-      case 'init':
-        result = await initIndex(parsed.data);
-        break;
-
-      case 'search':
-        result = await searchCode(parsed.data);
-        break;
-
-      case 'search_files':
-        result = await searchFiles(parsed.data);
-        break;
-
-      case 'status':
-        result = await getStatus(parsed.data);
-        break;
-
-      case 'symbol':
-        result = await extractSymbols(parsed.data);
-        break;
-
-      case 'check':
-        const checkStatus = await ensureReady();
-        result = {
-          success: checkStatus.ready,
-          ready: checkStatus.ready,
-          version: checkStatus.version,
-          error: checkStatus.error,
-        };
-        break;
-
-      case 'update':
-        // Update is an alias for init (incremental update)
-        result = await initIndex(parsed.data);
-        break;
-
-      case 'bootstrap':
-        const bootstrapResult = await bootstrapVenv();
-        result = {
-          success: bootstrapResult.success,
-          message: bootstrapResult.message,
-          error: bootstrapResult.error,
-        };
-        break;
-
-      default:
-        throw new Error(
-          `Unknown action: ${action}. Valid actions: init, search, search_files, status, symbol, check, update, bootstrap`
-        );
-    }
-
-    return result.success ? { success: true, result } : { success: false, error: result.error };
-  } catch (error) {
-    return { success: false, error: (error as Error).message };
-  }
+export async function handler(_params: Record<string, unknown>): Promise<ToolResult<ExecuteResult>> {
+  return {
+    success: false,
+    error: V1_REMOVED,
+    result: { success: false, error: V1_REMOVED },
+  };
 }
 
-/**
- * Uninstall CodexLens by removing the venv directory
- * @returns Uninstall result
- */
-async function uninstallCodexLens(): Promise<BootstrapResult> {
-  try {
-    // Check if venv exists
-    if (!existsSync(getCodexLensVenvDir())) {
-      return { success: false, error: 'CodexLens not installed (venv not found)' };
-    }
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
 
-    console.log('[CodexLens] Uninstalling CodexLens...');
+export type { ProgressInfo, ExecuteOptions, GpuMode, PythonEnvInfo };
 
-    // On Windows, kill any Python processes that might be holding locks on .db files
-    if (process.platform === 'win32') {
-      console.log('[CodexLens] Killing any CodexLens Python processes...');
-      const { execSync } = await import('child_process');
-      try {
-        // Kill any python processes from our venv that might be holding file locks
-        execSync(`taskkill /F /IM python.exe /FI "MODULES eq sqlite3" 2>nul`, { stdio: 'ignore', timeout: EXEC_TIMEOUTS.SYSTEM_INFO });
-      } catch {
-        // Ignore errors - no processes to kill
-      }
-      // Small delay to allow file handles to be released
-      await new Promise(resolve => setTimeout(resolve, 500));
-    }
-
-    const dataDir = getCodexLensDataDir();
-    console.log(`[CodexLens] Removing directory: ${dataDir}`);
-
-    // Remove the entire .codexlens directory with retry logic for locked files
-    const fs = await import('fs');
-    const path = await import('path');
-
-    // Helper function to remove directory with retries (Windows EBUSY workaround)
-    const removeWithRetry = async (dirPath: string, maxRetries = 3, delay = 1000): Promise<void> => {
-      for (let attempt = 1; attempt <= maxRetries; attempt++) {
-        try {
-          fs.rmSync(dirPath, { recursive: true, force: true, maxRetries: 3, retryDelay: 500 });
-          return;
-        } catch (err: any) {
-          if (err.code === 'EBUSY' || err.code === 'EPERM' || err.code === 'ENOTEMPTY') {
-            console.log(`[CodexLens] Retry ${attempt}/${maxRetries} - file locked, waiting...`);
-            if (attempt < maxRetries) {
-              // On Windows, try to forcefully release file handles
-              if (process.platform === 'win32' && err.path) {
-                try {
-                  const { execSync } = await import('child_process');
-                  // Try to close handles on the specific file
-                  execSync(`handle -c ${err.path} -y 2>nul`, { stdio: 'ignore', timeout: EXEC_TIMEOUTS.SYSTEM_INFO });
-                } catch {
-                  // handle.exe may not be installed, ignore
-                }
-              }
-              await new Promise(resolve => setTimeout(resolve, delay));
-              continue;
-            }
-          }
-          throw err;
-        }
-      }
-    };
-
-    await removeWithRetry(dataDir);
-
-    // Reset bootstrap cache
-    bootstrapChecked = false;
-    bootstrapReady = false;
-    clearVenvStatusCache();
-    clearSemanticStatusCache();
-
-    console.log('[CodexLens] CodexLens uninstalled successfully');
-    return { success: true, message: 'CodexLens uninstalled successfully' };
-  } catch (err) {
-    const errorMsg = (err as Error).message;
-    // Provide helpful message for Windows users with locked files
-    if (errorMsg.includes('EBUSY') || errorMsg.includes('resource busy')) {
-      return {
-        success: false,
-        error: `Failed to uninstall CodexLens: Files are locked. Please close any applications using CodexLens indexes (e.g., Claude Code, VS Code) and try again. Details: ${errorMsg}`
-      };
-    }
-    return { success: false, error: `Failed to uninstall CodexLens: ${errorMsg}` };
-  }
-}
-
-/**
- * Cancel the currently running indexing process
- * @returns Result indicating if cancellation was successful
- */
-function cancelIndexing(): { success: boolean; message?: string; error?: string } {
-  if (!currentIndexingProcess) {
-    return { success: false, error: 'No indexing process is currently running' };
-  }
-
-  if (currentIndexingAborted) {
-    return { success: false, error: 'Indexing process is already being cancelled' };
-  }
-
-  try {
-    currentIndexingAborted = true;
-
-    // Send SIGTERM first for graceful shutdown
-    if (process.platform === 'win32') {
-      // On Windows, use taskkill to kill the process tree
-      const { execSync } = require('child_process');
-      try {
-        execSync(`taskkill /pid ${currentIndexingProcess.pid} /T /F`, { stdio: 'ignore', timeout: EXEC_TIMEOUTS.SYSTEM_INFO });
-      } catch {
-        // Process may have already exited
-      }
-    } else {
-      // On Unix, send SIGTERM
-      currentIndexingProcess.kill('SIGTERM');
-
-      // Force kill after 3 seconds if still running
-      setTimeout(() => {
-        if (currentIndexingProcess) {
-          currentIndexingProcess.kill('SIGKILL');
-        }
-      }, 3000);
-    }
-
-    console.log('[CodexLens] Indexing process cancelled');
-    return { success: true, message: 'Indexing cancelled successfully' };
-  } catch (err) {
-    return { success: false, error: `Failed to cancel indexing: ${(err as Error).message}` };
-  }
-}
-
-/**
- * Check if an indexing process is currently running
- * @returns True if indexing is in progress
- */
-function isIndexingInProgress(): boolean {
-  return currentIndexingProcess !== null && !currentIndexingAborted;
-}
-
-// Export types
-export type { ProgressInfo, ExecuteOptions };
-
-// Export for direct usage
 export {
   ensureReady,
   executeCodexLens,
@@ -2613,37 +193,21 @@ export {
   uninstallCodexLens,
   cancelIndexing,
   isIndexingInProgress,
-  // UV-based installation functions
   bootstrapWithUv,
   installSemanticWithUv,
-  // v2 bridge support
   useCodexLensV2,
   isCodexLensV2Installed,
   bootstrapV2WithUv,
+  getVenvPythonPath,
 };
 
-// Export Python path for direct spawn usage (e.g., watcher)
-export function getVenvPythonPath(): string {
-  return getCodexLensHiddenPython();
-}
+export const __testables = {};
 
-export type { GpuMode, PythonEnvInfo };
-
-export const __testables = {
-  normalizeSearchCommandResult,
-  parseLegacySearchPaths,
-  buildCodexLensSpawnOptions,
-  probePythonVersion,
-};
-
-// Backward-compatible export for tests
 export const codexLensTool = {
   name: schema.name,
   description: schema.description,
   parameters: schema.inputSchema,
-  execute: async (params: Record<string, unknown>) => {
-    const result = await handler(params);
-    // Return the result directly - tests expect {success: boolean, ...} format
-    return result.success ? result.result : { success: false, error: result.error };
-  }
+  execute: async (_params: Record<string, unknown>) => {
+    return { success: false, error: V1_REMOVED };
+  },
 };
diff --git a/ccw/src/tools/index.ts b/ccw/src/tools/index.ts
index 4fdc1ca3..d009c6c0 100644
--- a/ccw/src/tools/index.ts
+++ b/ccw/src/tools/index.ts
@@ -21,7 +21,7 @@ import * as cliExecutorMod from './cli-executor.js';
 import * as smartSearchMod from './smart-search.js';
 import { executeInitWithProgress } from './smart-search.js';
 // codex_lens removed - functionality integrated into smart_search
-import * as codexLensLspMod from './codex-lens-lsp.js';
+// codex_lens_lsp removed - v1 LSP bridge removed
 import * as readFileMod from './read-file.js';
 import * as readManyFilesMod from './read-many-files.js';
 import * as readOutlineMod from './read-outline.js';
@@ -365,7 +365,7 @@ registerTool(toLegacyTool(sessionManagerMod));
 registerTool(toLegacyTool(cliExecutorMod));
 registerTool(toLegacyTool(smartSearchMod));
 // codex_lens removed - functionality integrated into smart_search
-registerTool(toLegacyTool(codexLensLspMod));
+// codex_lens_lsp removed - v1 LSP bridge removed
 registerTool(toLegacyTool(readFileMod));
 registerTool(toLegacyTool(readManyFilesMod));
 registerTool(toLegacyTool(readOutlineMod));
diff --git a/ccw/src/tools/litellm-client.ts b/ccw/src/tools/litellm-client.ts
index e2063efa..5654384c 100644
--- a/ccw/src/tools/litellm-client.ts
+++ b/ccw/src/tools/litellm-client.ts
@@ -1,64 +1,23 @@
 /**
- * LiteLLM Client - Bridge between CCW and ccw-litellm Python package
- * Provides LLM chat and embedding capabilities via spawned Python process
+ * LiteLLM Client - STUB (v1 Python bridge removed)
  *
- * Features:
- * - Chat completions with multiple models
- * - Text embeddings generation
- * - Configuration management
- * - JSON protocol communication
+ * The Python ccw-litellm bridge has been removed. This module provides
+ * no-op stubs so that existing consumers compile without errors.
  */
 
-import { spawn } from 'child_process';
-import { existsSync } from 'fs';
-import { join } from 'path';
-import { getCodexLensPython, getCodexLensHiddenPython, getCodexLensVenvDir } from '../utils/codexlens-path.js';
+const V1_REMOVED = 'LiteLLM Python bridge has been removed (v1 cleanup).';
 
 export interface LiteLLMConfig {
-  pythonPath?: string;  // Default: CodexLens venv Python
-  configPath?: string;  // Configuration file path
-  timeout?: number;     // Default 60000ms
+  pythonPath?: string;
+  configPath?: string;
+  timeout?: number;
 }
 
-// Platform-specific constants for CodexLens venv
-const IS_WINDOWS = process.platform === 'win32';
-const CODEXLENS_VENV = getCodexLensVenvDir();
-const VENV_BIN_DIR = IS_WINDOWS ? 'Scripts' : 'bin';
-const PYTHON_EXECUTABLE = IS_WINDOWS ? 'pythonw.exe' : 'python';
-
-/**
- * Get the Python path from CodexLens venv
- * Falls back to system 'python' if venv doesn't exist
- * @returns Path to Python executable
- */
 export function getCodexLensVenvPython(): string {
-  const venvPython = join(CODEXLENS_VENV, VENV_BIN_DIR, PYTHON_EXECUTABLE);
-  if (existsSync(venvPython)) {
-    return venvPython;
-  }
-  const hiddenPython = getCodexLensHiddenPython();
-  if (existsSync(hiddenPython)) {
-    return hiddenPython;
-  }
-  // Fallback to system Python if venv not available
   return 'python';
 }
 
-/**
- * Get the Python path from CodexLens venv using centralized path utility
- * Falls back to system 'python' if venv doesn't exist
- * @returns Path to Python executable
- */
 export function getCodexLensPythonPath(): string {
-  const codexLensPython = getCodexLensHiddenPython();
-  if (existsSync(codexLensPython)) {
-    return codexLensPython;
-  }
-  const fallbackPython = getCodexLensPython();
-  if (existsSync(fallbackPython)) {
-    return fallbackPython;
-  }
-  // Fallback to system Python if venv not available
   return 'python';
 }
 
@@ -90,179 +49,35 @@ export interface LiteLLMStatus {
 }
 
 export class LiteLLMClient {
-  private pythonPath: string;
-  private configPath?: string;
-  private timeout: number;
+  constructor(_config: LiteLLMConfig = {}) {}
 
-  constructor(config: LiteLLMConfig = {}) {
-    this.pythonPath = config.pythonPath || getCodexLensVenvPython();
-    this.configPath = config.configPath;
-    this.timeout = config.timeout || 60000;
-  }
-
-  /**
-   * Execute Python ccw-litellm command
-   */
-  private async executePython(args: string[], options: { timeout?: number } = {}): Promise<string> {
-    const timeout = options.timeout || this.timeout;
-
-    return new Promise((resolve, reject) => {
-      const proc = spawn(this.pythonPath, ['-m', 'ccw_litellm.cli', ...args], {
-        shell: false,
-        windowsHide: true,
-        stdio: ['pipe', 'pipe', 'pipe'],
-        env: { ...process.env, PYTHONIOENCODING: 'utf-8' }
-      });
-
-      let stdout = '';
-      let stderr = '';
-      let timedOut = false;
-
-      // Set up timeout
-      const timeoutId = setTimeout(() => {
-        timedOut = true;
-        proc.kill('SIGTERM');
-        reject(new Error(`Command timed out after ${timeout}ms`));
-      }, timeout);
-
-      proc.stdout.on('data', (data) => {
-        stdout += data.toString();
-      });
-
-      proc.stderr.on('data', (data) => {
-        stderr += data.toString();
-      });
-
-      proc.on('error', (error) => {
-        clearTimeout(timeoutId);
-        reject(new Error(`Failed to spawn Python process: ${error.message}`));
-      });
-
-      proc.on('close', (code) => {
-        clearTimeout(timeoutId);
-
-        if (timedOut) {
-          return; // Already rejected
-        }
-
-        if (code === 0) {
-          resolve(stdout.trim());
-        } else {
-          const errorMsg = stderr.trim() || `Process exited with code ${code}`;
-          reject(new Error(errorMsg));
-        }
-      });
-    });
-  }
-
-  /**
-   * Check if ccw-litellm is available
-   */
   async isAvailable(): Promise<boolean> {
-    try {
-      // Increased timeout to 15s for Python cold start
-      await this.executePython(['version'], { timeout: 15000 });
-      return true;
-    } catch {
-      return false;
-    }
+    return false;
   }
 
-  /**
-   * Get status information
-   */
   async getStatus(): Promise<LiteLLMStatus> {
-    try {
-      // Increased timeout to 15s for Python cold start
-      const output = await this.executePython(['version'], { timeout: 15000 });
-      // Parse "ccw-litellm 0.1.0" format
-      const versionMatch = output.trim().match(/ccw-litellm\s+([\d.]+)/);
-      const version = versionMatch ? versionMatch[1] : output.trim();
-      return {
-        available: true,
-        version
-      };
-    } catch (error: any) {
-      return {
-        available: false,
-        error: error.message
-      };
-    }
+    return { available: false, error: V1_REMOVED };
   }
 
-  /**
-   * Get current configuration
-   */
-  async getConfig(): Promise<any> {
-    // config command outputs JSON by default, no --json flag needed
-    const output = await this.executePython(['config']);
-    return JSON.parse(output);
+  async getConfig(): Promise<unknown> {
+    return { error: V1_REMOVED };
   }
 
-  /**
-   * Generate embeddings for texts
-   */
-  async embed(texts: string[], model: string = 'default'): Promise<EmbedResponse> {
-    if (!texts || texts.length === 0) {
-      throw new Error('texts array cannot be empty');
-    }
-
-    const args = ['embed', '--model', model, '--output', 'json'];
-
-    // Add texts as arguments
-    for (const text of texts) {
-      args.push(text);
-    }
-
-    const output = await this.executePython(args, { timeout: this.timeout * 2 });
-    const vectors = JSON.parse(output);
-
-    return {
-      vectors,
-      dimensions: vectors[0]?.length || 0,
-      model
-    };
+  async embed(_texts: string[], _model?: string): Promise<EmbedResponse> {
+    throw new Error(V1_REMOVED);
   }
 
-  /**
-   * Chat with LLM
-   */
-  async chat(message: string, model: string = 'default'): Promise<string> {
-    if (!message) {
-      throw new Error('message cannot be empty');
-    }
-
-    const args = ['chat', '--model', model, message];
-    return this.executePython(args, { timeout: this.timeout * 2 });
+  async chat(_message: string, _model?: string): Promise<string> {
+    throw new Error(V1_REMOVED);
   }
 
-  /**
-   * Multi-turn chat with messages array
-   */
-  async chatMessages(messages: ChatMessage[], model: string = 'default'): Promise<ChatResponse> {
-    if (!messages || messages.length === 0) {
-      throw new Error('messages array cannot be empty');
-    }
-
-    // For now, just use the last user message
-    // TODO: Implement full message history support in ccw-litellm
-    const lastMessage = messages[messages.length - 1];
-    const content = await this.chat(lastMessage.content, model);
-
-    return {
-      content,
-      model,
-      usage: undefined // TODO: Add usage tracking
-    };
+  async chatMessages(_messages: ChatMessage[], _model?: string): Promise<ChatResponse> {
+    throw new Error(V1_REMOVED);
   }
 }
 
-// Singleton instance
 let _client: LiteLLMClient | null = null;
 
-/**
- * Get or create singleton LiteLLM client
- */
 export function getLiteLLMClient(config?: LiteLLMConfig): LiteLLMClient {
   if (!_client) {
     _client = new LiteLLMClient(config);
@@ -270,29 +85,10 @@ export function getLiteLLMClient(config?: LiteLLMConfig): LiteLLMClient {
   return _client;
 }
 
-/**
- * Check if LiteLLM is available
- */
 export async function checkLiteLLMAvailable(): Promise<boolean> {
-  try {
-    const client = getLiteLLMClient();
-    return await client.isAvailable();
-  } catch {
-    return false;
-  }
+  return false;
 }
 
-/**
- * Get LiteLLM status
- */
 export async function getLiteLLMStatus(): Promise<LiteLLMStatus> {
-  try {
-    const client = getLiteLLMClient();
-    return await client.getStatus();
-  } catch (error: any) {
-    return {
-      available: false,
-      error: error.message
-    };
-  }
+  return { available: false, error: V1_REMOVED };
 }
diff --git a/ccw/src/utils/codexlens-path.ts b/ccw/src/utils/codexlens-path.ts
index 88ae5cbc..a0780504 100644
--- a/ccw/src/utils/codexlens-path.ts
+++ b/ccw/src/utils/codexlens-path.ts
@@ -9,7 +9,6 @@
  * 2. Default: ~/.codexlens
  */
 
-import { existsSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 
@@ -26,56 +25,3 @@ export function getCodexLensDataDir(): string {
   }
   return join(homedir(), '.codexlens');
 }
-
-/**
- * Get the CodexLens virtual environment path.
- *
- * @returns Path to CodexLens venv directory
- */
-export function getCodexLensVenvDir(): string {
-  return join(getCodexLensDataDir(), 'venv');
-}
-
-/**
- * Get the Python executable path in the CodexLens venv.
- *
- * @returns Path to python executable
- */
-export function getCodexLensPython(): string {
-  const venvDir = getCodexLensVenvDir();
-  return process.platform === 'win32'
-    ? join(venvDir, 'Scripts', 'python.exe')
-    : join(venvDir, 'bin', 'python');
-}
-
-/**
- * Get the preferred Python executable for hidden/windowless CodexLens subprocesses.
- * On Windows this prefers pythonw.exe when available to avoid transient console windows.
- *
- * @returns Path to the preferred hidden-subprocess Python executable
- */
-export function getCodexLensHiddenPython(): string {
-  if (process.platform !== 'win32') {
-    return getCodexLensPython();
-  }
-
-  const venvDir = getCodexLensVenvDir();
-  const pythonwPath = join(venvDir, 'Scripts', 'pythonw.exe');
-  if (existsSync(pythonwPath)) {
-    return pythonwPath;
-  }
-
-  return getCodexLensPython();
-}
-
-/**
- * Get the pip executable path in the CodexLens venv.
- *
- * @returns Path to pip executable
- */
-export function getCodexLensPip(): string {
-  const venvDir = getCodexLensVenvDir();
-  return process.platform === 'win32'
-    ? join(venvDir, 'Scripts', 'pip.exe')
-    : join(venvDir, 'bin', 'pip');
-}
diff --git a/ccw/src/utils/package-discovery.ts b/ccw/src/utils/package-discovery.ts
deleted file mode 100644
index a7a08b7a..00000000
--- a/ccw/src/utils/package-discovery.ts
+++ /dev/null
@@ -1,327 +0,0 @@
-/**
- * Unified Package Discovery for local Python packages (codex-lens, ccw-litellm)
- *
- * Provides a single, transparent path discovery mechanism with:
- * - Environment variable overrides (highest priority)
- * - ~/.codexlens/config.json configuration
- * - Extended search paths (npm global, PACKAGE_ROOT, siblings, etc.)
- * - Full search result transparency for diagnostics
- */
-
-import { existsSync, readFileSync } from 'fs';
-import { join, dirname, resolve } from 'path';
-import { homedir } from 'os';
-import { execSync } from 'child_process';
-import { fileURLToPath } from 'url';
-import { getCodexLensDataDir } from './codexlens-path.js';
-import { EXEC_TIMEOUTS } from './exec-constants.js';
-
-// Get directory of this module (src/utils/)
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// ========================================
-// Types
-// ========================================
-
-/** Source that found the package path */
-export type PackageSource =
-  | 'env'           // Environment variable override
-  | 'config'        // ~/.codexlens/config.json
-  | 'sibling'       // Sibling directory to ccw project root
-  | 'npm-global'    // npm global prefix
-  | 'cwd'           // Current working directory
-  | 'cwd-parent'    // Parent of current working directory
-  | 'homedir'       // User home directory
-  | 'package-root'; // npm package internal path
-
-/** A single search attempt result */
-export interface SearchAttempt {
-  path: string;
-  source: PackageSource;
-  exists: boolean;
-}
-
-/** Result of package discovery */
-export interface PackageDiscoveryResult {
-  /** Resolved package path, or null if not found */
-  path: string | null;
-  /** Source that found the package */
-  source: PackageSource | null;
-  /** All paths searched (for diagnostics) */
-  searchedPaths: SearchAttempt[];
-  /** Whether the found path is inside node_modules */
-  insideNodeModules: boolean;
-}
-
-/** Known local package names */
-export type LocalPackageName = 'codex-lens' | 'ccw-litellm' | 'codexlens-search';
-
-/** Environment variable mapping for each package */
-const PACKAGE_ENV_VARS: Record<LocalPackageName, string> = {
-  'codex-lens': 'CODEXLENS_PACKAGE_PATH',
-  'ccw-litellm': 'CCW_LITELLM_PATH',
-  'codexlens-search': 'CODEXLENS_SEARCH_PATH',
-};
-
-/** Config key mapping for each package */
-const PACKAGE_CONFIG_KEYS: Record<LocalPackageName, string> = {
-  'codex-lens': 'codexLensPath',
-  'ccw-litellm': 'ccwLitellmPath',
-  'codexlens-search': 'codexlensSearchPath',
-};
-
-// ========================================
-// Helpers
-// ========================================
-
-/**
- * Check if a path is inside node_modules
- */
-export function isInsideNodeModules(pathToCheck: string): boolean {
-  const normalized = pathToCheck.replace(/\\/g, '/').toLowerCase();
-  return normalized.includes('/node_modules/');
-}
-
-/**
- * Check if running in a development environment (not from node_modules)
- */
-export function isDevEnvironment(): boolean {
-  // Yarn PnP detection
-  if ((process.versions as Record<string, unknown>).pnp) {
-    return false;
-  }
-  return !isInsideNodeModules(__dirname);
-}
-
-/**
- * Read package paths from ~/.codexlens/config.json
- */
-function readConfigPath(packageName: LocalPackageName): string | null {
-  try {
-    const configPath = join(getCodexLensDataDir(), 'config.json');
-    if (!existsSync(configPath)) return null;
-
-    const config = JSON.parse(readFileSync(configPath, 'utf-8'));
-    const key = PACKAGE_CONFIG_KEYS[packageName];
-    const value = config?.packagePaths?.[key];
-    return typeof value === 'string' && value.trim() ? value.trim() : null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Get npm global prefix directory
- */
-let _npmGlobalPrefix: string | null | undefined;
-function getNpmGlobalPrefix(): string | null {
-  if (_npmGlobalPrefix !== undefined) return _npmGlobalPrefix;
-
-  try {
-    const result = execSync('npm prefix -g', {
-      encoding: 'utf-8',
-      timeout: EXEC_TIMEOUTS.SYSTEM_INFO,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-    _npmGlobalPrefix = result.trim() || null;
-  } catch {
-    _npmGlobalPrefix = null;
-  }
-  return _npmGlobalPrefix;
-}
-
-/**
- * Check if a directory contains a valid Python package (has pyproject.toml)
- */
-function isValidPackageDir(dir: string): boolean {
-  return existsSync(join(dir, 'pyproject.toml'));
-}
-
-// ========================================
-// Main Discovery Function
-// ========================================
-
-/**
- * Find a local Python package path with unified search logic.
- *
- * Search priority:
- * 1. Environment variable (CODEXLENS_PACKAGE_PATH / CCW_LITELLM_PATH)
- * 2. ~/.codexlens/config.json packagePaths
- * 3. Sibling directory to ccw project root (src/utils -> ../../..)
- * 4. npm global prefix node_modules path
- * 5. Current working directory
- * 6. Parent of current working directory
- * 7. Home directory
- *
- * Two-pass search: first pass skips node_modules paths, second pass allows them.
- *
- * @param packageName - Package to find ('codex-lens' or 'ccw-litellm')
- * @returns Discovery result with path, source, and all searched paths
- */
-export function findPackagePath(packageName: LocalPackageName): PackageDiscoveryResult {
-  const searched: SearchAttempt[] = [];
-
-  // Helper to check and record a path
-  const check = (path: string, source: PackageSource): boolean => {
-    const resolvedPath = resolve(path);
-    const exists = isValidPackageDir(resolvedPath);
-    searched.push({ path: resolvedPath, source, exists });
-    return exists;
-  };
-
-  // 1. Environment variable (highest priority, skip two-pass)
-  const envKey = PACKAGE_ENV_VARS[packageName];
-  const envPath = process.env[envKey];
-  if (envPath) {
-    if (check(envPath, 'env')) {
-      return {
-        path: resolve(envPath),
-        source: 'env',
-        searchedPaths: searched,
-        insideNodeModules: isInsideNodeModules(envPath),
-      };
-    }
-    // Env var set but path invalid — continue searching but warn
-    console.warn(`[PackageDiscovery] ${envKey}="${envPath}" set but pyproject.toml not found, continuing search...`);
-  }
-
-  // 2. Config file
-  const configPath = readConfigPath(packageName);
-  if (configPath) {
-    if (check(configPath, 'config')) {
-      return {
-        path: resolve(configPath),
-        source: 'config',
-        searchedPaths: searched,
-        insideNodeModules: isInsideNodeModules(configPath),
-      };
-    }
-  }
-
-  // Build candidate paths for two-pass search
-  const candidates: { path: string; source: PackageSource }[] = [];
-
-  // 3. Sibling directory to ccw project root
-  //    __dirname = src/utils/ → project root = ../../..
-  //    Also try one more level up for nested structures
-  const projectRoot = join(__dirname, '..', '..', '..');
-  candidates.push({ path: join(projectRoot, packageName), source: 'sibling' });
-  candidates.push({ path: join(projectRoot, '..', packageName), source: 'sibling' });
-
-  // 4. npm global prefix
-  const npmPrefix = getNpmGlobalPrefix();
-  if (npmPrefix) {
-    // npm global: prefix/node_modules/claude-code-workflow/<packageName>
-    candidates.push({
-      path: join(npmPrefix, 'node_modules', 'claude-code-workflow', packageName),
-      source: 'npm-global',
-    });
-    // npm global: prefix/lib/node_modules/claude-code-workflow/<packageName> (Linux/Mac)
-    candidates.push({
-      path: join(npmPrefix, 'lib', 'node_modules', 'claude-code-workflow', packageName),
-      source: 'npm-global',
-    });
-    // npm global sibling: prefix/node_modules/<packageName>
-    candidates.push({
-      path: join(npmPrefix, 'node_modules', packageName),
-      source: 'npm-global',
-    });
-  }
-
-  // 5. Current working directory
-  const cwd = process.cwd();
-  candidates.push({ path: join(cwd, packageName), source: 'cwd' });
-
-  // 6. Parent of cwd (common workspace layout)
-  const cwdParent = dirname(cwd);
-  if (cwdParent !== cwd) {
-    candidates.push({ path: join(cwdParent, packageName), source: 'cwd-parent' });
-  }
-
-  // 7. Home directory
-  candidates.push({ path: join(homedir(), packageName), source: 'homedir' });
-
-  // Two-pass search: prefer non-node_modules paths first
-  // First pass: skip node_modules
-  for (const candidate of candidates) {
-    const resolvedPath = resolve(candidate.path);
-    if (isInsideNodeModules(resolvedPath)) continue;
-    if (check(resolvedPath, candidate.source)) {
-      console.log(`[PackageDiscovery] Found ${packageName} at: ${resolvedPath} (source: ${candidate.source})`);
-      return {
-        path: resolvedPath,
-        source: candidate.source,
-        searchedPaths: searched,
-        insideNodeModules: false,
-      };
-    }
-  }
-
-  // Second pass: allow node_modules paths
-  for (const candidate of candidates) {
-    const resolvedPath = resolve(candidate.path);
-    if (!isInsideNodeModules(resolvedPath)) continue;
-    // Skip if already checked in first pass
-    if (searched.some(s => s.path === resolvedPath)) continue;
-    if (check(resolvedPath, candidate.source)) {
-      console.log(`[PackageDiscovery] Found ${packageName} in node_modules at: ${resolvedPath} (source: ${candidate.source})`);
-      return {
-        path: resolvedPath,
-        source: candidate.source,
-        searchedPaths: searched,
-        insideNodeModules: true,
-      };
-    }
-  }
-
-  // Not found
-  return {
-    path: null,
-    source: null,
-    searchedPaths: searched,
-    insideNodeModules: false,
-  };
-}
-
-/**
- * Find codex-lens package path (convenience wrapper)
- */
-export function findCodexLensPath(): PackageDiscoveryResult {
-  return findPackagePath('codex-lens');
-}
-
-/**
- * Find ccw-litellm package path (convenience wrapper)
- */
-export function findCcwLitellmPath(): PackageDiscoveryResult {
-  return findPackagePath('ccw-litellm');
-}
-
-/**
- * Find codexlens-search (v2) package path (convenience wrapper)
- */
-export function findCodexLensSearchPath(): PackageDiscoveryResult {
-  return findPackagePath('codexlens-search');
-}
-
-/**
- * Format search results for error messages
- */
-export function formatSearchResults(result: PackageDiscoveryResult, packageName: string): string {
-  const lines = [`Cannot find '${packageName}' package directory.\n`];
-  lines.push('Searched locations:');
-  for (const attempt of result.searchedPaths) {
-    const status = attempt.exists ? '✓' : '✗';
-    lines.push(`  ${status} [${attempt.source}] ${attempt.path}`);
-  }
-  lines.push('');
-  lines.push('To fix this:');
-
-  const envKey = PACKAGE_ENV_VARS[packageName as LocalPackageName] || `${packageName.toUpperCase().replace(/-/g, '_')}_PATH`;
-  lines.push(`  1. Set environment variable: ${envKey}=/path/to/${packageName}`);
-  lines.push(`  2. Or add to ~/.codexlens/config.json: { "packagePaths": { "${PACKAGE_CONFIG_KEYS[packageName as LocalPackageName] || packageName}": "/path/to/${packageName}" } }`);
-  lines.push(`  3. Or ensure '${packageName}' directory exists as a sibling to the ccw project`);
-
-  return lines.join('\n');
-}
diff --git a/ccw/src/utils/python-utils.ts b/ccw/src/utils/python-utils.ts
deleted file mode 100644
index 9bf989d7..00000000
--- a/ccw/src/utils/python-utils.ts
+++ /dev/null
@@ -1,269 +0,0 @@
-/**
- * Python detection and version compatibility utilities
- * Shared module for consistent Python discovery across the application
- */
-
-import { spawnSync, type SpawnSyncOptionsWithStringEncoding } from 'child_process';
-import { EXEC_TIMEOUTS } from './exec-constants.js';
-
-export interface PythonCommandSpec {
-  command: string;
-  args: string[];
-  display: string;
-}
-
-type HiddenPythonProbeOptions = Omit<SpawnSyncOptionsWithStringEncoding, 'encoding'> & {
-  encoding?: BufferEncoding;
-};
-
-function isExecTimeoutError(error: unknown): boolean {
-  const err = error as { code?: unknown; errno?: unknown; message?: unknown } | null;
-  const code = err?.code ?? err?.errno;
-  if (code === 'ETIMEDOUT') return true;
-  const message = typeof err?.message === 'string' ? err.message : '';
-  return message.includes('ETIMEDOUT');
-}
-
-function quoteCommandPart(value: string): string {
-  if (!/[\s"]/.test(value)) {
-    return value;
-  }
-  return `"${value.replaceAll('"', '\\"')}"`;
-}
-
-function formatPythonCommandDisplay(command: string, args: string[]): string {
-  return [quoteCommandPart(command), ...args.map(quoteCommandPart)].join(' ');
-}
-
-function buildPythonCommandSpec(command: string, args: string[] = []): PythonCommandSpec {
-  return {
-    command,
-    args: [...args],
-    display: formatPythonCommandDisplay(command, args),
-  };
-}
-
-function tokenizeCommandSpec(raw: string): string[] {
-  const tokens: string[] = [];
-  const tokenPattern = /"((?:\\"|[^"])*)"|(\S+)/g;
-
-  for (const match of raw.matchAll(tokenPattern)) {
-    const quoted = match[1];
-    const plain = match[2];
-    if (quoted !== undefined) {
-      tokens.push(quoted.replaceAll('\\"', '"'));
-    } else if (plain !== undefined) {
-      tokens.push(plain);
-    }
-  }
-
-  return tokens;
-}
-
-export function parsePythonCommandSpec(raw: string): PythonCommandSpec {
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    throw new Error('Python command cannot be empty');
-  }
-
-  // Unquoted executable paths on Windows commonly contain spaces.
-  if (!trimmed.includes('"') && /[\\/]/.test(trimmed)) {
-    return buildPythonCommandSpec(trimmed);
-  }
-
-  const tokens = tokenizeCommandSpec(trimmed);
-  if (tokens.length === 0) {
-    return buildPythonCommandSpec(trimmed);
-  }
-
-  return buildPythonCommandSpec(tokens[0], tokens.slice(1));
-}
-
-function buildPythonProbeOptions(
-  overrides: HiddenPythonProbeOptions = {},
-): SpawnSyncOptionsWithStringEncoding {
-  const { env, encoding, ...rest } = overrides;
-  return {
-    shell: false,
-    windowsHide: true,
-    timeout: EXEC_TIMEOUTS.PYTHON_VERSION,
-    stdio: ['ignore', 'pipe', 'pipe'],
-    env: { ...process.env, PYTHONIOENCODING: 'utf-8', ...env },
-    ...rest,
-    encoding: encoding ?? 'utf8',
-  };
-}
-
-export function probePythonCommandVersion(
-  pythonCommand: PythonCommandSpec,
-  runner: typeof spawnSync = spawnSync,
-): string {
-  const result = runner(
-    pythonCommand.command,
-    [...pythonCommand.args, '--version'],
-    buildPythonProbeOptions(),
-  );
-
-  if (result.error) {
-    throw result.error;
-  }
-
-  const versionOutput = `${result.stdout ?? ''}${result.stderr ?? ''}`.trim();
-  if (result.status !== 0) {
-    throw new Error(versionOutput || `Python version probe exited with code ${String(result.status)}`);
-  }
-
-  return versionOutput;
-}
-
-/**
- * Parse Python version string to major.minor numbers
- * @param versionStr - Version string like "Python 3.11.5"
- * @returns Object with major and minor version numbers, or null if parsing fails
- */
-export function parsePythonVersion(versionStr: string): { major: number; minor: number } | null {
-  const match = versionStr.match(/Python\s+(\d+)\.(\d+)/);
-  if (match) {
-    return { major: parseInt(match[1], 10), minor: parseInt(match[2], 10) };
-  }
-  return null;
-}
-
-/**
- * Check if Python version is compatible with onnxruntime (3.9-3.12)
- * @param major - Major version number
- * @param minor - Minor version number
- * @returns true if compatible
- */
-export function isPythonVersionCompatible(major: number, minor: number): boolean {
-  // onnxruntime currently supports Python 3.9-3.12
-  return major === 3 && minor >= 9 && minor <= 12;
-}
-
-/**
- * Detect available Python 3 executable
- * Supports CCW_PYTHON environment variable for custom Python path
- * On Windows, uses py launcher to find compatible versions
- * @returns Python executable command spec
- */
-export function getSystemPythonCommand(runner: typeof spawnSync = spawnSync): PythonCommandSpec {
-  const customPython = process.env.CCW_PYTHON?.trim();
-  if (customPython) {
-    const customSpec = parsePythonCommandSpec(customPython);
-    try {
-      const version = probePythonCommandVersion(customSpec, runner);
-      if (version.includes('Python 3')) {
-        const parsed = parsePythonVersion(version);
-        if (parsed && !isPythonVersionCompatible(parsed.major, parsed.minor)) {
-          console.warn(
-            `[Python] Warning: CCW_PYTHON points to Python ${parsed.major}.${parsed.minor}, which may not be compatible with onnxruntime (requires 3.9-3.12)`,
-          );
-        }
-        return customSpec;
-      }
-    } catch (err: unknown) {
-      if (isExecTimeoutError(err)) {
-        console.warn(
-          `[Python] Warning: CCW_PYTHON version check timed out after ${EXEC_TIMEOUTS.PYTHON_VERSION}ms, falling back to system Python`,
-        );
-      } else {
-        console.warn(
-          `[Python] Warning: CCW_PYTHON="${customPython}" is not a valid Python executable, falling back to system Python`,
-        );
-      }
-    }
-  }
-
-  if (process.platform === 'win32') {
-    const compatibleVersions = ['3.12', '3.11', '3.10', '3.9'];
-    for (const ver of compatibleVersions) {
-      const launcherSpec = buildPythonCommandSpec('py', [`-${ver}`]);
-      try {
-        const version = probePythonCommandVersion(launcherSpec, runner);
-        if (version.includes(`Python ${ver}`)) {
-          console.log(`[Python] Found compatible Python ${ver} via py launcher`);
-          return launcherSpec;
-        }
-      } catch (err: unknown) {
-        if (isExecTimeoutError(err)) {
-          console.warn(
-            `[Python] Warning: py -${ver} version check timed out after ${EXEC_TIMEOUTS.PYTHON_VERSION}ms`,
-          );
-        }
-      }
-    }
-  }
-
-  const commands = process.platform === 'win32' ? ['python', 'py', 'python3'] : ['python3', 'python'];
-  let fallbackCmd: PythonCommandSpec | null = null;
-  let fallbackVersion: { major: number; minor: number } | null = null;
-
-  for (const cmd of commands) {
-    const pythonSpec = buildPythonCommandSpec(cmd);
-    try {
-      const version = probePythonCommandVersion(pythonSpec, runner);
-      if (version.includes('Python 3')) {
-        const parsed = parsePythonVersion(version);
-        if (parsed) {
-          if (isPythonVersionCompatible(parsed.major, parsed.minor)) {
-            return pythonSpec;
-          }
-          if (!fallbackCmd) {
-            fallbackCmd = pythonSpec;
-            fallbackVersion = parsed;
-          }
-        }
-      }
-    } catch (err: unknown) {
-      if (isExecTimeoutError(err)) {
-        console.warn(`[Python] Warning: ${cmd} --version timed out after ${EXEC_TIMEOUTS.PYTHON_VERSION}ms`);
-      }
-    }
-  }
-
-  if (fallbackCmd && fallbackVersion) {
-    console.warn(
-      `[Python] Warning: Only Python ${fallbackVersion.major}.${fallbackVersion.minor} found, which may not be compatible with onnxruntime (requires 3.9-3.12).`,
-    );
-    console.warn('[Python] Semantic search may fail with ImportError for onnxruntime.');
-    console.warn('[Python] To use a specific Python version, set CCW_PYTHON environment variable:');
-    console.warn('  Windows: set CCW_PYTHON=C:\\path\\to\\python.exe');
-    console.warn('  Unix: export CCW_PYTHON=/path/to/python3.11');
-    console.warn('[Python] Alternatively, use LiteLLM embedding backend which has no Python version restrictions.');
-    return fallbackCmd;
-  }
-
-  throw new Error(
-    'Python 3 not found. Please install Python 3.9-3.12 and ensure it is in PATH, or set CCW_PYTHON environment variable.',
-  );
-}
-
-/**
- * Detect available Python 3 executable
- * Supports CCW_PYTHON environment variable for custom Python path
- * On Windows, uses py launcher to find compatible versions
- * @returns Python executable command
- */
-export function getSystemPython(): string {
-  return getSystemPythonCommand().display;
-}
-
-/**
- * Get the Python command for pip operations (uses -m pip for reliability)
- * @returns Array of command arguments for spawn
- */
-export function getPipCommand(): { pythonCmd: string; pipArgs: string[] } {
-  const pythonCmd = getSystemPython();
-  return {
-    pythonCmd,
-    pipArgs: ['-m', 'pip'],
-  };
-}
-
-export const __testables = {
-  buildPythonCommandSpec,
-  buildPythonProbeOptions,
-  formatPythonCommandDisplay,
-  parsePythonCommandSpec,
-  probePythonCommandVersion,
-};
diff --git a/ccw/src/utils/uv-manager.ts b/ccw/src/utils/uv-manager.ts
deleted file mode 100644
index 4d9cb9ee..00000000
--- a/ccw/src/utils/uv-manager.ts
+++ /dev/null
@@ -1,902 +0,0 @@
-/**
- * UV Package Manager Tool
- * Provides unified UV (https://github.com/astral-sh/uv) tool management capabilities
- *
- * Features:
- * - Cross-platform UV binary discovery and installation
- * - Virtual environment creation and management
- * - Python dependency installation with UV's fast resolver
- * - Support for local project installs with extras
- */
-
-import { spawn, spawnSync, type SpawnOptions, type SpawnSyncOptionsWithStringEncoding } from 'child_process';
-import { existsSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { homedir, platform, arch } from 'os';
-import { EXEC_TIMEOUTS } from './exec-constants.js';
-import { getCodexLensDataDir, getCodexLensVenvDir } from './codexlens-path.js';
-
-/**
- * Configuration for UvManager
- */
-export interface UvManagerConfig {
-  /** Path to the virtual environment directory */
-  venvPath: string;
-  /** Python version requirement (e.g., ">=3.10", "3.11") */
-  pythonVersion?: string;
-}
-
-/**
- * Result of UV operations
- */
-export interface UvInstallResult {
-  /** Whether the operation succeeded */
-  success: boolean;
-  /** Error message if operation failed */
-  error?: string;
-  /** Duration of the operation in milliseconds */
-  duration?: number;
-}
-
-/**
- * UV binary search locations in priority order
- */
-interface UvSearchLocation {
-  path: string;
-  description: string;
-}
-
-// Platform-specific constants
-const IS_WINDOWS = platform() === 'win32';
-const UV_BINARY_NAME = IS_WINDOWS ? 'uv.exe' : 'uv';
-const VENV_BIN_DIR = IS_WINDOWS ? 'Scripts' : 'bin';
-const PYTHON_EXECUTABLE = IS_WINDOWS ? 'python.exe' : 'python';
-
-type HiddenUvSpawnSyncOptions = Omit<SpawnSyncOptionsWithStringEncoding, 'encoding'> & {
-  encoding?: BufferEncoding;
-};
-
-function buildUvSpawnOptions(overrides: SpawnOptions = {}): SpawnOptions {
-  const { env, ...rest } = overrides;
-  return {
-    shell: false,
-    windowsHide: true,
-    env: { ...process.env, PYTHONIOENCODING: 'utf-8', ...env },
-    ...rest,
-  };
-}
-
-function buildUvSpawnSyncOptions(
-  overrides: HiddenUvSpawnSyncOptions = {},
-): SpawnSyncOptionsWithStringEncoding {
-  const { env, encoding, ...rest } = overrides;
-  return {
-    shell: false,
-    windowsHide: true,
-    env: { ...process.env, PYTHONIOENCODING: 'utf-8', ...env },
-    ...rest,
-    encoding: encoding ?? 'utf-8',
-  };
-}
-
-function findExecutableOnPath(executable: string, runner: typeof spawnSync = spawnSync): string | null {
-  const lookupCommand = IS_WINDOWS ? 'where' : 'which';
-  const result = runner(
-    lookupCommand,
-    [executable],
-    buildUvSpawnSyncOptions({
-      timeout: EXEC_TIMEOUTS.SYSTEM_INFO,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    }),
-  );
-
-  if (result.error || result.status !== 0) {
-    return null;
-  }
-
-  const output = `${result.stdout ?? ''}`.trim();
-  if (!output) {
-    return null;
-  }
-
-  return output.split(/\r?\n/)[0] || null;
-}
-
-function hasWindowsPythonLauncherVersion(version: string, runner: typeof spawnSync = spawnSync): boolean {
-  const result = runner(
-    'py',
-    [`-${version}`, '--version'],
-    buildUvSpawnSyncOptions({
-      timeout: EXEC_TIMEOUTS.PYTHON_VERSION,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    }),
-  );
-
-  if (result.error || result.status !== 0) {
-    return false;
-  }
-
-  const output = `${result.stdout ?? ''}${result.stderr ?? ''}`;
-  return output.includes(`Python ${version}`);
-}
-
-/**
- * Get the path to the UV binary
- * Search order:
- * 1. CCW_UV_PATH environment variable
- * 2. Project vendor/uv/ directory
- * 3. User local directories (~/.local/bin, ~/.cargo/bin)
- * 4. System PATH
- *
- * @returns Path to the UV binary
- */
-export function getUvBinaryPath(): string {
-  const searchLocations: UvSearchLocation[] = [];
-
-  // 1. Environment variable (highest priority)
-  const envPath = process.env.CCW_UV_PATH;
-  if (envPath) {
-    searchLocations.push({ path: envPath, description: 'CCW_UV_PATH environment variable' });
-  }
-
-  // 2. Project vendor directory
-  const vendorPaths = [
-    join(process.cwd(), 'vendor', 'uv', UV_BINARY_NAME),
-    join(dirname(process.cwd()), 'vendor', 'uv', UV_BINARY_NAME),
-  ];
-  for (const vendorPath of vendorPaths) {
-    searchLocations.push({ path: vendorPath, description: 'Project vendor directory' });
-  }
-
-  // 3. User local directories
-  const home = homedir();
-  if (IS_WINDOWS) {
-    // Windows: AppData\Local\uv and .cargo\bin
-    searchLocations.push(
-      { path: join(home, 'AppData', 'Local', 'uv', 'bin', UV_BINARY_NAME), description: 'UV AppData' },
-      { path: join(home, '.cargo', 'bin', UV_BINARY_NAME), description: 'Cargo bin' },
-      { path: join(home, '.local', 'bin', UV_BINARY_NAME), description: 'Local bin' },
-    );
-  } else {
-    // Unix: ~/.local/bin and ~/.cargo/bin
-    searchLocations.push(
-      { path: join(home, '.local', 'bin', UV_BINARY_NAME), description: 'Local bin' },
-      { path: join(home, '.cargo', 'bin', UV_BINARY_NAME), description: 'Cargo bin' },
-    );
-  }
-
-  // Check each location
-  for (const location of searchLocations) {
-    if (existsSync(location.path)) {
-      return location.path;
-    }
-  }
-
-  // 4. Try system PATH using 'which' or 'where'
-  const foundPath = findExecutableOnPath('uv');
-  if (foundPath && existsSync(foundPath)) {
-    return foundPath;
-  }
-
-  // Return default path (may not exist)
-  if (IS_WINDOWS) {
-    return join(home, 'AppData', 'Local', 'uv', 'bin', UV_BINARY_NAME);
-  }
-  return join(home, '.local', 'bin', UV_BINARY_NAME);
-}
-
-/**
- * Check if UV is available and working
- * @returns True if UV is installed and functional
- */
-export async function isUvAvailable(): Promise<boolean> {
-  const uvPath = getUvBinaryPath();
-
-  if (!existsSync(uvPath)) {
-    return false;
-  }
-
-  return new Promise((resolve) => {
-    const child = spawn(uvPath, ['--version'], buildUvSpawnOptions({
-      stdio: ['ignore', 'pipe', 'pipe'],
-      timeout: EXEC_TIMEOUTS.PYTHON_VERSION,
-    }));
-
-    child.on('close', (code) => {
-      resolve(code === 0);
-    });
-
-    child.on('error', () => {
-      resolve(false);
-    });
-  });
-}
-
-/**
- * Get UV version string
- * @returns UV version or null if not available
- */
-export async function getUvVersion(): Promise<string | null> {
-  const uvPath = getUvBinaryPath();
-
-  if (!existsSync(uvPath)) {
-    return null;
-  }
-
-  return new Promise((resolve) => {
-    const child = spawn(uvPath, ['--version'], buildUvSpawnOptions({
-      stdio: ['ignore', 'pipe', 'pipe'],
-      timeout: EXEC_TIMEOUTS.PYTHON_VERSION,
-    }));
-
-    let stdout = '';
-
-    child.stdout?.on('data', (data) => {
-      stdout += data.toString();
-    });
-
-    child.on('close', (code) => {
-      if (code === 0) {
-        // Parse "uv 0.4.0" -> "0.4.0"
-        const match = stdout.match(/uv\s+(\S+)/);
-        resolve(match ? match[1] : stdout.trim());
-      } else {
-        resolve(null);
-      }
-    });
-
-    child.on('error', () => {
-      resolve(null);
-    });
-  });
-}
-
-/**
- * Download and install UV using the official installation script
- * @returns True if installation succeeded
- */
-export async function ensureUvInstalled(): Promise<boolean> {
-  // Check if already installed
-  if (await isUvAvailable()) {
-    return true;
-  }
-
-  console.log('[UV] Installing UV package manager...');
-
-  return new Promise((resolve) => {
-    let child: ReturnType<typeof spawn>;
-
-    if (IS_WINDOWS) {
-      // Windows: Use PowerShell to run the install script
-      const installCmd = 'irm https://astral.sh/uv/install.ps1 | iex';
-      child = spawn('powershell', ['-ExecutionPolicy', 'ByPass', '-Command', installCmd], buildUvSpawnOptions({
-        stdio: ['pipe', 'pipe', 'pipe'],
-        timeout: EXEC_TIMEOUTS.PACKAGE_INSTALL,
-      }));
-    } else {
-      // Unix: Use curl and sh
-      const installCmd = 'curl -LsSf https://astral.sh/uv/install.sh | sh';
-      child = spawn('sh', ['-c', installCmd], buildUvSpawnOptions({
-        stdio: ['pipe', 'pipe', 'pipe'],
-        timeout: EXEC_TIMEOUTS.PACKAGE_INSTALL,
-      }));
-    }
-
-    child.stdout?.on('data', (data) => {
-      const line = data.toString().trim();
-      if (line) console.log(`[UV] ${line}`);
-    });
-
-    child.stderr?.on('data', (data) => {
-      const line = data.toString().trim();
-      if (line) console.log(`[UV] ${line}`);
-    });
-
-    child.on('close', (code) => {
-      if (code === 0) {
-        console.log('[UV] UV installed successfully');
-        resolve(true);
-      } else {
-        console.error(`[UV] Installation failed with code ${code}`);
-        resolve(false);
-      }
-    });
-
-    child.on('error', (err) => {
-      console.error(`[UV] Installation failed: ${err.message}`);
-      resolve(false);
-    });
-  });
-}
-
-/**
- * UvManager class for virtual environment and package management
- */
-export class UvManager {
-  private readonly venvPath: string;
-  private readonly pythonVersion?: string;
-
-  /**
-   * Create a new UvManager instance
-   * @param config - Configuration options
-   */
-  constructor(config: UvManagerConfig) {
-    this.venvPath = config.venvPath;
-    this.pythonVersion = config.pythonVersion;
-  }
-
-  /**
-   * Get the path to the Python executable inside the virtual environment
-   * @returns Path to the Python executable
-   */
-  getVenvPython(): string {
-    return join(this.venvPath, VENV_BIN_DIR, PYTHON_EXECUTABLE);
-  }
-
-  /**
-   * Get the path to pip inside the virtual environment
-   * @returns Path to the pip executable
-   */
-  getVenvPip(): string {
-    const pipName = IS_WINDOWS ? 'pip.exe' : 'pip';
-    return join(this.venvPath, VENV_BIN_DIR, pipName);
-  }
-
-  /**
-   * Check if the virtual environment exists and is valid
-   * @returns True if the venv exists and has a working Python
-   */
-  isVenvValid(): boolean {
-    const pythonPath = this.getVenvPython();
-    return existsSync(pythonPath);
-  }
-
-  /**
-   * Create a virtual environment using UV
-   * @returns Installation result
-   */
-  async createVenv(): Promise<UvInstallResult> {
-    const startTime = Date.now();
-
-    // Ensure UV is available
-    if (!(await isUvAvailable())) {
-      const installed = await ensureUvInstalled();
-      if (!installed) {
-        return { success: false, error: 'Failed to install UV' };
-      }
-    }
-
-    const uvPath = getUvBinaryPath();
-
-    // Ensure parent directory exists
-    const parentDir = dirname(this.venvPath);
-    if (!existsSync(parentDir)) {
-      mkdirSync(parentDir, { recursive: true });
-    }
-
-    return new Promise((resolve) => {
-      const args = ['venv', this.venvPath];
-
-      // Add Python version constraint if specified
-      if (this.pythonVersion) {
-        args.push('--python', this.pythonVersion);
-      }
-
-      console.log(`[UV] Creating virtual environment at ${this.venvPath}`);
-      if (this.pythonVersion) {
-        console.log(`[UV] Python version: ${this.pythonVersion}`);
-      }
-
-      const child = spawn(uvPath, args, buildUvSpawnOptions({
-        stdio: ['ignore', 'pipe', 'pipe'],
-        timeout: EXEC_TIMEOUTS.PROCESS_SPAWN,
-      }));
-
-      let stderr = '';
-
-      child.stdout?.on('data', (data) => {
-        const line = data.toString().trim();
-        if (line) {
-          console.log(`[UV] ${line}`);
-        }
-      });
-
-      child.stderr?.on('data', (data) => {
-        stderr += data.toString();
-        const line = data.toString().trim();
-        if (line) {
-          console.log(`[UV] ${line}`);
-        }
-      });
-
-      child.on('close', (code) => {
-        const duration = Date.now() - startTime;
-        if (code === 0) {
-          console.log(`[UV] Virtual environment created successfully (${duration}ms)`);
-          resolve({ success: true, duration });
-        } else {
-          resolve({ success: false, error: stderr || `Process exited with code ${code}`, duration });
-        }
-      });
-
-      child.on('error', (err) => {
-        const duration = Date.now() - startTime;
-        resolve({ success: false, error: `Failed to spawn UV: ${err.message}`, duration });
-      });
-    });
-  }
-
-  /**
-   * Install packages from a local project with optional extras
-   * Uses `uv pip install` for standard installs, or `-e` for editable installs
-   * @param projectPath - Path to the project directory (must contain pyproject.toml or setup.py)
-   * @param extras - Optional array of extras to install (e.g., ['semantic', 'dev'])
-   * @param editable - Whether to install in editable mode (default: false for stability)
-   * @returns Installation result
-   */
-  async installFromProject(projectPath: string, extras?: string[], editable = false): Promise<UvInstallResult> {
-    const startTime = Date.now();
-
-    // Ensure UV is available
-    if (!(await isUvAvailable())) {
-      return { success: false, error: 'UV is not available' };
-    }
-
-    // Ensure venv exists
-    if (!this.isVenvValid()) {
-      return { success: false, error: 'Virtual environment does not exist. Call createVenv() first.' };
-    }
-
-    const uvPath = getUvBinaryPath();
-
-    // Build the install specifier
-    let installSpec = projectPath;
-    if (extras && extras.length > 0) {
-      installSpec = `${projectPath}[${extras.join(',')}]`;
-    }
-
-    return new Promise((resolve) => {
-      const args = editable
-        ? ['pip', 'install', '-e', installSpec, '--python', this.getVenvPython()]
-        : ['pip', 'install', installSpec, '--python', this.getVenvPython()];
-
-      console.log(`[UV] Installing from project: ${installSpec} (editable: ${editable})`);
-
-      const child = spawn(uvPath, args, buildUvSpawnOptions({
-        stdio: ['ignore', 'pipe', 'pipe'],
-        timeout: EXEC_TIMEOUTS.PACKAGE_INSTALL,
-        cwd: projectPath,
-      }));
-
-      let stderr = '';
-
-      child.stdout?.on('data', (data) => {
-        const line = data.toString().trim();
-        if (line) {
-          console.log(`[UV] ${line}`);
-        }
-      });
-
-      child.stderr?.on('data', (data) => {
-        stderr += data.toString();
-        const line = data.toString().trim();
-        if (line && !line.startsWith('Resolved') && !line.startsWith('Prepared') && !line.startsWith('Installed')) {
-          // Only log non-progress lines to stderr
-          console.log(`[UV] ${line}`);
-        }
-      });
-
-      child.on('close', (code) => {
-        const duration = Date.now() - startTime;
-        if (code === 0) {
-          console.log(`[UV] Project installation successful (${duration}ms)`);
-          resolve({ success: true, duration });
-        } else {
-          resolve({ success: false, error: stderr || `Process exited with code ${code}`, duration });
-        }
-      });
-
-      child.on('error', (err) => {
-        const duration = Date.now() - startTime;
-        resolve({ success: false, error: `Failed to spawn UV: ${err.message}`, duration });
-      });
-    });
-  }
-
-  /**
-   * Install a list of packages
-   * @param packages - Array of package specifiers (e.g., ['numpy>=1.24', 'requests'])
-   * @returns Installation result
-   */
-  async install(packages: string[]): Promise<UvInstallResult> {
-    const startTime = Date.now();
-
-    if (packages.length === 0) {
-      return { success: true, duration: 0 };
-    }
-
-    // Ensure UV is available
-    if (!(await isUvAvailable())) {
-      return { success: false, error: 'UV is not available' };
-    }
-
-    // Ensure venv exists
-    if (!this.isVenvValid()) {
-      return { success: false, error: 'Virtual environment does not exist. Call createVenv() first.' };
-    }
-
-    const uvPath = getUvBinaryPath();
-
-    return new Promise((resolve) => {
-      const args = ['pip', 'install', ...packages, '--python', this.getVenvPython()];
-
-      console.log(`[UV] Installing packages: ${packages.join(', ')}`);
-
-      const child = spawn(uvPath, args, buildUvSpawnOptions({
-        stdio: ['ignore', 'pipe', 'pipe'],
-        timeout: EXEC_TIMEOUTS.PACKAGE_INSTALL,
-      }));
-
-      let stderr = '';
-
-      child.stdout?.on('data', (data) => {
-        const line = data.toString().trim();
-        if (line) {
-          console.log(`[UV] ${line}`);
-        }
-      });
-
-      child.stderr?.on('data', (data) => {
-        stderr += data.toString();
-      });
-
-      child.on('close', (code) => {
-        const duration = Date.now() - startTime;
-        if (code === 0) {
-          console.log(`[UV] Package installation successful (${duration}ms)`);
-          resolve({ success: true, duration });
-        } else {
-          resolve({ success: false, error: stderr || `Process exited with code ${code}`, duration });
-        }
-      });
-
-      child.on('error', (err) => {
-        const duration = Date.now() - startTime;
-        resolve({ success: false, error: `Failed to spawn UV: ${err.message}`, duration });
-      });
-    });
-  }
-
-  /**
-   * Uninstall packages
-   * @param packages - Array of package names to uninstall
-   * @returns Uninstall result
-   */
-  async uninstall(packages: string[]): Promise<UvInstallResult> {
-    const startTime = Date.now();
-
-    if (packages.length === 0) {
-      return { success: true, duration: 0 };
-    }
-
-    // Ensure UV is available
-    if (!(await isUvAvailable())) {
-      return { success: false, error: 'UV is not available' };
-    }
-
-    // Ensure venv exists
-    if (!this.isVenvValid()) {
-      return { success: false, error: 'Virtual environment does not exist.' };
-    }
-
-    const uvPath = getUvBinaryPath();
-
-    return new Promise((resolve) => {
-      const args = ['pip', 'uninstall', ...packages, '--python', this.getVenvPython()];
-
-      console.log(`[UV] Uninstalling packages: ${packages.join(', ')}`);
-
-      const child = spawn(uvPath, args, buildUvSpawnOptions({
-        stdio: ['ignore', 'pipe', 'pipe'],
-        timeout: EXEC_TIMEOUTS.PACKAGE_INSTALL,
-      }));
-
-      let stderr = '';
-
-      child.stdout?.on('data', (data) => {
-        const line = data.toString().trim();
-        if (line) {
-          console.log(`[UV] ${line}`);
-        }
-      });
-
-      child.stderr?.on('data', (data) => {
-        stderr += data.toString();
-      });
-
-      child.on('close', (code) => {
-        const duration = Date.now() - startTime;
-        if (code === 0) {
-          console.log(`[UV] Package uninstallation successful (${duration}ms)`);
-          resolve({ success: true, duration });
-        } else {
-          resolve({ success: false, error: stderr || `Process exited with code ${code}`, duration });
-        }
-      });
-
-      child.on('error', (err) => {
-        const duration = Date.now() - startTime;
-        resolve({ success: false, error: `Failed to spawn UV: ${err.message}`, duration });
-      });
-    });
-  }
-
-  /**
-   * Sync dependencies from a requirements file or pyproject.toml
-   * Uses `uv pip sync` for deterministic installs
-   * @param requirementsPath - Path to requirements.txt or pyproject.toml
-   * @returns Sync result
-   */
-  async sync(requirementsPath: string): Promise<UvInstallResult> {
-    const startTime = Date.now();
-
-    // Ensure UV is available
-    if (!(await isUvAvailable())) {
-      return { success: false, error: 'UV is not available' };
-    }
-
-    // Ensure venv exists
-    if (!this.isVenvValid()) {
-      return { success: false, error: 'Virtual environment does not exist. Call createVenv() first.' };
-    }
-
-    const uvPath = getUvBinaryPath();
-
-    return new Promise((resolve) => {
-      const args = ['pip', 'sync', requirementsPath, '--python', this.getVenvPython()];
-
-      console.log(`[UV] Syncing dependencies from: ${requirementsPath}`);
-
-      const child = spawn(uvPath, args, buildUvSpawnOptions({
-        stdio: ['ignore', 'pipe', 'pipe'],
-        timeout: EXEC_TIMEOUTS.PACKAGE_INSTALL,
-      }));
-
-      let stderr = '';
-
-      child.stdout?.on('data', (data) => {
-        const line = data.toString().trim();
-        if (line) {
-          console.log(`[UV] ${line}`);
-        }
-      });
-
-      child.stderr?.on('data', (data) => {
-        stderr += data.toString();
-      });
-
-      child.on('close', (code) => {
-        const duration = Date.now() - startTime;
-        if (code === 0) {
-          console.log(`[UV] Sync successful (${duration}ms)`);
-          resolve({ success: true, duration });
-        } else {
-          resolve({ success: false, error: stderr || `Process exited with code ${code}`, duration });
-        }
-      });
-
-      child.on('error', (err) => {
-        const duration = Date.now() - startTime;
-        resolve({ success: false, error: `Failed to spawn UV: ${err.message}`, duration });
-      });
-    });
-  }
-
-  /**
-   * List installed packages in the virtual environment
-   * @returns List of installed packages or null on error
-   */
-  async list(): Promise<{ name: string; version: string }[] | null> {
-    // Ensure UV is available
-    if (!(await isUvAvailable())) {
-      return null;
-    }
-
-    // Ensure venv exists
-    if (!this.isVenvValid()) {
-      return null;
-    }
-
-    const uvPath = getUvBinaryPath();
-
-    return new Promise((resolve) => {
-      const args = ['pip', 'list', '--format', 'json', '--python', this.getVenvPython()];
-
-      const child = spawn(uvPath, args, buildUvSpawnOptions({
-        stdio: ['ignore', 'pipe', 'pipe'],
-        timeout: EXEC_TIMEOUTS.PROCESS_SPAWN,
-      }));
-
-      let stdout = '';
-
-      child.stdout?.on('data', (data) => {
-        stdout += data.toString();
-      });
-
-      child.on('close', (code) => {
-        if (code === 0) {
-          try {
-            const packages = JSON.parse(stdout);
-            resolve(packages);
-          } catch {
-            resolve(null);
-          }
-        } else {
-          resolve(null);
-        }
-      });
-
-      child.on('error', () => {
-        resolve(null);
-      });
-    });
-  }
-
-  /**
-   * Check if a specific package is installed
-   * @param packageName - Name of the package to check
-   * @returns True if the package is installed
-   */
-  async isPackageInstalled(packageName: string): Promise<boolean> {
-    const packages = await this.list();
-    if (!packages) {
-      return false;
-    }
-
-    const normalizedName = packageName.toLowerCase().replace(/-/g, '_');
-    return packages.some(
-      (pkg) => pkg.name.toLowerCase().replace(/-/g, '_') === normalizedName
-    );
-  }
-
-  /**
-   * Run a Python command in the virtual environment
-   * @param args - Arguments to pass to Python
-   * @param options - Spawn options
-   * @returns Result with stdout/stderr
-   */
-  async runPython(
-    args: string[],
-    options: { timeout?: number; cwd?: string } = {}
-  ): Promise<{ success: boolean; stdout: string; stderr: string }> {
-    const pythonPath = this.getVenvPython();
-
-    if (!existsSync(pythonPath)) {
-      return { success: false, stdout: '', stderr: 'Virtual environment does not exist' };
-    }
-
-    return new Promise((resolve) => {
-      const child = spawn(pythonPath, args, buildUvSpawnOptions({
-        stdio: ['ignore', 'pipe', 'pipe'],
-        timeout: options.timeout ?? EXEC_TIMEOUTS.PROCESS_SPAWN,
-        cwd: options.cwd,
-      }));
-
-      let stdout = '';
-      let stderr = '';
-
-      child.stdout?.on('data', (data) => {
-        stdout += data.toString();
-      });
-
-      child.stderr?.on('data', (data) => {
-        stderr += data.toString();
-      });
-
-      child.on('close', (code) => {
-        resolve({ success: code === 0, stdout: stdout.trim(), stderr: stderr.trim() });
-      });
-
-      child.on('error', (err) => {
-        resolve({ success: false, stdout: '', stderr: err.message });
-      });
-    });
-  }
-
-  /**
-   * Get Python version in the virtual environment
-   * @returns Python version string or null
-   */
-  async getPythonVersion(): Promise<string | null> {
-    const result = await this.runPython(['--version']);
-    if (result.success) {
-      const match = result.stdout.match(/Python\s+(\S+)/);
-      return match ? match[1] : null;
-    }
-    return null;
-  }
-
-  /**
-   * Delete the virtual environment
-   * @returns True if deletion succeeded
-   */
-  async deleteVenv(): Promise<boolean> {
-    if (!existsSync(this.venvPath)) {
-      return true;
-    }
-
-    try {
-      const fs = await import('fs');
-      fs.rmSync(this.venvPath, { recursive: true, force: true });
-      console.log(`[UV] Virtual environment deleted: ${this.venvPath}`);
-      return true;
-    } catch (err) {
-      console.error(`[UV] Failed to delete venv: ${(err as Error).message}`);
-      return false;
-    }
-  }
-}
-
-export function getPreferredCodexLensPythonSpec(): string {
-  const override = process.env.CCW_PYTHON?.trim();
-  if (override) {
-    return override;
-  }
-
-  if (!IS_WINDOWS) {
-    return '>=3.10,<3.13';
-  }
-
-  // Prefer 3.11/3.10 on Windows because current CodexLens semantic GPU extras
-  // depend on onnxruntime 1.15.x wheels, which are not consistently available for cp312.
-  const preferredVersions = ['3.11', '3.10', '3.12'];
-  for (const version of preferredVersions) {
-    if (hasWindowsPythonLauncherVersion(version)) {
-      return version;
-    }
-  }
-
-  return '>=3.10,<3.13';
-}
-
-/**
- * Create a UvManager with default settings for CodexLens
- * @param dataDir - Base data directory (defaults to ~/.codexlens)
- * @returns Configured UvManager instance
- */
-export function createCodexLensUvManager(dataDir?: string): UvManager {
-  const baseDir = dataDir ?? getCodexLensDataDir();
-  void baseDir;
-  return new UvManager({
-    venvPath: getCodexLensVenvDir(),
-    pythonVersion: getPreferredCodexLensPythonSpec(),
-  });
-}
-
-/**
- * Quick bootstrap function: ensure UV is installed and create a venv
- * @param venvPath - Path to the virtual environment
- * @param pythonVersion - Optional Python version constraint
- * @returns Installation result
- */
-export async function bootstrapUvVenv(
-  venvPath: string,
-  pythonVersion?: string
-): Promise<UvInstallResult> {
-  // Ensure UV is installed first
-  const uvInstalled = await ensureUvInstalled();
-  if (!uvInstalled) {
-    return { success: false, error: 'Failed to install UV' };
-  }
-
-  // Create the venv
-  const manager = new UvManager({ venvPath, pythonVersion });
-  return manager.createVenv();
-}
-
-export const __testables = {
-  buildUvSpawnOptions,
-  buildUvSpawnSyncOptions,
-  findExecutableOnPath,
-  hasWindowsPythonLauncherVersion,
-};
diff --git a/ccw/tests/codex-lens-bootstrap-pip-missing.test.js b/ccw/tests/codex-lens-bootstrap-pip-missing.test.js
deleted file mode 100644
index c847698d..00000000
--- a/ccw/tests/codex-lens-bootstrap-pip-missing.test.js
+++ /dev/null
@@ -1,120 +0,0 @@
-/**
- * Regression test: CodexLens bootstrap should recover when UV bootstrap fails
- * and the existing venv is missing pip (common with UV-created venvs).
- *
- * We simulate "UV available but broken" by pointing CCW_UV_PATH to the current Node
- * executable. `node --version` exits 0 so isUvAvailable() returns true, but any
- * `node pip install ...` calls fail, forcing bootstrapVenv() to fall back to pip.
- *
- * Before running bootstrapVenv(), we pre-create the venv and delete its pip entrypoint
- * to mimic a venv that has Python but no pip executable. bootstrapVenv() should
- * re-bootstrap pip (ensurepip) or recreate the venv, then succeed.
- */
-
-import { describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import { spawn } from 'node:child_process';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { fileURLToPath } from 'node:url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// repo root: <repo>/ccw/tests -> <repo>
-const REPO_ROOT = join(__dirname, '..', '..');
-
-function runNodeEvalModule(script, env) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(process.execPath, ['--input-type=module', '-e', script], {
-      cwd: REPO_ROOT,
-      env,
-      stdio: ['ignore', 'pipe', 'pipe'],
-      windowsHide: true,
-    });
-
-    let stdout = '';
-    let stderr = '';
-
-    child.stdout.on('data', (d) => { stdout += d.toString(); });
-    child.stderr.on('data', (d) => { stderr += d.toString(); });
-
-    child.on('error', (err) => reject(err));
-    child.on('close', (code) => resolve({ code, stdout, stderr }));
-  });
-}
-
-describe('CodexLens bootstrap pip repair', () => {
-  it('repairs missing pip in existing venv during pip fallback', { timeout: 10 * 60 * 1000 }, async () => {
-    const dataDir = mkdtempSync(join(tmpdir(), 'codexlens-bootstrap-pip-missing-'));
-
-    try {
-      const script = `
-import { execSync } from 'node:child_process';
-import { existsSync, rmSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-
-import { getSystemPython } from './ccw/dist/utils/python-utils.js';
-import { bootstrapVenv } from './ccw/dist/tools/codex-lens.js';
-
-const dataDir = process.env.CODEXLENS_DATA_DIR;
-if (!dataDir) throw new Error('Missing CODEXLENS_DATA_DIR');
-
-mkdirSync(dataDir, { recursive: true });
-const venvDir = join(dataDir, 'venv');
-
-// Create a venv up-front so UV bootstrap will skip venv creation and fail on install.
-const pythonCmd = getSystemPython();
-execSync(pythonCmd + ' -m venv "' + venvDir + '"', { stdio: 'inherit' });
-
-// Simulate a "pip-less" venv by deleting the pip entrypoint.
-const pipPath = process.platform === 'win32'
-  ? join(venvDir, 'Scripts', 'pip.exe')
-  : join(venvDir, 'bin', 'pip');
-if (existsSync(pipPath)) {
-  rmSync(pipPath, { force: true });
-}
-
-const result = await bootstrapVenv();
-const pipRestored = existsSync(pipPath);
-
-console.log('@@RESULT@@' + JSON.stringify({ result, pipRestored }));
-`.trim();
-
-      const env = {
-        ...process.env,
-        // Isolate test venv + dependencies from user/global CodexLens state.
-        CODEXLENS_DATA_DIR: dataDir,
-        // Make isUvAvailable() return true, but installFromProject() fail.
-        CCW_UV_PATH: process.execPath,
-      };
-
-      const { code, stdout, stderr } = await runNodeEvalModule(script, env);
-      assert.equal(code, 0, `bootstrapVenv child process failed:\nSTDOUT:\n${stdout}\nSTDERR:\n${stderr}`);
-
-      const marker = '@@RESULT@@';
-      const idx = stdout.lastIndexOf(marker);
-      assert.ok(idx !== -1, `Missing result marker in stdout:\n${stdout}`);
-
-      const jsonText = stdout.slice(idx + marker.length).trim();
-      const parsed = JSON.parse(jsonText);
-
-      assert.equal(parsed?.result?.success, true, `Expected success=true, got:\n${jsonText}`);
-      assert.equal(parsed?.pipRestored, true, `Expected pipRestored=true, got:\n${jsonText}`);
-
-      // Best-effort: confirm we exercised the missing-pip repair path.
-      assert.ok(
-        String(stderr).includes('pip not found at:') || String(stdout).includes('pip not found at:'),
-        `Expected missing-pip warning in output. STDERR:\n${stderr}\nSTDOUT:\n${stdout}`
-      );
-    } finally {
-      try {
-        rmSync(dataDir, { recursive: true, force: true });
-      } catch {
-        // Best effort cleanup; leave artifacts only if Windows locks prevent removal.
-      }
-    }
-  });
-});
-
diff --git a/ccw/tests/codex-lens-uv-install.test.ts b/ccw/tests/codex-lens-uv-install.test.ts
deleted file mode 100644
index 6904e4e9..00000000
--- a/ccw/tests/codex-lens-uv-install.test.ts
+++ /dev/null
@@ -1,372 +0,0 @@
-/**
- * Integration tests for CodexLens UV installation functionality.
- *
- * Notes:
- * - Targets the runtime implementation shipped in `ccw/dist`.
- * - Tests real package installation (fastembed, hnswlib, onnxruntime, ccw-litellm, codex-lens).
- * - Verifies Python import success for installed packages.
- * - Tests UV's dependency conflict auto-resolution capability.
- * - Uses temporary directories with cleanup after tests.
- */
-
-import { after, before, describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-const uvManagerUrl = new URL('../dist/utils/uv-manager.js', import.meta.url);
-uvManagerUrl.searchParams.set('t', String(Date.now()));
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let mod: any;
-
-// Test venv path with unique timestamp
-const TEST_VENV_PATH = join(tmpdir(), `codexlens-install-test-${Date.now()}`);
-
-// Track UV availability for conditional tests
-let uvAvailable = false;
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let manager: any;
-
-describe('CodexLens UV Installation Tests', async () => {
-  mod = await import(uvManagerUrl.href);
-
-  before(async () => {
-    uvAvailable = await mod.isUvAvailable();
-    if (!uvAvailable) {
-      console.log('[Test] UV not available, attempting to install...');
-      uvAvailable = await mod.ensureUvInstalled();
-    }
-
-    if (uvAvailable) {
-      manager = new mod.UvManager({
-        venvPath: TEST_VENV_PATH,
-        pythonVersion: '>=3.10,<3.13', // onnxruntime compatibility range
-      });
-      console.log(`[Test] Created UvManager with venv path: ${TEST_VENV_PATH}`);
-    }
-  });
-
-  after(() => {
-    // Clean up test venv
-    if (existsSync(TEST_VENV_PATH)) {
-      console.log(`[Test] Cleaning up test venv: ${TEST_VENV_PATH}`);
-      try {
-        rmSync(TEST_VENV_PATH, { recursive: true, force: true });
-      } catch (err) {
-        console.log(`[Test] Failed to remove venv: ${(err as Error).message}`);
-      }
-    }
-  });
-
-  describe('Virtual Environment Setup', () => {
-    it('should create venv with correct Python version', async () => {
-      if (!uvAvailable) {
-        console.log('[Test] Skipping - UV not available');
-        return;
-      }
-
-      const result = await manager.createVenv();
-      console.log(`[Test] Create venv result:`, result);
-      assert.ok(result.success, `Venv creation failed: ${result.error}`);
-
-      // Verify Python version
-      const version = await manager.getPythonVersion();
-      console.log(`[Test] Python version: ${version}`);
-      const match = version?.match(/3\.(\d+)/);
-      assert.ok(match, 'Should be Python 3.x');
-      const minor = parseInt(match[1]);
-      assert.ok(minor >= 10 && minor < 13, `Python version should be 3.10-3.12, got 3.${minor}`);
-    });
-  });
-
-  describe('Semantic Search Dependencies (fastembed)', () => {
-    it('should install fastembed and hnswlib', async () => {
-      if (!uvAvailable || !manager?.isVenvValid()) {
-        console.log('[Test] Skipping - venv not ready');
-        return;
-      }
-
-      console.log('[Test] Installing fastembed and hnswlib...');
-      const startTime = Date.now();
-
-      const result = await manager.install([
-        'numpy>=1.24',
-        'fastembed>=0.5',
-        'hnswlib>=0.8.0',
-      ]);
-
-      const duration = Date.now() - startTime;
-      console.log(`[Test] Installation result:`, result);
-      console.log(`[Test] Installation took ${duration}ms`);
-
-      assert.ok(result.success, `fastembed installation failed: ${result.error}`);
-    });
-
-    it('should verify fastembed is importable', async () => {
-      if (!uvAvailable || !manager?.isVenvValid()) {
-        console.log('[Test] Skipping - venv not ready');
-        return;
-      }
-
-      const result = await manager.runPython([
-        '-c',
-        'import fastembed; print(f"fastembed version: {fastembed.__version__}")',
-      ]);
-
-      console.log(`[Test] fastembed import:`, result);
-      assert.ok(result.success, `fastembed import failed: ${result.stderr}`);
-      assert.ok(result.stdout.includes('fastembed version'), 'Should print fastembed version');
-    });
-
-    it('should verify hnswlib is importable', async () => {
-      if (!uvAvailable || !manager?.isVenvValid()) {
-        console.log('[Test] Skipping - venv not ready');
-        return;
-      }
-
-      const result = await manager.runPython(['-c', 'import hnswlib; print("hnswlib imported successfully")']);
-
-      console.log(`[Test] hnswlib import:`, result);
-      assert.ok(result.success, `hnswlib import failed: ${result.stderr}`);
-    });
-  });
-
-  describe('ONNX Runtime Installation', () => {
-    it('should install onnxruntime (CPU)', async () => {
-      if (!uvAvailable || !manager?.isVenvValid()) {
-        console.log('[Test] Skipping - venv not ready');
-        return;
-      }
-
-      console.log('[Test] Installing onnxruntime...');
-      const result = await manager.install(['onnxruntime>=1.18.0']);
-
-      console.log(`[Test] onnxruntime installation:`, result);
-      assert.ok(result.success, `onnxruntime installation failed: ${result.error}`);
-    });
-
-    it('should verify onnxruntime providers', async () => {
-      if (!uvAvailable || !manager?.isVenvValid()) {
-        console.log('[Test] Skipping - venv not ready');
-        return;
-      }
-
-      const result = await manager.runPython([
-        '-c',
-        'import onnxruntime; print("Providers:", onnxruntime.get_available_providers())',
-      ]);
-
-      console.log(`[Test] onnxruntime providers:`, result);
-      assert.ok(result.success, `onnxruntime import failed: ${result.stderr}`);
-      assert.ok(result.stdout.includes('CPUExecutionProvider'), 'Should have CPU provider');
-    });
-  });
-
-  describe('ccw-litellm Installation', () => {
-    it('should install ccw-litellm from local path', async () => {
-      if (!uvAvailable || !manager?.isVenvValid()) {
-        console.log('[Test] Skipping - venv not ready');
-        return;
-      }
-
-      // Find local ccw-litellm package
-      const possiblePaths = [join(process.cwd(), 'ccw-litellm'), 'D:\\Claude_dms3\\ccw-litellm'];
-
-      let localPath: string | null = null;
-      for (const p of possiblePaths) {
-        if (existsSync(join(p, 'pyproject.toml'))) {
-          localPath = p;
-          break;
-        }
-      }
-
-      if (!localPath) {
-        console.log('[Test] ccw-litellm local path not found, installing from PyPI...');
-        const result = await manager.install(['ccw-litellm']);
-        console.log(`[Test] PyPI installation:`, result);
-        // PyPI may not have it published, skip
-        return;
-      }
-
-      console.log(`[Test] Installing ccw-litellm from: ${localPath}`);
-      const result = await manager.installFromProject(localPath);
-
-      console.log(`[Test] ccw-litellm installation:`, result);
-      assert.ok(result.success, `ccw-litellm installation failed: ${result.error}`);
-    });
-
-    it('should verify ccw-litellm is importable', async () => {
-      if (!uvAvailable || !manager?.isVenvValid()) {
-        console.log('[Test] Skipping - venv not ready');
-        return;
-      }
-
-      const result = await manager.runPython([
-        '-c',
-        'import ccw_litellm; print(f"ccw-litellm version: {ccw_litellm.__version__}")',
-      ]);
-
-      console.log(`[Test] ccw-litellm import:`, result);
-      // If installation failed (PyPI doesn't have it), skip validation
-      if (!result.success && result.stderr.includes('No module named')) {
-        console.log('[Test] ccw-litellm not installed, skipping import test');
-        return;
-      }
-
-      assert.ok(result.success, `ccw-litellm import failed: ${result.stderr}`);
-    });
-  });
-
-  describe('Full codex-lens Installation', () => {
-    it('should install codex-lens with semantic extras from local path', async () => {
-      if (!uvAvailable || !manager?.isVenvValid()) {
-        console.log('[Test] Skipping - venv not ready');
-        return;
-      }
-
-      // Find local codex-lens package
-      const possiblePaths = [join(process.cwd(), 'codex-lens'), 'D:\\Claude_dms3\\codex-lens'];
-
-      let localPath: string | null = null;
-      for (const p of possiblePaths) {
-        if (existsSync(join(p, 'pyproject.toml'))) {
-          localPath = p;
-          break;
-        }
-      }
-
-      if (!localPath) {
-        console.log('[Test] codex-lens local path not found, skipping');
-        return;
-      }
-
-      console.log(`[Test] Installing codex-lens[semantic] from: ${localPath}`);
-      const startTime = Date.now();
-
-      const result = await manager.installFromProject(localPath, ['semantic']);
-
-      const duration = Date.now() - startTime;
-      console.log(`[Test] codex-lens installation:`, result);
-      console.log(`[Test] Installation took ${duration}ms`);
-
-      assert.ok(result.success, `codex-lens installation failed: ${result.error}`);
-    });
-
-    it('should verify codex-lens CLI is available', async () => {
-      if (!uvAvailable || !manager?.isVenvValid()) {
-        console.log('[Test] Skipping - venv not ready');
-        return;
-      }
-
-      const result = await manager.runPython(['-m', 'codexlens', '--help']);
-
-      console.log(`[Test] codexlens CLI help output length: ${result.stdout.length}`);
-      // CLI may fail due to dependency issues, log but don't force failure
-      if (!result.success) {
-        console.log(`[Test] codexlens CLI failed: ${result.stderr}`);
-      }
-    });
-  });
-
-  describe('Dependency Conflict Resolution', () => {
-    it('should handle onnxruntime version conflicts automatically', async () => {
-      if (!uvAvailable || !manager?.isVenvValid()) {
-        console.log('[Test] Skipping - venv not ready');
-        return;
-      }
-
-      // UV should auto-resolve conflicts between fastembed and onnxruntime
-      // Install onnxruntime first, then fastembed, verify no errors
-      console.log('[Test] Testing conflict resolution...');
-
-      // Check current onnxruntime version
-      const result = await manager.runPython(['-c', 'import onnxruntime; print(f"onnxruntime: {onnxruntime.__version__}")']);
-
-      console.log(`[Test] Current onnxruntime:`, result.stdout.trim());
-
-      // Reinstall fastembed, UV should handle dependencies
-      const installResult = await manager.install(['fastembed>=0.5']);
-      console.log(`[Test] Reinstall fastembed:`, installResult);
-
-      // Check onnxruntime again
-      const result2 = await manager.runPython(['-c', 'import onnxruntime; print(f"onnxruntime: {onnxruntime.__version__}")']);
-
-      console.log(`[Test] After reinstall onnxruntime:`, result2.stdout.trim());
-      assert.ok(result2.success, 'onnxruntime should still be importable after fastembed reinstall');
-    });
-  });
-
-  describe('Package List Verification', () => {
-    it('should list all installed packages', async () => {
-      if (!uvAvailable || !manager?.isVenvValid()) {
-        console.log('[Test] Skipping - venv not ready');
-        return;
-      }
-
-      const packages = await manager.list();
-      console.log(`[Test] Total installed packages: ${packages?.length ?? 0}`);
-
-      if (packages !== null) {
-        assert.ok(Array.isArray(packages), 'list() should return array');
-
-        // Check for expected packages
-        const packageNames = packages.map((p: { name: string }) => p.name.toLowerCase().replace(/-/g, '_'));
-        console.log(`[Test] Package names: ${packageNames.slice(0, 10).join(', ')}...`);
-
-        // Verify core packages are present
-        const hasNumpy = packageNames.includes('numpy');
-        const hasFastembed = packageNames.includes('fastembed');
-        const hasHnswlib = packageNames.includes('hnswlib');
-
-        console.log(`[Test] numpy: ${hasNumpy}, fastembed: ${hasFastembed}, hnswlib: ${hasHnswlib}`);
-        assert.ok(hasNumpy, 'numpy should be installed');
-        assert.ok(hasFastembed, 'fastembed should be installed');
-        assert.ok(hasHnswlib, 'hnswlib should be installed');
-      }
-    });
-
-    it('should check individual package installation status', async () => {
-      if (!uvAvailable || !manager?.isVenvValid()) {
-        console.log('[Test] Skipping - venv not ready');
-        return;
-      }
-
-      const numpyInstalled = await manager.isPackageInstalled('numpy');
-      const fastembedInstalled = await manager.isPackageInstalled('fastembed');
-      const nonexistentInstalled = await manager.isPackageInstalled('this-package-does-not-exist-12345');
-
-      console.log(`[Test] numpy installed: ${numpyInstalled}`);
-      console.log(`[Test] fastembed installed: ${fastembedInstalled}`);
-      console.log(`[Test] nonexistent installed: ${nonexistentInstalled}`);
-
-      assert.ok(numpyInstalled, 'numpy should be installed');
-      assert.ok(fastembedInstalled, 'fastembed should be installed');
-      assert.equal(nonexistentInstalled, false, 'nonexistent package should not be installed');
-    });
-  });
-
-  describe('CodexLens UV Manager Factory', () => {
-    it('should create CodexLens UV manager with default settings', () => {
-      const codexLensManager = mod.createCodexLensUvManager();
-      console.log(`[Test] CodexLens manager created`);
-      assert.ok(codexLensManager !== null, 'createCodexLensUvManager should return manager');
-      assert.ok(codexLensManager.getVenvPython, 'Manager should have getVenvPython method');
-
-      // Verify Python path is in default location
-      const pythonPath = codexLensManager.getVenvPython();
-      console.log(`[Test] Default CodexLens Python path: ${pythonPath}`);
-      assert.ok(pythonPath.includes('.codexlens'), 'Python path should be in .codexlens directory');
-    });
-
-    it('should create CodexLens UV manager with custom data dir', () => {
-      const customDir = join(tmpdir(), 'custom-codexlens-test');
-      const codexLensManager = mod.createCodexLensUvManager(customDir);
-      const pythonPath = codexLensManager.getVenvPython();
-      console.log(`[Test] Custom CodexLens manager Python path: ${pythonPath}`);
-      assert.ok(pythonPath.includes(customDir), 'Python path should use custom dir');
-    });
-  });
-});
diff --git a/ccw/tests/codexlens-path.test.js b/ccw/tests/codexlens-path.test.js
deleted file mode 100644
index 34f6163c..00000000
--- a/ccw/tests/codexlens-path.test.js
+++ /dev/null
@@ -1,66 +0,0 @@
-import { after, afterEach, describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { createRequire, syncBuiltinESMExports } from 'node:module';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-const require = createRequire(import.meta.url);
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const fs = require('node:fs');
-
-const originalExistsSync = fs.existsSync;
-const originalCodexLensDataDir = process.env.CODEXLENS_DATA_DIR;
-const tempDirs = [];
-
-afterEach(() => {
-  fs.existsSync = originalExistsSync;
-  syncBuiltinESMExports();
-
-  if (originalCodexLensDataDir === undefined) {
-    delete process.env.CODEXLENS_DATA_DIR;
-  } else {
-    process.env.CODEXLENS_DATA_DIR = originalCodexLensDataDir;
-  }
-});
-
-after(() => {
-  while (tempDirs.length > 0) {
-    rmSync(tempDirs.pop(), { recursive: true, force: true });
-  }
-});
-
-describe('codexlens-path hidden python selection', () => {
-  it('prefers pythonw.exe for hidden Windows subprocesses when available', async () => {
-    if (process.platform !== 'win32') {
-      return;
-    }
-
-    const dataDir = mkdtempSync(join(tmpdir(), 'ccw-codexlens-hidden-python-'));
-    tempDirs.push(dataDir);
-    process.env.CODEXLENS_DATA_DIR = dataDir;
-
-    const expectedPythonw = join(dataDir, 'venv', 'Scripts', 'pythonw.exe');
-    fs.existsSync = (path) => String(path) === expectedPythonw;
-    syncBuiltinESMExports();
-
-    const moduleUrl = new URL(`../dist/utils/codexlens-path.js?t=${Date.now()}`, import.meta.url);
-    const mod = await import(moduleUrl.href);
-
-    assert.equal(mod.getCodexLensHiddenPython(), expectedPythonw);
-  });
-
-  it('falls back to python.exe when pythonw.exe is unavailable', async () => {
-    const dataDir = mkdtempSync(join(tmpdir(), 'ccw-codexlens-hidden-fallback-'));
-    tempDirs.push(dataDir);
-    process.env.CODEXLENS_DATA_DIR = dataDir;
-
-    fs.existsSync = () => false;
-    syncBuiltinESMExports();
-
-    const moduleUrl = new URL(`../dist/utils/codexlens-path.js?t=${Date.now()}`, import.meta.url);
-    const mod = await import(moduleUrl.href);
-
-    assert.equal(mod.getCodexLensHiddenPython(), mod.getCodexLensPython());
-  });
-});
diff --git a/ccw/tests/uv-manager-codexlens-python.test.js b/ccw/tests/uv-manager-codexlens-python.test.js
deleted file mode 100644
index ad0eae30..00000000
--- a/ccw/tests/uv-manager-codexlens-python.test.js
+++ /dev/null
@@ -1,121 +0,0 @@
-import { afterEach, before, describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import { execSync } from 'node:child_process';
-
-const uvManagerPath = new URL('../dist/utils/uv-manager.js', import.meta.url).href;
-const pythonUtilsPath = new URL('../dist/utils/python-utils.js', import.meta.url).href;
-
-describe('CodexLens UV python preference', async () => {
-  let mod;
-  let pythonUtils;
-  const originalPython = process.env.CCW_PYTHON;
-
-  before(async () => {
-    mod = await import(uvManagerPath);
-    pythonUtils = await import(pythonUtilsPath);
-  });
-
-  afterEach(() => {
-    if (originalPython === undefined) {
-      delete process.env.CCW_PYTHON;
-      return;
-    }
-    process.env.CCW_PYTHON = originalPython;
-  });
-
-  it('honors CCW_PYTHON override', () => {
-    process.env.CCW_PYTHON = 'C:/Custom/Python/python.exe';
-    assert.equal(mod.getPreferredCodexLensPythonSpec(), 'C:/Custom/Python/python.exe');
-  });
-
-  it('parses py launcher commands into spawn-safe command specs', () => {
-    const spec = pythonUtils.parsePythonCommandSpec('py -3.11');
-
-    assert.equal(spec.command, 'py');
-    assert.deepEqual(spec.args, ['-3.11']);
-    assert.equal(spec.display, 'py -3.11');
-  });
-
-  it('treats unquoted Windows-style executable paths as a single command', () => {
-    const spec = pythonUtils.parsePythonCommandSpec('C:/Program Files/Python311/python.exe');
-
-    assert.equal(spec.command, 'C:/Program Files/Python311/python.exe');
-    assert.deepEqual(spec.args, []);
-    assert.equal(spec.display, '"C:/Program Files/Python311/python.exe"');
-  });
-
-  it('probes Python launcher versions without opening a shell window', () => {
-    const probeCalls = [];
-    const version = pythonUtils.probePythonCommandVersion(
-      { command: 'py', args: ['-3.11'], display: 'py -3.11' },
-      (command, args, options) => {
-        probeCalls.push({ command, args, options });
-        return { status: 0, stdout: '', stderr: 'Python 3.11.9\n' };
-      },
-    );
-
-    assert.equal(version, 'Python 3.11.9');
-    assert.equal(probeCalls.length, 1);
-    assert.equal(probeCalls[0].command, 'py');
-    assert.deepEqual(probeCalls[0].args, ['-3.11', '--version']);
-    assert.equal(probeCalls[0].options.shell, false);
-    assert.equal(probeCalls[0].options.windowsHide, true);
-    assert.equal(probeCalls[0].options.env.PYTHONIOENCODING, 'utf-8');
-  });
-
-  it('looks up uv on PATH without spawning a visible shell window', () => {
-    const lookupCalls = [];
-    const found = mod.__testables.findExecutableOnPath('uv', (command, args, options) => {
-      lookupCalls.push({ command, args, options });
-      return { status: 0, stdout: 'C:/Tools/uv.exe\n', stderr: '' };
-    });
-
-    assert.equal(found, 'C:/Tools/uv.exe');
-    assert.equal(lookupCalls.length, 1);
-    assert.equal(lookupCalls[0].command, process.platform === 'win32' ? 'where' : 'which');
-    assert.deepEqual(lookupCalls[0].args, ['uv']);
-    assert.equal(lookupCalls[0].options.shell, false);
-    assert.equal(lookupCalls[0].options.windowsHide, true);
-    assert.equal(lookupCalls[0].options.env.PYTHONIOENCODING, 'utf-8');
-  });
-
-  it('checks Windows launcher preferences with hidden subprocess options', () => {
-    const probeCalls = [];
-    const available = mod.__testables.hasWindowsPythonLauncherVersion('3.11', (command, args, options) => {
-      probeCalls.push({ command, args, options });
-      return { status: 0, stdout: '', stderr: 'Python 3.11.9\n' };
-    });
-
-    assert.equal(available, true);
-    assert.equal(probeCalls.length, 1);
-    assert.equal(probeCalls[0].command, 'py');
-    assert.deepEqual(probeCalls[0].args, ['-3.11', '--version']);
-    assert.equal(probeCalls[0].options.shell, false);
-    assert.equal(probeCalls[0].options.windowsHide, true);
-    assert.equal(probeCalls[0].options.env.PYTHONIOENCODING, 'utf-8');
-  });
-
-  it('prefers Python 3.11 or 3.10 on Windows when available', () => {
-    if (process.platform !== 'win32') return;
-    delete process.env.CCW_PYTHON;
-
-    let installed = '';
-    try {
-      installed = execSync('py -0p', { encoding: 'utf-8' });
-    } catch {
-      return;
-    }
-
-    const has311 = installed.includes('-V:3.11');
-    const has310 = installed.includes('-V:3.10');
-    if (!has311 && !has310) {
-      return;
-    }
-
-    const preferred = mod.getPreferredCodexLensPythonSpec();
-    assert.ok(
-      preferred === '3.11' || preferred === '3.10',
-      `expected Windows preference to avoid 3.12 when 3.11/3.10 exists, got ${preferred}`,
-    );
-  });
-});
diff --git a/ccw/tests/uv-manager.test.ts b/ccw/tests/uv-manager.test.ts
deleted file mode 100644
index 522e911d..00000000
--- a/ccw/tests/uv-manager.test.ts
+++ /dev/null
@@ -1,414 +0,0 @@
-/**
- * Unit tests for uv-manager utility module.
- *
- * Notes:
- * - Targets the runtime implementation shipped in `ccw/dist`.
- * - Tests UV binary detection, installation, and virtual environment management.
- * - Gracefully handles cases where UV is not installed.
- */
-
-import { after, before, describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-const uvManagerUrl = new URL('../dist/utils/uv-manager.js', import.meta.url);
-uvManagerUrl.searchParams.set('t', String(Date.now()));
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let mod: any;
-
-// Test venv path with unique timestamp
-const TEST_VENV_PATH = join(tmpdir(), `uv-test-venv-${Date.now()}`);
-
-// Track UV availability for conditional tests
-let uvAvailable = false;
-
-describe('UV Manager Tests', async () => {
-  mod = await import(uvManagerUrl.href);
-
-  // Cleanup after all tests
-  after(() => {
-    if (existsSync(TEST_VENV_PATH)) {
-      console.log(`[Cleanup] Removing test venv: ${TEST_VENV_PATH}`);
-      try {
-        rmSync(TEST_VENV_PATH, { recursive: true, force: true });
-      } catch (err) {
-        console.log(`[Cleanup] Failed to remove venv: ${(err as Error).message}`);
-      }
-    }
-  });
-
-  describe('UV Binary Detection', () => {
-    it('should check UV availability', async () => {
-      uvAvailable = await mod.isUvAvailable();
-      console.log(`[Test] UV available: ${uvAvailable}`);
-      assert.equal(typeof uvAvailable, 'boolean', 'isUvAvailable should return boolean');
-    });
-
-    it('should get UV version when available', async () => {
-      if (uvAvailable) {
-        const version = await mod.getUvVersion();
-        console.log(`[Test] UV version: ${version}`);
-        assert.ok(version !== null, 'getUvVersion should return version string');
-        assert.ok(version.length > 0, 'Version string should not be empty');
-      } else {
-        console.log('[Test] UV not installed, skipping version test');
-        const version = await mod.getUvVersion();
-        assert.equal(version, null, 'getUvVersion should return null when UV not available');
-      }
-    });
-
-    it('should get UV binary path', async () => {
-      const path = mod.getUvBinaryPath();
-      console.log(`[Test] UV path: ${path}`);
-      assert.equal(typeof path, 'string', 'getUvBinaryPath should return string');
-      assert.ok(path.length > 0, 'Path should not be empty');
-
-      if (uvAvailable) {
-        assert.ok(existsSync(path), 'UV binary should exist when UV is available');
-      }
-    });
-  });
-
-  describe('UV Installation', () => {
-    it('should ensure UV is installed', async () => {
-      const installed = await mod.ensureUvInstalled();
-      console.log(`[Test] UV ensured: ${installed}`);
-      assert.equal(typeof installed, 'boolean', 'ensureUvInstalled should return boolean');
-
-      // Update availability after potential installation
-      if (installed) {
-        uvAvailable = await mod.isUvAvailable();
-        assert.ok(uvAvailable, 'UV should be available after ensureUvInstalled returns true');
-      }
-    });
-  });
-
-  describe('UvManager Class', () => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let manager: any;
-
-    before(async () => {
-      // Ensure UV is available for class tests
-      if (!uvAvailable) {
-        console.log('[Test] UV not available, attempting installation...');
-        await mod.ensureUvInstalled();
-        uvAvailable = await mod.isUvAvailable();
-      }
-
-      manager = new mod.UvManager({
-        venvPath: TEST_VENV_PATH,
-        pythonVersion: '>=3.10',
-      });
-      console.log(`[Test] Created UvManager with venv path: ${TEST_VENV_PATH}`);
-    });
-
-    it('should get venv Python path', () => {
-      const pythonPath = manager.getVenvPython();
-      console.log(`[Test] Venv Python path: ${pythonPath}`);
-      assert.equal(typeof pythonPath, 'string', 'getVenvPython should return string');
-      assert.ok(pythonPath.includes(TEST_VENV_PATH), 'Python path should be inside venv');
-    });
-
-    it('should get venv pip path', () => {
-      const pipPath = manager.getVenvPip();
-      console.log(`[Test] Venv pip path: ${pipPath}`);
-      assert.equal(typeof pipPath, 'string', 'getVenvPip should return string');
-      assert.ok(pipPath.includes(TEST_VENV_PATH), 'Pip path should be inside venv');
-    });
-
-    it('should report venv as invalid before creation', () => {
-      const valid = manager.isVenvValid();
-      console.log(`[Test] Venv valid (before create): ${valid}`);
-      assert.equal(valid, false, 'Venv should not be valid before creation');
-    });
-
-    it('should create virtual environment', async () => {
-      if (!uvAvailable) {
-        console.log('[Test] Skipping venv creation - UV not available');
-        return;
-      }
-
-      const result = await manager.createVenv();
-      console.log(`[Test] Create venv result:`, result);
-
-      if (result.success) {
-        assert.ok(existsSync(TEST_VENV_PATH), 'Venv directory should exist');
-        assert.ok(result.duration !== undefined, 'Duration should be reported');
-        console.log(`[Test] Venv created in ${result.duration}ms`);
-      } else {
-        // May fail if Python is not installed
-        console.log(`[Test] Venv creation failed: ${result.error}`);
-        assert.equal(typeof result.error, 'string', 'Error should be a string');
-      }
-    });
-
-    it('should check if venv is valid after creation', () => {
-      const valid = manager.isVenvValid();
-      console.log(`[Test] Venv valid (after create): ${valid}`);
-      assert.equal(typeof valid, 'boolean', 'isVenvValid should return boolean');
-    });
-
-    it('should get Python version in venv', async () => {
-      if (!manager.isVenvValid()) {
-        console.log('[Test] Skipping Python version check - venv not valid');
-        return;
-      }
-
-      const version = await manager.getPythonVersion();
-      console.log(`[Test] Python version: ${version}`);
-      assert.ok(version !== null, 'getPythonVersion should return version');
-      assert.ok(version.startsWith('3.'), 'Should be Python 3.x');
-    });
-
-    it('should list installed packages', async () => {
-      if (!manager.isVenvValid()) {
-        console.log('[Test] Skipping package list - venv not valid');
-        return;
-      }
-
-      const packages = await manager.list();
-      console.log(`[Test] Installed packages count: ${packages?.length ?? 0}`);
-
-      if (packages !== null) {
-        assert.ok(Array.isArray(packages), 'list() should return array');
-        // UV creates minimal venvs without pip by default
-        console.log(`[Test] Packages in venv: ${packages.map((p: { name: string }) => p.name).join(', ') || '(empty)'}`);
-      }
-    });
-
-    it('should check if package is installed', async () => {
-      if (!manager.isVenvValid()) {
-        console.log('[Test] Skipping package check - venv not valid');
-        return;
-      }
-
-      // First install a package, then check if it's installed
-      const installResult = await manager.install(['six']);
-      if (installResult.success) {
-        const installed = await manager.isPackageInstalled('six');
-        console.log(`[Test] six installed: ${installed}`);
-        assert.ok(installed, 'six should be installed after install');
-
-        // Clean up
-        await manager.uninstall(['six']);
-      } else {
-        console.log('[Test] Could not install test package, skipping check');
-      }
-    });
-
-    it('should install a simple package', async () => {
-      if (!manager.isVenvValid()) {
-        console.log('[Test] Skipping package install - venv not valid');
-        return;
-      }
-
-      // Install a small, fast-installing package
-      const result = await manager.install(['pip-install-test']);
-      console.log(`[Test] Install result:`, result);
-      assert.equal(typeof result.success, 'boolean', 'success should be boolean');
-
-      if (result.success) {
-        console.log(`[Test] Package installed in ${result.duration}ms`);
-      } else {
-        console.log(`[Test] Package install failed: ${result.error}`);
-      }
-    });
-
-    it('should uninstall a package', async () => {
-      if (!manager.isVenvValid()) {
-        console.log('[Test] Skipping uninstall - venv not valid');
-        return;
-      }
-
-      const result = await manager.uninstall(['pip-install-test']);
-      console.log(`[Test] Uninstall result:`, result);
-      assert.equal(typeof result.success, 'boolean', 'success should be boolean');
-
-      if (result.success) {
-        console.log(`[Test] Package uninstalled in ${result.duration}ms`);
-      } else {
-        console.log(`[Test] Package uninstall failed: ${result.error}`);
-      }
-    });
-
-    it('should handle empty package list for install', async () => {
-      const result = await manager.install([]);
-      console.log(`[Test] Empty install result:`, result);
-      assert.ok(result.success, 'Empty install should succeed');
-      assert.equal(result.duration, 0, 'Empty install should have 0 duration');
-    });
-
-    it('should handle empty package list for uninstall', async () => {
-      const result = await manager.uninstall([]);
-      console.log(`[Test] Empty uninstall result:`, result);
-      assert.ok(result.success, 'Empty uninstall should succeed');
-      assert.equal(result.duration, 0, 'Empty uninstall should have 0 duration');
-    });
-
-    it('should run Python command in venv', async () => {
-      if (!manager.isVenvValid()) {
-        console.log('[Test] Skipping Python command - venv not valid');
-        return;
-      }
-
-      const result = await manager.runPython(['-c', 'print("hello from venv")']);
-      console.log(`[Test] Run Python result:`, result);
-
-      if (result.success) {
-        assert.ok(result.stdout.includes('hello from venv'), 'Output should contain expected text');
-      } else {
-        console.log(`[Test] Python command failed: ${result.stderr}`);
-      }
-    });
-
-    it('should delete virtual environment', async () => {
-      if (!manager.isVenvValid()) {
-        console.log('[Test] Skipping delete - venv not valid');
-        return;
-      }
-
-      const result = await manager.deleteVenv();
-      console.log(`[Test] Delete venv result: ${result}`);
-
-      if (result) {
-        assert.ok(!existsSync(TEST_VENV_PATH), 'Venv directory should be deleted');
-      }
-    });
-
-    it('should handle deleteVenv when venv does not exist', async () => {
-      const result = await manager.deleteVenv();
-      console.log(`[Test] Delete non-existent venv result: ${result}`);
-      assert.ok(result, 'Deleting non-existent venv should succeed');
-    });
-  });
-
-  describe('Helper Functions', () => {
-    it('should create CodexLens UV manager with defaults', () => {
-      const codexLensManager = mod.createCodexLensUvManager();
-      console.log(`[Test] CodexLens manager created`);
-      assert.ok(codexLensManager !== null, 'createCodexLensUvManager should return manager');
-      assert.ok(codexLensManager.getVenvPython, 'Manager should have getVenvPython method');
-    });
-
-    it('should create CodexLens UV manager with custom data dir', () => {
-      const customDir = join(tmpdir(), 'custom-codexlens');
-      const codexLensManager = mod.createCodexLensUvManager(customDir);
-      const pythonPath = codexLensManager.getVenvPython();
-      console.log(`[Test] Custom CodexLens manager Python path: ${pythonPath}`);
-      assert.ok(pythonPath.includes(customDir), 'Python path should use custom dir');
-    });
-
-    it('should bootstrap UV venv', async () => {
-      if (!uvAvailable) {
-        console.log('[Test] Skipping bootstrap - UV not available');
-        return;
-      }
-
-      const bootstrapPath = join(tmpdir(), `uv-bootstrap-test-${Date.now()}`);
-      console.log(`[Test] Bootstrap venv path: ${bootstrapPath}`);
-
-      try {
-        const result = await mod.bootstrapUvVenv(bootstrapPath, '>=3.10');
-        console.log(`[Test] Bootstrap result:`, result);
-        assert.equal(typeof result.success, 'boolean', 'success should be boolean');
-
-        if (result.success) {
-          assert.ok(existsSync(bootstrapPath), 'Bootstrap venv should exist');
-        }
-      } finally {
-        // Cleanup bootstrap venv
-        if (existsSync(bootstrapPath)) {
-          rmSync(bootstrapPath, { recursive: true, force: true });
-        }
-      }
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should handle install when UV not available gracefully', async () => {
-      // Create manager pointing to non-existent venv
-      const badManager = new mod.UvManager({
-        venvPath: join(tmpdir(), 'non-existent-venv'),
-        pythonVersion: '>=3.10',
-      });
-
-      const result = await badManager.install(['some-package']);
-      console.log(`[Test] Install with invalid venv:`, result);
-      assert.equal(result.success, false, 'Install should fail with invalid venv');
-      assert.ok(result.error, 'Error message should be present');
-    });
-
-    it('should handle uninstall when venv not valid', async () => {
-      const badManager = new mod.UvManager({
-        venvPath: join(tmpdir(), 'non-existent-venv'),
-        pythonVersion: '>=3.10',
-      });
-
-      const result = await badManager.uninstall(['some-package']);
-      console.log(`[Test] Uninstall with invalid venv:`, result);
-      assert.equal(result.success, false, 'Uninstall should fail with invalid venv');
-      assert.ok(result.error, 'Error message should be present');
-    });
-
-    it('should handle list when venv not valid', async () => {
-      const badManager = new mod.UvManager({
-        venvPath: join(tmpdir(), 'non-existent-venv'),
-        pythonVersion: '>=3.10',
-      });
-
-      const packages = await badManager.list();
-      console.log(`[Test] List with invalid venv: ${packages}`);
-      assert.equal(packages, null, 'list() should return null for invalid venv');
-    });
-
-    it('should handle isPackageInstalled when venv not valid', async () => {
-      const badManager = new mod.UvManager({
-        venvPath: join(tmpdir(), 'non-existent-venv'),
-        pythonVersion: '>=3.10',
-      });
-
-      const installed = await badManager.isPackageInstalled('pip');
-      console.log(`[Test] isPackageInstalled with invalid venv: ${installed}`);
-      assert.equal(installed, false, 'isPackageInstalled should return false for invalid venv');
-    });
-
-    it('should handle runPython when venv not valid', async () => {
-      const badManager = new mod.UvManager({
-        venvPath: join(tmpdir(), 'non-existent-venv'),
-        pythonVersion: '>=3.10',
-      });
-
-      const result = await badManager.runPython(['--version']);
-      console.log(`[Test] runPython with invalid venv:`, result);
-      assert.equal(result.success, false, 'runPython should fail for invalid venv');
-      assert.ok(result.stderr.length > 0, 'Error message should be present');
-    });
-
-    it('should handle sync when venv not valid', async () => {
-      const badManager = new mod.UvManager({
-        venvPath: join(tmpdir(), 'non-existent-venv'),
-        pythonVersion: '>=3.10',
-      });
-
-      const result = await badManager.sync('requirements.txt');
-      console.log(`[Test] sync with invalid venv:`, result);
-      assert.equal(result.success, false, 'sync should fail for invalid venv');
-      assert.ok(result.error, 'Error message should be present');
-    });
-
-    it('should handle installFromProject when venv not valid', async () => {
-      const badManager = new mod.UvManager({
-        venvPath: join(tmpdir(), 'non-existent-venv'),
-        pythonVersion: '>=3.10',
-      });
-
-      const result = await badManager.installFromProject('/some/project');
-      console.log(`[Test] installFromProject with invalid venv:`, result);
-      assert.equal(result.success, false, 'installFromProject should fail for invalid venv');
-      assert.ok(result.error, 'Error message should be present');
-    });
-  });
-});
diff --git a/codex-lens-v2/.gitignore b/codex-lens-v2/.gitignore
index b4a7d405..7cd674bd 100644
--- a/codex-lens-v2/.gitignore
+++ b/codex-lens-v2/.gitignore
@@ -1 +1,33 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Index / cache
+.codexlens/
+.index_cache/
 .ace-tool/
+
+# Workflow (internal)
+.workflow/
+
+# OS
+.DS_Store
+Thumbs.db
diff --git a/codex-lens-v2/README.md b/codex-lens-v2/README.md
index 06b23c75..1a3cf2b3 100644
--- a/codex-lens-v2/README.md
+++ b/codex-lens-v2/README.md
@@ -1,143 +1,221 @@
 # codexlens-search
 
-Lightweight semantic code search engine with 2-stage vector search, full-text search, and Reciprocal Rank Fusion.
+Semantic code search engine with MCP server for Claude Code.
 
-## Overview
+2-stage vector search + FTS + RRF fusion + reranking — install once, configure API keys, ready to use.
 
-codexlens-search provides fast, accurate code search through a multi-stage retrieval pipeline:
+## Quick Start (Claude Code MCP)
 
-1. **Binary coarse search** - Hamming-distance filtering narrows candidates quickly
-2. **ANN fine search** - HNSW or FAISS refines the candidate set with float vectors
-3. **Full-text search** - SQLite FTS5 handles exact and fuzzy keyword matching
-4. **RRF fusion** - Reciprocal Rank Fusion merges vector and text results
-5. **Reranking** - Optional cross-encoder or API-based reranker for final ordering
+Add to your project `.mcp.json`:
 
-The core library has **zero required dependencies**. Install optional extras to enable semantic search, GPU acceleration, or FAISS backends.
+```json
+{
+  "mcpServers": {
+    "codexlens": {
+      "command": "uvx",
+      "args": ["--from", "codexlens-search[mcp]", "codexlens-mcp"],
+      "env": {
+        "CODEXLENS_EMBED_API_URL": "https://api.openai.com/v1",
+        "CODEXLENS_EMBED_API_KEY": "${OPENAI_API_KEY}",
+        "CODEXLENS_EMBED_API_MODEL": "text-embedding-3-small",
+        "CODEXLENS_EMBED_DIM": "1536"
+      }
+    }
+  }
+}
+```
 
-## Installation
+That's it. Claude Code will auto-discover the tools: `index_project` → `search_code`.
+
+## Install
 
 ```bash
-# Core only (FTS search, no vector search)
+# Standard install (includes vector search + API clients)
 pip install codexlens-search
 
-# With semantic search (recommended)
-pip install codexlens-search[semantic]
-
-# Semantic search + GPU acceleration
-pip install codexlens-search[semantic-gpu]
-
-# With FAISS backend (CPU)
-pip install codexlens-search[faiss-cpu]
-
-# With API-based reranker
-pip install codexlens-search[reranker-api]
-
-# Everything (semantic + GPU + FAISS + reranker)
-pip install codexlens-search[semantic-gpu,faiss-gpu,reranker-api]
+# With MCP server for Claude Code
+pip install codexlens-search[mcp]
 ```
 
-## Quick Start
+Optional extras for advanced use:
 
-```python
-from codexlens_search import Config, IndexingPipeline, SearchPipeline
-from codexlens_search.core import create_ann_index, create_binary_index
-from codexlens_search.embed.local import FastEmbedEmbedder
-from codexlens_search.rerank.local import LocalReranker
-from codexlens_search.search.fts import FTSEngine
+| Extra | Description |
+|-------|-------------|
+| `mcp` | MCP server (`codexlens-mcp` command) |
+| `gpu` | GPU-accelerated embedding (onnxruntime-gpu) |
+| `faiss-cpu` | FAISS ANN backend |
+| `watcher` | File watcher for auto-indexing |
 
-# 1. Configure
-config = Config(embed_model="BAAI/bge-small-en-v1.5", embed_dim=384)
+## MCP Tools
 
-# 2. Create components
-embedder = FastEmbedEmbedder(config)
-binary_store = create_binary_index(config, db_path="index/binary.db")
-ann_index = create_ann_index(config, index_path="index/ann.bin")
-fts = FTSEngine("index/fts.db")
-reranker = LocalReranker()
+| Tool | Description |
+|------|-------------|
+| `search_code` | Semantic search with hybrid fusion + reranking |
+| `index_project` | Build or rebuild the search index |
+| `index_status` | Show index statistics |
+| `index_update` | Incremental sync (only changed files) |
+| `find_files` | Glob file discovery |
+| `list_models` | List models with cache status |
+| `download_models` | Download local fastembed models |
 
-# 3. Index files
-indexer = IndexingPipeline(embedder, binary_store, ann_index, fts, config)
-stats = indexer.index_directory("./src")
-print(f"Indexed {stats.files_processed} files, {stats.chunks_created} chunks")
+## MCP Configuration Examples
 
-# 4. Search
-pipeline = SearchPipeline(embedder, binary_store, ann_index, reranker, fts, config)
-results = pipeline.search("authentication handler", top_k=10)
-for r in results:
-    print(f"  {r.path} (score={r.score:.3f})")
+### API Embedding Only (simplest)
+
+```json
+{
+  "mcpServers": {
+    "codexlens": {
+      "command": "uvx",
+      "args": ["--from", "codexlens-search[mcp]", "codexlens-mcp"],
+      "env": {
+        "CODEXLENS_EMBED_API_URL": "https://api.openai.com/v1",
+        "CODEXLENS_EMBED_API_KEY": "${OPENAI_API_KEY}",
+        "CODEXLENS_EMBED_API_MODEL": "text-embedding-3-small",
+        "CODEXLENS_EMBED_DIM": "1536"
+      }
+    }
+  }
+}
 ```
 
-## Extras
+### API Embedding + API Reranker (best quality)
 
-| Extra | Dependencies | Description |
-|-------|-------------|-------------|
-| `semantic` | hnswlib, numpy, fastembed | Vector search with local embeddings |
-| `gpu` | onnxruntime-gpu | GPU-accelerated embedding inference |
-| `semantic-gpu` | semantic + gpu combined | Vector search with GPU acceleration |
-| `faiss-cpu` | faiss-cpu | FAISS ANN backend (CPU) |
-| `faiss-gpu` | faiss-gpu | FAISS ANN backend (GPU) |
-| `reranker-api` | httpx | Remote reranker API client |
-| `dev` | pytest, pytest-cov | Development and testing |
+```json
+{
+  "mcpServers": {
+    "codexlens": {
+      "command": "uvx",
+      "args": ["--from", "codexlens-search[mcp]", "codexlens-mcp"],
+      "env": {
+        "CODEXLENS_EMBED_API_URL": "https://api.openai.com/v1",
+        "CODEXLENS_EMBED_API_KEY": "${OPENAI_API_KEY}",
+        "CODEXLENS_EMBED_API_MODEL": "text-embedding-3-small",
+        "CODEXLENS_EMBED_DIM": "1536",
+        "CODEXLENS_RERANKER_API_URL": "https://api.jina.ai/v1",
+        "CODEXLENS_RERANKER_API_KEY": "${JINA_API_KEY}",
+        "CODEXLENS_RERANKER_API_MODEL": "jina-reranker-v2-base-multilingual"
+      }
+    }
+  }
+}
+```
+
+### Multi-Endpoint Load Balancing
+
+```json
+{
+  "mcpServers": {
+    "codexlens": {
+      "command": "uvx",
+      "args": ["--from", "codexlens-search[mcp]", "codexlens-mcp"],
+      "env": {
+        "CODEXLENS_EMBED_API_ENDPOINTS": "https://api1.example.com/v1|sk-key1|model,https://api2.example.com/v1|sk-key2|model",
+        "CODEXLENS_EMBED_DIM": "1536"
+      }
+    }
+  }
+}
+```
+
+Format: `url|key|model,url|key|model,...`
+
+### Local Models (Offline, No API)
+
+```bash
+pip install codexlens-search[mcp]
+codexlens-search download-models
+```
+
+```json
+{
+  "mcpServers": {
+    "codexlens": {
+      "command": "codexlens-mcp",
+      "env": {}
+    }
+  }
+}
+```
+
+### Pre-installed (no uvx)
+
+```json
+{
+  "mcpServers": {
+    "codexlens": {
+      "command": "codexlens-mcp",
+      "env": {
+        "CODEXLENS_EMBED_API_URL": "https://api.openai.com/v1",
+        "CODEXLENS_EMBED_API_KEY": "${OPENAI_API_KEY}",
+        "CODEXLENS_EMBED_API_MODEL": "text-embedding-3-small",
+        "CODEXLENS_EMBED_DIM": "1536"
+      }
+    }
+  }
+}
+```
+
+## CLI
+
+```bash
+codexlens-search --db-path .codexlens sync --root ./src
+codexlens-search --db-path .codexlens search -q "auth handler" -k 10
+codexlens-search --db-path .codexlens status
+codexlens-search list-models
+codexlens-search download-models
+```
+
+## Environment Variables
+
+### Embedding
+
+| Variable | Description | Example |
+|----------|-------------|---------|
+| `CODEXLENS_EMBED_API_URL` | Embedding API base URL | `https://api.openai.com/v1` |
+| `CODEXLENS_EMBED_API_KEY` | API key | `sk-xxx` |
+| `CODEXLENS_EMBED_API_MODEL` | Model name | `text-embedding-3-small` |
+| `CODEXLENS_EMBED_API_ENDPOINTS` | Multi-endpoint: `url\|key\|model,...` | See above |
+| `CODEXLENS_EMBED_DIM` | Vector dimension | `1536` |
+
+### Reranker
+
+| Variable | Description | Example |
+|----------|-------------|---------|
+| `CODEXLENS_RERANKER_API_URL` | Reranker API base URL | `https://api.jina.ai/v1` |
+| `CODEXLENS_RERANKER_API_KEY` | API key | `jina-xxx` |
+| `CODEXLENS_RERANKER_API_MODEL` | Model name | `jina-reranker-v2-base-multilingual` |
+
+### Tuning
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `CODEXLENS_BINARY_TOP_K` | `200` | Binary coarse search candidates |
+| `CODEXLENS_ANN_TOP_K` | `50` | ANN fine search candidates |
+| `CODEXLENS_FTS_TOP_K` | `50` | FTS results per method |
+| `CODEXLENS_FUSION_K` | `60` | RRF fusion k parameter |
+| `CODEXLENS_RERANKER_TOP_K` | `20` | Results to rerank |
+| `CODEXLENS_INDEX_WORKERS` | `2` | Parallel indexing workers |
+| `CODEXLENS_MAX_FILE_SIZE` | `1000000` | Max file size in bytes |
 
 ## Architecture
 
 ```
-Query
-  |
-  v
-[Embedder] --> query vector
-  |
-  +---> [BinaryStore.coarse_search] --> candidate IDs (Hamming distance)
-  |         |
-  |         v
-  +---> [ANNIndex.fine_search] ------> ranked IDs (cosine/L2)
-  |         |
-  |         v  (intersect)
-  |     vector_results
-  |
-  +---> [FTSEngine.exact_search] ----> exact text matches
-  +---> [FTSEngine.fuzzy_search] ----> fuzzy text matches
-  |
-  v
-[RRF Fusion] --> merged ranking (adaptive weights by query intent)
-  |
-  v
-[Reranker] --> final top-k results
-```
-
-### Key Design Decisions
-
-- **2-stage vector search**: Binary coarse search (fast Hamming distance on binarized vectors) filters candidates before the more expensive ANN search. This keeps memory usage low and search fast even on large corpora.
-- **Parallel retrieval**: Vector search and FTS run concurrently via ThreadPoolExecutor.
-- **Adaptive fusion weights**: Query intent detection adjusts RRF weights between vector and text signals.
-- **Backend abstraction**: ANN index supports both hnswlib and FAISS backends via a factory function.
-- **Zero core dependencies**: The base package requires only Python 3.10+. All heavy dependencies are optional.
-
-## Configuration
-
-The `Config` dataclass controls all pipeline parameters:
-
-```python
-from codexlens_search import Config
-
-config = Config(
-    embed_model="BAAI/bge-small-en-v1.5",  # embedding model name
-    embed_dim=384,                           # embedding dimension
-    embed_batch_size=64,                     # batch size for embedding
-    ann_backend="auto",                      # 'auto', 'faiss', 'hnswlib'
-    binary_top_k=200,                        # binary coarse search candidates
-    ann_top_k=50,                            # ANN fine search candidates
-    fts_top_k=50,                            # FTS results per method
-    device="auto",                           # 'auto', 'cuda', 'cpu'
-)
+Query → [Embedder] → query vector
+         ├→ [BinaryStore] → candidates (Hamming)
+         │     └→ [ANNIndex] → ranked IDs (cosine)
+         ├→ [FTS exact] → exact matches
+         └→ [FTS fuzzy] → fuzzy matches
+              └→ [RRF Fusion] → merged ranking
+                    └→ [Reranker] → final top-k
 ```
 
 ## Development
 
 ```bash
-git clone https://github.com/nicepkg/codexlens-search.git
+git clone https://github.com/catlog22/codexlens-search.git
 cd codexlens-search
-pip install -e ".[dev,semantic]"
+pip install -e ".[dev]"
 pytest
 ```
 
diff --git a/codex-lens-v2/dist/codexlens_search-0.2.0-py3-none-any.whl b/codex-lens-v2/dist/codexlens_search-0.2.0-py3-none-any.whl
deleted file mode 100644
index 807978dcb6d71998f77be793940a8226bed08a2d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 30402
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

diff --git a/codex-lens-v2/dist/codexlens_search-0.2.0.tar.gz b/codex-lens-v2/dist/codexlens_search-0.2.0.tar.gz
deleted file mode 100644
index e90bbb8a259daa31b105c648dafe33cca019f2df..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 31214
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

diff --git a/codex-lens-v2/pyproject.toml b/codex-lens-v2/pyproject.toml
index d3224eea..18384691 100644
--- a/codex-lens-v2/pyproject.toml
+++ b/codex-lens-v2/pyproject.toml
@@ -4,10 +4,15 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codexlens-search"
-version = "0.2.0"
-description = "Lightweight semantic code search engine — 2-stage vector + FTS + RRF fusion"
+version = "0.3.0"
+description = "Lightweight semantic code search engine — 2-stage vector + FTS + RRF fusion + MCP server"
 requires-python = ">=3.10"
-dependencies = []
+dependencies = [
+    "hnswlib>=0.8.0",
+    "numpy>=1.26",
+    "fastembed>=0.4.0,<2.0",
+    "httpx>=0.25",
+]
 license = {text = "MIT"}
 readme = "README.md"
 authors = [
@@ -26,14 +31,12 @@ classifiers = [
 ]
 
 [project.urls]
-Homepage = "https://github.com/nicepkg/codexlens-search"
-Repository = "https://github.com/nicepkg/codexlens-search"
+Homepage = "https://github.com/catlog22/codexlens-search"
+Repository = "https://github.com/catlog22/codexlens-search"
 
 [project.optional-dependencies]
-semantic = [
-    "hnswlib>=0.8.0",
-    "numpy>=1.26",
-    "fastembed>=0.4.0,<2.0",
+mcp = [
+    "mcp[cli]>=1.0.0",
 ]
 gpu = [
     "onnxruntime-gpu>=1.16",
@@ -44,21 +47,9 @@ faiss-cpu = [
 faiss-gpu = [
     "faiss-gpu>=1.7.4",
 ]
-embed-api = [
-    "httpx>=0.25",
-]
-reranker-api = [
-    "httpx>=0.25",
-]
 watcher = [
     "watchdog>=3.0",
 ]
-semantic-gpu = [
-    "hnswlib>=0.8.0",
-    "numpy>=1.26",
-    "fastembed>=0.4.0,<2.0",
-    "onnxruntime-gpu>=1.16",
-]
 dev = [
     "pytest>=7.0",
     "pytest-cov",
@@ -66,6 +57,7 @@ dev = [
 
 [project.scripts]
 codexlens-search = "codexlens_search.bridge:main"
+codexlens-mcp = "codexlens_search.mcp_server:main"
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/codexlens_search"]
diff --git a/codex-lens-v2/src/codexlens_search/bridge.py b/codex-lens-v2/src/codexlens_search/bridge.py
index ae9016fb..ff2d86df 100644
--- a/codex-lens-v2/src/codexlens_search/bridge.py
+++ b/codex-lens-v2/src/codexlens_search/bridge.py
@@ -50,21 +50,19 @@ def _resolve_db_path(args: argparse.Namespace) -> Path:
     return db_path
 
 
-def _create_config(args: argparse.Namespace) -> "Config":
-    """Build Config from CLI args."""
+def create_config_from_env(db_path: str | Path, **overrides: object) -> "Config":
+    """Build Config from environment variables and optional overrides.
+
+    Used by both CLI bridge and MCP server.
+    """
     from codexlens_search.config import Config
 
     kwargs: dict = {}
-    if hasattr(args, "embed_model") and args.embed_model:
-        kwargs["embed_model"] = args.embed_model
-    # API embedding overrides
-    if hasattr(args, "embed_api_url") and args.embed_api_url:
-        kwargs["embed_api_url"] = args.embed_api_url
-    if hasattr(args, "embed_api_key") and args.embed_api_key:
-        kwargs["embed_api_key"] = args.embed_api_key
-    if hasattr(args, "embed_api_model") and args.embed_api_model:
-        kwargs["embed_api_model"] = args.embed_api_model
-    # Also check env vars as fallback
+    # Apply explicit overrides first
+    for key in ("embed_model", "embed_api_url", "embed_api_key", "embed_api_model"):
+        if overrides.get(key):
+            kwargs[key] = overrides[key]
+    # Env vars as fallback
     if "embed_api_url" not in kwargs and os.environ.get("CODEXLENS_EMBED_API_URL"):
         kwargs["embed_api_url"] = os.environ["CODEXLENS_EMBED_API_URL"]
     if "embed_api_key" not in kwargs and os.environ.get("CODEXLENS_EMBED_API_KEY"):
@@ -124,18 +122,33 @@ def _create_config(args: argparse.Namespace) -> "Config":
         kwargs["hnsw_ef"] = int(os.environ["CODEXLENS_HNSW_EF"])
     if os.environ.get("CODEXLENS_HNSW_M"):
         kwargs["hnsw_M"] = int(os.environ["CODEXLENS_HNSW_M"])
-    db_path = Path(args.db_path).resolve()
-    kwargs["metadata_db_path"] = str(db_path / "metadata.db")
+    resolved = Path(db_path).resolve()
+    kwargs["metadata_db_path"] = str(resolved / "metadata.db")
     return Config(**kwargs)
 
 
-def _create_pipeline(
-    args: argparse.Namespace,
+def _create_config(args: argparse.Namespace) -> "Config":
+    """Build Config from CLI args (delegates to create_config_from_env)."""
+    overrides: dict = {}
+    if hasattr(args, "embed_model") and args.embed_model:
+        overrides["embed_model"] = args.embed_model
+    if hasattr(args, "embed_api_url") and args.embed_api_url:
+        overrides["embed_api_url"] = args.embed_api_url
+    if hasattr(args, "embed_api_key") and args.embed_api_key:
+        overrides["embed_api_key"] = args.embed_api_key
+    if hasattr(args, "embed_api_model") and args.embed_api_model:
+        overrides["embed_api_model"] = args.embed_api_model
+    return create_config_from_env(args.db_path, **overrides)
+
+
+def create_pipeline(
+    db_path: str | Path,
+    config: "Config | None" = None,
 ) -> tuple:
-    """Lazily construct pipeline components from CLI args.
+    """Construct pipeline components from db_path and config.
 
     Returns (indexing_pipeline, search_pipeline, config).
-    Only loads embedder/reranker models when needed.
+    Used by both CLI bridge and MCP server.
     """
     from codexlens_search.config import Config
     from codexlens_search.core.factory import create_ann_index, create_binary_index
@@ -144,8 +157,10 @@ def _create_pipeline(
     from codexlens_search.search.fts import FTSEngine
     from codexlens_search.search.pipeline import SearchPipeline
 
-    config = _create_config(args)
-    db_path = _resolve_db_path(args)
+    if config is None:
+        config = create_config_from_env(db_path)
+    resolved = Path(db_path).resolve()
+    resolved.mkdir(parents=True, exist_ok=True)
 
     # Select embedder: API if configured, otherwise local fastembed
     if config.embed_api_url:
@@ -163,10 +178,10 @@ def _create_pipeline(
         from codexlens_search.embed.local import FastEmbedEmbedder
         embedder = FastEmbedEmbedder(config)
 
-    binary_store = create_binary_index(db_path, config.embed_dim, config)
-    ann_index = create_ann_index(db_path, config.embed_dim, config)
-    fts = FTSEngine(db_path / "fts.db")
-    metadata = MetadataStore(db_path / "metadata.db")
+    binary_store = create_binary_index(resolved, config.embed_dim, config)
+    ann_index = create_ann_index(resolved, config.embed_dim, config)
+    fts = FTSEngine(resolved / "fts.db")
+    metadata = MetadataStore(resolved / "metadata.db")
 
     # Select reranker: API if configured, otherwise local fastembed
     if config.reranker_api_url:
@@ -199,6 +214,15 @@ def _create_pipeline(
     return indexing, search, config
 
 
+def _create_pipeline(
+    args: argparse.Namespace,
+) -> tuple:
+    """CLI wrapper: construct pipeline from argparse args."""
+    config = _create_config(args)
+    db_path = _resolve_db_path(args)
+    return create_pipeline(db_path, config)
+
+
 # ---------------------------------------------------------------------------
 # Subcommand handlers
 # ---------------------------------------------------------------------------
@@ -269,14 +293,14 @@ def cmd_remove_file(args: argparse.Namespace) -> None:
     })
 
 
-_DEFAULT_EXCLUDES = frozenset({
+DEFAULT_EXCLUDES = frozenset({
     "node_modules", ".git", "__pycache__", "dist", "build",
     ".venv", "venv", ".tox", ".mypy_cache", ".pytest_cache",
     ".next", ".nuxt", "coverage", ".eggs", "*.egg-info",
 })
 
 
-def _should_exclude(path: Path, exclude_dirs: frozenset[str]) -> bool:
+def should_exclude(path: Path, exclude_dirs: frozenset[str]) -> bool:
     """Check if any path component matches an exclude pattern."""
     parts = path.parts
     return any(part in exclude_dirs for part in parts)
@@ -290,11 +314,11 @@ def cmd_sync(args: argparse.Namespace) -> None:
     if not root.is_dir():
         _error_exit(f"Root directory not found: {root}")
 
-    exclude_dirs = frozenset(args.exclude) if args.exclude else _DEFAULT_EXCLUDES
+    exclude_dirs = frozenset(args.exclude) if args.exclude else DEFAULT_EXCLUDES
     pattern = args.glob or "**/*"
     file_paths = [
         p for p in root.glob(pattern)
-        if p.is_file() and not _should_exclude(p.relative_to(root), exclude_dirs)
+        if p.is_file() and not should_exclude(p.relative_to(root), exclude_dirs)
     ]
 
     log.debug("Sync: %d files after exclusion (root=%s, pattern=%s)", len(file_paths), root, pattern)
diff --git a/codex-lens-v2/src/codexlens_search/mcp_server.py b/codex-lens-v2/src/codexlens_search/mcp_server.py
new file mode 100644
index 00000000..d292042a
--- /dev/null
+++ b/codex-lens-v2/src/codexlens_search/mcp_server.py
@@ -0,0 +1,367 @@
+"""MCP server for codexlens-search.
+
+Exposes semantic code search tools via FastMCP for Claude Code integration.
+Run as: codexlens-mcp (entry point) or python -m codexlens_search.mcp_server
+
+## .mcp.json Configuration Examples
+
+### API embedding + API reranker (single endpoint):
+{
+  "mcpServers": {
+    "codexlens": {
+      "command": "codexlens-mcp",
+      "env": {
+        "CODEXLENS_EMBED_API_URL": "https://api.openai.com/v1",
+        "CODEXLENS_EMBED_API_KEY": "sk-xxx",
+        "CODEXLENS_EMBED_API_MODEL": "text-embedding-3-small",
+        "CODEXLENS_EMBED_DIM": "1536",
+        "CODEXLENS_RERANKER_API_URL": "https://api.jina.ai/v1",
+        "CODEXLENS_RERANKER_API_KEY": "jina-xxx",
+        "CODEXLENS_RERANKER_API_MODEL": "jina-reranker-v2-base-multilingual"
+      }
+    }
+  }
+}
+
+### API embedding (multi-endpoint load balancing):
+{
+  "mcpServers": {
+    "codexlens": {
+      "command": "codexlens-mcp",
+      "env": {
+        "CODEXLENS_EMBED_API_ENDPOINTS": "url1|key1|model1,url2|key2|model2",
+        "CODEXLENS_EMBED_DIM": "1536",
+        "CODEXLENS_RERANKER_API_URL": "https://api.jina.ai/v1",
+        "CODEXLENS_RERANKER_API_KEY": "jina-xxx",
+        "CODEXLENS_RERANKER_API_MODEL": "jina-reranker-v2-base-multilingual"
+      }
+    }
+  }
+}
+
+### Local fastembed model (no API, requires codexlens-search[semantic]):
+{
+  "mcpServers": {
+    "codexlens": {
+      "command": "codexlens-mcp",
+      "env": {}
+    }
+  }
+}
+Pre-download models via CLI: codexlens-search download-models
+
+### Env vars reference:
+Embedding:  CODEXLENS_EMBED_API_URL, _KEY, _MODEL, _ENDPOINTS (multi), _DIM
+Reranker:   CODEXLENS_RERANKER_API_URL, _KEY, _MODEL
+Tuning:     CODEXLENS_BINARY_TOP_K, _ANN_TOP_K, _FTS_TOP_K, _FUSION_K,
+            CODEXLENS_RERANKER_TOP_K, _RERANKER_BATCH_SIZE
+"""
+from __future__ import annotations
+
+import logging
+import threading
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+from codexlens_search.bridge import (
+    DEFAULT_EXCLUDES,
+    create_config_from_env,
+    create_pipeline,
+    should_exclude,
+)
+
+log = logging.getLogger("codexlens_search.mcp_server")
+
+mcp = FastMCP("codexlens-search")
+
+# Pipeline cache: keyed by resolved project_path -> (indexing, search, config)
+_pipelines: dict[str, tuple] = {}
+_lock = threading.Lock()
+
+
+def _db_path_for_project(project_path: str) -> Path:
+    """Return the index database path for a project."""
+    return Path(project_path).resolve() / ".codexlens"
+
+
+def _get_pipelines(project_path: str) -> tuple:
+    """Get or create cached (indexing_pipeline, search_pipeline, config) for a project."""
+    resolved = str(Path(project_path).resolve())
+    with _lock:
+        if resolved not in _pipelines:
+            db_path = _db_path_for_project(resolved)
+            config = create_config_from_env(db_path)
+            _pipelines[resolved] = create_pipeline(db_path, config)
+        return _pipelines[resolved]
+
+
+# ---------------------------------------------------------------------------
+# Search tools
+# ---------------------------------------------------------------------------
+
+@mcp.tool()
+def search_code(project_path: str, query: str, top_k: int = 10) -> str:
+    """Semantic code search with hybrid fusion (vector + FTS + reranking).
+
+    Args:
+        project_path: Absolute path to the project root directory.
+        query: Natural language or code search query.
+        top_k: Maximum number of results to return (default 10).
+
+    Returns:
+        Search results as formatted text with file paths, line numbers, scores, and code snippets.
+    """
+    root = Path(project_path).resolve()
+    if not root.is_dir():
+        return f"Error: project path not found: {root}"
+
+    db_path = _db_path_for_project(project_path)
+    if not (db_path / "metadata.db").exists():
+        return f"Error: no index found at {db_path}. Run index_project first."
+
+    _, search, _ = _get_pipelines(project_path)
+    results = search.search(query, top_k=top_k)
+
+    if not results:
+        return "No results found."
+
+    lines = []
+    for i, r in enumerate(results, 1):
+        lines.append(f"## Result {i} — {r.path} (L{r.line}-{r.end_line}, score: {r.score:.4f})")
+        lines.append(f"```\n{r.content}\n```")
+        lines.append("")
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Indexing tools
+# ---------------------------------------------------------------------------
+
+@mcp.tool()
+def index_project(
+    project_path: str, glob_pattern: str = "**/*", force: bool = False
+) -> str:
+    """Build or rebuild the search index for a project.
+
+    Args:
+        project_path: Absolute path to the project root directory.
+        glob_pattern: Glob pattern for files to index (default "**/*").
+        force: If True, rebuild index from scratch even if it exists.
+
+    Returns:
+        Indexing summary with file count, chunk count, and duration.
+    """
+    root = Path(project_path).resolve()
+    if not root.is_dir():
+        return f"Error: project path not found: {root}"
+
+    if force:
+        with _lock:
+            _pipelines.pop(str(root), None)
+
+    indexing, _, _ = _get_pipelines(project_path)
+
+    file_paths = [
+        p for p in root.glob(glob_pattern)
+        if p.is_file() and not should_exclude(p.relative_to(root), DEFAULT_EXCLUDES)
+    ]
+
+    stats = indexing.sync(file_paths, root=root)
+    return (
+        f"Indexed {stats.files_processed} files, "
+        f"{stats.chunks_created} chunks in {stats.duration_seconds:.1f}s. "
+        f"DB: {_db_path_for_project(project_path)}"
+    )
+
+
+@mcp.tool()
+def index_status(project_path: str) -> str:
+    """Show index statistics for a project.
+
+    Args:
+        project_path: Absolute path to the project root directory.
+
+    Returns:
+        Index statistics including file count, chunk count, and deleted chunks.
+    """
+    from codexlens_search.indexing.metadata import MetadataStore
+
+    db_path = _db_path_for_project(project_path)
+    meta_path = db_path / "metadata.db"
+
+    if not meta_path.exists():
+        return f"No index found at {db_path}. Run index_project first."
+
+    metadata = MetadataStore(meta_path)
+    all_files = metadata.get_all_files()
+    deleted_ids = metadata.get_deleted_ids()
+    max_chunk = metadata.max_chunk_id()
+
+    total = max_chunk + 1 if max_chunk >= 0 else 0
+    return (
+        f"Index: {db_path}\n"
+        f"Files tracked: {len(all_files)}\n"
+        f"Total chunks: {total}\n"
+        f"Deleted chunks: {len(deleted_ids)}"
+    )
+
+
+@mcp.tool()
+def index_update(project_path: str, glob_pattern: str = "**/*") -> str:
+    """Incrementally sync the index with current project files.
+
+    Only re-indexes files that changed since last indexing.
+
+    Args:
+        project_path: Absolute path to the project root directory.
+        glob_pattern: Glob pattern for files to sync (default "**/*").
+
+    Returns:
+        Sync summary with processed file count and duration.
+    """
+    root = Path(project_path).resolve()
+    if not root.is_dir():
+        return f"Error: project path not found: {root}"
+
+    indexing, _, _ = _get_pipelines(project_path)
+
+    file_paths = [
+        p for p in root.glob(glob_pattern)
+        if p.is_file() and not should_exclude(p.relative_to(root), DEFAULT_EXCLUDES)
+    ]
+
+    stats = indexing.sync(file_paths, root=root)
+    return (
+        f"Synced {stats.files_processed} files, "
+        f"{stats.chunks_created} chunks in {stats.duration_seconds:.1f}s."
+    )
+
+
+# ---------------------------------------------------------------------------
+# File discovery
+# ---------------------------------------------------------------------------
+
+@mcp.tool()
+def find_files(
+    project_path: str, pattern: str = "**/*", max_results: int = 100
+) -> str:
+    """Find files in a project by glob pattern.
+
+    Args:
+        project_path: Absolute path to the project root directory.
+        pattern: Glob pattern to match files (default "**/*").
+        max_results: Maximum number of file paths to return (default 100).
+
+    Returns:
+        List of matching file paths (relative to project root), one per line.
+    """
+    root = Path(project_path).resolve()
+    if not root.is_dir():
+        return f"Error: project path not found: {root}"
+
+    matches = []
+    for p in root.glob(pattern):
+        if p.is_file() and not should_exclude(p.relative_to(root), DEFAULT_EXCLUDES):
+            matches.append(str(p.relative_to(root)))
+            if len(matches) >= max_results:
+                break
+
+    if not matches:
+        return "No files found matching the pattern."
+
+    header = f"Found {len(matches)} files"
+    if len(matches) >= max_results:
+        header += f" (limited to {max_results})"
+    return header + ":\n" + "\n".join(matches)
+
+
+# ---------------------------------------------------------------------------
+# Model management tools
+# ---------------------------------------------------------------------------
+
+@mcp.tool()
+def list_models() -> str:
+    """List available embedding and reranker models with cache status.
+
+    Shows which models are downloaded locally and ready for use.
+    Models are needed when using local fastembed mode (no API URL configured).
+
+    Returns:
+        Table of models with name, type, and installed status.
+    """
+    from codexlens_search import model_manager
+    from codexlens_search.config import Config
+
+    config = create_config_from_env(".")
+    models = model_manager.list_known_models(config)
+
+    if not models:
+        return "No known models found."
+
+    lines = ["| Model | Type | Installed |", "| --- | --- | --- |"]
+    for m in models:
+        status = "Yes" if m["installed"] else "No"
+        lines.append(f"| {m['name']} | {m['type']} | {status} |")
+
+    # Show current config
+    lines.append("")
+    if config.embed_api_url:
+        lines.append(f"Mode: API embedding ({config.embed_api_url})")
+    else:
+        lines.append(f"Mode: Local fastembed (model: {config.embed_model})")
+    return "\n".join(lines)
+
+
+@mcp.tool()
+def download_models(embed_model: str = "", reranker_model: str = "") -> str:
+    """Download embedding and reranker models for local (fastembed) mode.
+
+    Not needed when using API embedding (CODEXLENS_EMBED_API_URL is set).
+    Downloads are cached — subsequent calls are no-ops if already downloaded.
+
+    Args:
+        embed_model: Embedding model name (default: BAAI/bge-small-en-v1.5).
+        reranker_model: Reranker model name (default: Xenova/ms-marco-MiniLM-L-6-v2).
+
+    Returns:
+        Download status for each model.
+    """
+    from codexlens_search import model_manager
+    from codexlens_search.config import Config
+
+    config = create_config_from_env(".")
+    if embed_model:
+        config.embed_model = embed_model
+    if reranker_model:
+        config.reranker_model = reranker_model
+
+    results = []
+    for name, kind in [
+        (config.embed_model, "embedding"),
+        (config.reranker_model, "reranker"),
+    ]:
+        try:
+            model_manager.ensure_model(name, config)
+            results.append(f"{kind}: {name} — ready")
+        except Exception as e:
+            results.append(f"{kind}: {name} — failed: {e}")
+
+    return "\n".join(results)
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    """Entry point for codexlens-mcp command."""
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(levelname)s %(name)s: %(message)s",
+    )
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()