diff --git a/.github/workflows/label-pr-review-state.yml b/.github/workflows/label-pr-review-state.yml
index 98f7428c7a..08ecf2e3fe 100644
--- a/.github/workflows/label-pr-review-state.yml
+++ b/.github/workflows/label-pr-review-state.yml
@@ -14,7 +14,7 @@ on:
   # This workflow only reads PR metadata and never checks out or executes PR code.
   # pull_request_target gives fork PRs a token that can update labels and comments.
   pull_request_target:
-    types: [opened, reopened, ready_for_review, synchronize, review_requested, review_request_removed, labeled, unlabeled]
+    types: [opened, reopened, ready_for_review, converted_to_draft, synchronize, review_requested, review_request_removed, labeled, unlabeled]
   pull_request_review:
     types: [submitted, dismissed]
   # Fork review events have a read-only token. CodeRabbit's status-comment update
@@ -81,6 +81,11 @@ jobs:
                 color: '5319e7',
                 description: 'Required CI passed; CodeRabbit review is active',
               },
+              {
+                name: 'community-approved',
+                color: 'c2e0c6',
+                description: 'Fresh community approval on the current head; maintainer review still required',
+              },
             ];
             const guideMarker = '<!-- zoo-code-pr-review-process -->';
             const codeRabbitLabelMarkerPrefix = '<!-- coderabbit-review-label:';
@@ -88,6 +93,9 @@ jobs:
             const codeRabbitLogins = new Set([codeRabbitLogin, 'coderabbitai']);
             const codeRabbitActiveLabel = 'coderabbit-review-active';
             const codeRabbitEligibleBotLogins = new Set(['zoomote[bot]']);
+            // Advisory priority signal only — kept outside stateLabels so it never
+            // replaces or blocks the review-state queue labels.
+            const communityApprovedLabel = 'community-approved';
             const reviewGateName = 'Zoo Code / PR review gate';
             const reconciliationCheckName = 'Zoo Code / reconcile PR review state';
 
@@ -310,6 +318,48 @@ jobs:
               }
             }
 
+            // Reconciles the advisory community-approved label. The label means
+            // "fresh community code approval for the current head; maintainer
+            // review still required" — it is a priority signal only and never
+            // grants merge authority. Every reconciliation branch routes through
+            // this one helper with a single decision:
+            //   'add'      — stable head, maintainer queue, qualifying fresh approval
+            //   'remove'   — known non-maintainer phase, known head change, or
+            //                invalidated approval (known invalidation beats uncertainty)
+            //   'preserve' — unknown mergeability, or a permission lookup that
+            //                fails only in the community check, with no known
+            //                invalidation. A lookup failure that also blocks
+            //                maintainer classification fails the PR and removes
+            //                the label through the outer catch instead.
+            // A failed community label update is advisory: it must not clear the
+            // queue label or fail the review gate, so errors are logged, not thrown.
+            async function reconcileCommunityApproval(pr, decision) {
+              if (isReadOnlyRun && isForkPR(pr)) return;
+              if (decision === 'preserve') return;
+              const hasLabel = pr.labels.some(label => label.name === communityApprovedLabel);
+              try {
+                if (decision === 'add' && !hasLabel) {
+                  await github.rest.issues.addLabels({
+                    owner, repo, issue_number: pr.number, labels: [communityApprovedLabel],
+                  });
+                  pr.labels.push({ name: communityApprovedLabel });
+                } else if (decision === 'remove' && hasLabel) {
+                  await github.rest.issues.removeLabel({
+                    owner, repo, issue_number: pr.number, name: communityApprovedLabel,
+                  });
+                  pr.labels = pr.labels.filter(label => label.name !== communityApprovedLabel);
+                }
+              } catch (error) {
+                if (decision === 'remove' && error.status === 404) {
+                  pr.labels = pr.labels.filter(label => label.name !== communityApprovedLabel);
+                  return;
+                }
+                core.warning(
+                  `PR #${pr.number}: could not ${decision} ${communityApprovedLabel}: ${error.message}`
+                );
+              }
+            }
+
             function codeRabbitLabelHead(comment) {
               const markerPattern = new RegExp(`${codeRabbitLabelMarkerPrefix}([a-f0-9]{40}) -->`);
               const match = comment?.body?.match(markerPattern);
@@ -419,7 +469,10 @@ jobs:
 
               return `${guideMarker}\n### Review status\n\n${authorNote}\n\n` +
                 `**Current step:** ${phaseMessage(phase)}${phaseHelp}\n\n` +
-                'Review-state labels are managed by this workflow; do not edit them manually.' +
+                'Review-state labels are managed by this workflow; do not edit them manually. ' +
+                '`community-approved` is managed the same way — do not add or remove it manually. ' +
+                'It signals a fresh community code approval for the current head as an advisory ' +
+                'priority only; maintainer review is still required.' +
                 labelMarker;
             }
 
@@ -497,6 +550,7 @@ jobs:
                   const existingGuide = await findReviewGuide(pr);
                   await setCodeRabbitReviewActive(pr, false);
                   await reconcileLabels(pr, null);
+                  await reconcileCommunityApproval(pr, 'remove');
                   await updateReviewGuide(pr, 'configuration-error', existingGuide);
                   continue;
                 }
@@ -518,6 +572,7 @@ jobs:
                   await updateReviewGate(pr, 'conflict', false);
                   await setCodeRabbitReviewActive(pr, false);
                   await reconcileLabels(pr, 'has-conflicts');
+                  await reconcileCommunityApproval(pr, 'remove');
                   await updateReviewGuide(pr, 'conflict', existingGuide);
                   continue;
                 }
@@ -623,6 +678,7 @@ jobs:
                   await updateReviewGate(pr, ciPending ? 'ci-pending' : 'ci-failed', false);
                   await setCodeRabbitReviewActive(pr, false);
                   await reconcileLabels(pr, null);
+                  await reconcileCommunityApproval(pr, 'remove');
                   await updateReviewGuide(
                     pr,
                     ciPending ? 'ci-pending' : 'ci-failed',
@@ -642,7 +698,10 @@ jobs:
                 // block the PR or indicate the author needs to act.
                 const latest = new Map();
                 for (const r of reviews) {
-                  const reviewer = r.user.login.toLowerCase();
+                  // Ghost accounts have no usable identity; their reviews carry
+                  // no actionable state for either review loop.
+                  const reviewer = r.user?.login?.toLowerCase();
+                  if (!reviewer) continue;
                   const reviewerKey = codeRabbitLogins.has(reviewer) ? codeRabbitLogin : reviewer;
                   if (r.state === 'DISMISSED') {
                     latest.delete(reviewerKey);
@@ -742,6 +801,43 @@ jobs:
                     freshMaintainerReviews.push(review);
                   }
                 }
+                // Community approval eligibility reuses the decisive per-reviewer
+                // reduction above: the reviewer's latest decisive review (selected
+                // by review id, not array order) must be an approval on the current
+                // head. Ghost accounts, bots, CodeRabbit, and the PR author are
+                // already excluded there; comments are neutral. Permission results
+                // are shared with maintainer classification through permissionFor:
+                // a 404 qualifies an otherwise valid reviewer, while a lookup
+                // failure is unknown permission and never counts as community
+                // eligibility. One eligible approval is enough; bot-authored PRs
+                // follow the same rule. A known invalidation — an approval that
+                // was dismissed, replaced, or left behind by a head change —
+                // takes priority over any lookup uncertainty.
+                const approvedByReviewer = new Set();
+                for (const r of reviews) {
+                  const reviewer = r.user?.login?.toLowerCase();
+                  if (reviewer && r.state === 'APPROVED') approvedByReviewer.add(reviewer);
+                }
+                let communityApprovalFresh = false;
+                let communityPermissionUncertain = false;
+                let communityApprovalInvalidated = false;
+                for (const [reviewer, review] of latestHumanReview) {
+                  if (review.state === 'APPROVED' && review.commit_id === pr.head.sha) {
+                    let permission;
+                    try {
+                      permission = await permissionFor(review.user.login);
+                    } catch (error) {
+                      communityPermissionUncertain = true;
+                      continue;
+                    }
+                    if (!['admin', 'maintain', 'write'].includes(permission)) {
+                      communityApprovalFresh = true;
+                      break;
+                    }
+                  } else if (approvedByReviewer.has(reviewer)) {
+                    communityApprovalInvalidated = true;
+                  }
+                }
                 const automatedAuthor = pr.user?.type === 'Bot';
                 const codeRabbitEligibleAuthor = !automatedAuthor ||
                   codeRabbitEligibleBotLogins.has(pr.user?.login.toLowerCase());
@@ -793,15 +889,24 @@ jobs:
                   phase = 'approved';
                 }
 
+                // Advisory community label decision for the branches below.
+                // Non-maintainer phases always remove it; the maintainer queue
+                // refines the decision after the head/mergeability refetch.
+                let communityDecision = 'remove';
                 if (desiredLabel === 'awaiting-maintainer') {
                   const { data: latestPrDetail } = await github.rest.pulls.get({
                     owner, repo, pull_number: pr.number,
                   });
+                  // A head change since the event fetch invalidates every
+                  // approval, even if another check is uncertain.
+                  const headChanged = Boolean(latestPrDetail.head?.sha) &&
+                    latestPrDetail.head.sha !== pr.head.sha;
                   if (latestPrDetail.mergeable === false && latestPrDetail.mergeable_state === 'dirty') {
                     core.info(`PR #${pr.number}: has merge conflicts — labeling has-conflicts`);
                     await updateReviewGate(pr, 'conflict', false);
                     await setCodeRabbitReviewActive(pr, false);
                     await reconcileLabels(pr, 'has-conflicts');
+                    await reconcileCommunityApproval(pr, 'remove');
                     await updateReviewGuide(pr, 'conflict', existingGuide);
                     continue;
                   }
@@ -815,8 +920,23 @@ jobs:
                       error.preserveStateLabels = true;
                       throw error;
                     }
+                    // Unknown mergeability alone, with an unchanged head and no
+                    // known invalidation, preserves an existing label and never adds it.
+                    await reconcileCommunityApproval(
+                      pr,
+                      headChanged || communityApprovalInvalidated ? 'remove' : 'preserve'
+                    );
                     continue;
                   }
+                  communityDecision = headChanged
+                    ? 'remove'
+                    : communityApprovalFresh
+                      ? 'add'
+                      : communityApprovalInvalidated
+                        ? 'remove'
+                        : communityPermissionUncertain
+                          ? 'preserve'
+                          : 'remove';
                 }
 
                 core.info(
@@ -842,6 +962,7 @@ jobs:
                   await updateReviewGuide(pr, phase, existingGuide);
                 }
                 await reconcileLabels(pr, desiredLabel);
+                await reconcileCommunityApproval(pr, communityDecision);
                 if (readyForMaintainer) {
                   await updateReviewGate(pr, phase, true);
                 }
@@ -864,6 +985,9 @@ jobs:
                   } catch (cleanupError) {
                     metadataErrors.push(cleanupError);
                   }
+                  // A global failure that clears the maintainer queue clears the
+                  // advisory community signal too.
+                  await reconcileCommunityApproval(pr, 'remove');
                 }
                 const detail = error.status
                   ? `${error.message} (HTTP ${error.status}${error.response?.data?.message ? `: ${error.response.data.message}` : ''})`
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index f22cf96e9a..4b40d7e504 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -134,7 +134,7 @@ pnpm install
 
 ### Review Process
 
-Ready-for-review PRs must pass required CI checks, address actionable review feedback, and receive fresh maintainer or CODEOWNER approval after automated review completes for the latest commit. Automated review may add a guidance comment and managed state labels; contributors should follow the indicated next step rather than editing those labels directly. New commits reset review state for the updated code.
+Ready-for-review PRs must pass required CI checks, address actionable review feedback, and receive fresh maintainer or CODEOWNER approval after automated review completes for the latest commit. Automated review may add a guidance comment and managed state labels; contributors should follow the indicated next step rather than editing those labels directly. New commits reset review state for the updated code. A `community-approved` label marks a fresh community approval on the latest commit while the PR waits for maintainer review. It is an advisory priority signal for maintainers; it does not replace maintainer review or any required check, and it is managed by the review workflow.
 
 Automated review supports maintainers but does not replace human approval. Outside contributors cannot direct CodeRabbit through comments; eligible reviews restart automatically after required CI passes, and maintainers handle any exceptional restart. Warnings are advisory unless repository policy says otherwise, and native GitHub required-check, CODEOWNER, and review protections remain authoritative for merging.
 
diff --git a/apps/vscode-e2e/package.json b/apps/vscode-e2e/package.json
index 4a2bed8a87..d19b5b765b 100644
--- a/apps/vscode-e2e/package.json
+++ b/apps/vscode-e2e/package.json
@@ -29,7 +29,7 @@
 		"@vscode/test-electron": "2.5.2",
 		"dotenv-cli": "11.0.0",
 		"glob": "11.1.0",
-		"mocha": "11.2.2",
+		"mocha": "11.8.0",
 		"rimraf": "6.0.1"
 	}
 }
diff --git a/apps/vscode-e2e/src/visual/__screenshots__/electron-chat-dark-sidebar.png b/apps/vscode-e2e/src/visual/__screenshots__/electron-chat-dark-sidebar.png
index e8497070ef..3c03cbac03 100644
Binary files a/apps/vscode-e2e/src/visual/__screenshots__/electron-chat-dark-sidebar.png and b/apps/vscode-e2e/src/visual/__screenshots__/electron-chat-dark-sidebar.png differ
diff --git a/package.json b/package.json
index 1dd8d3d260..1bf0b4e8dd 100644
--- a/package.json
+++ b/package.json
@@ -61,6 +61,7 @@
 		],
 		"overrides": {
 			"tar-fs": ">=3.1.1",
+			"mocha>diff": "8.0.4",
 			"esbuild": "0.28.1",
 			"rollup": "4.60.4",
 			"vite": "8.1.0",
diff --git a/packages/types/src/__tests__/openai-models.test.ts b/packages/types/src/__tests__/openai-models.test.ts
index bc2b41427c..78a3259f09 100644
--- a/packages/types/src/__tests__/openai-models.test.ts
+++ b/packages/types/src/__tests__/openai-models.test.ts
@@ -1,7 +1,69 @@
-import { openAiCodexModels } from "../providers/openai-codex.js"
+import { openAiCodexDefaultModelId, openAiCodexModels } from "../providers/openai-codex.js"
 import { openAiNativeDefaultModelId, openAiNativeModels } from "../providers/openai.js"
 
 describe("OpenAI native models", () => {
+	it("describes GPT-6.1 Sol pricing and required reasoning without changing defaults", () => {
+		expect(openAiNativeDefaultModelId).toBe("gpt-5.6-sol")
+		expect(openAiCodexDefaultModelId).toBe("gpt-5.6-sol")
+		expect(openAiNativeModels["gpt-6.1-sol"]).toMatchObject({
+			maxTokens: 128_000,
+			contextWindow: 1_050_000,
+			includedTools: ["apply_patch"],
+			excludedTools: ["apply_diff", "write_to_file"],
+			supportsImages: true,
+			supportsPromptCache: true,
+			supportsReasoningEffort: ["low", "medium", "high", "xhigh", "max"],
+			requiredReasoningEffort: true,
+			reasoningEffort: "medium",
+			supportsTemperature: false,
+			supportsVerbosity: true,
+			inputPrice: 2,
+			outputPrice: 10,
+			cacheWritesPrice: 2.5,
+			cacheReadsPrice: 0.1,
+			longContextPricing: {
+				thresholdTokens: 272_000,
+				inputPriceMultiplier: 2,
+				outputPriceMultiplier: 1.5,
+				cacheWritesPriceMultiplier: 2,
+				cacheReadsPriceMultiplier: 2,
+				appliesToServiceTiers: ["default", "flex", "priority"],
+			},
+		})
+		expect(openAiNativeModels["gpt-6.1-sol"].tiers).toEqual([
+			{
+				name: "flex",
+				contextWindow: 1_050_000,
+				inputPrice: 1,
+				outputPrice: 5,
+				cacheWritesPrice: 1.25,
+				cacheReadsPrice: 0.05,
+			},
+			{
+				name: "priority",
+				contextWindow: 1_050_000,
+				inputPrice: 4,
+				outputPrice: 20,
+				cacheWritesPrice: 5,
+				cacheReadsPrice: 0.2,
+			},
+		])
+		expect(openAiCodexModels["gpt-6.1-sol"]).toMatchObject({
+			maxTokens: 128_000,
+			contextWindow: 872_000,
+			includedTools: ["apply_patch"],
+			excludedTools: ["apply_diff", "write_to_file"],
+			supportsImages: true,
+			supportsPromptCache: true,
+			supportsReasoningEffort: ["low", "medium", "high", "xhigh", "max"],
+			requiredReasoningEffort: true,
+			reasoningEffort: "low",
+			supportsTemperature: false,
+			inputPrice: 0,
+			outputPrice: 0,
+		})
+	})
+
 	it("describes GPT-6 Astra without changing the provider default", () => {
 		expect(openAiNativeDefaultModelId).toBe("gpt-5.6-sol")
 		expect(openAiNativeModels["gpt-6-astra"]).toMatchObject({
diff --git a/packages/types/src/__tests__/opencode-go.test.ts b/packages/types/src/__tests__/opencode-go.test.ts
index 2a69eb7c00..7a253d156f 100644
--- a/packages/types/src/__tests__/opencode-go.test.ts
+++ b/packages/types/src/__tests__/opencode-go.test.ts
@@ -33,6 +33,7 @@ describe("opencode-go registry", () => {
 		"mimo-v2.5-pro",
 		"deepseek-v4-pro",
 		"deepseek-v4-flash",
+		"deepseek-v4.1-flash",
 		"omen-alpha",
 		"grok-4.5",
 	]
@@ -224,6 +225,19 @@ describe("opencode-go registry", () => {
 					cacheReadsPrice: 0.19,
 				},
 			},
+			{
+				id: "deepseek-v4.1-flash",
+				expected: {
+					maxTokens: 384_000,
+					contextWindow: 1_000_000,
+					supportsImages: true,
+					supportsPromptCache: true,
+					supportsMaxTokens: true,
+					inputPrice: 0.3,
+					outputPrice: 1.2,
+					cacheReadsPrice: 0.006,
+				},
+			},
 			{
 				id: "longcat-2.0",
 				expected: {
@@ -444,6 +458,7 @@ describe("opencode-go registry", () => {
 		it("DeepSeek entries expose supportsMaxTokens so the max-output slider is available", () => {
 			expect(getOpencodeGoModelInfo("deepseek-v4-pro")?.supportsMaxTokens).toBe(true)
 			expect(getOpencodeGoModelInfo("deepseek-v4-flash")?.supportsMaxTokens).toBe(true)
+			expect(getOpencodeGoModelInfo("deepseek-v4.1-flash")?.supportsMaxTokens).toBe(true)
 		})
 	})
 
diff --git a/packages/types/src/providers/anthropic.ts b/packages/types/src/providers/anthropic.ts
index 8103690da0..7584225aa0 100644
--- a/packages/types/src/providers/anthropic.ts
+++ b/packages/types/src/providers/anthropic.ts
@@ -165,7 +165,7 @@ export const anthropicModels = {
 		description: "Claude Opus 5 is Anthropic's most capable model for complex agentic coding and enterprise work.",
 	},
 	"claude-opus-5-5": {
-		maxTokens: 128_000, // Overridden to 8k if `enableReasoningEffort` is false.
+		maxTokens: 128_000,
 		contextWindow: 1_000_000, // 1M context window native (no beta header required)
 		supportsImages: true,
 		supportsPromptCache: true,
@@ -173,10 +173,7 @@ export const anthropicModels = {
 		outputPrice: 20.0, // $20 per million output tokens
 		cacheWritesPrice: 5.0, // $5 per million tokens
 		cacheReadsPrice: 0.2, // $0.20 per million tokens
-		// Opus 5.5 keeps the Opus 5 adaptive-thinking / binary-toggle convention on
-		// the direct Anthropic provider path: manual budget_tokens and non-default
-		// sampling parameters return a 400.
-		supportsReasoningBudget: true,
+		// Opus 5.5 always uses adaptive thinking and rejects manual budget_tokens.
 		supportsReasoningBinary: true,
 		supportsTemperature: false,
 		description:
diff --git a/packages/types/src/providers/openai-codex.ts b/packages/types/src/providers/openai-codex.ts
index dab48ef218..95ba2dfae1 100644
--- a/packages/types/src/providers/openai-codex.ts
+++ b/packages/types/src/providers/openai-codex.ts
@@ -24,6 +24,25 @@ export const openAiCodexDefaultModelId: OpenAiCodexModelId = "gpt-5.6-sol"
  * Costs are 0 as they are covered by the subscription.
  */
 export const openAiCodexModels = {
+	// https://github.com/openai/codex/blob/main/codex-rs/models-manager/models.json
+	"gpt-6.1-sol": {
+		maxTokens: 128000,
+		// Use Codex's supported maximum rather than its 272K default compaction budget.
+		contextWindow: 872000,
+		includedTools: ["apply_patch"],
+		excludedTools: ["apply_diff", "write_to_file"],
+		supportsImages: true,
+		supportsPromptCache: true,
+		supportsReasoningEffort: ["low", "medium", "high", "xhigh", "max"],
+		requiredReasoningEffort: true,
+		reasoningEffort: "low",
+		inputPrice: 0,
+		outputPrice: 0,
+		supportsVerbosity: true,
+		supportsTemperature: false,
+		description:
+			"GPT-6.1 Sol: Near-Astra performance for complex coding and professional work via ChatGPT subscription",
+	},
 	"gpt-6-astra": {
 		maxTokens: 128000,
 		contextWindow: 872000,
diff --git a/packages/types/src/providers/openai.ts b/packages/types/src/providers/openai.ts
index 4f56bb740a..b5db12bb70 100644
--- a/packages/types/src/providers/openai.ts
+++ b/packages/types/src/providers/openai.ts
@@ -17,6 +17,51 @@ export const OPENAI_API_PROTOCOL = "openai"
 export const openAiNativeDefaultModelId: OpenAiNativeModelId = "gpt-5.6-sol"
 
 export const openAiNativeModels = {
+	// https://developers.openai.com/api/docs/models/gpt-6.1-sol
+	"gpt-6.1-sol": {
+		maxTokens: 128000,
+		contextWindow: 1_050_000,
+		includedTools: ["apply_patch"],
+		excludedTools: ["apply_diff", "write_to_file"],
+		supportsImages: true,
+		supportsPromptCache: true,
+		supportsReasoningEffort: ["low", "medium", "high", "xhigh", "max"],
+		requiredReasoningEffort: true,
+		reasoningEffort: "medium",
+		inputPrice: 2.0,
+		outputPrice: 10.0,
+		cacheWritesPrice: 2.5,
+		cacheReadsPrice: 0.1,
+		longContextPricing: {
+			thresholdTokens: 272_000,
+			inputPriceMultiplier: 2,
+			outputPriceMultiplier: 1.5,
+			cacheWritesPriceMultiplier: 2,
+			cacheReadsPriceMultiplier: 2,
+			appliesToServiceTiers: ["default", "flex", "priority"],
+		},
+		supportsVerbosity: true,
+		supportsTemperature: false,
+		tiers: [
+			{
+				name: "flex",
+				contextWindow: 1_050_000,
+				inputPrice: 1.0,
+				outputPrice: 5.0,
+				cacheWritesPrice: 1.25,
+				cacheReadsPrice: 0.05,
+			},
+			{
+				name: "priority",
+				contextWindow: 1_050_000,
+				inputPrice: 4.0,
+				outputPrice: 20.0,
+				cacheWritesPrice: 5.0,
+				cacheReadsPrice: 0.2,
+			},
+		],
+		description: "GPT-6.1 Sol: Near-Astra performance for complex coding and professional work at a lower cost",
+	},
 	"gpt-6-astra": {
 		maxTokens: 128000,
 		contextWindow: 1_050_000,
diff --git a/packages/types/src/providers/opencode-go.ts b/packages/types/src/providers/opencode-go.ts
index b31db1bd99..17120858bc 100644
--- a/packages/types/src/providers/opencode-go.ts
+++ b/packages/types/src/providers/opencode-go.ts
@@ -465,6 +465,22 @@ export const opencodeGoModels: Record<string, ModelInfo> = {
 		description:
 			"DeepSeek-V4-Flash is DeepSeek's fast, cost-efficient V4 model supporting thinking and non-thinking modes. Available via the Opencode Go plan.",
 	},
+	"deepseek-v4.1-flash": {
+		maxTokens: 384_000,
+		contextWindow: 1_000_000,
+		supportsImages: true,
+		supportsPromptCache: true,
+		supportsMaxTokens: true,
+		supportsReasoningEffort: ["disable", "low", "medium", "high", "xhigh"],
+		preserveReasoning: true,
+		reasoningEffort: "high",
+		// Go has weekday peak/off-peak pricing; use peak rates until ModelInfo can express schedules.
+		inputPrice: 0.3,
+		outputPrice: 1.2,
+		cacheReadsPrice: 0.006,
+		description:
+			"DeepSeek V4.1 Flash is a fast, cost-efficient reasoning model with a 1M context window. Available via the Opencode Go plan.",
+	},
 	"deepseek-v4-flash-vision-exp": {
 		maxTokens: 384_000,
 		contextWindow: 1_000_000,
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 9b93c1cfe5..044ce1a3e4 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -6,6 +6,7 @@ settings:
 
 overrides:
   tar-fs: '>=3.1.1'
+  mocha>diff: 8.0.4
   esbuild: 0.28.1
   rollup: 4.60.4
   vite: 8.1.0
@@ -190,8 +191,8 @@ importers:
         specifier: 11.1.0
         version: 11.1.0
       mocha:
-        specifier: 11.2.2
-        version: 11.2.2
+        specifier: 11.8.0
+        version: 11.8.0
       rimraf:
         specifier: 6.0.1
         version: 6.0.1
@@ -799,7 +800,7 @@ importers:
         version: 0.16.47
       lru-cache:
         specifier: ^11.1.0
-        version: 11.2.2
+        version: 11.5.3
       lucide-react:
         specifier: ^1.18.0
         version: 1.21.0(react@18.3.1)
@@ -4789,6 +4790,10 @@ packages:
     resolution: {integrity: sha512-vtcDfH3TOjP8UekytvnHH1o1P4FcUdt4eQ1Y+Abap1tk/OB2MWQvcwS2ClCd1zuIhc3JKOx6p3kod8Vfys3E+A==}
     engines: {node: '>=0.3.1'}
 
+  diff@8.0.4:
+    resolution: {integrity: sha512-DPi0FmjiSU5EvQV0++GFDOJ9ASQUVFh5kD+OzOnYdi7n3Wpm9hWWGfB/O2blfHcMVTL5WkQXSnRiK9makhrcnw==}
+    engines: {node: '>=0.3.1'}
+
   dingbat-to-unicode@1.0.1:
     resolution: {integrity: sha512-98l0sW87ZT58pU4i61wa2OHwxbiYSbuxsCBozaVnYX2iCnr3bLM3fIes1/ej7h1YdOKuKt/MLs706TVnALA65w==}
 
@@ -5851,6 +5856,10 @@ packages:
     resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==}
     engines: {node: '>=0.12.0'}
 
+  is-path-inside@3.0.3:
+    resolution: {integrity: sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==}
+    engines: {node: '>=8'}
+
   is-plain-obj@2.1.0:
     resolution: {integrity: sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==}
     engines: {node: '>=8'}
@@ -6402,8 +6411,8 @@ packages:
   lru-cache@10.4.3:
     resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==}
 
-  lru-cache@11.2.2:
-    resolution: {integrity: sha512-F9ODfyqML2coTIsQpSkRHnLSZMtkU8Q+mSfcaIyKwy58u+8k5nvAYeiNhsyMARvzNcXJ9QfWVrcPsC9e9rAxtg==}
+  lru-cache@11.5.3:
+    resolution: {integrity: sha512-U4N8FgzmWxc8k1VH8Kr6lQg18U7Fjvby6wXHVRX/ZZ7IwWbRMgrRbP0Wrb5q5NVinryp4SQampHKdvtecItxUg==}
     engines: {node: 20 || >=22}
 
   lru-cache@5.1.1:
@@ -6734,8 +6743,8 @@ packages:
   mlly@1.7.4:
     resolution: {integrity: sha512-qmdSIPC4bDJXgZTCR7XosJiNKySV7O215tsPtDN9iEO/7q/76b/ijtgRu/+epFXSJhijtTCCGp3DWS549P3xKw==}
 
-  mocha@11.2.2:
-    resolution: {integrity: sha512-VlSBxrPYHK4YNOEbFdkCxHQbZMoNzBkoPprqtZRW6311EUF/DlSxoycE2e/2NtRk4WKkIXzyrXDTrlikJMWgbw==}
+  mocha@11.8.0:
+    resolution: {integrity: sha512-VyCeUdGN3A9lmCTTgG4yuvY9ixxaDk+xt2R/7/+1AP6EqNG+G9OKkzBwhVtVYoNX8YsxNSgAl8mOv3IAeOpFbw==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     hasBin: true
 
@@ -8780,9 +8789,6 @@ packages:
     resolution: {integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==}
     engines: {node: '>=0.10.0'}
 
-  workerpool@6.5.1:
-    resolution: {integrity: sha512-Fs4dNYcsdpYSAfVxhnl1L5zTksjvOJxtC5hzMNl+1t9B8hTJTdKDyZ5ju7ztgPy+ft9tBFXoOlDNiOT9WUXZlA==}
-
   workerpool@9.2.0:
     resolution: {integrity: sha512-PKZqBOCo6CYkVOwAxWxQaSF2Fvb5Iv2fCeTP7buyWI2GiynWr46NcXSgK/idoV6e60dgCBfgYc+Un3HMvmqP8w==}
 
@@ -9418,7 +9424,7 @@ snapshots:
       '@babel/compat-data': 8.0.0
       '@babel/helper-validator-option': 8.0.0
       browserslist: 4.24.5
-      lru-cache: 11.2.2
+      lru-cache: 11.5.3
       semver: 7.8.5
 
   '@babel/helper-create-class-features-plugin@8.0.1(@babel/core@8.0.1)':
@@ -13147,6 +13153,8 @@ snapshots:
 
   diff@5.2.2: {}
 
+  diff@8.0.4: {}
+
   dingbat-to-unicode@1.0.1: {}
 
   dir-glob@3.0.1:
@@ -14440,6 +14448,8 @@ snapshots:
 
   is-number@7.0.0: {}
 
+  is-path-inside@3.0.3: {}
+
   is-plain-obj@2.1.0: {}
 
   is-plain-obj@4.1.0: {}
@@ -15001,7 +15011,7 @@ snapshots:
 
   lru-cache@10.4.3: {}
 
-  lru-cache@11.2.2: {}
+  lru-cache@11.5.3: {}
 
   lru-cache@5.1.1:
     dependencies:
@@ -15577,25 +15587,26 @@ snapshots:
       pkg-types: 1.3.1
       ufo: 1.6.1
 
-  mocha@11.2.2:
+  mocha@11.8.0:
     dependencies:
       browser-stdout: 1.3.1
       chokidar: 4.0.3
       debug: 4.4.3(supports-color@8.1.1)
-      diff: 5.2.2
+      diff: 8.0.4
       escape-string-regexp: 4.0.0
       find-up: 5.0.0
       glob: 11.1.0
       he: 1.2.0
+      is-path-inside: 3.0.3
       js-yaml: 4.2.0
       log-symbols: 4.1.0
-      minimatch: 5.1.6
+      minimatch: 9.0.5
       ms: 2.1.3
       picocolors: 1.1.1
       serialize-javascript: 6.0.2
       strip-json-comments: 3.1.1
       supports-color: 8.1.1
-      workerpool: 6.5.1
+      workerpool: 9.2.0
       yargs: 17.7.2
       yargs-parser: 21.1.1
       yargs-unparser: 2.0.0
@@ -16033,7 +16044,7 @@ snapshots:
 
   path-scurry@2.0.0:
     dependencies:
-      lru-cache: 11.2.2
+      lru-cache: 11.5.3
       minipass: 7.1.2
 
   path-to-regexp@8.2.0: {}
@@ -17872,8 +17883,6 @@ snapshots:
 
   word-wrap@1.2.5: {}
 
-  workerpool@6.5.1: {}
-
   workerpool@9.2.0: {}
 
   wrap-ansi@7.0.0:
diff --git a/src/__tests__/extension.spec.ts b/src/__tests__/extension.spec.ts
index 56ccd52588..d0a8b274b8 100644
--- a/src/__tests__/extension.spec.ts
+++ b/src/__tests__/extension.spec.ts
@@ -12,7 +12,7 @@ vi.mock("vscode", () => ({
 		tabGroups: {
 			onDidChangeTabs: vi.fn(),
 		},
-		onDidChangeActiveTextEditor: vi.fn(),
+		onDidChangeActiveTextEditor: vi.fn().mockReturnValue({ dispose: vi.fn() }),
 	},
 	workspace: {
 		registerTextDocumentContentProvider: vi.fn(),
@@ -205,6 +205,7 @@ vi.mock("../core/webview/ClineProvider", async () => {
 			{
 				// Static method used by extension.ts
 				getVisibleInstance: vi.fn().mockReturnValue(mockInstance),
+				getAllInstances: vi.fn().mockReturnValue([]),
 				sideBarId: "zoo-code.SidebarProvider",
 			},
 		),
@@ -238,6 +239,141 @@ describe("extension.ts", () => {
 		settingsUpdatedHandler = undefined
 	})
 
+	test("initializes the code index scope and registers it for extension cleanup", async () => {
+		vi.resetModules()
+		const { CodeIndexScope } = await import("../services/code-index/code-index-scope")
+		const init = vi.spyOn(CodeIndexScope.prototype, "init")
+		const dispose = vi.spyOn(CodeIndexScope.prototype, "dispose")
+		try {
+			const { activate } = await import("../extension")
+			await activate(mockContext)
+
+			const scopes = mockContext.subscriptions.filter((entry) => entry instanceof CodeIndexScope)
+			expect(scopes).toHaveLength(1)
+			expect(init).toHaveBeenCalledExactlyOnceWith()
+			expect(init.mock.contexts[0]).toBe(scopes[0])
+			expect(dispose).not.toHaveBeenCalled()
+			scopes[0].dispose()
+			expect(dispose).toHaveBeenCalledExactlyOnceWith()
+		} finally {
+			init.mockRestore()
+			dispose.mockRestore()
+		}
+	})
+
+	test("publishes indexing status to matching providers and logs delivery failures", async () => {
+		vi.resetModules()
+		const { CodeIndexScope } = await import("../services/code-index/code-index-scope")
+		const { ClineProvider } = await import("../core/webview/ClineProvider")
+		const log = vi.spyOn(console, "error").mockImplementation(() => {})
+		const provider = ClineProvider.getVisibleInstance()!
+		Object.defineProperty(provider, "workspacePath", { configurable: true, value: "/workspace" })
+		const getAll = vi.mocked(ClineProvider.getAllInstances)
+		const post = vi.mocked(provider.postMessageToWebview)
+		getAll.mockReturnValue([provider, provider])
+		post.mockRejectedValueOnce(new Error("delivery failed")).mockResolvedValue(undefined)
+		try {
+			const { activate } = await import("../extension")
+			await activate(mockContext)
+			const scope = mockContext.subscriptions.find((entry) => entry instanceof CodeIndexScope)!
+			const status = {
+				systemStatus: "Standby" as const,
+				message: "Ready",
+				processedItems: 0,
+				totalItems: 0,
+				currentItemUnit: "blocks",
+				workspacePath: "/workspace",
+				workspaceEnabled: true,
+				autoEnableDefault: true,
+			}
+			scope["statusManager"]!["publishStatus"](status)
+			await Promise.resolve()
+			expect(post).toHaveBeenCalledTimes(2)
+			expect(post).toHaveBeenCalledWith({ type: "indexingStatusUpdate", values: status })
+			expect(log).toHaveBeenCalledWith(
+				"[CodeIndexStatusManager] Failed to publish indexing status:",
+				expect.objectContaining({ message: "delivery failed" }),
+			)
+			scope.dispose()
+		} finally {
+			log.mockRestore()
+			getAll.mockReturnValue([])
+			post.mockReset()
+			Reflect.deleteProperty(provider, "workspacePath")
+		}
+	})
+
+	test.each([
+		{ workspacePath: "/other-workspace", receivesStatus: false },
+		{ workspacePath: "/workspace", receivesStatus: true },
+		{ workspacePath: undefined, receivesStatus: true },
+		{ workspacePath: "", receivesStatus: true },
+	])(
+		"routes status for provider workspace=$workspacePath with receivesStatus=$receivesStatus",
+		async ({ workspacePath, receivesStatus }) => {
+			vi.resetModules()
+			const { CodeIndexScope } = await import("../services/code-index/code-index-scope")
+			const { ClineProvider } = await import("../core/webview/ClineProvider")
+			const provider = ClineProvider.getVisibleInstance()!
+			Object.defineProperty(provider, "workspacePath", { configurable: true, value: workspacePath })
+			const getAll = vi.mocked(ClineProvider.getAllInstances)
+			getAll.mockReturnValue([provider])
+			try {
+				const { activate } = await import("../extension")
+				await activate(mockContext)
+				const scope = mockContext.subscriptions.find((entry) => entry instanceof CodeIndexScope)!
+				const status = {
+					systemStatus: "Indexing" as const,
+					message: "Processing confidential.ts",
+					processedItems: 1,
+					totalItems: 2,
+					currentItemUnit: "files",
+					workspacePath: "/workspace",
+					workspaceEnabled: true,
+					autoEnableDefault: true,
+				}
+				scope["statusManager"]!["publishStatus"](status)
+				await Promise.resolve()
+				if (receivesStatus) {
+					expect(provider.postMessageToWebview).toHaveBeenCalledExactlyOnceWith({
+						type: "indexingStatusUpdate",
+						values: status,
+					})
+				} else {
+					expect(provider.postMessageToWebview).not.toHaveBeenCalled()
+				}
+				scope.dispose()
+			} finally {
+				getAll.mockReturnValue([])
+				Reflect.deleteProperty(provider, "workspacePath")
+			}
+		},
+	)
+
+	test.each([new Error("scope initialization failed"), "scope initialization failed"])(
+		"continues activation and logs code index scope initialization failure: %s",
+		async (error) => {
+			vi.resetModules()
+			const { CodeIndexScope } = await import("../services/code-index/code-index-scope")
+			const init = vi.spyOn(CodeIndexScope.prototype, "init").mockImplementationOnce(() => {
+				throw error
+			})
+			try {
+				const { activate } = await import("../extension")
+				await expect(activate(mockContext)).resolves.toBeDefined()
+
+				const vscode = await import("vscode")
+				const channel = vi.mocked(vscode.window.createOutputChannel).mock.results.at(-1)?.value
+				expect(channel?.appendLine).toHaveBeenCalledWith(
+					"[CodeIndexScope] Failed to initialize: scope initialization failed",
+				)
+				expect(mockContext.subscriptions.filter((entry) => entry instanceof CodeIndexScope)).toHaveLength(1)
+			} finally {
+				init.mockRestore()
+			}
+		},
+	)
+
 	test("does not call dotenv.config when optional .env does not exist", async () => {
 		vi.resetModules()
 		vi.clearAllMocks()
diff --git a/src/api/providers/__tests__/anthropic.spec.ts b/src/api/providers/__tests__/anthropic.spec.ts
index 6a3192798f..a53fc62ce5 100644
--- a/src/api/providers/__tests__/anthropic.spec.ts
+++ b/src/api/providers/__tests__/anthropic.spec.ts
@@ -486,7 +486,6 @@ describe("AnthropicHandler", () => {
 				apiKey: "test-api-key",
 				apiModelId: "claude-opus-5-5",
 				enableReasoningEffort: true,
-				modelMaxTokens: 32768,
 			})
 
 			const stream = opusHandler.createMessage(systemPrompt, [
@@ -502,7 +501,7 @@ describe("AnthropicHandler", () => {
 			const requestOptions = mockCreate.mock.calls[mockCreate.mock.calls.length - 1]?.[1]
 			expect(requestBody?.thinking).toEqual({ type: "adaptive" })
 			expect(requestBody?.temperature).toBeUndefined()
-			expect(requestBody?.max_tokens).toBe(32768)
+			expect(requestBody?.max_tokens).toBe(128_000)
 			expect(requestOptions?.headers?.["anthropic-beta"]).toContain("prompt-caching-2024-07-31")
 		})
 
@@ -755,9 +754,9 @@ describe("AnthropicHandler", () => {
 			expect(model.info.outputPrice).toBe(20.0)
 			expect(model.info.cacheWritesPrice).toBe(5.0)
 			expect(model.info.cacheReadsPrice).toBe(0.2)
-			expect(model.maxTokens).toBe(8192)
+			expect(model.maxTokens).toBe(128000)
 			expect(model.info.supportsReasoningBinary).toBe(true)
-			expect(model.info.supportsReasoningBudget).toBe(true)
+			expect(model.info.supportsReasoningBudget).toBeUndefined()
 			expect(model.info.supportsPromptCache).toBe(true)
 			expect(model.info.supportsTemperature).toBe(false)
 			expect(model.reasoningBudget).toBeUndefined()
diff --git a/src/api/providers/__tests__/openai-sol-6.1.spec.ts b/src/api/providers/__tests__/openai-sol-6.1.spec.ts
new file mode 100644
index 0000000000..ea9e8e59e8
--- /dev/null
+++ b/src/api/providers/__tests__/openai-sol-6.1.spec.ts
@@ -0,0 +1,116 @@
+vitest.mock("@roo-code/telemetry", () => ({
+	TelemetryService: { instance: { captureException: vitest.fn() } },
+}))
+
+import type { ApiHandlerOptions } from "../../../shared/api"
+import { openAiCodexOAuthManager } from "../../../integrations/openai-codex/oauth"
+import { asyncStreamFrom, collectStream } from "../../../test-utils/stream"
+import { OpenAiNativeHandler } from "../openai-native"
+import { OpenAiCodexHandler } from "../openai-codex"
+
+const reasoningCases: { options: ApiHandlerOptions; native: string; codex: string }[] = [
+	{ options: {}, native: "medium", codex: "low" },
+	{ options: { reasoningEffort: "none" }, native: "medium", codex: "low" },
+	{ options: { reasoningEffort: "minimal" }, native: "medium", codex: "low" },
+	{ options: { reasoningEffort: "disable" }, native: "medium", codex: "low" },
+	{ options: { enableReasoningEffort: false }, native: "medium", codex: "low" },
+	...(["low", "medium", "high", "xhigh", "max"] as const).map((effort) => ({
+		options: { reasoningEffort: effort },
+		native: effort,
+		codex: effort,
+	})),
+]
+
+describe("GPT-6.1 Sol requests", () => {
+	afterEach(() => vitest.restoreAllMocks())
+
+	it.each(reasoningCases)("uses supported reasoning for $options", ({ options, native, codex }) => {
+		const settings = { apiModelId: "gpt-6.1-sol", openAiNativeApiKey: "test-key", ...options }
+		const nativeHandler = new OpenAiNativeHandler(settings)
+		const codexHandler = new OpenAiCodexHandler(settings)
+		expect(nativeHandler.getModel().id).toBe("gpt-6.1-sol")
+		expect(codexHandler.getModel().id).toBe("gpt-6.1-sol")
+		expect(nativeHandler["getReasoningEffort"](nativeHandler.getModel())).toBe(native)
+		expect(codexHandler["getReasoningEffort"](codexHandler.getModel())).toBe(codex)
+	})
+
+	it("builds native Responses tool requests with verified pricing and no temperature", () => {
+		const handler = new OpenAiNativeHandler({
+			apiModelId: "gpt-6.1-sol",
+			openAiNativeApiKey: "test-key",
+			openAiNativeServiceTier: "priority",
+			modelTemperature: 0.7,
+		})
+		const model = handler.getModel()
+		const body = handler["buildRequestBody"](model, [], "System", "low", handler["getReasoningEffort"](model), {
+			taskId: "sol-task",
+			tools: [
+				{ type: "function", function: { name: "read_file", parameters: { type: "object", properties: {} } } },
+			],
+		})
+		expect(body).toMatchObject({
+			model: "gpt-6.1-sol",
+			max_output_tokens: 128_000,
+			reasoning: { effort: "medium" },
+			service_tier: "priority",
+			tools: [{ type: "function", name: "read_file", strict: true }],
+		})
+		expect(body).not.toHaveProperty("temperature")
+		expect(handler["applyServiceTierPricing"](model.info, "priority")).toMatchObject({
+			inputPrice: 4,
+			outputPrice: 20,
+			cacheReadsPrice: 0.2,
+			cacheWritesPrice: 5,
+		})
+	})
+
+	it("routes Codex tool requests through Responses Lite with Fast mode and required reasoning", async () => {
+		const handler = new OpenAiCodexHandler({
+			apiModelId: "gpt-6.1-sol",
+			reasoningEffort: "none",
+			openAiCodexServiceTier: "priority",
+		})
+		vitest.spyOn(openAiCodexOAuthManager, "getAccessToken").mockResolvedValue("test-token")
+		vitest.spyOn(openAiCodexOAuthManager, "getAccountId").mockResolvedValue("test-account")
+		const create = vitest.fn().mockResolvedValue(asyncStreamFrom([]))
+		Reflect.set(handler, "client", { responses: { create } })
+		await collectStream(
+			handler.createMessage("System", [{ role: "user", content: "Read the file" }], {
+				taskId: "sol-task",
+				tools: [
+					{
+						type: "function",
+						function: { name: "read_file", parameters: { type: "object", properties: {} } },
+					},
+				],
+			}),
+		)
+		expect(create).toHaveBeenCalledWith(
+			expect.objectContaining({
+				model: "gpt-6.1-sol",
+				service_tier: "priority",
+				prompt_cache_key: "sol-task",
+				reasoning: { effort: "low", summary: "auto", context: "all_turns" },
+				tool_choice: "auto",
+				parallel_tool_calls: false,
+				input: expect.arrayContaining([
+					expect.objectContaining({
+						type: "additional_tools",
+						tools: [expect.objectContaining({ type: "function", name: "read_file" })],
+					}),
+				]),
+			}),
+			expect.objectContaining({
+				headers: expect.objectContaining({
+					"x-openai-internal-codex-responses-lite": "true",
+					"session-id": "sol-task",
+				}),
+			}),
+		)
+		const body = create.mock.calls[0][0]
+		expect(body).not.toHaveProperty("instructions")
+		expect(body).not.toHaveProperty("tools")
+		expect(body).not.toHaveProperty("max_output_tokens")
+		expect(body).not.toHaveProperty("temperature")
+	})
+})
diff --git a/src/api/providers/__tests__/vscode-lm.spec.ts b/src/api/providers/__tests__/vscode-lm.spec.ts
index 8010a27532..86a9a30c38 100644
--- a/src/api/providers/__tests__/vscode-lm.spec.ts
+++ b/src/api/providers/__tests__/vscode-lm.spec.ts
@@ -69,7 +69,15 @@ vi.mock("vscode", () => {
 })
 
 import * as vscode from "vscode"
-import { VsCodeLmHandler, extractLeakedToolCalls, trailingPartialToolMarkerLength } from "../vscode-lm"
+import {
+	VsCodeLmHandler,
+	extractLeakedToolCalls,
+	trailingPartialToolMarkerLength,
+	middleOutTruncate,
+	estimateMessagesChars,
+	truncateToolResultsToFitWindow,
+} from "../vscode-lm"
+import { checkContextWindowExceededError } from "../../../core/context/context-management/context-error-handling"
 import type { ApiHandlerOptions } from "../../../shared/api"
 import type { Anthropic } from "@anthropic-ai/sdk"
 import { openAiModelInfoSaneDefaults, vscodeLlmDefaultModelId, vscodeLlmModels } from "@roo-code/types"
@@ -507,6 +515,174 @@ describe("VsCodeLmHandler", () => {
 			})
 		})
 
+		it("still trims oversized tool_results when the system prompt consumes most of the budget", async () => {
+			// A system prompt large enough to drive the raw budget negative; the clamp keeps trimming
+			// active for the case where the request is most oversized.
+			const systemPrompt = "S".repeat(handler.getCondenseContextWindow() * 3)
+			const messages: Anthropic.Messages.MessageParam[] = [
+				{
+					role: "user",
+					content: [{ type: "text", text: "hi" }],
+				},
+				{
+					role: "assistant",
+					content: [{ type: "tool_use", id: "t1", name: "some_tool", input: { a: 1 } }],
+				},
+				{
+					role: "user",
+					content: [{ type: "tool_result", tool_use_id: "t1", content: "X".repeat(50_000) }],
+				},
+			]
+
+			// No sendRequest response is queued: the request must be refused before it is sent, and a
+			// queued-but-unconsumed response would leak into later tests.
+			// The clamped floor cannot be met once the tool_result bottoms out at its minimum, so the
+			// request must be refused rather than sent over-window (which orphans the tool_result).
+			const stream = handler.createMessage(systemPrompt, messages, { taskId: "test-task" })
+			let refusal: unknown
+			try {
+				for await (const _chunk of stream) {
+					// drain
+				}
+			} catch (error) {
+				refusal = error
+			}
+			const message = (refusal as Error | undefined)?.message ?? ""
+			expect(message).toMatch(/too large for this model's context window/)
+
+			// The reported figure proves trimming ran: without it the estimate would still carry the
+			// full 50,000-char tool_result.
+			const reported = Number(message.match(/estimated ([\d,]+) characters/)?.[1]?.replace(/,/g, ""))
+			expect(reported).toBeLessThan(10_000)
+
+			expect(mockLanguageModelChat.sendRequest).not.toHaveBeenCalled()
+		})
+
+		it("refuses a request that exceeds a small positive raw budget below the trimming floor", async () => {
+			// The clamp to MIN_TOOL_RESULT_CHARS only keeps trimming productive; admission must still
+			// respect the raw budget, otherwise a conversation between the raw budget and the floor is
+			// sent over-window. Sized so the remaining content exceeds the raw budget but stays under
+			// the floor, and so no tool_result is large enough for trimming to shrink anything.
+			const targetRawBudgetChars = 1000
+			const systemPrompt = "S".repeat(
+				Math.floor(handler.getCondenseContextWindow() * 0.8 * 3) - targetRawBudgetChars,
+			)
+			const messages: Anthropic.Messages.MessageParam[] = [
+				{
+					role: "assistant",
+					content: [{ type: "tool_use", id: "t1", name: "some_tool", input: { a: 1 } }],
+				},
+				{
+					role: "user",
+					content: [{ type: "tool_result", tool_use_id: "t1", content: "X".repeat(1999) }],
+				},
+			]
+
+			// No sendRequest response is queued: refusal must happen before the request is sent.
+			const stream = handler.createMessage(systemPrompt, messages, { taskId: "test-task" })
+			await expect(
+				(async () => {
+					for await (const _chunk of stream) {
+						// drain
+					}
+				})(),
+			).rejects.toThrow(/too large for this model's context window/)
+			expect(mockLanguageModelChat.sendRequest).not.toHaveBeenCalled()
+		})
+
+		it("refuses with an error the task recognises as a context-window failure", async () => {
+			// Asserted through the real detector: without a recognised shape the task takes its
+			// generic retry path and re-sends the same over-window history instead of condensing.
+			const systemPrompt = "S".repeat(handler.getCondenseContextWindow() * 3)
+			const messages: Anthropic.Messages.MessageParam[] = [
+				{
+					role: "assistant",
+					content: [{ type: "tool_use", id: "t1", name: "some_tool", input: { a: 1 } }],
+				},
+				{
+					role: "user",
+					content: [{ type: "tool_result", tool_use_id: "t1", content: "X".repeat(50_000) }],
+				},
+			]
+
+			const stream = handler.createMessage(systemPrompt, messages, { taskId: "test-task" })
+			const refusal = await (async () => {
+				try {
+					for await (const _chunk of stream) {
+						// drain
+					}
+				} catch (error) {
+					return error
+				}
+				throw new Error("expected the request to be refused")
+			})()
+
+			expect(checkContextWindowExceededError(refusal)).toBe(true)
+		})
+
+		it("sends a request that fits within a small positive raw budget", async () => {
+			const targetRawBudgetChars = 1000
+			const systemPrompt = "S".repeat(
+				Math.floor(handler.getCondenseContextWindow() * 0.8 * 3) - targetRawBudgetChars,
+			)
+			const messages: Anthropic.Messages.MessageParam[] = [
+				{
+					role: "user",
+					content: [{ type: "text", text: "Y".repeat(500) }],
+				},
+			]
+
+			mockLanguageModelChat.sendRequest.mockResolvedValueOnce({
+				stream: (async function* () {
+					yield new vscode.LanguageModelTextPart("ok")
+					return
+				})(),
+				text: (async function* () {
+					yield "ok"
+					return
+				})(),
+			})
+
+			const stream = handler.createMessage(systemPrompt, messages, { taskId: "test-task" })
+			const chunks = await collectStream(stream)
+
+			expect(mockLanguageModelChat.sendRequest).toHaveBeenCalled()
+			expect(chunks).toContainEqual({ type: "text", text: "ok" })
+		})
+
+		it("sends the request when trimming brings the conversation back under budget", async () => {
+			const messages: Anthropic.Messages.MessageParam[] = [
+				{
+					role: "assistant",
+					content: [{ type: "tool_use", id: "t1", name: "some_tool", input: { a: 1 } }],
+				},
+				{
+					role: "user",
+					content: [{ type: "tool_result", tool_use_id: "t1", content: "X".repeat(500_000) }],
+				},
+			]
+
+			mockLanguageModelChat.sendRequest.mockResolvedValueOnce({
+				stream: (async function* () {
+					yield new vscode.LanguageModelTextPart("ok")
+					return
+				})(),
+				text: (async function* () {
+					yield "ok"
+					return
+				})(),
+			})
+
+			const stream = handler.createMessage("system", messages, { taskId: "test-task" })
+			for await (const _chunk of stream) {
+				// drain
+			}
+
+			const sent = JSON.stringify(mockLanguageModelChat.sendRequest.mock.calls[0][0])
+			expect(sent).toContain("characters truncated")
+			expect(sent).not.toContain("X".repeat(400_000))
+		})
+
 		it("should handle native tool calls when tools are provided", async () => {
 			const systemPrompt = "You are a helpful assistant"
 			const messages: Anthropic.Messages.MessageParam[] = [
@@ -2535,3 +2711,373 @@ describe("leaked tool-call parser scaling", () => {
 		expect(extractLeakedToolCalls(cues(500), tools).calls).toHaveLength(0)
 	})
 })
+
+describe("context-window tool_result truncation", () => {
+	describe("middleOutTruncate", () => {
+		it("returns text unchanged when within the limit", () => {
+			expect(middleOutTruncate("hello world", 100)).toBe("hello world")
+		})
+
+		it("returns text unchanged when its length exactly equals the limit", () => {
+			// Longer than the truncation marker, so `<=` is observable here: the marker-less
+			// fallback for tiny limits would otherwise return the same text under either operator.
+			const text = "A".repeat(200)
+			expect(middleOutTruncate(text, 200)).toBe(text)
+		})
+
+		it("stays within a limit too small to hold the truncation marker", () => {
+			const text = "A".repeat(500)
+			for (const limit of [1, 5, 50]) {
+				const result = middleOutTruncate(text, limit)
+				expect(result).toBe("A".repeat(limit))
+			}
+		})
+
+		it("does not end a marker-less truncation on a lone high surrogate", () => {
+			// Index-based so a surrogate pair contributes BOTH of its code units to the assertion.
+			const codeUnits = (value: string): number[] =>
+				Array.from({ length: value.length }, (_, index) => value.charCodeAt(index))
+
+			// The limit lands between the halves of the pair at index 3, which would otherwise be
+			// emitted alone and make the payload un-encodable as UTF-8.
+			const result = middleOutTruncate(`abc\uD83D\uDE00${"z".repeat(200)}`, 4)
+
+			expect(codeUnits(result)).toEqual(codeUnits("abc"))
+		})
+
+		it("keeps the head and tail and inserts a truncation marker", () => {
+			const text = "A".repeat(500) + "B".repeat(500)
+			const result = middleOutTruncate(text, 200)
+
+			expect(result.length).toBeLessThanOrEqual(200)
+			expect(result).toContain("characters truncated to fit the model context window")
+			expect(result.startsWith("A")).toBe(true)
+			expect(result.endsWith("B")).toBe(true)
+		})
+
+		it("returns an empty string for a non-positive limit", () => {
+			expect(middleOutTruncate("anything", 0)).toBe("")
+		})
+
+		// A lone surrogate cannot be encoded as UTF-8 and 400s the whole request.
+		it("never splits a surrogate pair across the removed middle", () => {
+			const pair = "\u{1F600}" // one astral char = high + low surrogate
+			const text = pair.repeat(400)
+			const result = middleOutTruncate(text, 200)
+
+			expect(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/.test(result)).toBe(false)
+		})
+	})
+
+	describe("truncateToolResultsToFitWindow", () => {
+		const toolUseMessage = (id: string): Anthropic.Messages.MessageParam => ({
+			role: "assistant",
+			content: [
+				{ type: "text", text: "Calling a tool." },
+				{ type: "tool_use", id, name: "some_tool", input: { a: 1 } },
+			],
+		})
+
+		const toolResultMessage = (id: string, content: string): Anthropic.Messages.MessageParam => ({
+			role: "user",
+			content: [
+				{ type: "tool_result", tool_use_id: id, content },
+				{ type: "text", text: "<environment_details>env</environment_details>" },
+			],
+		})
+
+		const findBlock = (message: Anthropic.Messages.MessageParam, type: string) =>
+			(message.content as unknown as Array<{ type: string; [key: string]: unknown }>).find(
+				(block) => block.type === type,
+			)!
+
+		it("is a no-op when the conversation already fits the budget", () => {
+			const messages: Anthropic.Messages.MessageParam[] = [
+				toolUseMessage("t1"),
+				toolResultMessage("t1", "small result"),
+			]
+			const before = JSON.parse(JSON.stringify(messages))
+
+			truncateToolResultsToFitWindow(messages, 100_000)
+
+			expect(messages).toEqual(before)
+		})
+
+		it("returns messages untouched when the budget is not a usable number", () => {
+			const messages: Anthropic.Messages.MessageParam[] = [
+				toolUseMessage("t1"),
+				toolResultMessage("t1", "Y".repeat(50_000)),
+			]
+			const before = JSON.parse(JSON.stringify(messages))
+
+			expect(truncateToolResultsToFitWindow(messages, 0).messages).toBe(messages)
+			expect(truncateToolResultsToFitWindow(messages, Number.NaN).messages).toBe(messages)
+			expect(messages).toEqual(before)
+		})
+
+		it("returns a remainingChars equal to a fresh scan on every path", () => {
+			// The caller trusts remainingChars instead of re-scanning, so incremental bookkeeping
+			// that drifts from estimateMessagesChars would silently admit an over-window request.
+			const scenarios: Array<{ name: string; messages: Anthropic.Messages.MessageParam[]; budget: number }> = [
+				{
+					name: "unusable budget",
+					messages: [toolUseMessage("t1"), toolResultMessage("t1", "Y".repeat(50_000))],
+					budget: 0,
+				},
+				{
+					name: "already fits",
+					messages: [toolUseMessage("t1"), toolResultMessage("t1", "small result")],
+					budget: 100_000,
+				},
+				{
+					name: "single oversized result",
+					messages: [toolUseMessage("t1"), toolResultMessage("t1", "X".repeat(50_000))],
+					budget: 10_000,
+				},
+				{
+					name: "several results, largest first",
+					messages: [
+						toolUseMessage("t1"),
+						toolResultMessage("t1", "B".repeat(40_000)),
+						toolUseMessage("t2"),
+						toolResultMessage("t2", "C".repeat(20_000)),
+						toolUseMessage("t3"),
+						toolResultMessage("t3", "small but real result"),
+					],
+					budget: 12_000,
+				},
+				{
+					name: "floor reached, budget unreachable",
+					messages: [
+						toolUseMessage("t1"),
+						toolResultMessage("t1", "D".repeat(30_000)),
+						toolUseMessage("t2"),
+						toolResultMessage("t2", "E".repeat(30_000)),
+					],
+					budget: 100,
+				},
+				{
+					name: "array-form content with an image part",
+					messages: [
+						toolUseMessage("t1"),
+						{
+							role: "user",
+							content: [
+								{
+									type: "tool_result",
+									tool_use_id: "t1",
+									content: [
+										{ type: "text", text: "Z".repeat(50_000) },
+										{
+											type: "image",
+											source: { type: "base64", media_type: "image/png", data: "abc" },
+										},
+									],
+								},
+							],
+						} as unknown as Anthropic.Messages.MessageParam,
+					],
+					budget: 9_000,
+				},
+				{
+					name: "plain string turn and a non-string non-array tool_result",
+					messages: [
+						{ role: "user", content: "a plain string turn" },
+						toolUseMessage("t1"),
+						toolResultMessage("t1", "F".repeat(50_000)),
+						{
+							role: "user",
+							content: [{ type: "tool_result", tool_use_id: "t2", content: undefined }],
+						} as unknown as Anthropic.Messages.MessageParam,
+					],
+					budget: 10_000,
+				},
+				{
+					name: "astral characters that truncation may trim by a surrogate",
+					messages: [toolUseMessage("t1"), toolResultMessage("t1", "😀".repeat(20_000))],
+					budget: 7_000,
+				},
+			]
+
+			for (const scenario of scenarios) {
+				const { messages, remainingChars } = truncateToolResultsToFitWindow(scenario.messages, scenario.budget)
+				expect(`${scenario.name}:${remainingChars}`).toBe(`${scenario.name}:${estimateMessagesChars(messages)}`)
+			}
+		})
+
+		it("truncates the largest tool_result first, sparing a smaller one above the floor", () => {
+			// Both results sit above MIN_TOOL_RESULT_CHARS, so descending order is what spares the
+			// smaller one; ascending order would shrink it before reaching the larger result.
+			const messages: Anthropic.Messages.MessageParam[] = [
+				toolUseMessage("t1"),
+				toolResultMessage("t1", "B".repeat(30_000)),
+				toolUseMessage("t2"),
+				toolResultMessage("t2", "C".repeat(5_000)),
+			]
+
+			truncateToolResultsToFitWindow(messages, 20_000)
+
+			expect(String(findBlock(messages[1], "tool_result").content)).toContain("characters truncated")
+			expect(findBlock(messages[3], "tool_result").content).toBe("C".repeat(5_000))
+		})
+
+		it("truncates array-form tool_result content and preserves non-text parts", () => {
+			const messages: Anthropic.Messages.MessageParam[] = [
+				toolUseMessage("t1"),
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "t1",
+							content: [
+								{ type: "text", text: "Z".repeat(50_000) },
+								{ type: "image", source: { type: "base64", media_type: "image/png", data: "abc" } },
+							],
+						},
+					],
+				} as unknown as Anthropic.Messages.MessageParam,
+			]
+
+			truncateToolResultsToFitWindow(messages, 10_000)
+
+			const toolResult = findBlock(messages[1], "tool_result")
+			const parts = toolResult.content as Array<{ type: string; text?: string }>
+			expect(parts[0].text).toContain("characters truncated")
+			// Exact shape: a surviving original text part would leave a third element behind.
+			expect(parts.map((part) => part.type)).toEqual(["text", "image"])
+		})
+
+		it("ignores string content and skips messages that cannot hold tool_result blocks", () => {
+			const messages: Anthropic.Messages.MessageParam[] = [
+				{ role: "user", content: "a plain string turn" },
+				toolUseMessage("t1"),
+				{
+					role: "user",
+					content: [
+						{ type: "tool_result", tool_use_id: "t1", content: "W".repeat(50_000) },
+						{ type: "image", source: { type: "base64", media_type: "image/png", data: "abc" } },
+					],
+				} as unknown as Anthropic.Messages.MessageParam,
+			]
+
+			truncateToolResultsToFitWindow(messages, 10_000)
+
+			expect(messages[0].content).toBe("a plain string turn")
+			expect(String(findBlock(messages[2], "tool_result").content)).toContain("characters truncated")
+		})
+
+		it("ignores a tool_result whose content is neither string nor array", () => {
+			const messages: Anthropic.Messages.MessageParam[] = [
+				toolUseMessage("t1"),
+				toolResultMessage("t1", "V".repeat(50_000)),
+				{
+					role: "user",
+					content: [{ type: "tool_result", tool_use_id: "t2", content: undefined }],
+				} as unknown as Anthropic.Messages.MessageParam,
+			]
+
+			truncateToolResultsToFitWindow(messages, 10_000)
+
+			expect(findBlock(messages[2], "tool_result").content).toBeUndefined()
+			expect(String(findBlock(messages[1], "tool_result").content)).toContain("characters truncated")
+		})
+
+		it("leaves every tool_result untouched when the conversation already fits the budget", () => {
+			// Budget exceeds the estimated total, so the early return fires and nothing is trimmed.
+			const messages: Anthropic.Messages.MessageParam[] = [
+				toolUseMessage("t1"),
+				toolResultMessage("t1", "U".repeat(3000)),
+				toolUseMessage("t2"),
+				toolResultMessage("t2", "T".repeat(2500)),
+			]
+
+			truncateToolResultsToFitWindow(messages, 5700)
+
+			expect(findBlock(messages[1], "tool_result").content).toBe("U".repeat(3000))
+			expect(findBlock(messages[3], "tool_result").content).toBe("T".repeat(2500))
+		})
+
+		it("leaves a tool_result at or below the minimum size alone", () => {
+			const shortResult = "S".repeat(1500)
+			const messages: Anthropic.Messages.MessageParam[] = [
+				toolUseMessage("t1"),
+				toolResultMessage("t1", shortResult),
+				toolUseMessage("t2"),
+				toolResultMessage("t2", shortResult),
+			]
+
+			truncateToolResultsToFitWindow(messages, 100)
+
+			expect(findBlock(messages[1], "tool_result").content).toBe(shortResult)
+			expect(findBlock(messages[3], "tool_result").content).toBe(shortResult)
+		})
+
+		it("shrinks an oversized tool_result so the conversation fits the budget", () => {
+			const messages: Anthropic.Messages.MessageParam[] = [
+				toolUseMessage("t1"),
+				toolResultMessage("t1", "X".repeat(50_000)),
+			]
+
+			truncateToolResultsToFitWindow(messages, 10_000)
+
+			const toolResult = findBlock(messages[1], "tool_result")
+			expect(toolResult.tool_use_id).toBe("t1") // pairing preserved
+			expect(String(toolResult.content).length).toBeLessThanOrEqual(10_000)
+			expect(String(toolResult.content)).toContain("characters truncated")
+		})
+
+		it("truncates the largest tool_result first and leaves small ones intact", () => {
+			const small = "small but real result"
+			const messages: Anthropic.Messages.MessageParam[] = [
+				toolUseMessage("t1"),
+				toolResultMessage("t1", "B".repeat(40_000)),
+				toolUseMessage("t2"),
+				toolResultMessage("t2", small),
+			]
+
+			truncateToolResultsToFitWindow(messages, 12_000)
+
+			expect(String(findBlock(messages[1], "tool_result").content)).toContain("characters truncated")
+			expect(findBlock(messages[3], "tool_result").content).toBe(small) // untouched
+		})
+
+		it("never truncates tool_use blocks, assistant text, or environment details", () => {
+			const messages: Anthropic.Messages.MessageParam[] = [
+				toolUseMessage("t1"),
+				toolResultMessage("t1", "X".repeat(50_000)),
+			]
+
+			truncateToolResultsToFitWindow(messages, 8_000)
+
+			expect(findBlock(messages[0], "text").text).toBe("Calling a tool.")
+			expect(findBlock(messages[0], "tool_use")).toMatchObject({ id: "t1", name: "some_tool" })
+			expect(findBlock(messages[1], "text").text).toBe("<environment_details>env</environment_details>")
+		})
+
+		it("handles array-form tool_result content and keeps it valid", () => {
+			const messages: Anthropic.Messages.MessageParam[] = [
+				toolUseMessage("t1"),
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "t1",
+							content: [{ type: "text", text: "Y".repeat(40_000) }],
+						},
+					],
+				},
+			]
+
+			truncateToolResultsToFitWindow(messages, 8_000)
+
+			const toolResult = findBlock(messages[1], "tool_result")
+			expect(toolResult.tool_use_id).toBe("t1")
+			expect(Array.isArray(toolResult.content)).toBe(true)
+			const parts = toolResult.content as Array<{ type: string; text?: string }>
+			expect(parts[0].type).toBe("text")
+			expect(String(parts[0].text)).toContain("characters truncated")
+		})
+	})
+})
diff --git a/src/api/providers/fetchers/__tests__/opencode-go.spec.ts b/src/api/providers/fetchers/__tests__/opencode-go.spec.ts
index 123e912f7f..b39e4e772c 100644
--- a/src/api/providers/fetchers/__tests__/opencode-go.spec.ts
+++ b/src/api/providers/fetchers/__tests__/opencode-go.spec.ts
@@ -197,6 +197,7 @@ describe("Opencode Go Fetchers", () => {
 				"glm-5",
 				"deepseek-v4-pro",
 				"deepseek-v4-flash",
+				"deepseek-v4.1-flash",
 				"deepseek-v4-flash-vision-exp",
 				"qwen3.7-max",
 				"qwen3.8-max",
@@ -257,6 +258,19 @@ describe("Opencode Go Fetchers", () => {
 			expect(info.supportsReasoningEffort).toEqual(["disable", "low", "medium", "high", "xhigh"])
 		})
 
+		it("resolves DeepSeek V4.1 Flash to its 1M context when live metadata is absent", () => {
+			const info = parseOpencodeGoModel({ id: "deepseek-v4.1-flash" })
+			expect(info.contextWindow).toBe(1_000_000)
+			expect(info.maxTokens).toBe(384_000)
+			expect(info.supportsPromptCache).toBe(true)
+			expect(info.supportsMaxTokens).toBe(true)
+			expect(info.supportsReasoningEffort).toEqual(["disable", "low", "medium", "high", "xhigh"])
+			expect(info.supportsImages).toBe(true)
+			expect(info.inputPrice).toBe(0.3)
+			expect(info.outputPrice).toBe(1.2)
+			expect(info.cacheReadsPrice).toBe(0.006)
+		})
+
 		it("resolves GLM-5.2 with its 1M context and High/Max reasoning effort", () => {
 			const info = parseOpencodeGoModel({ id: "glm-5.2" })
 			expect(info.contextWindow).toBe(1_000_000)
diff --git a/src/api/providers/openai-codex.ts b/src/api/providers/openai-codex.ts
index 1498aafc66..ff8f4a24b0 100644
--- a/src/api/providers/openai-codex.ts
+++ b/src/api/providers/openai-codex.ts
@@ -41,7 +41,7 @@ type OpenAiCodexRequestServiceTier = typeof OpenAiCodexServiceTier.Priority
 const CODEX_API_BASE_URL = "https://chatgpt.com/backend-api/codex"
 const LUNA_MODEL_ID = "gpt-5.6-luna"
 const LUNA_CODEX_VERSION = "0.144.0"
-const RESPONSES_LITE_MODEL_IDS = new Set<OpenAiCodexModelId>([LUNA_MODEL_ID, "gpt-6-astra"])
+const RESPONSES_LITE_MODEL_IDS = new Set<OpenAiCodexModelId>([LUNA_MODEL_ID, "gpt-6-astra", "gpt-6.1-sol"])
 
 /**
  * A refusal is streamed as text so the chat still shows why the model declined, but it is not part
diff --git a/src/api/providers/vscode-lm.ts b/src/api/providers/vscode-lm.ts
index d1ede2d09e..2771227680 100644
--- a/src/api/providers/vscode-lm.ts
+++ b/src/api/providers/vscode-lm.ts
@@ -24,6 +24,8 @@ import {
 	sanitizeToolNameSurrogates,
 } from "../transform/vscode-lm-format"
 
+import { CONTEXT_WINDOW_EXCEEDED_STATUS } from "../../core/context/context-management/context-error-handling"
+
 import { BaseProvider } from "./base-provider"
 import type { SingleCompletionHandler, ApiHandlerCreateMessageMetadata, CompletePromptOptions } from "../index"
 
@@ -357,6 +359,210 @@ function declaredParamType(schema: Record<string, unknown> | undefined, paramNam
 	return undefined
 }
 
+/**
+ * Context-window safety for Copilot's backend
+ * -------------------------------------------
+ * Copilot's backend enforces its own context window and, for third-party `sendRequest` callers,
+ * trims an over-window request in a way that is NOT tool-pair-aware: it can drop the assistant
+ * message holding a `tool_use` while keeping the matching `tool_result`, after which Anthropic
+ * rejects the request with "unexpected tool_use_id". To keep trimming on OUR side — where
+ * pairing is preserved — we shrink oversized `tool_result` payloads before sending. Only
+ * `tool_result` text is truncated (never `tool_use`, assistant text, summaries, or environment
+ * details), and only when the request would otherwise exceed the budget.
+ */
+
+/**
+ * Conservative characters-per-token ratio used to turn a token window into a character budget.
+ *
+ * `client.countTokens` is the model's real tokenizer, but it counts only a string: it cannot price
+ * the tool schemas, image placeholders, or per-message framing the backend adds, so it cannot give
+ * the true total for the request we are about to send. It is also an async, per-call RPC, and the
+ * budget is needed for every message on every turn. We therefore keep a character estimate here
+ * and stay deliberately conservative — 3 chars/token rather than the ~4 typical of English —
+ * because the token-dense JSON, logs, and code that dominate oversized tool results tokenize to
+ * fewer characters per token than prose. Under-counting biases toward trimming too early, which is
+ * recoverable; over-counting sends an over-window request, which is not.
+ */
+const VSCODE_LM_BUDGET_CHARS_PER_TOKEN = 3
+
+/**
+ * Fraction of the context window the *entire* input (system prompt + tool schemas + conversation)
+ * is allowed to occupy. The remaining headroom absorbs char/token estimation variance and any
+ * output/overhead the backend reserves.
+ */
+const VSCODE_LM_INPUT_BUDGET_FRACTION = 0.8
+
+/** A tool_result is never shrunk below this many characters, so a truncated result stays useful. */
+const MIN_TOOL_RESULT_CHARS = 2000
+
+/**
+ * Length charged for an image block. VS Code LM cannot carry image data, so
+ * `convertToVsCodeLmMessages` replaces each image with a sentence-long textual placeholder; this
+ * is that placeholder's approximate length.
+ */
+const IMAGE_PLACEHOLDER_CHARS = 64
+
+function readToolResultText(block: Anthropic.Messages.ContentBlockParam): string | undefined {
+	if (!block || (block as { type?: string }).type !== "tool_result") {
+		return undefined
+	}
+	const content = (block as Anthropic.Messages.ToolResultBlockParam).content
+	if (typeof content === "string") {
+		return content
+	}
+	if (Array.isArray(content)) {
+		return content
+			.filter((part): part is Anthropic.Messages.TextBlockParam => (part as { type?: string })?.type === "text")
+			.map((part) => part.text ?? "")
+			.join("")
+	}
+	return undefined
+}
+
+function writeToolResultText(block: Anthropic.Messages.ContentBlockParam, text: string): void {
+	const toolResult = block as Anthropic.Messages.ToolResultBlockParam
+	const content = toolResult.content
+	if (Array.isArray(content)) {
+		// Preserve any non-text parts (e.g. images) and collapse the text into one truncated part.
+		const nonText = content.filter((part) => (part as { type?: string })?.type !== "text")
+		toolResult.content = [{ type: "text", text }, ...nonText] as typeof content
+		return
+	}
+	toolResult.content = text
+}
+
+/**
+ * Drops a trailing lone high surrogate, whose low half was cut away. A lone surrogate cannot be
+ * encoded as UTF-8, and the backend 400s the whole request when one is present.
+ */
+function trimTrailingHighSurrogate(text: string): string {
+	return text.length > 0 && (text.charCodeAt(text.length - 1) & 0xfc00) === 0xd800 ? text.slice(0, -1) : text
+}
+
+/**
+ * Middle-out truncate `text` to at most `maxChars`, keeping the head and tail and replacing the
+ * middle with a marker noting how many characters were removed. Head/tail are preserved because
+ * logs and file dumps carry the most signal at their start (structure) and end (recent output).
+ */
+export function middleOutTruncate(text: string, maxChars: number): string {
+	if (maxChars <= 0) {
+		return ""
+	}
+	if (text.length <= maxChars) {
+		return text
+	}
+
+	const buildMarker = (removed: number) =>
+		`\n\n[... ${removed.toLocaleString("en-US")} characters truncated to fit the model context window ...]\n\n`
+
+	// Reserve room for the marker, sized against the original length so the result never grows.
+	const reservedMarkerLength = buildMarker(text.length).length
+	// A budget too small to hold the marker cannot describe its own truncation without breaking the
+	// maxChars promise this function makes to callers, so drop the marker and keep a bare head.
+	if (maxChars <= reservedMarkerLength) {
+		return trimTrailingHighSurrogate(text.slice(0, maxChars))
+	}
+	const keep = maxChars - reservedMarkerLength
+	const headLength = Math.ceil(keep / 2)
+	const tailLength = keep - headLength
+	const head = trimTrailingHighSurrogate(text.slice(0, headLength))
+	let tail = tailLength > 0 ? text.slice(text.length - tailLength) : ""
+	// Likewise, don't start the tail on a lone low surrogate (its high half is in the removed middle).
+	if (tail.length > 0 && (tail.charCodeAt(0) & 0xfc00) === 0xdc00) {
+		tail = tail.slice(1)
+	}
+	const removed = text.length - head.length - tail.length
+	return `${head}${buildMarker(removed)}${tail}`
+}
+
+/** Estimated character cost of a whole conversation, using the same accounting as truncation. */
+export function estimateMessagesChars(messages: Anthropic.Messages.MessageParam[]): number {
+	return messages.reduce((sum, message) => sum + estimateContentChars(message.content), 0)
+}
+
+function estimateContentChars(content: Anthropic.Messages.MessageParam["content"]): number {
+	if (typeof content === "string") {
+		return content.length
+	}
+	if (!Array.isArray(content)) {
+		return 0
+	}
+	let total = 0
+	for (const block of content) {
+		const type = (block as { type?: string })?.type
+		if (type === "text") {
+			total += (block as Anthropic.Messages.TextBlockParam).text?.length ?? 0
+		} else if (type === "tool_result") {
+			total += readToolResultText(block)?.length ?? 0
+		} else if (type === "tool_use") {
+			total += JSON.stringify((block as Anthropic.Messages.ToolUseBlockParam).input ?? {}).length
+		} else if (type === "image") {
+			// VS Code LM cannot send image data; convertToVsCodeLmMessages substitutes a textual
+			// placeholder, so charge that placeholder's real length rather than a token-sized guess.
+			total += IMAGE_PLACEHOLDER_CHARS
+		}
+	}
+	return total
+}
+
+/**
+ * Shrinks oversized `tool_result` payloads (largest first, middle-out) until the conversation fits
+ * `budgetChars`. Mutates the tool_result blocks of the supplied messages in place — callers pass a
+ * cloned array (see `createMessage`) so stored history is never mutated. A no-op when the
+ * conversation already fits. `remainingChars` is the post-truncation cost, equal to
+ * `estimateMessagesChars(messages)`, so callers need not re-scan.
+ */
+export function truncateToolResultsToFitWindow(
+	messages: Anthropic.Messages.MessageParam[],
+	budgetChars: number,
+): { messages: Anthropic.Messages.MessageParam[]; remainingChars: number } {
+	const initialTotal = () => messages.reduce((sum, message) => sum + estimateContentChars(message.content), 0)
+	if (!Number.isFinite(budgetChars) || budgetChars <= 0) {
+		return { messages, remainingChars: initialTotal() }
+	}
+
+	let total = initialTotal()
+	if (total <= budgetChars) {
+		return { messages, remainingChars: total }
+	}
+
+	// Collect every truncatable tool_result block, largest first. The text is derived once per
+	// block here because the comparator and the truncation loop below would otherwise re-derive it.
+	const blockText = new Map<Anthropic.Messages.ContentBlockParam, string>()
+	for (const message of messages) {
+		if (!Array.isArray(message.content)) {
+			continue
+		}
+		for (const block of message.content) {
+			const text = readToolResultText(block)
+			if (text !== undefined) {
+				blockText.set(block, text)
+			}
+		}
+	}
+	const toolResultBlocks = [...blockText.keys()]
+	toolResultBlocks.sort((a, b) => (blockText.get(b)?.length ?? 0) - (blockText.get(a)?.length ?? 0))
+
+	for (const block of toolResultBlocks) {
+		if (total <= budgetChars) {
+			break
+		}
+		const text = blockText.get(block)
+		if (text === undefined || text.length <= MIN_TOOL_RESULT_CHARS) {
+			continue
+		}
+
+		const overage = total - budgetChars
+		const target = Math.max(MIN_TOOL_RESULT_CHARS, text.length - overage)
+
+		const truncated = middleOutTruncate(text, target)
+		total -= text.length - truncated.length
+		writeToolResultText(block, truncated)
+	}
+
+	return { messages, remainingChars: total }
+}
+
 /**
  * Converts one leaked parameter's raw text to the type its schema declares.
  *
@@ -843,6 +1049,45 @@ export class VsCodeLmHandler extends BaseProvider implements SingleCompletionHan
 			content: this.cleanMessageContent(msg.content),
 		}))
 
+		// Keep context-window trimming on OUR side. Copilot's backend trims an over-window request
+		// without preserving tool_use/tool_result pairing, which orphans a tool_result and triggers a
+		// 400 ("unexpected tool_use_id"). See truncateToolResultsToFitWindow.
+		const contextWindowTokens = this.getCondenseContextWindow()
+		if (Number.isFinite(contextWindowTokens) && contextWindowTokens > 0) {
+			const toolSchemaChars = metadata?.tools ? JSON.stringify(metadata.tools).length : 0
+			const rawBudgetChars =
+				contextWindowTokens * VSCODE_LM_INPUT_BUDGET_FRACTION * VSCODE_LM_BUDGET_CHARS_PER_TOKEN -
+				systemPrompt.length -
+				toolSchemaChars
+			// A system prompt or tool schema large enough to consume the whole budget would leave a
+			// non-positive budget, which disables trimming exactly when the request is most oversized.
+			const messagesBudgetChars = Math.max(MIN_TOOL_RESULT_CHARS, rawBudgetChars)
+			const { remainingChars } = truncateToolResultsToFitWindow(cleanedMessages, messagesBudgetChars)
+
+			// Shrinking tool_results cannot always reach the budget: each keeps MIN_TOOL_RESULT_CHARS,
+			// and the excess may be non-tool content (a huge paste, tool_use inputs, or the system
+			// prompt) that we must not touch. Dropping messages here would orphan a tool_result from
+			// its tool_use — the exact 400 this guard exists to prevent — so fail loudly instead of
+			// sending a request we already know is over the window.
+			// Admission is judged against the RAW budget, not the clamped one: the clamp exists only
+			// to keep trimming productive, so accepting up to it would send a request the window
+			// genuinely cannot hold whenever the raw budget falls below MIN_TOOL_RESULT_CHARS.
+			if (remainingChars > rawBudgetChars) {
+				// `status` is what makes checkContextWindowExceededError recognise this as a context
+				// -window failure; without it the task takes its generic retry path and re-sends the
+				// same over-window history instead of condensing.
+				throw Object.assign(
+					new Error(
+						"Zoo Code <Language Model API>: The request is too large for this model's context window " +
+							`(estimated ${remainingChars.toLocaleString("en-US")} characters against a budget of ` +
+							`${Math.max(0, Math.floor(rawBudgetChars)).toLocaleString("en-US")}), and it cannot be reduced further without ` +
+							"breaking tool-call pairing. Condense the conversation or start a new task.",
+					),
+					{ status: CONTEXT_WINDOW_EXCEEDED_STATUS },
+				)
+			}
+		}
+
 		// Convert Anthropic messages to VS Code LM messages
 		const vsCodeLmMessages: vscode.LanguageModelChatMessage[] = [
 			vscode.LanguageModelChatMessage.Assistant(sanitizeSurrogates(systemPrompt)),
diff --git a/src/core/assistant-message/NativeToolCallParser.ts b/src/core/assistant-message/NativeToolCallParser.ts
index 10a4446182..122579c2a0 100644
--- a/src/core/assistant-message/NativeToolCallParser.ts
+++ b/src/core/assistant-message/NativeToolCallParser.ts
@@ -61,7 +61,17 @@ export class NativeToolCallParser {
 	// Raw chunk tracking state (keyed by index from one API stream)
 	private static rawChunkTrackersByScope = new WeakMap<
 		object,
-		Map<number, { id: string; name: string; hasStarted: boolean; deltaBuffer: string[] }>
+		Map<
+			number,
+			{
+				id?: string
+				name: string
+				// Track whether the provider sent a name, including an empty name.
+				nameSeen: boolean
+				hasStarted: boolean
+				deltaBuffer: string[]
+			}
+		>
 	>()
 
 	public static createScope(): object {
@@ -124,49 +134,54 @@ export class NativeToolCallParser {
 
 		let tracked = rawChunkTracker.get(index)
 
-		// Initialize new tool call tracking when we receive an id
-		if (id && !tracked) {
+		// Create the tracker on first sight of this index, independent of whether
+		// an id has arrived yet. Keying the lifecycle by index (not id) ensures any
+		// `arguments` that stream before the id is known are buffered rather than dropped.
+		if (!tracked) {
 			tracked = {
 				id,
 				name: name || "",
+				nameSeen: name !== undefined,
 				hasStarted: false,
 				deltaBuffer: [],
 			}
 			rawChunkTracker.set(index, tracked)
 		}
 
-		if (!tracked) {
-			return events
+		// Record id and name as they arrive (they may come in separate chunks).
+		if (id) {
+			tracked.id = id
 		}
-
-		// Update name if present in chunk and not yet set
-		if (name) {
+		if (name !== undefined) {
 			tracked.name = name
+			tracked.nameSeen = true
 		}
 
-		// Emit start event when we have the name
-		if (!tracked.hasStarted && tracked.name) {
+		// Emit start event only once both id and name are known. Using a local
+		// non-null id keeps emitted events typed as id: string.
+		if (!tracked.hasStarted && tracked.id && tracked.nameSeen) {
+			const startedId = tracked.id
 			events.push({
 				type: "tool_call_start",
-				id: tracked.id,
+				id: startedId,
 				name: tracked.name,
 			})
 			tracked.hasStarted = true
 
-			// Flush buffered deltas
+			// Flush buffered deltas accumulated during the pre-start window.
 			for (const bufferedDelta of tracked.deltaBuffer) {
 				events.push({
 					type: "tool_call_delta",
-					id: tracked.id,
+					id: startedId,
 					delta: bufferedDelta,
 				})
 			}
 			tracked.deltaBuffer = []
 		}
 
-		// Emit delta event for argument chunks
+		// Emit delta event for argument chunks, buffering until start is emitted.
 		if (args) {
-			if (tracked.hasStarted) {
+			if (tracked.hasStarted && tracked.id) {
 				events.push({
 					type: "tool_call_delta",
 					id: tracked.id,
@@ -190,7 +205,7 @@ export class NativeToolCallParser {
 
 		if (rawChunkTracker) {
 			for (const [, tracked] of rawChunkTracker.entries()) {
-				if (tracked.hasStarted) {
+				if (tracked.hasStarted && tracked.id) {
 					events.push({
 						type: "tool_call_end",
 						id: tracked.id,
diff --git a/src/core/assistant-message/__tests__/NativeToolCallParser.spec.ts b/src/core/assistant-message/__tests__/NativeToolCallParser.spec.ts
index 47ea2a36cc..ee79d7963f 100644
--- a/src/core/assistant-message/__tests__/NativeToolCallParser.spec.ts
+++ b/src/core/assistant-message/__tests__/NativeToolCallParser.spec.ts
@@ -1,4 +1,4 @@
-import { NativeToolCallParser } from "../NativeToolCallParser"
+import { NativeToolCallParser, type ToolCallStreamEvent } from "../NativeToolCallParser"
 
 describe("NativeToolCallParser", () => {
 	describe("parseToolCall", () => {
@@ -289,6 +289,69 @@ describe("NativeToolCallParser", () => {
 	})
 
 	describe("processStreamingChunk", () => {
+		it("preserves read_file arguments that arrive before the call id and name", () => {
+			const scope = NativeToolCallParser.createScope()
+			const argumentsJson = JSON.stringify({ path: "src/leading.ts", mode: "slice", offset: 1, limit: 2000 })
+			const split = 24
+
+			expect(
+				NativeToolCallParser.processRawChunk({ index: 0, arguments: argumentsJson.slice(0, split) }, scope),
+			).toEqual([])
+
+			const identifiedEvents = NativeToolCallParser.processRawChunk(
+				{ index: 0, id: "call_late_identity", name: "read_file" },
+				scope,
+			)
+			expect(identifiedEvents).toEqual([
+				{ type: "tool_call_start", id: "call_late_identity", name: "read_file" },
+				{
+					type: "tool_call_delta",
+					id: "call_late_identity",
+					delta: argumentsJson.slice(0, split),
+				},
+			])
+
+			NativeToolCallParser.startStreamingToolCall("call_late_identity", "read_file", scope)
+			for (const event of identifiedEvents) {
+				if (event.type === "tool_call_delta") {
+					NativeToolCallParser.processStreamingChunk(event.id, event.delta, scope)
+				}
+			}
+
+			const trailingEvents = NativeToolCallParser.processRawChunk(
+				{ index: 0, arguments: argumentsJson.slice(split) },
+				scope,
+			)
+			expect(trailingEvents).toEqual([
+				{
+					type: "tool_call_delta",
+					id: "call_late_identity",
+					delta: argumentsJson.slice(split),
+				},
+			])
+			for (const event of trailingEvents) {
+				if (event.type === "tool_call_delta") {
+					NativeToolCallParser.processStreamingChunk(event.id, event.delta, scope)
+				}
+			}
+
+			expect(NativeToolCallParser.finalizeRawChunks(scope)).toEqual([
+				{ type: "tool_call_end", id: "call_late_identity" },
+			])
+			const result = NativeToolCallParser.finalizeStreamingToolCall("call_late_identity", scope)
+			expect(result?.type).toBe("tool_use")
+			if (result?.type === "tool_use") {
+				expect(result.nativeArgs).toEqual({ path: "src/leading.ts", mode: "slice", offset: 1, limit: 2000 })
+			}
+		})
+
+		it("does not emit an end event for argument chunks that never receive an identity", () => {
+			const scope = NativeToolCallParser.createScope()
+			NativeToolCallParser.processRawChunk({ index: 0, arguments: '{"path":"orphan.ts"}' }, scope)
+
+			expect(NativeToolCallParser.finalizeRawChunks(scope)).toEqual([])
+		})
+
 		it("retains peer calls until each call in a scope is finalized", () => {
 			const scope = NativeToolCallParser.createScope()
 			NativeToolCallParser.startStreamingToolCall("call_first", "read_file", scope)
@@ -391,11 +454,14 @@ describe("NativeToolCallParser", () => {
 			expect(NativeToolCallParser.finalizeRawChunks(firstScope)).toEqual([])
 			expect(NativeToolCallParser.finalizeStreamingToolCall("call_first", firstScope)).toBeNull()
 			expect(
-				NativeToolCallParser.processRawChunk({ index: 0, arguments: "ignored-after-cleanup" }, firstScope),
+				NativeToolCallParser.processRawChunk({ index: 0, arguments: "buffered-after-cleanup" }, firstScope),
 			).toEqual([])
 			expect(
 				NativeToolCallParser.processRawChunk({ index: 0, id: "call_reprobe", name: "read_file" }, firstScope),
-			).toEqual([{ type: "tool_call_start", id: "call_reprobe", name: "read_file" }])
+			).toEqual([
+				{ type: "tool_call_start", id: "call_reprobe", name: "read_file" },
+				{ type: "tool_call_delta", id: "call_reprobe", delta: "buffered-after-cleanup" },
+			])
 		})
 
 		describe("read_file tool", () => {
@@ -450,4 +516,255 @@ describe("NativeToolCallParser", () => {
 			})
 		})
 	})
+
+	describe("processRawChunk streaming reassembly", () => {
+		// Mirror the sequencing Task.ts performs: feed each raw chunk through
+		// processRawChunk, drive startStreamingToolCall on tool_call_start, feed
+		// tool_call_delta into processStreamingChunk, and emit ends at stream close
+		// via finalizeRawChunks() (the same call Task.ts makes after the stream ends).
+		// Returns the ordered event types/ids plus the finalized tool uses by id.
+		const drive = (rawChunks: Array<{ index: number; id?: string; name?: string; arguments?: string }>) => {
+			const events: ToolCallStreamEvent[] = []
+			const scope = NativeToolCallParser.createScope()
+
+			const handleEvent = (event: ToolCallStreamEvent) => {
+				events.push(event)
+				if (event.type === "tool_call_start") {
+					NativeToolCallParser.startStreamingToolCall(event.id, event.name, scope)
+				} else if (event.type === "tool_call_delta") {
+					NativeToolCallParser.processStreamingChunk(event.id, event.delta, scope)
+				}
+			}
+
+			for (const chunk of rawChunks) {
+				for (const event of NativeToolCallParser.processRawChunk(chunk, scope)) {
+					handleEvent(event)
+				}
+			}
+
+			// Task.ts finalizes any tool calls still open at stream end via
+			// finalizeRawChunks(), which emits the tool_call_end events.
+			for (const event of NativeToolCallParser.finalizeRawChunks(scope)) {
+				handleEvent(event)
+			}
+
+			const finalized = new Map<string, ReturnType<typeof NativeToolCallParser.finalizeStreamingToolCall>>()
+			const startIds = events.filter((e) => e.type === "tool_call_start").map((e) => e.id)
+			for (const id of startIds) {
+				finalized.set(id, NativeToolCallParser.finalizeStreamingToolCall(id, scope))
+			}
+
+			return { events, finalized }
+		}
+
+		it("preserves leading argument bytes that arrive before the id", () => {
+			// First chunk carries arguments but NO id; id+name arrive later, then more args.
+			const fullArgs = JSON.stringify({ path: "src/leading.ts", mode: "slice" })
+			const firstHalf = fullArgs.slice(0, 10)
+			const secondHalf = fullArgs.slice(10)
+
+			const { events, finalized } = drive([
+				{ index: 0, arguments: firstHalf },
+				{ index: 0, id: "call_late_id", name: "read_file" },
+				{ index: 0, arguments: secondHalf },
+			])
+
+			// Exactly one start, in the right order, with the late id.
+			const starts = events.filter((e) => e.type === "tool_call_start")
+			expect(starts).toHaveLength(1)
+			expect(starts[0].id).toBe("call_late_id")
+
+			// The finalized arguments must contain the complete, uncorrupted payload.
+			const result = finalized.get("call_late_id")
+			expect(result).not.toBeNull()
+			expect(result?.type).toBe("tool_use")
+			if (result?.type === "tool_use") {
+				const nativeArgs = result.nativeArgs as { path: string; mode?: string }
+				expect(nativeArgs.path).toBe("src/leading.ts")
+				expect(nativeArgs.mode).toBe("slice")
+			}
+		})
+
+		it("handles id and name arriving in separate chunks (issue #218)", () => {
+			const fullArgs = JSON.stringify({ path: "src/split.ts" })
+
+			const { events, finalized } = drive([
+				{ index: 0, id: "call_split" },
+				{ index: 0, name: "read_file" },
+				{ index: 0, arguments: fullArgs },
+			])
+
+			const starts = events.filter((e) => e.type === "tool_call_start")
+			expect(starts).toHaveLength(1)
+			expect(starts[0].id).toBe("call_split")
+
+			const result = finalized.get("call_split")
+			expect(result?.type).toBe("tool_use")
+			if (result?.type === "tool_use") {
+				const nativeArgs = result.nativeArgs as { path: string }
+				expect(nativeArgs.path).toBe("src/split.ts")
+			}
+		})
+
+		it("handles name arriving before id with buffered args in between (reverse ordering)", () => {
+			const fullArgs = JSON.stringify({ path: "src/reverse.ts" })
+			const firstHalf = fullArgs.slice(0, 9)
+			const secondHalf = fullArgs.slice(9)
+
+			const { events, finalized } = drive([
+				{ index: 0, name: "read_file" },
+				{ index: 0, arguments: firstHalf },
+				{ index: 0, id: "call_reverse" },
+				{ index: 0, arguments: secondHalf },
+			])
+
+			// Start must not fire until the id arrives, so exactly one start with the late id.
+			const starts = events.filter((e) => e.type === "tool_call_start")
+			expect(starts).toHaveLength(1)
+			expect(starts[0].id).toBe("call_reverse")
+
+			// The buffered delta must be flushed only after the start event.
+			const startIndex = events.findIndex((e) => e.type === "tool_call_start")
+			const firstDeltaIndex = events.findIndex((e) => e.type === "tool_call_delta")
+			expect(startIndex).toBeLessThan(firstDeltaIndex)
+
+			const result = finalized.get("call_reverse")
+			expect(result).not.toBeNull()
+			expect(result?.type).toBe("tool_use")
+			if (result?.type === "tool_use") {
+				expect((result.nativeArgs as { path: string }).path).toBe("src/reverse.ts")
+			}
+		})
+
+		it("keeps two parallel tool calls on distinct indices isolated", () => {
+			const argsA = JSON.stringify({ path: "src/a.ts" })
+			const argsB = JSON.stringify({ path: "src/b.ts" })
+
+			const { events, finalized } = drive([
+				{ index: 0, arguments: argsA.slice(0, 8) },
+				{ index: 1, arguments: argsB.slice(0, 8) },
+				{ index: 0, id: "call_a", name: "read_file" },
+				{ index: 1, id: "call_b", name: "read_file" },
+				{ index: 0, arguments: argsA.slice(8) },
+				{ index: 1, arguments: argsB.slice(8) },
+			])
+
+			const starts = events.filter((e) => e.type === "tool_call_start")
+			expect(starts).toHaveLength(2)
+
+			const resultA = finalized.get("call_a")
+			const resultB = finalized.get("call_b")
+			expect(resultA).not.toBeNull()
+			expect(resultB).not.toBeNull()
+			if (resultA?.type === "tool_use") {
+				expect((resultA.nativeArgs as { path: string }).path).toBe("src/a.ts")
+			}
+			if (resultB?.type === "tool_use") {
+				expect((resultB.nativeArgs as { path: string }).path).toBe("src/b.ts")
+			}
+		})
+
+		it("emits the same event sequence for the single-chunk-with-id flow (regression guard)", () => {
+			const fullArgs = JSON.stringify({ path: "src/single.ts" })
+
+			const { events, finalized } = drive([
+				{ index: 0, id: "call_single", name: "read_file", arguments: fullArgs },
+			])
+
+			expect(events.map((e) => e.type)).toEqual(["tool_call_start", "tool_call_delta", "tool_call_end"])
+			expect(events.every((e) => e.id === "call_single")).toBe(true)
+
+			const result = finalized.get("call_single")
+			expect(result).not.toBeNull()
+			expect(result?.type).toBe("tool_use")
+			if (result?.type === "tool_use") {
+				expect((result.nativeArgs as { path: string }).path).toBe("src/single.ts")
+			}
+		})
+
+		it("does not emit a phantom tool_call_end for a tracker that never received an id", () => {
+			const { events } = drive([{ index: 0, arguments: '{"path":"orphan.ts"}' }])
+
+			expect(events.filter((e) => e.type === "tool_call_start")).toHaveLength(0)
+			expect(events.filter((e) => e.type === "tool_call_end")).toHaveLength(0)
+		})
+
+		it("finalizeRawChunks() emits end events and guards against missing id", () => {
+			const scope = NativeToolCallParser.createScope()
+			// Simulate a started tool call: process chunks to populate state
+			const chunks = [
+				{ index: 0, id: "call_finalize", name: "read_file" },
+				{ index: 0, arguments: '{"path":"file.ts"' },
+				{ index: 0, arguments: ',"mode":"slice"}' },
+			]
+
+			const events: Array<{ type: string; id?: string }> = []
+			for (const chunk of chunks) {
+				for (const event of NativeToolCallParser.processRawChunk(chunk, scope)) {
+					events.push(event)
+					if (event.type === "tool_call_start") {
+						NativeToolCallParser.startStreamingToolCall(event.id, event.name, scope)
+					} else if (event.type === "tool_call_delta") {
+						NativeToolCallParser.processStreamingChunk(event.id, event.delta, scope)
+					}
+				}
+			}
+
+			// Now finalize the raw chunks to emit the end event
+			const finalizeEvents = NativeToolCallParser.finalizeRawChunks(scope)
+			for (const event of finalizeEvents) {
+				events.push(event)
+			}
+
+			// Verify the end event was produced by finalizeRawChunks
+			const ends = events.filter((e) => e.type === "tool_call_end")
+			expect(ends).toHaveLength(1)
+			expect(ends[0].id).toBe("call_finalize")
+
+			// Finalize the tool call to ensure it contains the complete arguments
+			const result = NativeToolCallParser.finalizeStreamingToolCall("call_finalize", scope)
+			expect(result?.type).toBe("tool_use")
+			if (result?.type === "tool_use") {
+				expect((result.nativeArgs as { path: string }).path).toBe("file.ts")
+			}
+		})
+
+		it("finalizeRawChunks() does not emit end for tracker without id", () => {
+			const scope = NativeToolCallParser.createScope()
+			// Start a tracker with arguments but no id, then finalize
+			const chunks = [{ index: 0, arguments: '{"incomplete":true}' }]
+
+			for (const chunk of chunks) {
+				NativeToolCallParser.processRawChunk(chunk, scope)
+			}
+
+			// Finalize should not emit an end event if id was never set
+			const finalizeEvents = NativeToolCallParser.finalizeRawChunks(scope)
+			const ends = finalizeEvents.filter((e) => e.type === "tool_call_end")
+			expect(ends).toHaveLength(0)
+
+			NativeToolCallParser.clearRawChunkState(scope)
+		})
+
+		it("does not double-fire end events across repeated finalizeRawChunks calls", () => {
+			const scope = NativeToolCallParser.createScope()
+			// Drive a started tool call through the raw chunk path.
+			const chunks = [
+				{ index: 0, id: "call_dup", name: "read_file" },
+				{ index: 0, arguments: '{"path":"file.ts"}' },
+			]
+			for (const chunk of chunks) {
+				NativeToolCallParser.processRawChunk(chunk, scope)
+			}
+
+			const finishEvents = NativeToolCallParser.finalizeRawChunks(scope)
+			const finalizeEvents = NativeToolCallParser.finalizeRawChunks(scope)
+
+			const allEnds = [...finishEvents, ...finalizeEvents].filter((e) => e.type === "tool_call_end")
+			expect(allEnds).toHaveLength(1)
+			expect(allEnds[0].id).toBe("call_dup")
+
+			NativeToolCallParser.clearRawChunkState(scope)
+		})
+	})
 })
diff --git a/src/core/assistant-message/__tests__/presentAssistantMessage-tool-usage-attribution.spec.ts b/src/core/assistant-message/__tests__/presentAssistantMessage-tool-usage-attribution.spec.ts
index 3247ba49d2..7381b2c2d0 100644
--- a/src/core/assistant-message/__tests__/presentAssistantMessage-tool-usage-attribution.spec.ts
+++ b/src/core/assistant-message/__tests__/presentAssistantMessage-tool-usage-attribution.spec.ts
@@ -348,6 +348,309 @@ describe("presentAssistantMessage - tool usage attribution", () => {
 			expect(mockTask.recordToolUsage).not.toHaveBeenCalled()
 			expect(TelemetryService.instance.captureToolUsage).not.toHaveBeenCalled()
 		})
+
+		it("rejects at dispatch when use_mcp_tool is in disabledTools, without invoking the server method", async () => {
+			const mockHub = {
+				findServerNameBySanitizedName: () => "my_server",
+				getAllServers: () => [
+					{
+						name: "my_server",
+						tools: [{ name: "do_thing", enabledForPrompt: true }],
+					},
+				],
+				callTool: vi.fn(),
+			}
+			mockTask.providerRef = {
+				deref: () => ({
+					getState: vi.fn().mockResolvedValue({
+						mode: "code",
+						customModes: [],
+						disabledTools: ["use_mcp_tool"],
+					}),
+					getMcpHub: () => mockHub,
+				}),
+			}
+			vi.mocked(validateToolUse).mockImplementationOnce(() => {
+				throw new Error('Tool "use_mcp_tool" is not allowed in code mode.')
+			})
+
+			mockTask.assistantMessageContent = [
+				{
+					type: "mcp_tool_use",
+					id: "call_native_mcp_disabled",
+					name: "mcp_my_server_do_thing",
+					serverName: "my_server",
+					toolName: "do_thing",
+					arguments: {},
+					partial: false,
+				},
+			]
+
+			await presentAssistantMessage(mockTask as unknown as Task)
+
+			// The decision must come from the shared layer, under the canonical name,
+			// with the disabledTools entry folded into the requirements map.
+			const calls = vi.mocked(validateToolUse).mock.calls
+			expect(calls.length).toBeGreaterThan(0)
+			expect(calls[calls.length - 1][0]).toBe("use_mcp_tool")
+			expect(calls[calls.length - 1][3]).toMatchObject({ use_mcp_tool: false })
+
+			// Exactly one error tool_result for the block's id; the handler is never
+			// reached, so the server method is never invoked.
+			expect(mockTask.userMessageContent).toHaveLength(1)
+			expect(mockTask.userMessageContent).toContainEqual(
+				expect.objectContaining({
+					type: "tool_result",
+					tool_use_id: "call_native_mcp_disabled",
+					is_error: true,
+					content: expect.stringContaining("not allowed in code mode"),
+				}),
+			)
+			expect(mockHub.callTool).not.toHaveBeenCalled()
+
+			// No success attribution on rejection; a safe static failure key instead.
+			expect(mockTask.recordToolUsage).not.toHaveBeenCalled()
+			expect(TelemetryService.instance.captureToolUsage).not.toHaveBeenCalled()
+			expect(mockTask.recordToolError).toHaveBeenCalledWith("use_mcp_tool", expect.any(String))
+			expect(mockTask.consecutiveMistakeCount).toBe(1)
+			// The stream must not be interrupted by a validation rejection.
+			expect(mockTask.didAlreadyUseTool).toBe(false)
+		})
+
+		it("rejects at dispatch when use_mcp_tool is in the model's excludedTools", async () => {
+			const mockHub = {
+				findServerNameBySanitizedName: () => "my_server",
+				getAllServers: () => [
+					{
+						name: "my_server",
+						tools: [{ name: "do_thing", enabledForPrompt: true }],
+					},
+				],
+				callTool: vi.fn(),
+			}
+			mockTask.providerRef = {
+				deref: () => ({
+					getState: vi.fn().mockResolvedValue({
+						mode: "code",
+						customModes: [],
+					}),
+					getMcpHub: () => mockHub,
+				}),
+			}
+			// excludedTools reaches the requirements map only through
+			// buildToolRequirements' modelInfo fold, so this pins that input on the
+			// native path.
+			mockTask.api = {
+				getModel: () => ({ id: "test-model", info: { excludedTools: ["use_mcp_tool"] } }),
+			}
+			vi.mocked(validateToolUse).mockImplementationOnce(() => {
+				throw new Error('Tool "use_mcp_tool" is not allowed in code mode.')
+			})
+
+			mockTask.assistantMessageContent = [
+				{
+					type: "mcp_tool_use",
+					id: "call_native_mcp_excluded",
+					name: "mcp_my_server_do_thing",
+					serverName: "my_server",
+					toolName: "do_thing",
+					arguments: {},
+					partial: false,
+				},
+			]
+
+			await presentAssistantMessage(mockTask as unknown as Task)
+
+			const calls = vi.mocked(validateToolUse).mock.calls
+			expect(calls.length).toBeGreaterThan(0)
+			expect(calls[calls.length - 1][0]).toBe("use_mcp_tool")
+			expect(calls[calls.length - 1][3]).toMatchObject({ use_mcp_tool: false })
+
+			expect(mockTask.userMessageContent).toHaveLength(1)
+			expect(mockTask.userMessageContent).toContainEqual(
+				expect.objectContaining({
+					type: "tool_result",
+					tool_use_id: "call_native_mcp_excluded",
+					is_error: true,
+					content: expect.stringContaining("not allowed in code mode"),
+				}),
+			)
+			expect(mockHub.callTool).not.toHaveBeenCalled()
+
+			expect(mockTask.recordToolUsage).not.toHaveBeenCalled()
+			expect(TelemetryService.instance.captureToolUsage).not.toHaveBeenCalled()
+			expect(mockTask.recordToolError).toHaveBeenCalledWith("use_mcp_tool", expect.any(String))
+			expect(mockTask.consecutiveMistakeCount).toBe(1)
+			expect(mockTask.didAlreadyUseTool).toBe(false)
+		})
+
+		it("skips shared-layer validation for partial blocks so streaming never pushes error results", async () => {
+			// Validating partial blocks would surface one validation error tool_result
+			// per streamed chunk for the same tool_use_id.
+			mockTask.providerRef = {
+				deref: () => ({
+					getState: vi.fn().mockResolvedValue({
+						mode: "code",
+						customModes: [],
+					}),
+					getMcpHub: () => ({
+						findServerNameBySanitizedName: () => "my_server",
+					}),
+				}),
+			}
+			vi.mocked(validateToolUse).mockImplementationOnce(() => {
+				throw new Error('Tool "use_mcp_tool" is not allowed in code mode.')
+			})
+
+			mockTask.assistantMessageContent = [
+				{
+					type: "mcp_tool_use",
+					id: "call_native_mcp_partial",
+					name: "mcp_my_server_do_thing",
+					serverName: "my_server",
+					toolName: "do_thing",
+					arguments: {},
+					partial: true,
+				},
+			]
+
+			await presentAssistantMessage(mockTask as unknown as Task)
+
+			expect(validateToolUse).not.toHaveBeenCalled()
+			expect(mockTask.userMessageContent).toHaveLength(0)
+			expect(mockTask.consecutiveMistakeCount).toBe(0)
+		})
+
+		it("rejects through the state ?? {} fallback when the provider is unavailable", async () => {
+			// With no provider state the validator must still receive the task-local
+			// mode plus empty policy inputs: customModes [] and an empty requirements
+			// map, rather than the dispatch crashing.
+			mockTask.providerRef = { deref: () => undefined }
+			vi.mocked(validateToolUse).mockImplementationOnce(() => {
+				throw new Error('Tool "use_mcp_tool" is not allowed in code mode.')
+			})
+
+			mockTask.assistantMessageContent = [
+				{
+					type: "mcp_tool_use",
+					id: "call_native_mcp_no_provider",
+					name: "mcp_my_server_do_thing",
+					serverName: "my_server",
+					toolName: "do_thing",
+					arguments: {},
+					partial: false,
+				},
+			]
+
+			await presentAssistantMessage(mockTask as unknown as Task)
+
+			// The validator throws so the handler is never reached — the assertions
+			// pin the arguments the call site passed under the empty-state fallback.
+			const calls = vi.mocked(validateToolUse).mock.calls
+			expect(calls.length).toBeGreaterThan(0)
+			expect(calls[calls.length - 1][0]).toBe("use_mcp_tool")
+			expect(calls[calls.length - 1][1]).toBe("code")
+			expect(calls[calls.length - 1][2]).toEqual([])
+			expect(calls[calls.length - 1][3]).toEqual({})
+			// The default model info carries no includedTools.
+			expect(calls[calls.length - 1][6]).toBeUndefined()
+
+			expect(mockTask.userMessageContent).toHaveLength(1)
+			expect(mockTask.userMessageContent).toContainEqual(
+				expect.objectContaining({
+					type: "tool_result",
+					tool_use_id: "call_native_mcp_no_provider",
+					is_error: true,
+					content: expect.stringContaining("not allowed in code mode"),
+				}),
+			)
+
+			expect(mockTask.recordToolUsage).not.toHaveBeenCalled()
+			expect(TelemetryService.instance.captureToolUsage).not.toHaveBeenCalled()
+			expect(mockTask.recordToolError).toHaveBeenCalledWith("use_mcp_tool", expect.any(String))
+			expect(mockTask.consecutiveMistakeCount).toBe(1)
+			expect(mockTask.didAlreadyUseTool).toBe(false)
+		})
+
+		it("resolves aliases in the model's includedTools before passing them to the shared layer", async () => {
+			// A model may advertise tools under alias names; the shared layer compares
+			// canonical names, so "write_file" must arrive as "write_to_file".
+			mockTask.api = {
+				getModel: () => ({ id: "test-model", info: { includedTools: ["write_file"] } }),
+			}
+			mockTask.providerRef = {
+				deref: () => ({
+					getState: vi.fn().mockResolvedValue({
+						mode: "code",
+						customModes: [],
+					}),
+					getMcpHub: () => ({
+						findServerNameBySanitizedName: () => "my_server",
+					}),
+				}),
+			}
+			vi.mocked(validateToolUse).mockImplementationOnce(() => {
+				throw new Error('Tool "use_mcp_tool" is not allowed in code mode.')
+			})
+
+			mockTask.assistantMessageContent = [
+				{
+					type: "mcp_tool_use",
+					id: "call_native_mcp_alias",
+					name: "mcp_my_server_do_thing",
+					serverName: "my_server",
+					toolName: "do_thing",
+					arguments: {},
+					partial: false,
+				},
+			]
+
+			await presentAssistantMessage(mockTask as unknown as Task)
+
+			const calls = vi.mocked(validateToolUse).mock.calls
+			expect(calls.length).toBeGreaterThan(0)
+			expect(calls[calls.length - 1][0]).toBe("use_mcp_tool")
+			expect(calls[calls.length - 1][6]).toEqual(["write_to_file"])
+		})
+
+		it("pushes no tool_result when the native block omits its id, but still records the rejection", async () => {
+			// McpToolUse.id is optional; with no tool_use_id there is nothing to
+			// answer, so the error tool_result is skipped while the rejection is
+			// still recorded.
+			mockTask.providerRef = {
+				deref: () => ({
+					getState: vi.fn().mockResolvedValue({
+						mode: "code",
+						customModes: [],
+					}),
+					getMcpHub: () => ({
+						findServerNameBySanitizedName: () => "my_server",
+					}),
+				}),
+			}
+			vi.mocked(validateToolUse).mockImplementationOnce(() => {
+				throw new Error('Tool "use_mcp_tool" is not allowed in code mode.')
+			})
+
+			mockTask.assistantMessageContent = [
+				{
+					type: "mcp_tool_use",
+					name: "mcp_my_server_do_thing",
+					serverName: "my_server",
+					toolName: "do_thing",
+					arguments: {},
+					partial: false,
+				},
+			]
+
+			await presentAssistantMessage(mockTask as unknown as Task)
+
+			expect(mockTask.pushToolResultToUserContent).not.toHaveBeenCalled()
+			expect(mockTask.userMessageContent).toHaveLength(0)
+			expect(mockTask.recordToolError).toHaveBeenCalledWith("use_mcp_tool", expect.any(String))
+			expect(mockTask.consecutiveMistakeCount).toBe(1)
+			expect(mockTask.didAlreadyUseTool).toBe(false)
+		})
 	})
 
 	describe("undefined provider state", () => {
@@ -415,5 +718,49 @@ describe("presentAssistantMessage - tool usage attribution", () => {
 			expect(calls[0][0]).toBe("read_file")
 			expect(calls[0][1]).toBe("architect")
 		})
+
+		it("passes the task-local mode to validateToolUse for a native mcp_tool_use block", async () => {
+			// The native mcp arm has its own validateToolUse call site and must honor
+			// the same task-local mode contract as the tool_use arm: provider state
+			// deliberately reports a different mode than the task's.
+			mockTask.providerRef = {
+				deref: () => ({
+					getState: vi.fn().mockResolvedValue({
+						mode: "orchestrator",
+						customModes: [],
+					}),
+					getMcpHub: () => ({
+						findServerNameBySanitizedName: () => "my_server",
+					}),
+				}),
+			}
+			mockTask.getTaskMode = vi.fn().mockResolvedValue("architect")
+			// Throw so the handler is never reached — the assertion is on the
+			// arguments the call site passed to the shared layer.
+			vi.mocked(validateToolUse).mockImplementationOnce(() => {
+				throw new Error("Task-local mode check.")
+			})
+
+			mockTask.assistantMessageContent = [
+				{
+					type: "mcp_tool_use",
+					id: "call_delegation_mcp",
+					name: "mcp_my_server_do_thing",
+					serverName: "my_server",
+					toolName: "do_thing",
+					arguments: {},
+					partial: false,
+				},
+			]
+
+			await presentAssistantMessage(mockTask as unknown as Task)
+
+			const calls = vi.mocked(validateToolUse).mock.calls
+			expect(calls.length).toBeGreaterThan(0)
+			expect(calls[calls.length - 1][0]).toBe("use_mcp_tool")
+			// The discriminating assertion: task-local "architect", not provider
+			// "orchestrator" — the exact pre-delegation bug shape.
+			expect(calls[calls.length - 1][1]).toBe("architect")
+		})
 	})
 })
diff --git a/src/core/assistant-message/presentAssistantMessage.ts b/src/core/assistant-message/presentAssistantMessage.ts
index 546c43c06c..610e034ab6 100644
--- a/src/core/assistant-message/presentAssistantMessage.ts
+++ b/src/core/assistant-message/presentAssistantMessage.ts
@@ -290,6 +290,67 @@ export async function presentAssistantMessage(cline: Task) {
 				},
 			}
 
+			// Consult the shared policy layer before executing — ONLY for complete
+			// (non-partial) blocks. Validating partial blocks would surface validation
+			// errors repeatedly during streaming, pushing multiple tool_results for the
+			// same tool_use_id and making the stream appear frozen.
+			if (!mcpBlock.partial) {
+				const state = await cline.providerRef.deref()?.getState()
+				const { customModes, experiments: stateExperiments, disabledTools } = state ?? {}
+				// Read the task-local mode, not the shared provider mode.
+				// A delegated child task may run in a different mode than its parent.
+				const taskMode = await cline.getTaskMode()
+
+				const modelInfo = cline.api.getModel()
+				// Resolve aliases in includedTools before validation
+				// e.g., "write_file" should resolve to "write_to_file"
+				const rawIncludedTools = modelInfo.info.includedTools
+				const { resolveToolAlias } = await import("../prompts/tools/filter-tools-for-mode")
+				const includedTools = rawIncludedTools?.map((tool) => resolveToolAlias(tool))
+
+				try {
+					// Validate under the canonical "use_mcp_tool" name: the requirements map
+					// is keyed by canonical/alias names, so the dynamic mcp_* name would never
+					// key-match a disabledTools or excludedTools entry naming use_mcp_tool.
+					// Build requirements through the shared policy module so every suppressed
+					// entry reaches the validator, which checks them before the
+					// always-available class. See `buildToolRequirements` in
+					// effective-tool-policy.ts.
+					const toolRequirements = buildToolRequirements(disabledTools, modelInfo.info)
+
+					validateToolUse(
+						"use_mcp_tool",
+						taskMode,
+						customModes ?? [],
+						toolRequirements,
+						syntheticToolUse.params,
+						stateExperiments,
+						includedTools,
+					)
+				} catch (error) {
+					cline.consecutiveMistakeCount++
+					// For validation errors, send a tool_result with the error (required for
+					// native tool calling) but do NOT set didAlreadyUseTool = true — the tool
+					// was never executed, and interrupting the stream here would make the
+					// extension appear to hang.
+					const errorContent = formatResponse.toolError(error.message)
+					if (toolCallId) {
+						cline.pushToolResultToUserContent({
+							type: "tool_result",
+							tool_use_id: sanitizeToolUseId(toolCallId),
+							content: errorContent,
+							is_error: true,
+						})
+					}
+
+					// The validator's message names the canonical tool, never the
+					// model-controlled dynamic name, so this key is safe.
+					cline.recordToolError("use_mcp_tool", error.message)
+
+					break
+				}
+			}
+
 			await useMcpToolTool.handle(cline, syntheticToolUse, {
 				askApproval,
 				handleError,
diff --git a/src/core/config/ProviderSettingsManager.ts b/src/core/config/ProviderSettingsManager.ts
index 3fcc0e6e43..19fae0e38c 100644
--- a/src/core/config/ProviderSettingsManager.ts
+++ b/src/core/config/ProviderSettingsManager.ts
@@ -504,9 +504,9 @@ export class ProviderSettingsManager {
 	}
 
 	/**
-	 * Set the API config for a specific mode.
+	 * Set the API config for a specific mode, or remove its mapping with undefined.
 	 */
-	public async setModeConfig(mode: Mode, configId: string) {
+	public async setModeConfig(mode: Mode, configId: string | undefined) {
 		try {
 			return await this.lock(async () => {
 				const providerProfiles = await this.load()
@@ -514,8 +514,11 @@ export class ProviderSettingsManager {
 				if (!providerProfiles.modeApiConfigs) {
 					providerProfiles.modeApiConfigs = {}
 				}
-				// Assign the chosen config ID to this mode
-				providerProfiles.modeApiConfigs[mode] = configId
+				if (configId === undefined) {
+					delete providerProfiles.modeApiConfigs[mode]
+				} else {
+					providerProfiles.modeApiConfigs[mode] = configId
+				}
 				await this.store(providerProfiles)
 			})
 		} catch (error) {
diff --git a/src/core/config/__tests__/ProviderSettingsManager.spec.ts b/src/core/config/__tests__/ProviderSettingsManager.spec.ts
index 13e1aeeb2d..8f87573e2f 100644
--- a/src/core/config/__tests__/ProviderSettingsManager.spec.ts
+++ b/src/core/config/__tests__/ProviderSettingsManager.spec.ts
@@ -350,6 +350,26 @@ describe("ProviderSettingsManager", () => {
 		})
 	})
 
+	describe("setModeConfig", () => {
+		it("persists removal of one mapping while preserving other modes", async () => {
+			let stored = JSON.stringify({
+				currentApiConfigName: "default",
+				apiConfigs: { default: { id: "default" } },
+				modeApiConfigs: { code: "new-profile", ask: "default" },
+			})
+			mockSecrets.get.mockImplementation(async () => stored)
+			mockSecrets.store.mockImplementation(async (_key: string, value: string) => {
+				stored = value
+			})
+			await providerSettingsManager.setModeConfig("code", undefined)
+			expect(JSON.parse(stored).modeApiConfigs).toEqual({ ask: "default" })
+			expect(await providerSettingsManager.getModeConfigId("code")).toBeUndefined()
+			expect(await providerSettingsManager.getModeConfigId("ask")).toBe("default")
+			await providerSettingsManager.setModeConfig("code", "default")
+			expect(await providerSettingsManager.getModeConfigId("code")).toBe("default")
+		})
+	})
+
 	describe("ListConfig", () => {
 		it("should list all available configs", async () => {
 			const existingConfig: ProviderProfiles = {
diff --git a/src/core/context/context-management/context-error-handling.ts b/src/core/context/context-management/context-error-handling.ts
index 6cfe993f95..b7ed0cad16 100644
--- a/src/core/context/context-management/context-error-handling.ts
+++ b/src/core/context/context-management/context-error-handling.ts
@@ -1,5 +1,11 @@
 import { APIError } from "openai"
 
+/**
+ * Status a provider must attach to an error for it to be routed to the condense path. Exported so
+ * providers raising a context-window failure locally stay coupled to the predicate below.
+ */
+export const CONTEXT_WINDOW_EXCEEDED_STATUS = 400
+
 export function checkContextWindowExceededError(error: unknown): boolean {
 	return (
 		checkIsOpenAIContextWindowError(error) ||
@@ -27,7 +33,10 @@ function checkIsOpenRouterContextWindowError(error: unknown): boolean {
 			/\btoo\s*many\s*tokens?\b/i,
 		] as const
 
-		return String(status) === "400" && CONTEXT_ERROR_PATTERNS.some((pattern) => pattern.test(message))
+		return (
+			String(status) === String(CONTEXT_WINDOW_EXCEEDED_STATUS) &&
+			CONTEXT_ERROR_PATTERNS.some((pattern) => pattern.test(message))
+		)
 	} catch {
 		return false
 	}
@@ -46,7 +55,7 @@ function checkIsOpenAIContextWindowError(error: unknown): boolean {
 		return (
 			Boolean(error) &&
 			error instanceof APIError &&
-			error.code?.toString() === "400" &&
+			error.code?.toString() === String(CONTEXT_WINDOW_EXCEEDED_STATUS) &&
 			KNOWN_CONTEXT_ERROR_SUBSTRINGS.some((substring) => error.message.includes(substring))
 		)
 	} catch {
diff --git a/src/core/task/Task.ts b/src/core/task/Task.ts
index 88bd8141b8..0362252174 100644
--- a/src/core/task/Task.ts
+++ b/src/core/task/Task.ts
@@ -1292,8 +1292,19 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		this.clineMessages.push(message)
 		const provider = this.providerRef.deref()
 		// Unanswered asks must reach the webview before Message listeners can respond against its state.
-		const requiresImmediateState =
-			message.partial === true || (message.type === "ask" && message.isAnswered !== true)
+		//
+		// Partial `say` messages deliberately do NOT flush. `flushPostStateToWebviewThrottled()`
+		// invoked right after a leading-edge debounce call has no pending trailing invocation to
+		// run, so it only cancels the trailing timer — which makes the *next* call hit the leading
+		// edge and post immediately. Flushing on every partial therefore defeated the debounce
+		// entirely (one full-state post per message, the very behaviour #1078 set out to remove).
+		// They are safe on the throttled path: the trailing/maxWait post carries the message's
+		// current text, so a `messageUpdated` dropped for a not-yet-known `ts` is superseded
+		// rather than lost.
+		//
+		// Partial *asks* still flush, via the clause below — `Task#ask` adds them without
+		// `isAnswered`, so they keep the ordering guarantee that unanswered asks depend on.
+		const requiresImmediateState = message.type === "ask" && message.isAnswered !== true
 		try {
 			await provider?.postStateToWebviewThrottled()
 		} catch (error) {
@@ -3236,6 +3247,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 				this.didRejectTool = false
 				this.didAlreadyUseTool = false
 				this.assistantMessageSavedToHistory = false
+				this.didFinishAbortingStream = false
 				this.resetAssistantMessagePersistence()
 				// Reset tool failure flag for each new assistant turn - this ensures that tool failures
 				// only prevent attempt_completion within the same assistant message, not across turns
@@ -3715,8 +3727,8 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 						await abortStream(cancelReason, streamingFailedMessage)
 
 						if (this.abort) {
-							// User cancelled - abort the entire task
-							this.abortReason = cancelReason
+							// ??= keeps the first reason; a cancel can land during abortStream after cancelReason was already computed.
+							this.abortReason ??= "user_cancelled"
 							await this.abortTask()
 						} else if (error instanceof OutputTokenLimitError) {
 							// Truncation repeats on an identical request, so never auto-retry it
@@ -3751,8 +3763,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 									console.log(
 										`[Task#${this.taskId}.${this.instanceId}] Task aborted during mid-stream retry backoff`,
 									)
-									// Abort the entire task
-									this.abortReason = "user_cancelled"
+									this.abortReason ??= "user_cancelled"
 									await this.abortTask()
 									break
 								}
diff --git a/src/core/task/__tests__/Task.abort-reason-race.spec.ts b/src/core/task/__tests__/Task.abort-reason-race.spec.ts
new file mode 100644
index 0000000000..7b71ee1dd6
--- /dev/null
+++ b/src/core/task/__tests__/Task.abort-reason-race.spec.ts
@@ -0,0 +1,216 @@
+// npx vitest run core/task/__tests__/Task.abort-reason-race.spec.ts
+
+import * as os from "os"
+import * as path from "path"
+
+import type { GlobalState, ProviderSettings } from "@roo-code/types"
+import { providerIdentifiers } from "@roo-code/types/provider-identifiers"
+import { findLast } from "../../../shared/array"
+import { TelemetryService } from "@roo-code/telemetry"
+
+import { Task } from "../Task"
+import { ClineProvider } from "../../webview/ClineProvider"
+
+const { mockSaveTaskMessages, mockSaveApiMessages } = vi.hoisted(() => ({
+	mockSaveTaskMessages: vi.fn().mockResolvedValue(undefined),
+	mockSaveApiMessages: vi.fn().mockResolvedValue(undefined),
+}))
+
+// vscode is globally aliased to __mocks__/vscode.js by vitest.config.ts.
+vi.mock("delay", () => ({ __esModule: true, default: vi.fn().mockResolvedValue(undefined) }))
+vi.mock("execa", () => ({ execa: vi.fn() }))
+vi.mock("p-wait-for", () => ({ default: vi.fn().mockResolvedValue(undefined) }))
+
+vi.mock("../../task-persistence", async (importOriginal) => {
+	const mod = await importOriginal<typeof import("../../task-persistence")>()
+	return {
+		...mod,
+		saveApiMessages: mockSaveApiMessages,
+		saveTaskMessages: mockSaveTaskMessages,
+		TaskHistoryStore: vi.fn().mockImplementation(function () {
+			return {
+				initialize: vi.fn().mockResolvedValue(undefined),
+				dispose: vi.fn(),
+				get: vi.fn(),
+				getAll: vi.fn().mockReturnValue([]),
+				upsert: vi.fn().mockResolvedValue([]),
+				delete: vi.fn().mockResolvedValue(undefined),
+				deleteMany: vi.fn().mockResolvedValue(undefined),
+				reconcile: vi.fn().mockResolvedValue(undefined),
+				initialized: Promise.resolve(),
+			}
+		}),
+	}
+})
+
+vi.mock("../../mentions", () => ({
+	parseMentions: vi
+		.fn()
+		.mockImplementation((text) =>
+			Promise.resolve({ text: `processed: ${text}`, mode: undefined, contentBlocks: [] }),
+		),
+	openMention: vi.fn(),
+	getLatestTerminalOutput: vi.fn(),
+}))
+
+vi.mock("../../mentions/processUserContentMentions", () => ({
+	processUserContentMentions: vi.fn().mockImplementation(async ({ userContent }: { userContent: unknown[] }) => ({
+		content: userContent,
+		mode: undefined,
+	})),
+}))
+
+vi.mock("../../../integrations/misc/extract-text", () => ({
+	extractTextFromFile: vi.fn().mockResolvedValue(""),
+}))
+
+vi.mock("../../environment/getEnvironmentDetails", () => ({
+	getEnvironmentDetails: vi.fn().mockResolvedValue(""),
+}))
+
+vi.mock("../../ignore/RooIgnoreController")
+
+vi.mock("../../../utils/storage", () => ({
+	getTaskDirectoryPath: vi
+		.fn()
+		.mockImplementation((base: string, id: string) => Promise.resolve(`${base}/tasks/${id}`)),
+	getSettingsDirectoryPath: vi.fn().mockImplementation((base: string) => Promise.resolve(`${base}/settings`)),
+}))
+
+vi.mock("../../../utils/fs", () => ({
+	fileExistsAtPath: vi.fn().mockReturnValue(false),
+}))
+
+vi.mock("../../../i18n", () => ({
+	t: (key: string) => key,
+}))
+
+function makeMockProvider() {
+	return {
+		log: vi.fn(),
+		taskHistoryStore: { get: () => undefined },
+		updateTaskHistory: vi.fn().mockResolvedValue([]),
+		getState: vi.fn().mockResolvedValue({}),
+		getSkillsManager: vi.fn().mockReturnValue(undefined),
+		postStateToWebviewWithoutTaskHistory: vi.fn().mockResolvedValue(undefined),
+		flushPostStateToWebviewThrottled: vi.fn().mockResolvedValue(undefined),
+		postMessageToWebview: vi.fn().mockResolvedValue(undefined),
+		postStateToWebview: vi.fn().mockResolvedValue(undefined),
+		postStateToWebviewThrottled: vi.fn().mockResolvedValue(undefined),
+		context: {
+			globalStorageUri: { fsPath: path.join(os.tmpdir(), "test-storage-abort-race") },
+			globalState: {
+				get: vi.fn().mockImplementation((_key: keyof GlobalState) => undefined),
+				update: vi.fn().mockResolvedValue(undefined),
+				keys: vi.fn().mockReturnValue([]),
+			},
+			workspaceState: {
+				get: vi.fn().mockImplementation(() => undefined),
+				update: vi.fn().mockResolvedValue(undefined),
+				keys: vi.fn().mockReturnValue([]),
+			},
+			secrets: {
+				get: vi.fn().mockResolvedValue(undefined),
+				store: vi.fn().mockResolvedValue(undefined),
+				delete: vi.fn().mockResolvedValue(undefined),
+			},
+			extensionUri: { fsPath: "/mock/extension" },
+			extension: { packageJSON: { version: "1.0.0" } },
+		},
+	}
+}
+
+describe("Task abort-reason race", () => {
+	let mockApiConfig: ProviderSettings
+
+	beforeEach(() => {
+		vi.clearAllMocks()
+		mockSaveTaskMessages.mockResolvedValue(undefined)
+
+		if (!TelemetryService.hasInstance()) {
+			TelemetryService.createInstance([])
+		}
+
+		mockApiConfig = {
+			apiProvider: providerIdentifiers.anthropic,
+			apiModelId: "claude-3-5-sonnet-20241022",
+			apiKey: "test-api-key",
+		}
+	})
+
+	it("keeps user_cancelled when a cancel lands during abortStream cleanup", async () => {
+		const mockProvider = makeMockProvider()
+
+		// Double cast: plain object satisfies only the methods called by this code path.
+		const task = new Task({
+			provider: mockProvider as unknown as ClineProvider,
+			apiConfiguration: mockApiConfig,
+			task: "test task",
+			startTask: false,
+		})
+
+		vi.spyOn(task.diffViewProvider, "reset").mockResolvedValue(undefined)
+		vi.spyOn(task, "dispose").mockResolvedValue(undefined)
+		const abortTaskSpy = vi.spyOn(task, "abortTask")
+
+		// eslint-disable-next-line require-yield -- intentional error-only async source
+		task["attemptApiRequest"] = async function* () {
+			throw new Error("mid-stream API failure")
+		}
+
+		// abortStream calls updateApiReqMsg("streaming_failed") synchronously before saving,
+		// so the api_req_started row has cancelReason="streaming_failed" when we are inside it.
+		mockSaveTaskMessages.mockImplementation(async () => {
+			const apiReqMsg = findLast(task.clineMessages, (m) => m.say === "api_req_started")
+			const parsed = apiReqMsg?.text ? (JSON.parse(apiReqMsg.text) as { cancelReason?: string }) : {}
+			if (parsed.cancelReason === "streaming_failed" && !task.didFinishAbortingStream) {
+				// cancelTask sets abortReason before abort=true.
+				task["abortReason"] = "user_cancelled"
+				task["abort"] = true
+			}
+		})
+
+		// The outer catch in recursivelyMakeClineRequests swallows the abort throw and returns true.
+		const result = await task.recursivelyMakeClineRequests([{ type: "text", text: "help me" }])
+		expect(result).toBe(true)
+		expect(task.didFinishAbortingStream).toBe(true)
+		expect(abortTaskSpy).toHaveBeenCalledOnce()
+		expect(task.abortReason).toBe("user_cancelled")
+	})
+
+	it("keeps pre-existing abortReason when cancel lands during retry backoff", async () => {
+		const mockProvider = makeMockProvider()
+		// autoApprovalEnabled causes the else branch to call backoffAndAnnounce.
+		mockProvider.getState = vi.fn().mockResolvedValue({ autoApprovalEnabled: true })
+
+		// Double cast: plain object satisfies only the methods called by this code path.
+		const task = new Task({
+			provider: mockProvider as unknown as ClineProvider,
+			apiConfiguration: mockApiConfig,
+			task: "test task",
+			startTask: false,
+		})
+
+		vi.spyOn(task.diffViewProvider, "reset").mockResolvedValue(undefined)
+		vi.spyOn(task, "dispose").mockResolvedValue(undefined)
+
+		// eslint-disable-next-line require-yield -- intentional error-only async source
+		task["attemptApiRequest"] = async function* () {
+			throw new Error("mid-stream failure")
+		}
+
+		// Simulate cancel landing during backoff: cancelTask sets abortReason before abort=true.
+		// Use a distinct seed value so ??= (keeps it) is distinguishable from = (overwrites).
+		task["backoffAndAnnounce"] = async () => {
+			task["abortReason"] = "streaming_failed"
+			task["abort"] = true
+		}
+
+		const abortTaskSpy = vi.spyOn(task, "abortTask")
+		// break after backoff exits the while loop; the outer try returns false.
+		const result = await task.recursivelyMakeClineRequests([{ type: "text", text: "help me" }])
+		expect(result).toBe(false)
+		expect(abortTaskSpy).toHaveBeenCalledOnce()
+		expect(task.abortReason).toBe("streaming_failed")
+	})
+})
diff --git a/src/core/task/__tests__/Task.spec.ts b/src/core/task/__tests__/Task.spec.ts
index 72d0641efd..88db6f2f2a 100644
--- a/src/core/task/__tests__/Task.spec.ts
+++ b/src/core/task/__tests__/Task.spec.ts
@@ -86,6 +86,7 @@ vi.mock("delay", () => ({
 }))
 
 import delay from "delay"
+import pWaitFor from "p-wait-for"
 
 vi.mock("uuid", async (importOriginal) => {
 	const actual = await importOriginal<typeof import("uuid")>()
@@ -713,6 +714,98 @@ describe("Cline", () => {
 			])
 		})
 
+		it("clears didFinishAbortingStream on retry so cancelTask waits for the new stream (#1801)", async () => {
+			const task = new Task({
+				provider: mockProvider,
+				apiConfiguration: mockApiConfig,
+				task: "abort flag reset test",
+				startTask: false,
+			})
+
+			vi.spyOn(task.diffViewProvider, "reset").mockResolvedValue(undefined)
+			vi.spyOn(getTaskTestAccess(task), "safeEnsureModelFetched").mockResolvedValue(stubModelInfo)
+			vi.spyOn(getTaskTestAccess(task), "presentAssistantMessageSafe").mockImplementation(() => {})
+
+			const failingStream = async function* (): AsyncGenerator<ApiStreamChunk> {
+				yield { type: "text", text: "partial" }
+				throw new Error("simulated mid-stream failure")
+			}
+
+			let releaseRetryStream: (() => void) | undefined
+			let markRetryStreamPaused: (() => void) | undefined
+			const retryStreamRelease = new Promise<void>((resolve) => {
+				releaseRetryStream = resolve
+			})
+			const retryStreamPaused = new Promise<void>((resolve) => {
+				markRetryStreamPaused = resolve
+			})
+			const pausedRetryStream = async function* (): AsyncGenerator<ApiStreamChunk> {
+				yield { type: "text", text: "retry" }
+				markRetryStreamPaused?.()
+				await retryStreamRelease
+			}
+
+			const attemptApiRequestSpy = vi
+				.spyOn(task, "attemptApiRequest")
+				.mockImplementationOnce(() => failingStream())
+				.mockImplementationOnce(() => pausedRetryStream())
+				.mockImplementation(() => {
+					throw new Error("stop after retry response")
+				})
+
+			const { default: realPWaitFor } = await vi.importActual<typeof import("p-wait-for")>("p-wait-for")
+			vi.mocked(pWaitFor).mockImplementation(realPWaitFor)
+			let request: Promise<boolean> | undefined
+			let cancel: Promise<void> | undefined
+			try {
+				await mockProvider.addClineToStack(task)
+				request = task.recursivelyMakeClineRequests([{ type: "text", text: "abort flag reset test" }])
+				await Promise.race([
+					retryStreamPaused,
+					request.then(() => {
+						throw new Error("request settled before the retry stream paused")
+					}),
+				])
+
+				const firstApiReq = task.clineMessages.find((message) => message.say === "api_req_started")
+				expect(JSON.parse(firstApiReq?.text ?? "{}")).toMatchObject({ cancelReason: "streaming_failed" })
+				expect(attemptApiRequestSpy).toHaveBeenCalledTimes(2)
+
+				let markCancelWaiting: (() => void) | undefined
+				const cancelWaiting = new Promise<void>((resolve) => {
+					markCancelWaiting = resolve
+				})
+				vi.mocked(pWaitFor).mockImplementation((condition, options) =>
+					realPWaitFor(async () => {
+						const done = await condition()
+						if (!done) markCancelWaiting?.()
+						return done
+					}, options),
+				)
+
+				vi.spyOn(mockProvider, "createTaskWithHistoryItem").mockImplementation((historyItem) =>
+					ClineProvider.prototype.createTaskWithHistoryItem.call(mockProvider, historyItem, {
+						startTask: false,
+					}),
+				)
+
+				let cancelSettled = false
+				cancel = mockProvider.cancelTask().then(() => {
+					cancelSettled = true
+				})
+				await Promise.race([cancelWaiting, cancel])
+				expect(cancelSettled, "cancelTask must wait while the retry stream is live").toBe(false)
+
+				releaseRetryStream?.()
+				await cancel
+				await expect(request).resolves.toBe(true)
+			} finally {
+				releaseRetryStream?.()
+				await Promise.allSettled([request, cancel])
+				vi.mocked(pWaitFor).mockImplementation(async () => {})
+			}
+		})
+
 		it("finalizes MCP tool call using the request-scoped parser state", async () => {
 			const task = new Task({
 				provider: mockProvider,
@@ -2955,7 +3048,7 @@ describe("Cline", () => {
 			expect(mockProvider.flushPostStateToWebviewThrottled).not.toHaveBeenCalled()
 		})
 
-		it("waits for a new partial message flush before a following message update", async () => {
+		it("keeps a new partial message on the throttled path without flushing", async () => {
 			const task = new Task({
 				provider: mockProvider,
 				apiConfiguration: mockApiConfig,
@@ -2964,11 +3057,6 @@ describe("Cline", () => {
 			})
 			const taskAccess = getTaskTestAccess(task)
 			vi.spyOn(taskAccess, "saveClineMessages").mockResolvedValue(true)
-			let releaseFlush!: () => void
-			const pendingFlush = new Promise<void>((resolve) => {
-				releaseFlush = resolve
-			})
-			const flushSpy = vi.mocked(mockProvider.flushPostStateToWebviewThrottled).mockReturnValueOnce(pendingFlush)
 			const updatePostSpy = vi.mocked(mockProvider.postMessageToWebview)
 			const partialMessage = {
 				ts: 1,
@@ -2977,22 +3065,15 @@ describe("Cline", () => {
 				text: "partial message",
 				partial: true,
 			}
-			let partialAddSettled = false
-			const addThenUpdate = taskAccess.addToClineMessages(partialMessage).then(async () => {
-				partialAddSettled = true
-				await taskAccess.updateClineMessage({ ...partialMessage, text: "updated partial" })
-			})
 
-			await Promise.resolve()
-			expect(mockProvider.postStateToWebviewThrottled).toHaveBeenCalledWith()
-			expect(flushSpy).toHaveBeenCalledWith()
-			expect(partialAddSettled).toBe(false)
-			expect(updatePostSpy).not.toHaveBeenCalled()
-
-			releaseFlush()
-			await addThenUpdate
+			await taskAccess.addToClineMessages(partialMessage)
+			await taskAccess.updateClineMessage({ ...partialMessage, text: "updated partial" })
 
-			expect(flushSpy.mock.invocationCallOrder[0]).toBeLessThan(updatePostSpy.mock.invocationCallOrder[0])
+			// Flushing here would cancel the debounce's trailing timer and send the *next*
+			// message straight through the leading edge, collapsing the throttle back to one
+			// full-state post per message.
+			expect(mockProvider.postStateToWebviewThrottled).toHaveBeenCalledWith()
+			expect(mockProvider.flushPostStateToWebviewThrottled).not.toHaveBeenCalled()
 			expect(updatePostSpy).toHaveBeenCalledWith({
 				type: "messageUpdated",
 				clineMessage: {
diff --git a/src/core/tools/__tests__/CodebaseSearchTool.workspace.spec.ts b/src/core/tools/__tests__/CodebaseSearchTool.workspace.spec.ts
index 03789f7d40..f2c4cc2aed 100644
--- a/src/core/tools/__tests__/CodebaseSearchTool.workspace.spec.ts
+++ b/src/core/tools/__tests__/CodebaseSearchTool.workspace.spec.ts
@@ -6,6 +6,7 @@ import type { ToolCallbacks } from "../BaseTool"
 import { CodebaseSearchTool } from "../CodebaseSearchTool"
 import { CodeIndexManagerRegistry } from "../../../services/code-index/code-index-manager-registry"
 import { CodeIndexManager } from "../../../services/code-index/manager"
+import { CodeIndexStateManager } from "../../../services/code-index/state-manager"
 import { getWorkspacePath } from "../../../utils/path"
 import { makeExtensionContext, makeTextDocument, makeTextEditor, makeUri } from "../../../test-utils/vscode"
 
@@ -15,6 +16,7 @@ vi.mock("vscode", () => ({
 	Uri: { file: vi.fn() },
 }))
 vi.mock("../../../utils/path", () => ({ getWorkspacePath: vi.fn() }))
+vi.mock("../../../services/code-index/state-manager")
 vi.mock("../../../services/code-index/manager", () => ({
 	CodeIndexManager: vi.fn().mockImplementation(function (workspacePath: string) {
 		let initialized = false
@@ -196,6 +198,7 @@ describe("CodebaseSearchTool workspace selection", () => {
 			"/external-task",
 			expect.objectContaining({ fsPath: "/external-task" }),
 			provider.context,
+			expect.any(CodeIndexStateManager),
 		)
 		expect(vscode.Uri.file).toHaveBeenCalledExactlyOnceWith("/external-task")
 		const manager = CodeIndexManagerRegistry.getOrCreate(provider.context, "/external-task")!
diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts
index 2f8c7f8adc..b0d76ecbf8 100644
--- a/src/core/webview/ClineProvider.ts
+++ b/src/core/webview/ClineProvider.ts
@@ -90,9 +90,8 @@ import { McpHub } from "../../services/mcp/McpHub"
 import { McpServerManager } from "../../services/mcp/McpServerManager"
 import { MarketplaceManager } from "../../services/marketplace"
 import { ShadowCheckpointService } from "../../services/checkpoints/ShadowCheckpointService"
-import type { CodeIndexManager } from "../../services/code-index/manager"
 import { CodeIndexManagerRegistry } from "../../services/code-index/code-index-manager-registry"
-import type { IndexProgressUpdate } from "../../services/code-index/interfaces/manager"
+import type { CodeIndexWorkspaceScope } from "../../services/code-index/code-index-workspace-scope"
 import { MdmService } from "../../services/mdm/MdmService"
 import { SkillsManager } from "../../services/skills/SkillsManager"
 
@@ -186,6 +185,25 @@ type GetStateOptions = {
 	includeTaskHistory?: boolean
 }
 
+/**
+ * Internal options for {@link ClineProvider.upsertProviderProfile}.
+ */
+type UpsertProviderProfileOptions = {
+	/**
+	 * Internal-only bypass of the organization model allow-list, used exclusively
+	 * for Zoo Gateway credential synchronization (token refresh) and sign-out
+	 * writes. These are auth writes, not model selections: a restrictive
+	 * allow-list may omit `zoo-gateway` entirely, or list the provider without the
+	 * active `zooGatewayModelId`, and must not reject the credential write and
+	 * leave stale credentials behind in the active profile.
+	 *
+	 * This flag must never be set from a webview-originated code path: the webview
+	 * is not a trusted boundary, so every user-driven profile write keeps the
+	 * allow-list enforcement.
+	 */
+	bypassAllowList?: boolean
+}
+
 export class ClineProvider
 	extends EventEmitter<TaskProviderEvents>
 	implements vscode.WebviewViewProvider, TelemetryPropertiesProvider, TaskProviderLike
@@ -212,8 +230,6 @@ export class ClineProvider
 	private taskScheduler = new TaskScheduler()
 	private static readonly delegationTransitionLocks = new Map<string, Promise<void>>()
 	private cancelledDelegationChildIds = new Set<string>()
-	private codeIndexStatusSubscription?: vscode.Disposable
-	private codeIndexManager?: CodeIndexManager
 	private _workspaceTracker?: WorkspaceTracker // workSpaceTracker read-only for access outside this class
 	protected mcpHub?: McpHub // Change from private to protected
 	protected skillsManager?: SkillsManager
@@ -406,35 +422,7 @@ export class ClineProvider
 				}
 				this.emit(RooCodeEventName.TaskCompleted, taskId, tokenUsage, toolUsage)
 			}
-			const onTaskAborted = async () => {
-				this.emit(RooCodeEventName.TaskAborted, instance.taskId)
-
-				try {
-					// Only rehydrate on genuine streaming failures.
-					// User-initiated cancels are handled by cancelTask().
-					if (instance.abortReason === "streaming_failed") {
-						// Defensive safeguard: if another path already replaced this instance, skip
-						const current = this.getCurrentTask()
-						if (current && current.instanceId !== instance.instanceId) {
-							this.log(
-								`[onTaskAborted] Skipping rehydrate: current instance ${current.instanceId} != aborted ${instance.instanceId}`,
-							)
-							return
-						}
-
-						const { historyItem } = await this.getTaskWithId(instance.taskId)
-						const rootTask = instance.rootTask
-						const parentTask = instance.parentTask
-						await this.createTaskWithHistoryItem({ ...historyItem, rootTask, parentTask })
-					}
-				} catch (error) {
-					this.log(
-						`[onTaskAborted] Failed to rehydrate after streaming failure: ${
-							error instanceof Error ? error.message : String(error)
-						}`,
-					)
-				}
-			}
+			const onTaskAborted = () => this.emit(RooCodeEventName.TaskAborted, instance.taskId)
 			const onTaskFocused = () => this.emit(RooCodeEventName.TaskFocused, instance.taskId)
 			const onTaskUnfocused = () => this.emit(RooCodeEventName.TaskUnfocused, instance.taskId)
 			const onTaskActive = (taskId: string) => this.emit(RooCodeEventName.TaskActive, taskId)
@@ -1073,17 +1061,6 @@ export class ClineProvider
 		// and executes code based on the message that is received.
 		this.setWebviewMessageListener(webviewView.webview)
 
-		// Initialize code index status subscription for the current workspace.
-		this.updateCodeIndexStatusSubscription()
-
-		// Listen for active editor changes to update code index status for the
-		// current workspace.
-		const activeEditorSubscription = vscode.window.onDidChangeActiveTextEditor(() => {
-			// Update subscription when workspace might have changed.
-			this.updateCodeIndexStatusSubscription()
-		})
-		this.webviewDisposables.push(activeEditorSubscription)
-
 		// Listen for when the panel becomes visible.
 		// https://github.com/microsoft/vscode-discussions/discussions/840
 		if ("onDidChangeViewState" in webviewView) {
@@ -1121,8 +1098,6 @@ export class ClineProvider
 				} else {
 					this.log("Clearing webview resources for sidebar view")
 					this.clearWebviewResources()
-					// Reset current workspace manager reference when view is disposed
-					this.codeIndexManager = undefined
 				}
 			},
 			null,
@@ -1534,7 +1509,7 @@ export class ClineProvider
 			console.error("[ClineProvider:Vite] Failed to read Vite port file:", err)
 		}
 
-		const localServerUrl = `localhost:${localPort}`
+		const localServerUrl = `127.0.0.1:${localPort}`
 
 		// Check if local dev server is running.
 		try {
@@ -1573,7 +1548,7 @@ export class ClineProvider
 
 		const reactRefresh = /*html*/ `
 			<script nonce="${nonce}" type="module">
-				import RefreshRuntime from "http://localhost:${localPort}/@react-refresh"
+				import RefreshRuntime from "http://127.0.0.1:${localPort}/@react-refresh"
 				RefreshRuntime.injectIntoGlobalHook(window)
 				window.$RefreshReg$ = () => {}
 				window.$RefreshSig$ = () => (type) => type
@@ -1879,7 +1854,52 @@ export class ClineProvider
 		name: string,
 		providerSettings: ProviderSettings,
 		activate: boolean = true,
+		options: UpsertProviderProfileOptions = {},
 	): Promise<string | undefined> {
+		// Enforce the organization model allow-list before persisting or
+		// activating a profile. The webview is not a trusted boundary, so the
+		// model selector's client-side gating cannot be the only check.
+		// Task creation validates too, but rejecting here prevents an
+		// unauthorized profile from being written or activated at all.
+		//
+		// `bypassAllowList` is reserved for internal Zoo Gateway credential
+		// writes (token refresh / sign-out), which are auth writes rather than
+		// model selections; see `UpsertProviderProfileOptions`.
+		if (!options.bypassAllowList) {
+			let organizationAllowList = ORGANIZATION_ALLOW_ALL
+
+			if (CloudService.hasInstance()) {
+				// The webview is not a trusted boundary, so a profile write must not
+				// fail open. Allow-all is only legitimate when no cloud instance exists
+				// (positively no organization policy). If a cloud instance exists but its
+				// policy cannot be read, reject the write rather than persisting a
+				// possibly disallowed model during a transient cloud/allow-list failure.
+				try {
+					organizationAllowList = await CloudService.instance.getAllowList()
+				} catch (error) {
+					this.log(
+						`[upsertProviderProfile] Blocked profile "${name}": organization allow-list unavailable: ${
+							error instanceof Error ? error.message : String(error)
+						}`,
+					)
+					void vscode.window.showErrorMessage(t("common:errors.violated_organization_allowlist"))
+					return undefined
+				}
+			}
+
+			if (!ProfileValidator.isProfileAllowed(providerSettings, organizationAllowList)) {
+				this.log(
+					`[upsertProviderProfile] Blocked profile "${name}": model is not allowed by the organization allow-list`,
+				)
+				// Surface the rejection to the user here rather than in the webview
+				// handler: direct callers (OAuth callbacks, sign-out) reach this
+				// method without the handler and would otherwise fail silently. No
+				// webview context is required, so non-webview callers are safe.
+				void vscode.window.showErrorMessage(t("common:errors.violated_organization_allowlist"))
+				return undefined
+			}
+		}
+
 		try {
 			return await this.enqueueProviderProfileMutation(async (signal) => {
 				// TODO: Do we need to be calling `activateProfile`? It's not
@@ -1887,13 +1907,50 @@ export class ClineProvider
 				// we rely on the `ContextProxy`'s data store and in other cases
 				// we rely on the `ProviderSettingsManager`'s data store. It might
 				// be simpler to unify these two.
+				// Snapshot the pre-write state so a failure *after* `saveConfig`
+				// succeeds (during the activation writes below) can be rolled back
+				// instead of leaving the profile secret and the active/mode state
+				// divergent — the profile would carry the new model while the mode
+				// or current profile still pointed at the old one.
+				const priorCurrentApiConfigName = this.contextProxy.getValue("currentApiConfigName")
+				const priorProviderSettings = this.contextProxy.getProviderSettings()
+
+				// `getProfile` wraps both "not found" and transient read failures in the
+				// same error, so it cannot decide whether the profile pre-existed. Probe
+				// existence explicitly: a destructive rollback (`deleteConfig`) must only
+				// run when absence is confirmed, never on a swallowed read error that would
+				// otherwise delete an existing profile and its secrets.
+				let profileExisted: boolean | undefined
+				try {
+					profileExisted = await this.providerSettingsManager.hasConfig(name)
+				} catch {
+					// Existence is unknown; rollback will restore/no-op rather than delete.
+					profileExisted = undefined
+				}
+
+				let priorProfile: Awaited<ReturnType<ProviderSettingsManager["getProfile"]>> | undefined
+				if (profileExisted !== false) {
+					try {
+						priorProfile = await this.providerSettingsManager.getProfile({ name })
+					} catch (error) {
+						// The profile exists (or existence is unknown) but could not be read.
+						// When existence was confirmed, propagate so the write aborts *before*
+						// `saveConfig` rather than proceeding with an unknown prior state.
+						if (profileExisted === true) {
+							throw error
+						}
+					}
+				}
+
+				// Read the mapping before writing so an unavailable snapshot aborts safely.
+				const mode = activate ? (await this.getState()).mode : undefined
+				const priorModeConfigId =
+					mode !== undefined ? await this.providerSettingsManager.getModeConfigId(mode) : undefined
 				const id = await this.providerSettingsManager.saveConfig(name, providerSettings)
 
 				if (signal.aborted) return id
 
-				if (activate) {
-					const { mode } = await this.getState()
-
+				if (mode !== undefined) {
 					// These promises do the following:
 					// 1. Adds or updates the list of provider profiles.
 					// 2. Sets the current provider profile.
@@ -1904,19 +1961,54 @@ export class ClineProvider
 					// this.contextProxy.setValues({ ...providerSettings, listApiConfigMeta: ..., currentApiConfigName: ... })
 					// We should probably switch to that and verify that it works.
 					// I left the original implementation in just to be safe.
-					await Promise.all([
-						this.updateGlobalState("listApiConfigMeta", await this.providerSettingsManager.listConfig()),
-						this.updateGlobalState("currentApiConfigName", name),
-						this.providerSettingsManager.setModeConfig(mode, id),
-						this.contextProxy.setProviderSettings(providerSettings),
-					])
-
-					// Change the provider for the current task.
-					// TODO: We should rename `buildApiHandler` for clarity (e.g. `getProviderClient`).
-					this.updateTaskApiHandlerIfNeeded(providerSettings, { forceRebuild: true })
-
-					// Keep the current task's sticky provider profile in sync with the newly-activated profile.
-					await this.persistStickyProviderProfileToCurrentTask(name)
+					try {
+						const results = await Promise.allSettled([
+							this.updateGlobalState(
+								"listApiConfigMeta",
+								await this.providerSettingsManager.listConfig(),
+							),
+							this.updateGlobalState("currentApiConfigName", name),
+							this.providerSettingsManager.setModeConfig(mode, id),
+							this.contextProxy.setProviderSettings(providerSettings),
+						])
+						// Roll back only after every write has finished, including late successes.
+						const failure = results.find((result) => result.status === "rejected")
+						if (failure?.status === "rejected") throw failure.reason
+
+						// Change the provider for the current task.
+						// TODO: We should rename `buildApiHandler` for clarity (e.g. `getProviderClient`).
+						this.updateTaskApiHandlerIfNeeded(providerSettings, { forceRebuild: true })
+
+						// Keep the current task's sticky provider profile in sync with the newly-activated profile.
+						await this.persistStickyProviderProfileToCurrentTask(name)
+					} catch (error) {
+						// Compensating rollback: restore the profile secret, the active
+						// profile name, the mode mapping and the in-memory provider
+						// settings to their pre-write values so a partial activation
+						// cannot report success while leaving inconsistent state.
+						try {
+							if (priorProfile) {
+								await this.providerSettingsManager.saveConfig(name, priorProfile)
+							} else if (profileExisted === false) {
+								// Absence was confirmed before the write; remove the new profile.
+								// A swallowed read error (unknown existence) must never reach here.
+								await this.providerSettingsManager.deleteConfig(name)
+							}
+							await this.providerSettingsManager.setModeConfig(mode, priorModeConfigId)
+							await this.contextProxy.setValue("currentApiConfigName", priorCurrentApiConfigName)
+							await this.contextProxy.setValues({
+								listApiConfigMeta: await this.providerSettingsManager.listConfig(),
+							})
+							await this.contextProxy.setProviderSettings(priorProviderSettings)
+						} catch (rollbackError) {
+							this.log(
+								`[upsertProviderProfile] rollback failed for "${name}": ${
+									rollbackError instanceof Error ? rollbackError.message : String(rollbackError)
+								}`,
+							)
+						}
+						throw error
+					}
 				} else {
 					await this.updateGlobalState("listApiConfigMeta", await this.providerSettingsManager.listConfig())
 				}
@@ -2168,7 +2260,13 @@ export class ClineProvider
 				}
 				// Activate only if zoo-gateway was the active provider (shouldn't happen if
 				// no profiles exist, but defensive).
-				await this.upsertProviderProfile("Zoo Gateway", newConfiguration, isZooGatewayActive)
+				//
+				// `bypassAllowList`: internal auth credential write. `ProfileValidator`
+				// cannot map zoo-gateway to a model id, so a restrictive organization
+				// allow-list would reject this write and leave no credentials persisted.
+				await this.upsertProviderProfile("Zoo Gateway", newConfiguration, isZooGatewayActive, {
+					bypassAllowList: true,
+				})
 			} else {
 				// Update every existing zoo-gateway profile with the new token and the
 				// derived base URL so that environment-specific routing stays consistent.
@@ -2183,7 +2281,8 @@ export class ClineProvider
 					if (isActiveProfile) {
 						// Use upsertProviderProfile with activate: true so the in-memory handler
 						// picks up the new token immediately for the current task.
-						await this.upsertProviderProfile(entry.name, updated, true)
+						// `bypassAllowList`: internal auth credential write (see above).
+						await this.upsertProviderProfile(entry.name, updated, true, { bypassAllowList: true })
 					} else {
 						// Non-active profiles just need the token saved to disk.
 						await this.providerSettingsManager.saveConfig(entry.name, updated)
@@ -3263,59 +3362,8 @@ export class ClineProvider
 		return true
 	}
 
-	/**
-	 * Gets the CodeIndexManager for the current active workspace
-	 * @returns CodeIndexManager instance for the current workspace or the default one
-	 */
-	public getCurrentWorkspaceCodeIndexManager(): CodeIndexManager | undefined {
-		return CodeIndexManagerRegistry.getOrCreate(this.context)
-	}
-
-	/**
-	 * Updates the code index status subscription to listen to the current workspace manager
-	 */
-	private updateCodeIndexStatusSubscription(): void {
-		// Get the current workspace manager
-		const currentManager = this.getCurrentWorkspaceCodeIndexManager()
-
-		// If the manager hasn't changed, no need to update subscription
-		if (currentManager === this.codeIndexManager) {
-			return
-		}
-
-		// Dispose the old subscription if it exists
-		if (this.codeIndexStatusSubscription) {
-			this.codeIndexStatusSubscription.dispose()
-			this.codeIndexStatusSubscription = undefined
-		}
-
-		// Update the current workspace manager reference
-		this.codeIndexManager = currentManager
-
-		// Subscribe to the new manager's progress updates if it exists
-		if (currentManager) {
-			this.codeIndexStatusSubscription = currentManager.onProgressUpdate((update: IndexProgressUpdate) => {
-				// Only send updates if this manager is still the current one
-				if (currentManager === this.getCurrentWorkspaceCodeIndexManager()) {
-					// Get the full status from the manager to ensure we have all fields correctly formatted
-					const fullStatus = currentManager.getCurrentStatus()
-					void this.postMessageToWebview({
-						type: "indexingStatusUpdate",
-						values: fullStatus,
-					})
-				}
-			})
-
-			if (this.view) {
-				this.webviewDisposables.push(this.codeIndexStatusSubscription)
-			}
-
-			// Send initial status for the current workspace
-			void this.postMessageToWebview({
-				type: "indexingStatusUpdate",
-				values: currentManager.getCurrentStatus(),
-			})
-		}
+	public getCurrentWorkspaceCodeIndexScope(): CodeIndexWorkspaceScope | undefined {
+		return CodeIndexManagerRegistry.getOrCreateScope(this.context)
 	}
 
 	/**
@@ -3805,6 +3853,11 @@ export class ClineProvider
 		}
 	}
 
+	/** Workspace explicitly associated with this provider, without an active-editor fallback. */
+	public get workspacePath(): string | undefined {
+		return this.currentWorkspacePath
+	}
+
 	public get cwd() {
 		return this.currentWorkspacePath || getWorkspacePath()
 	}
diff --git a/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts b/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts
index 99d254cb9a..df0de21878 100644
--- a/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts
+++ b/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts
@@ -3,7 +3,7 @@
 import * as vscode from "vscode"
 
 import { TelemetryService } from "@roo-code/telemetry"
-import { getModelId, RooCodeEventName } from "@roo-code/types"
+import { getModelId, ORGANIZATION_ALLOW_ALL, RooCodeEventName } from "@roo-code/types"
 
 import { ContextProxy } from "../../config/ContextProxy"
 import type { Mode } from "../../../shared/modes"
@@ -11,6 +11,13 @@ import { Task, TaskOptions } from "../../task/Task"
 import { ClineProvider } from "../ClineProvider"
 import { providerIdentifiers } from "@roo-code/types/provider-identifiers"
 
+// Partial mock: other provider modules (e.g. `deepseek.ts`) import
+// `OpenAiHandler` from here, so the real exports must remain available.
+vi.mock("../../../api/providers/openai", async (importOriginal) => ({
+	...(await importOriginal<typeof import("../../../api/providers/openai")>()),
+	getOpenAiModels: vi.fn(),
+}))
+
 // Mock setup
 vi.mock("fs/promises", () => ({
 	mkdir: vi.fn().mockResolvedValue(undefined),
@@ -130,12 +137,20 @@ vi.mock("../../task/Task", () => ({
 	}),
 }))
 
+// Hoisted so the `@roo-code/cloud` mock factory (which is hoisted above the
+// imports) can expose the same `getAllowList`/`hasInstance` spies the tests configure.
+const { mockGetAllowList, mockHasInstance } = vi.hoisted(() => ({
+	mockGetAllowList: vi.fn(),
+	mockHasInstance: vi.fn(),
+}))
+
 vi.mock("@roo-code/cloud", () => ({
 	CloudService: {
-		hasInstance: vi.fn().mockReturnValue(true),
+		hasInstance: mockHasInstance,
 		get instance() {
 			return {
 				isAuthenticated: vi.fn().mockReturnValue(false),
+				getAllowList: mockGetAllowList,
 			}
 		},
 	},
@@ -153,6 +168,10 @@ describe("ClineProvider - API Handler Rebuild Guard", () => {
 
 	beforeEach(async () => {
 		vi.clearAllMocks()
+		// Default to allow-all; individual tests override with a restrictive list.
+		mockGetAllowList.mockResolvedValue(ORGANIZATION_ALLOW_ALL)
+		// A cloud instance exists by default, which is the fail-closed case.
+		mockHasInstance.mockReturnValue(true)
 
 		if (!TelemetryService.hasInstance()) {
 			TelemetryService.createInstance([])
@@ -257,6 +276,9 @@ describe("ClineProvider - API Handler Rebuild Guard", () => {
 				apiProvider: providerIdentifiers.openrouter,
 				openRouterModelId: "openai/gpt-4",
 			}),
+			// Default to "does not exist yet"; tests that simulate an existing
+			// profile must override this so the prior-profile snapshot is taken.
+			hasConfig: vi.fn().mockResolvedValue(false),
 		}
 
 		// Get the buildApiHandler mock
@@ -417,6 +439,288 @@ describe("ClineProvider - API Handler Rebuild Guard", () => {
 			// Should not call buildApiHandler when there's no task
 			expect(buildApiHandlerMock).not.toHaveBeenCalled()
 		})
+
+		test("persists and activates an allowed profile under a restrictive allow-list", async () => {
+			mockGetAllowList.mockResolvedValue({
+				allowAll: false,
+				providers: {
+					[providerIdentifiers.openrouter]: { allowAll: false, models: ["openai/gpt-4"] },
+				},
+			})
+
+			const result = await provider.upsertProviderProfile("test-config", {
+				apiProvider: providerIdentifiers.openrouter,
+				openRouterModelId: "openai/gpt-4",
+			})
+
+			expect(result).toBe("test-id")
+			expect(provider["providerSettingsManager"].saveConfig).toHaveBeenCalledWith(
+				"test-config",
+				expect.objectContaining({ openRouterModelId: "openai/gpt-4" }),
+			)
+			expect(mockContext.globalState.update).toHaveBeenCalledWith("currentApiConfigName", "test-config")
+			expect(vscode.window.showErrorMessage).not.toHaveBeenCalled()
+		})
+
+		test("rejects a disallowed profile: not persisted, not activated, user notified", async () => {
+			mockGetAllowList.mockResolvedValue({
+				allowAll: false,
+				providers: {
+					[providerIdentifiers.openrouter]: { allowAll: false, models: ["openai/gpt-4"] },
+				},
+			})
+			const saveConfig = provider["providerSettingsManager"].saveConfig
+
+			const result = await provider.upsertProviderProfile("blocked-config", {
+				apiProvider: providerIdentifiers.openrouter,
+				openRouterModelId: "openai/forbidden",
+			})
+
+			// No id means the write was rejected before any persistence/activation.
+			expect(result).toBeUndefined()
+			expect(saveConfig).not.toHaveBeenCalled()
+			expect(mockContext.globalState.update).not.toHaveBeenCalledWith("currentApiConfigName", "blocked-config")
+			// The notification lives in `upsertProviderProfile` so direct callers
+			// (OAuth callbacks, sign-out) do not fail silently.
+			expect(vscode.window.showErrorMessage).toHaveBeenCalledWith("errors.violated_organization_allowlist")
+		})
+
+		test("rejects the write when a cloud instance exists but the allow-list is unavailable", async () => {
+			mockGetAllowList.mockRejectedValue(new Error("cloud unavailable"))
+
+			const saveConfig = provider["providerSettingsManager"].saveConfig
+			const result = await provider.upsertProviderProfile("test-config", {
+				apiProvider: providerIdentifiers.openrouter,
+				openRouterModelId: "openai/gpt-4",
+			})
+
+			// Fail closed: a transient allow-list failure with a live cloud instance
+			// must not persist a possibly disallowed model.
+			expect(result).toBeUndefined()
+			expect(saveConfig).not.toHaveBeenCalled()
+			expect(vscode.window.showErrorMessage).toHaveBeenCalledWith("errors.violated_organization_allowlist")
+		})
+
+		test("allows the write when no cloud instance exists (positively no organization policy)", async () => {
+			mockHasInstance.mockReturnValue(false)
+			// Even a failing policy read must not matter: allow-all is legitimate
+			// when no organization policy positively applies.
+			mockGetAllowList.mockRejectedValue(new Error("should not be consulted for the gate"))
+
+			const result = await provider.upsertProviderProfile("test-config", {
+				apiProvider: providerIdentifiers.openrouter,
+				openRouterModelId: "openai/gpt-4",
+			})
+
+			expect(result).toBe("test-id")
+			expect(provider["providerSettingsManager"].saveConfig).toHaveBeenCalled()
+			expect(vscode.window.showErrorMessage).not.toHaveBeenCalled()
+		})
+
+		test("bypassAllowList writes Zoo Gateway credentials even when the allow-list forbids the provider", async () => {
+			// A restrictive allow-list that does not mention zoo-gateway at all. This
+			// is exactly the case that used to strand a refreshed/cleared token, and
+			// it is why the credential write opts out of the model allow-list.
+			mockGetAllowList.mockResolvedValue({
+				allowAll: false,
+				providers: {
+					[providerIdentifiers.openrouter]: { allowAll: false, models: ["openai/gpt-4"] },
+				},
+			})
+
+			const result = await provider.upsertProviderProfile(
+				"Zoo Gateway",
+				{ apiProvider: providerIdentifiers.zooGateway, zooSessionToken: "zoo_ext_token" },
+				false,
+				{ bypassAllowList: true },
+			)
+
+			// The write succeeded even though the allow-list forbids zoo-gateway:
+			// without the bypass this exact profile is rejected (see the next test).
+			expect(result).toBe("test-id")
+			expect(provider["providerSettingsManager"].saveConfig).toHaveBeenCalledWith(
+				"Zoo Gateway",
+				expect.objectContaining({ zooSessionToken: "zoo_ext_token" }),
+			)
+			expect(vscode.window.showErrorMessage).not.toHaveBeenCalled()
+		})
+
+		test("accepts a Zoo Gateway profile whose model is on the allow-list", async () => {
+			// `ProfileValidator.getModelIdFromProfile` maps zoo-gateway to
+			// `zooGatewayModelId`, so a listed model passes without the bypass.
+			mockGetAllowList.mockResolvedValue({
+				allowAll: false,
+				providers: {
+					[providerIdentifiers.zooGateway]: {
+						allowAll: false,
+						models: ["anthropic/claude-sonnet-4"],
+					},
+				},
+			})
+
+			const result = await provider.upsertProviderProfile("Zoo Gateway", {
+				apiProvider: providerIdentifiers.zooGateway,
+				zooSessionToken: "zoo_ext_token",
+				zooGatewayModelId: "anthropic/claude-sonnet-4",
+			})
+
+			expect(result).toBe("test-id")
+			expect(provider["providerSettingsManager"].saveConfig).toHaveBeenCalledWith(
+				"Zoo Gateway",
+				expect.objectContaining({ zooGatewayModelId: "anthropic/claude-sonnet-4" }),
+			)
+			expect(vscode.window.showErrorMessage).not.toHaveBeenCalled()
+		})
+
+		test("rejects a Zoo Gateway profile whose model is not on the allow-list", async () => {
+			mockGetAllowList.mockResolvedValue({
+				allowAll: false,
+				providers: {
+					[providerIdentifiers.zooGateway]: {
+						allowAll: false,
+						models: ["anthropic/claude-sonnet-4"],
+					},
+				},
+			})
+
+			const result = await provider.upsertProviderProfile("Zoo Gateway", {
+				apiProvider: providerIdentifiers.zooGateway,
+				zooSessionToken: "zoo_ext_token",
+				zooGatewayModelId: "anthropic/claude-opus-4",
+			})
+
+			expect(result).toBeUndefined()
+			expect(vscode.window.showErrorMessage).toHaveBeenCalledWith("errors.violated_organization_allowlist")
+		})
+
+		test("the Zoo Gateway bypass does not leak to other providers", async () => {
+			mockGetAllowList.mockResolvedValue({
+				allowAll: false,
+				providers: {
+					[providerIdentifiers.openrouter]: { allowAll: false, models: ["openai/gpt-4"] },
+				},
+			})
+
+			// Same restrictive list, but without the internal bypass the write is
+			// still rejected — proving the escape hatch is opt-in per call.
+			const result = await provider.upsertProviderProfile("blocked-config", {
+				apiProvider: providerIdentifiers.zooGateway,
+				zooSessionToken: "zoo_ext_token",
+			})
+
+			expect(result).toBeUndefined()
+			expect(vscode.window.showErrorMessage).toHaveBeenCalledWith("errors.violated_organization_allowlist")
+		})
+
+		test("rolls back the profile and active state when an activation write fails after saveConfig", async () => {
+			// Seed the previously active profile name so the rollback restores a known value.
+			await provider.contextProxy.setValue("currentApiConfigName", "test-config")
+			const priorProfile = {
+				name: "new-config",
+				id: "prior-id",
+				apiProvider: providerIdentifiers.openrouter,
+				openRouterModelId: "openai/gpt-4",
+			}
+			// The profile pre-exists, so existence is confirmed and its prior value is read.
+			provider["providerSettingsManager"].hasConfig = vi.fn().mockResolvedValue(true)
+			provider["providerSettingsManager"].getProfile = vi.fn().mockResolvedValue(priorProfile)
+			provider["providerSettingsManager"].getModeConfigId = vi.fn().mockResolvedValue(undefined)
+			// Fail an activation write that runs *after* saveConfig succeeded.
+			provider["providerSettingsManager"].setModeConfig = vi
+				.fn()
+				.mockRejectedValueOnce(new Error("mode write failed"))
+			const saveConfig = provider["providerSettingsManager"].saveConfig
+
+			const result = await provider.upsertProviderProfile("new-config", {
+				apiProvider: providerIdentifiers.openrouter,
+				openRouterModelId: "openai/gpt-4-turbo",
+			})
+
+			// The partial write is reported as a failure, never a success.
+			expect(result).toBeUndefined()
+			// The new model was written first, then the prior profile was restored so
+			// the secret cannot carry the new model while the active state is stale.
+			expect(saveConfig).toHaveBeenNthCalledWith(
+				1,
+				"new-config",
+				expect.objectContaining({ openRouterModelId: "openai/gpt-4-turbo" }),
+			)
+			expect(saveConfig).toHaveBeenNthCalledWith(2, "new-config", priorProfile)
+			// The previously active profile name ("test-config") is restored.
+			expect(mockContext.globalState.update).toHaveBeenCalledWith("currentApiConfigName", "test-config")
+			// No activation success state leaked to the webview.
+			expect(vscode.window.showErrorMessage).toHaveBeenCalledWith("errors.create_api_config")
+		})
+
+		test.each([undefined, "prior-id"])(
+			"restores prior mapping %s after a concurrent activation failure",
+			async (priorId) => {
+				const manager = provider["providerSettingsManager"]
+				let modeId: string | undefined = priorId
+				const events: string[] = []
+				manager.getModeConfigId = vi.fn(async () => modeId)
+				manager.setModeConfig = vi.fn(async (_mode, id) => {
+					if (id === "test-id") {
+						// Keep this write pending past the other activation write's rejection.
+						await new Promise<void>((resolve) => setTimeout(resolve, 0))
+						events.push("activation settled")
+					}
+					modeId = id
+				})
+				manager.deleteConfig = vi.fn(async () => {
+					events.push("profile deleted")
+				})
+				vi.spyOn(provider.contextProxy, "setProviderSettings").mockRejectedValueOnce(
+					new Error("activation failed"),
+				)
+
+				const result = await provider.upsertProviderProfile("new-config", {
+					apiProvider: providerIdentifiers.openrouter,
+					openRouterModelId: "openai/gpt-4-turbo",
+				})
+
+				expect(result).toBeUndefined()
+				expect(manager.deleteConfig).toHaveBeenCalledExactlyOnceWith("new-config")
+				expect(await manager.getModeConfigId("code")).toBe(priorId)
+				expect(events).toEqual(["activation settled", "profile deleted"])
+			},
+		)
+
+		test("aborts before saving when the prior mode mapping cannot be read", async () => {
+			const manager = provider["providerSettingsManager"]
+			manager.getModeConfigId = vi.fn().mockRejectedValue(new Error("mapping read failed"))
+			expect(
+				await provider.upsertProviderProfile("new-config", {
+					apiProvider: providerIdentifiers.openrouter,
+				}),
+			).toBeUndefined()
+			expect(manager.saveConfig).not.toHaveBeenCalled()
+			expect(manager.setModeConfig).not.toHaveBeenCalled()
+		})
+
+		test("aborts without deleting an existing profile when the prior profile cannot be read", async () => {
+			// The profile exists, but reading it fails (e.g. a transient secrets error).
+			// A swallowed failure must NOT be treated as "absent": rollback must never
+			// delete the still-existing profile and its secrets.
+			provider["providerSettingsManager"].hasConfig = vi.fn().mockResolvedValue(true)
+			provider["providerSettingsManager"].getProfile = vi
+				.fn()
+				.mockRejectedValue(new Error("transient secrets read failure"))
+			const saveConfig = provider["providerSettingsManager"].saveConfig
+			const deleteConfig = vi.fn().mockResolvedValue(undefined)
+			provider["providerSettingsManager"].deleteConfig = deleteConfig
+
+			const result = await provider.upsertProviderProfile("test-config", {
+				apiProvider: providerIdentifiers.openrouter,
+				openRouterModelId: "openai/gpt-4-turbo",
+			})
+
+			// The write aborts *before* saveConfig, so the existing profile is untouched.
+			expect(result).toBeUndefined()
+			expect(saveConfig).not.toHaveBeenCalled()
+			expect(deleteConfig).not.toHaveBeenCalled()
+			expect(vscode.window.showErrorMessage).toHaveBeenCalledWith("errors.create_api_config")
+		})
 	})
 
 	describe("activateProviderProfile", () => {
diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts
index 72aa1bcb76..a22fd885a0 100644
--- a/src/core/webview/__tests__/ClineProvider.spec.ts
+++ b/src/core/webview/__tests__/ClineProvider.spec.ts
@@ -1,5 +1,6 @@
 // pnpm --filter roo-cline test core/webview/__tests__/ClineProvider.spec.ts
 
+import fs from "fs"
 import * as path from "path"
 import { TaskRegistry } from "../../task/TaskRegistry"
 
@@ -27,6 +28,7 @@ import { defaultModeSlug } from "../../../shared/modes"
 import { experimentDefault } from "../../../shared/experiments"
 import { setTtsEnabled } from "../../../utils/tts"
 import { ContextProxy } from "../../config/ContextProxy"
+import { WorkspaceIndexingEnablementManager } from "../../../services/code-index/workspace-indexing-enablement-manager"
 import { Task, TaskOptions } from "../../task/Task"
 import { safeWriteJson } from "../../../utils/safeWriteJson"
 
@@ -400,6 +402,9 @@ vi.mock("@roo-code/cloud", () => ({
 				login: vi.fn().mockResolvedValue(undefined),
 				logout: vi.fn().mockResolvedValue(undefined),
 				off: vi.fn(),
+				// A cloud instance is present, so the fail-closed allow-list guard reads
+				// this. Default to allow-all so profile writes behave as before.
+				getAllowList: vi.fn().mockReturnValue({ allowAll: true, providers: {} }),
 			}
 		},
 	},
@@ -561,6 +566,15 @@ describe("ClineProvider", () => {
 		})
 	})
 
+	test("exposes only the explicitly associated workspace without a fallback", () => {
+		provider["currentWorkspacePath"] = "/workspace-a"
+		expect(provider.workspacePath).toBe("/workspace-a")
+		provider["currentWorkspacePath"] = "/workspace-b"
+		expect(provider.workspacePath).toBe("/workspace-b")
+		provider["currentWorkspacePath"] = undefined
+		expect(provider.workspacePath).toBeUndefined()
+	})
+
 	test("constructor initializes correctly", () => {
 		expect(provider).toBeInstanceOf(ClineProvider)
 		// Since getVisibleInstance returns the last instance where view.visible is true
@@ -664,12 +678,14 @@ describe("ClineProvider", () => {
 	})
 
 	test("resolveWebviewView sets up webview correctly in development mode even if local server is not running", async () => {
+		const developmentContext = { ...mockContext, extensionMode: vscode.ExtensionMode.Development }
 		provider = new ClineProvider(
-			{ ...mockContext, extensionMode: vscode.ExtensionMode.Development },
+			developmentContext,
 			mockOutputChannel,
 			"sidebar",
-			new ContextProxy(mockContext),
+			new ContextProxy(developmentContext),
 		)
+		// The dev-server probe fails, so the HMR path falls back to the production HTML.
 		;(axios.get as any).mockRejectedValueOnce(new Error("Network error"))
 
 		await provider.resolveWebviewView(mockWebviewView)
@@ -695,6 +711,56 @@ describe("ClineProvider", () => {
 		expect(scriptSrcMatch![0]).toContain("'wasm-unsafe-eval'")
 	})
 
+	test("resolveWebviewView builds HMR content against the local dev server when it is reachable", async () => {
+		const originalThemeFixtureProbe = process.env.ROO_CODE_THEME_FIXTURE_PROBE
+		delete process.env.ROO_CODE_THEME_FIXTURE_PROBE
+		// getHMRHtmlContent prefers an on-disk .vite-port file when one exists, so a
+		// stale dev leftover could silently move the probe (and the HMR URLs) to
+		// another port. Establish the default-port branch for this test by hiding
+		// exactly that file from the existence check; every other path falls
+		// through to the real implementation.
+		const realExistsSync = fs.existsSync
+		const existsSyncSpy = vi
+			.spyOn(fs, "existsSync")
+			.mockImplementation((target) =>
+				path.basename(String(target)) === ".vite-port" ? false : realExistsSync(target),
+			)
+
+		try {
+			provider = new ClineProvider(
+				{ ...mockContext, extensionMode: vscode.ExtensionMode.Development },
+				mockOutputChannel,
+				"sidebar",
+				new ContextProxy({ ...mockContext, extensionMode: vscode.ExtensionMode.Development }),
+			)
+			// The default axios mock resolves, so the dev-server probe succeeds and the
+			// HMR HTML branch (instead of the production fallback) is taken.
+			vi.mocked(axios.get).mockClear()
+			await provider.resolveWebviewView(mockWebviewView)
+
+			// Pin the health-check URL itself: the mock resolves for any URL, so only
+			// this assertion keeps the probe from silently drifting back to
+			// `localhost` (the IPv6 resolution failure this branch fixes).
+			expect(axios.get).toHaveBeenCalledWith("http://127.0.0.1:5173")
+
+			const html = mockWebviewView.webview.html
+			// The dev server URL must be baked into the module script tag and CSP directives.
+			expect(html).toContain("http://127.0.0.1:5173/src/index.tsx")
+			expect(html).toContain("ws://127.0.0.1:5173")
+			expect(html).toContain("http://127.0.0.1:5173/@react-refresh")
+		} finally {
+			existsSyncSpy.mockRestore()
+			// Always restore the probe flag (even when an assertion above throws),
+			// so later tests outside the fixture-probe describe block cannot observe
+			// this test's deletion.
+			if (originalThemeFixtureProbe !== undefined) {
+				process.env.ROO_CODE_THEME_FIXTURE_PROBE = originalThemeFixtureProbe
+			} else {
+				delete process.env.ROO_CODE_THEME_FIXTURE_PROBE
+			}
+		}
+	})
+
 	test("postMessageToWebview sends message to webview", async () => {
 		await provider.resolveWebviewView(mockWebviewView)
 
@@ -1020,6 +1086,33 @@ describe("ClineProvider", () => {
 			expect(postStateSpy).toHaveBeenCalledTimes(2)
 		})
 
+		// Characterization test for the semantics that made #1078's throttle a no-op in practice:
+		// flushing right after a leading-edge post has no pending trailing invocation to run, so it
+		// only cancels the trailing timer — and the next call then hits the leading edge again.
+		// Callers on a hot path (see Task#addToClineMessages) must therefore not flush per message.
+		test("flushing after every post defeats coalescing entirely", async () => {
+			const postStateSpy = vi.spyOn(provider, "postStateToWebviewWithoutTaskHistory").mockResolvedValue(undefined)
+
+			for (let i = 0; i < 5; i++) {
+				await provider.postStateToWebviewThrottled()
+				await provider.flushPostStateToWebviewThrottled()
+				await vi.advanceTimersByTimeAsync(100)
+			}
+
+			// One full-state post per call: no coalescing at all.
+			expect(postStateSpy).toHaveBeenCalledTimes(5)
+
+			// The same burst without the interleaved flush coalesces into far fewer posts.
+			postStateSpy.mockClear()
+			for (let i = 0; i < 5; i++) {
+				await provider.postStateToWebviewThrottled()
+				await vi.advanceTimersByTimeAsync(100)
+			}
+			await vi.advanceTimersByTimeAsync(500)
+
+			expect(postStateSpy.mock.calls.length).toBeLessThan(5)
+		})
+
 		test("flushes a pending trailing post exactly once and waits for it", async () => {
 			let releasePost!: () => void
 			const pendingPost = new Promise<void>((resolve) => {
@@ -2051,6 +2144,7 @@ describe("ClineProvider", () => {
 				]),
 			saveConfig: vi.fn().mockResolvedValue("test-id"),
 			setModeConfig: vi.fn(),
+			getModeConfigId: vi.fn().mockResolvedValue(undefined),
 		} as any
 
 		// Update API configuration
@@ -2819,6 +2913,7 @@ describe("ClineProvider", () => {
 
 			;(provider as any).providerSettingsManager = {
 				setModeConfig: vi.fn(),
+				getModeConfigId: vi.fn().mockResolvedValue(undefined),
 				saveConfig: vi.fn().mockResolvedValue(undefined),
 				listConfig: vi
 					.fn()
@@ -2864,6 +2959,7 @@ describe("ClineProvider", () => {
 			})
 			;(provider as any).providerSettingsManager = {
 				setModeConfig: vi.fn(),
+				getModeConfigId: vi.fn().mockResolvedValue(undefined),
 				saveConfig: vi.fn().mockResolvedValue(undefined),
 				listConfig: vi
 					.fn()
@@ -2957,7 +3053,7 @@ describe("webviewMessageHandler no-floating-promises coverage", () => {
 				postMessageToWebview: vi.fn().mockResolvedValue(true),
 				postStateToWebview: vi.fn().mockResolvedValue(undefined),
 				getCurrentTask: vi.fn(),
-				getCurrentWorkspaceCodeIndexManager: vi.fn(),
+				getCurrentWorkspaceCodeIndexScope: vi.fn(),
 				getMcpHub: vi.fn().mockReturnValue({
 					getMcpSettingsFilePath: vi.fn().mockResolvedValue("/test/mcp.json"),
 				}),
@@ -3013,10 +3109,11 @@ describe("webviewMessageHandler no-floating-promises coverage", () => {
 			startIndexing: vi.fn().mockReturnValue(indexingPromise),
 		})
 		const provider = createProvider({
-			getCurrentWorkspaceCodeIndexManager: vi.fn().mockReturnValue(manager),
+			getCurrentWorkspaceCodeIndexScope: vi.fn().mockReturnValue({ codeIndexManager: manager }),
 		})
 
 		await expect(webviewMessageHandler(provider, { type: "startIndexing" })).resolves.toBeUndefined()
+		expect(provider.getCurrentWorkspaceCodeIndexScope).toHaveBeenCalledOnce()
 		expect(manager.startIndexing).toHaveBeenCalledOnce()
 
 		rejectIndexing(new Error("boom"))
@@ -3170,14 +3267,29 @@ describe("webviewMessageHandler no-floating-promises coverage", () => {
 
 	it("covers changed indexing status, secret, and missing-manager responses", async () => {
 		const manager = createIndexManager()
-		const getManager = vi.fn().mockReturnValueOnce(undefined).mockReturnValue(manager)
-		const provider = createProvider({ getCurrentWorkspaceCodeIndexManager: getManager })
+		const getScope = vi.fn().mockReturnValueOnce(undefined).mockReturnValue({ codeIndexManager: manager })
+		const provider = createProvider({
+			getCurrentWorkspaceCodeIndexScope: getScope,
+		})
 
 		await webviewMessageHandler(provider, { type: "requestIndexingStatus" })
+		expect(manager.getCurrentStatus).not.toHaveBeenCalled()
+		expect(provider.postMessageToWebview).toHaveBeenCalledWith({
+			type: "indexingStatusUpdate",
+			values: expect.objectContaining({ systemStatus: "Error", message: expect.any(String) }),
+		})
 		await webviewMessageHandler(provider, { type: "requestIndexingStatus" })
+		expect(getScope).toHaveBeenCalledTimes(2)
+		expect(manager.getCurrentStatus).toHaveBeenCalledOnce()
+		expect(provider.postMessageToWebview).toHaveBeenLastCalledWith({
+			type: "indexingStatusUpdate",
+			values: manager.getCurrentStatus.mock.results[0].value,
+		})
 		await webviewMessageHandler(provider, { type: "requestCodeIndexSecretStatus" })
-		getManager.mockReturnValueOnce(undefined)
+		getScope.mockReturnValueOnce(undefined)
 		await webviewMessageHandler(provider, { type: "startIndexing" })
+		expect(getScope).toHaveBeenCalledTimes(3)
+		expect(manager.setWorkspaceEnabled).not.toHaveBeenCalled()
 
 		expect(provider.postMessageToWebview).toHaveBeenCalledWith(
 			expect.objectContaining({ type: "codeIndexSecretStatus" }),
@@ -3194,7 +3306,7 @@ describe("webviewMessageHandler no-floating-promises coverage", () => {
 				.mockRejectedValueOnce(new Error("second failure")),
 		})
 		const provider = createProvider({
-			getCurrentWorkspaceCodeIndexManager: vi.fn().mockReturnValue(manager),
+			getCurrentWorkspaceCodeIndexScope: vi.fn().mockReturnValue({ codeIndexManager: manager }),
 		})
 
 		await webviewMessageHandler(provider, { type: "startIndexing" })
@@ -3210,10 +3322,18 @@ describe("webviewMessageHandler no-floating-promises coverage", () => {
 			startIndexing: vi.fn().mockRejectedValue(new Error("toggle failure")),
 		})
 		const provider = createProvider({
-			getCurrentWorkspaceCodeIndexManager: vi.fn().mockReturnValue(manager),
+			getCurrentWorkspaceCodeIndexScope: vi.fn().mockReturnValue({
+				codeIndexManager: manager,
+				workspaceIndexingEnablementManager: new WorkspaceIndexingEnablementManager(manager),
+			}),
 		})
 
 		await webviewMessageHandler(provider, { type: "stopIndexing" })
+		expect(provider.getCurrentWorkspaceCodeIndexScope).toHaveBeenCalledOnce()
+		expect(provider.postMessageToWebview).toHaveBeenCalledExactlyOnceWith({
+			type: "indexingStatusUpdate",
+			values: manager.getCurrentStatus(),
+		})
 		await webviewMessageHandler(provider, { type: "toggleWorkspaceIndexing", bool: true })
 		await Promise.resolve()
 
@@ -3224,6 +3344,85 @@ describe("webviewMessageHandler no-floating-promises coverage", () => {
 		)
 	})
 
+	it("does not toggle indexing or publish status without a workspace scope", async () => {
+		const provider = createProvider()
+		await webviewMessageHandler(provider, { type: "toggleWorkspaceIndexing", bool: true })
+		expect(provider.getCurrentWorkspaceCodeIndexScope).toHaveBeenCalledOnce()
+		expect(provider.log).toHaveBeenCalledExactlyOnceWith(
+			"Cannot toggle workspace indexing: No workspace folder open",
+		)
+		expect(provider.postMessageToWebview).not.toHaveBeenCalled()
+	})
+
+	it.each([
+		{ bool: true, expected: true },
+		{ bool: false, expected: false },
+		{ bool: undefined, expected: false },
+	])("delegates workspace enablement with bool=$bool as $expected", async ({ bool, expected }) => {
+		const setEnabled = vi.fn().mockResolvedValue(undefined)
+		const provider = createProvider({
+			getCurrentWorkspaceCodeIndexScope: vi.fn().mockReturnValue({
+				workspaceIndexingEnablementManager: { setEnabled },
+			}),
+		})
+		const message: WebviewMessage = { type: "toggleWorkspaceIndexing" }
+		if (bool !== undefined) {
+			message.bool = bool
+		}
+		await webviewMessageHandler(provider, message)
+		expect(setEnabled).toHaveBeenCalledExactlyOnceWith(expected, provider)
+		// Status publication belongs to the enablement manager, not the handler.
+		expect(provider.postMessageToWebview).not.toHaveBeenCalled()
+		expect(provider.log).not.toHaveBeenCalled()
+	})
+
+	it("does not stop indexing or publish status without a workspace scope", async () => {
+		const provider = createProvider()
+		await webviewMessageHandler(provider, { type: "stopIndexing" })
+		expect(provider.getCurrentWorkspaceCodeIndexScope).toHaveBeenCalledOnce()
+		expect(provider.log).toHaveBeenCalledWith("Cannot stop indexing: No workspace folder open")
+		expect(provider.postMessageToWebview).not.toHaveBeenCalled()
+	})
+
+	it.each([true, false])("resolves the scope after saving index settings (workspace=%s)", async (hasWorkspace) => {
+		const handleSettingsChange = vi.fn().mockResolvedValue(undefined)
+		const manager = createIndexManager({ handleSettingsChange, isFeatureEnabled: false })
+		const provider = createProvider({
+			getCurrentWorkspaceCodeIndexScope: vi
+				.fn()
+				.mockReturnValue(hasWorkspace ? { codeIndexManager: manager } : undefined),
+		})
+
+		await webviewMessageHandler(provider, {
+			type: "saveCodeIndexSettingsAtomic",
+			codeIndexSettings: {
+				codebaseIndexEnabled: false,
+				codebaseIndexQdrantUrl: "http://localhost:6333",
+				codebaseIndexEmbedderProvider: providerIdentifiers.openai,
+				codebaseIndexEmbedderModelId: "text-embedding-3-small",
+			},
+		})
+
+		expect(provider.getCurrentWorkspaceCodeIndexScope).toHaveBeenCalledOnce()
+		expect(provider.postMessageToWebview).toHaveBeenCalledWith(
+			expect.objectContaining({ type: "codeIndexSettingsSaved", success: true }),
+		)
+		if (hasWorkspace) {
+			expect(handleSettingsChange).toHaveBeenCalledOnce()
+		} else {
+			expect(handleSettingsChange).not.toHaveBeenCalled()
+			expect(provider.log).toHaveBeenCalledWith("Cannot save code index settings: No workspace folder open")
+		}
+	})
+
+	it("does not update auto-enable defaults without a workspace scope", async () => {
+		const provider = createProvider()
+		await webviewMessageHandler(provider, { type: "setAutoEnableDefault", bool: true })
+		expect(provider.getCurrentWorkspaceCodeIndexScope).toHaveBeenCalledOnce()
+		expect(provider.log).toHaveBeenCalledWith("Cannot set auto-enable default: No workspace folder open")
+		expect(provider.postMessageToWebview).not.toHaveBeenCalled()
+	})
+
 	it("catches auto-enabled indexing failures and posts the resulting status", async () => {
 		const { CodeIndexManagerRegistry } = await import("../../../services/code-index/code-index-manager-registry")
 		let workspaceEnabled = false
@@ -3238,13 +3437,14 @@ describe("webviewMessageHandler no-floating-promises coverage", () => {
 			.spyOn(CodeIndexManagerRegistry, "getAllInstances")
 			.mockReturnValue([manager] as unknown as ReturnType<typeof CodeIndexManagerRegistry.getAllInstances>)
 		const provider = createProvider({
-			getCurrentWorkspaceCodeIndexManager: vi.fn().mockReturnValue(manager),
+			getCurrentWorkspaceCodeIndexScope: vi.fn().mockReturnValue({ codeIndexManager: manager }),
 		})
 
 		try {
 			await webviewMessageHandler(provider, { type: "setAutoEnableDefault", bool: true })
 			await Promise.resolve()
 
+			expect(provider.getCurrentWorkspaceCodeIndexScope).toHaveBeenCalledOnce()
 			expect(manager.startIndexing).toHaveBeenCalledOnce()
 			expect(provider.log).toHaveBeenCalledWith("Indexing error: Error: auto-enable failure")
 			expect(provider.postMessageToWebview).toHaveBeenCalledWith(
@@ -3257,14 +3457,22 @@ describe("webviewMessageHandler no-floating-promises coverage", () => {
 
 	it("covers changed clear-index response paths", async () => {
 		const manager = createIndexManager()
-		const getManager = vi.fn().mockReturnValueOnce(undefined).mockReturnValue(manager)
-		const provider = createProvider({ getCurrentWorkspaceCodeIndexManager: getManager })
+		const getScope = vi.fn().mockReturnValueOnce(undefined).mockReturnValue({ codeIndexManager: manager })
+		const provider = createProvider({ getCurrentWorkspaceCodeIndexScope: getScope })
 
 		await webviewMessageHandler(provider, { type: "clearIndexData" })
+		expect(manager.clearIndexData).not.toHaveBeenCalled()
+		expect(provider.log).toHaveBeenCalledWith("Cannot clear index data: No workspace folder open")
+		expect(provider.postMessageToWebview).toHaveBeenCalledExactlyOnceWith({
+			type: "indexCleared",
+			values: { success: false, error: expect.any(String) },
+		})
 		await webviewMessageHandler(provider, { type: "clearIndexData" })
 		manager.clearIndexData.mockRejectedValueOnce(new Error("clear failed"))
 		await webviewMessageHandler(provider, { type: "clearIndexData" })
 
+		expect(getScope).toHaveBeenCalledTimes(3)
+		expect(manager.clearIndexData).toHaveBeenCalledTimes(2)
 		expect(provider.postMessageToWebview).toHaveBeenCalledWith({
 			type: "indexCleared",
 			values: { success: true },
@@ -5075,6 +5283,7 @@ describe("ClineProvider - Comprehensive Edit/Delete Edge Cases", () => {
 						zooGatewayBaseUrl: "https://www.zoocode.dev/api/gateway/v1",
 					}),
 					false,
+					{ bypassAllowList: true },
 				)
 			})
 
@@ -5119,6 +5328,7 @@ describe("ClineProvider - Comprehensive Edit/Delete Edge Cases", () => {
 						zooGatewayBaseUrl: "https://www.zoocode.dev/api/gateway/v1",
 					}),
 					true,
+					{ bypassAllowList: true },
 				)
 				expect(saveConfig).toHaveBeenCalledWith(
 					"Backup Zoo",
diff --git a/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts b/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts
index 55e26a9667..b70ae6aa6f 100644
--- a/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts
+++ b/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts
@@ -118,6 +118,9 @@ vi.mock("@roo-code/cloud", () => ({
 		get instance() {
 			return {
 				isAuthenticated: vi.fn().mockReturnValue(false),
+				// A cloud instance is present, so the fail-closed allow-list guard reads
+				// this. Default to allow-all so profile writes behave as before.
+				getAllowList: vi.fn().mockReturnValue({ allowAll: true, providers: {} }),
 			}
 		},
 	},
diff --git a/src/core/webview/__tests__/ClineProvider.taskHistory.spec.ts b/src/core/webview/__tests__/ClineProvider.taskHistory.spec.ts
index 61254a67d6..753332dd5b 100644
--- a/src/core/webview/__tests__/ClineProvider.taskHistory.spec.ts
+++ b/src/core/webview/__tests__/ClineProvider.taskHistory.spec.ts
@@ -961,6 +961,25 @@ describe("ClineProvider Task History Synchronization", () => {
 			expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("[onTaskCompleted] Failed to write"))
 		})
 
+		it("onTaskAborted does not call createTaskWithHistoryItem", async () => {
+			// Store the item so getTaskWithId succeeds: without it, the old branch's catch
+			// swallows the error and the test passes even if the branch comes back.
+			const existing = createHistoryItem({ id: "task-abort-1", task: "T" })
+			await provider.updateTaskHistory(existing, { broadcast: false })
+
+			const createSpy = vi.spyOn(provider, "createTaskWithHistoryItem")
+			const abortedListener = vi.fn()
+			provider.on(RooCodeEventName.TaskAborted, abortedListener)
+
+			const fakeTask = { ...makeFakeTask("task-abort-1"), abortReason: "streaming_failed" }
+			// Double cast: taskCreationCallback reads only on/taskId/abortReason from the fake.
+			provider["taskCreationCallback"](fakeTask as unknown as Task)
+			await fakeTask.emit(RooCodeEventName.TaskAborted)
+
+			expect(abortedListener).toHaveBeenCalledExactlyOnceWith("task-abort-1")
+			expect(createSpy).not.toHaveBeenCalled()
+		})
+
 		it("emits delegated completion through the provider after the child is disposed", () => {
 			const listener = vi.fn()
 			provider.on(RooCodeEventName.TaskCompleted, listener)
diff --git a/src/core/webview/__tests__/webviewMessageHandler.openFile.spec.ts b/src/core/webview/__tests__/webviewMessageHandler.openFile.spec.ts
new file mode 100644
index 0000000000..07b9f0c09e
--- /dev/null
+++ b/src/core/webview/__tests__/webviewMessageHandler.openFile.spec.ts
@@ -0,0 +1,603 @@
+// npx vitest core/webview/__tests__/webviewMessageHandler.openFile.spec.ts
+
+import { describe, it, expect, vi, beforeEach } from "vitest"
+import * as nodePath from "path"
+import * as nodeFs from "fs"
+import type { PathLike, Stats } from "fs"
+import * as vscode from "vscode"
+import { openFile } from "../../../integrations/misc/open-file"
+import { webviewMessageHandler } from "../webviewMessageHandler"
+import { decodeUntrustedPathToStable, isRealPathOutsideWorkspace } from "../../../utils/pathUtils"
+import type { ClineProvider } from "../ClineProvider"
+import type { Task } from "../../task/Task"
+
+vi.mock("../../../api/providers/fetchers/modelCache")
+
+// Platform-native mock roots: the production isPathOutsideWorkspace resolves
+// with node's path module, so POSIX-style roots would not match on Windows.
+const IS_WIN = process.platform === "win32"
+const WORKSPACE_ROOT = IS_WIN ? "C:\\mock\\workspace" : "/mock/workspace"
+const OTHER_ROOT = IS_WIN ? "C:\\mock\\workspace2" : "/mock/workspace2"
+const OUTSIDE_ROOT = IS_WIN ? "C:\\outside" : "/outside"
+const MOCK_CWD = nodePath.join(WORKSPACE_ROOT, "project")
+const OUTSIDE_ABS = nodePath.join(OUTSIDE_ROOT, "passwd")
+
+// Mirrors the i18n mock's echo format so assertions are exact on every platform.
+const cannotAccessPathError = (pathValue: string) =>
+	`common:errors.cannot_access_path:${JSON.stringify({ path: pathValue, error: "common:errors.path_outside_workspace" })}`
+
+// Mutable holder for the vscode mock (vi.mock factories are hoisted above the
+// constants above): tests reassign the workspace folders per case, and the
+// production isPathOutsideWorkspace reads them through this getter.
+const vscodeState = vi.hoisted(() => ({
+	workspaceFolders: [] as { uri: { fsPath: string } }[],
+}))
+
+vi.mock("vscode", () => ({
+	window: {
+		showInformationMessage: vi.fn(),
+		showErrorMessage: vi.fn(),
+		showTextDocument: vi.fn(),
+	},
+	workspace: {
+		get workspaceFolders() {
+			return vscodeState.workspaceFolders
+		},
+		openTextDocument: vi.fn().mockResolvedValue({}),
+	},
+	commands: {
+		executeCommand: vi.fn(),
+	},
+}))
+
+vi.mock("../../../i18n", () => ({
+	// Echo the key with params serialized so tests can assert the full
+	// message arguments without loading a real i18n catalogue.
+	t: vi.fn((key: string, params?: Record<string, unknown>) => (params ? `${key}:${JSON.stringify(params)}` : key)),
+}))
+
+vi.mock("../../../utils/fs")
+vi.mock("../../../utils/path")
+vi.mock("../../../utils/globalContext")
+
+// The real utils/pathUtils runs unmocked on purpose: the handler's
+// containment must be exercised through the production predicate (lexical
+// and realpath-based), not a hand-rolled copy.
+
+vi.mock("../../mentions/resolveImageMentions", () => ({
+	resolveImageMentions: vi.fn(async ({ text, images }: { text: string; images?: string[] }) => ({
+		text,
+		images: [...(images ?? [])],
+	})),
+}))
+
+// Mock the openFile module so the test observes the handler's resolved path and
+// proves markdown-sourced requests never reach out-of-workspace targets.
+vi.mock("../../../integrations/misc/open-file", () => ({
+	openFile: vi.fn().mockResolvedValue(undefined),
+}))
+
+// Deterministic real-filesystem model for the realpath-based containment:
+// explicit symlink targets plus a set of "existing" paths; everything else is
+// ENOENT, so the real-path helper walks up to the deepest existing ancestor.
+// Keeps the tests portable without touching the real filesystem.
+const realWorld = vi.hoisted(() => ({
+	existing: new Set<string>(),
+	symlinks: new Map<string, string>(),
+	// Existing entries whose symlink target is missing: realpath fails with
+	// ENOENT, lstat still reports them as symlinks.
+	dangling: new Set<string>(),
+	// Paths where lstat must throw a specific error code (fail-closed test).
+	lstatErrors: new Map<string, string>(),
+}))
+
+const mockProvider = {
+	getState: vi.fn(),
+	postMessageToWebview: vi.fn(),
+	customModesManager: {
+		getCustomModes: vi.fn(),
+		deleteCustomMode: vi.fn(),
+	},
+	context: {
+		extensionPath: "/mock/extension/path",
+		globalStorageUri: { fsPath: "/mock/global/storage" },
+	},
+	contextProxy: {
+		context: {
+			extensionPath: "/mock/extension/path",
+			globalStorageUri: { fsPath: "/mock/global/storage" },
+		},
+		setValue: vi.fn(),
+		getValue: vi.fn(),
+	},
+	log: vi.fn(),
+	postStateToWebview: vi.fn(),
+	getCurrentTask: vi.fn().mockReturnValue({ cwd: MOCK_CWD }),
+	getTaskWithId: vi.fn(),
+	createTaskWithHistoryItem: vi.fn(),
+	cwd: MOCK_CWD,
+} as unknown as ClineProvider
+
+describe("webviewMessageHandler - openFile markdown workspace containment", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+		vscodeState.workspaceFolders = [{ uri: { fsPath: WORKSPACE_ROOT } }]
+		realWorld.existing.clear()
+		realWorld.symlinks.clear()
+		realWorld.dangling.clear()
+		realWorld.lstatErrors.clear()
+		realWorld.existing.add(WORKSPACE_ROOT)
+		realWorld.existing.add(MOCK_CWD)
+		vi.spyOn(nodeFs.promises, "realpath").mockImplementation(async (p: PathLike) => {
+			const key = String(p)
+			// A dangling symlink's target is missing, so realpath fails with
+			// ENOENT exactly like a nonexistent path; lstat distinguishes it.
+			if (realWorld.dangling.has(key)) {
+				const err = new Error(`ENOENT: no such file or directory, realpath '${key}'`)
+				;(err as NodeJS.ErrnoException).code = "ENOENT"
+				throw err
+			}
+			const symlink = realWorld.symlinks.get(key)
+			if (symlink) {
+				return symlink
+			}
+			if (realWorld.existing.has(key)) {
+				return key
+			}
+			const err = new Error(`ENOENT: no such file or directory, realpath '${key}'`)
+			;(err as NodeJS.ErrnoException).code = "ENOENT"
+			throw err
+		})
+		// lstat does not follow the final entry: a dangling symlink is still a
+		// directory entry and reports as a symlink, while a genuinely absent
+		// entry is ENOENT.
+		vi.spyOn(nodeFs.promises, "lstat").mockImplementation(async (p: PathLike) => {
+			const key = String(p)
+			const code = realWorld.lstatErrors.get(key)
+			if (code) {
+				const err = new Error(`${code}: error, lstat '${key}'`)
+				;(err as NodeJS.ErrnoException).code = code
+				throw err
+			}
+			if (realWorld.dangling.has(key) || realWorld.symlinks.has(key) || realWorld.existing.has(key)) {
+				// Minimal test double; the containment code only reads isSymbolicLink().
+				return { isSymbolicLink: () => realWorld.dangling.has(key) || realWorld.symlinks.has(key) } as Stats
+			}
+			const err = new Error(`ENOENT: no such file or directory, lstat '${key}'`)
+			;(err as NodeJS.ErrnoException).code = "ENOENT"
+			throw err
+		})
+		// The containment logic only reads `cwd`; a full Task would be noise. The single
+		// assertion is safe because Task is structurally compatible with the stub.
+		vi.mocked(mockProvider.getCurrentTask).mockReturnValue({ cwd: MOCK_CWD } as Task)
+		;(mockProvider as { cwd?: string }).cwd = MOCK_CWD
+	})
+
+	// MarkdownBlock tags its openFile posts with fromMarkdown, flagging the
+	// request as sourced from untrusted task markdown.
+	it("opens a markdown file within the workspace using a relative path", async () => {
+		await webviewMessageHandler(mockProvider, {
+			type: "openFile",
+			text: "src/index.ts",
+			values: { line: 3, fromMarkdown: true },
+		})
+
+		expect(openFile).toHaveBeenCalledWith(nodePath.resolve(MOCK_CWD, "src/index.ts"), {
+			line: 3,
+			fromMarkdown: true,
+		})
+		expect(vscode.window.showErrorMessage).not.toHaveBeenCalled()
+	})
+
+	it.each(["../../.env", "./../../.env"])("rejects a markdown traversal %s", async (text) => {
+		await webviewMessageHandler(mockProvider, {
+			type: "openFile",
+			text,
+			values: { fromMarkdown: true },
+		})
+
+		expect(openFile).not.toHaveBeenCalled()
+		expect(vscode.window.showErrorMessage).toHaveBeenCalledWith(cannotAccessPathError(text))
+	})
+
+	it("rejects a markdown absolute path outside the workspace", async () => {
+		await webviewMessageHandler(mockProvider, {
+			type: "openFile",
+			text: OUTSIDE_ABS,
+			values: { fromMarkdown: true },
+		})
+
+		expect(openFile).not.toHaveBeenCalled()
+		expect(vscode.window.showErrorMessage).toHaveBeenCalledWith(cannotAccessPathError(OUTSIDE_ABS))
+	})
+
+	it("opens a markdown file using an absolute path within the workspace", async () => {
+		await webviewMessageHandler(mockProvider, {
+			type: "openFile",
+			text: nodePath.join(MOCK_CWD, "src/index.ts"),
+			values: { fromMarkdown: true },
+		})
+
+		expect(openFile).toHaveBeenCalledWith(nodePath.join(MOCK_CWD, "src/index.ts"), { fromMarkdown: true })
+		expect(vscode.window.showErrorMessage).not.toHaveBeenCalled()
+	})
+
+	// openFile decodes the path AFTER the containment checks, so percent-encoded
+	// traversal must be decoded at the containment boundary instead.
+	it("rejects a percent-encoded traversal (%2e%2e) posted by the webview", async () => {
+		await webviewMessageHandler(mockProvider, {
+			type: "openFile",
+			text: "./%2e%2e/%2e%2e/.env",
+			values: { fromMarkdown: true },
+		})
+
+		expect(openFile).not.toHaveBeenCalled()
+		expect(vscode.window.showErrorMessage).toHaveBeenCalledWith(cannotAccessPathError("./%2e%2e/%2e%2e/.env"))
+	})
+
+	it("rejects a double-encoded traversal (%252e%252e) that only escapes after two decodes", async () => {
+		await webviewMessageHandler(mockProvider, {
+			type: "openFile",
+			text: "./%252e%252e/%252e%252e/.env",
+			values: { fromMarkdown: true },
+		})
+
+		expect(openFile).not.toHaveBeenCalled()
+		expect(vscode.window.showErrorMessage).toHaveBeenCalledWith(
+			cannotAccessPathError("./%252e%252e/%252e%252e/.env"),
+		)
+	})
+
+	it("opens a legitimately percent-encoded filename within the workspace", async () => {
+		await webviewMessageHandler(mockProvider, {
+			type: "openFile",
+			text: "src/report%202024.txt",
+			values: { fromMarkdown: true },
+		})
+
+		expect(openFile).toHaveBeenCalledWith(nodePath.join(MOCK_CWD, "src/report 2024.txt"), { fromMarkdown: true })
+		expect(vscode.window.showErrorMessage).not.toHaveBeenCalled()
+	})
+
+	// Lexical containment cannot see symlinks: a link inside the workspace may
+	// resolve to a target outside it.
+	it("rejects a symlink inside the workspace that resolves outside of it", async () => {
+		realWorld.symlinks.set(nodePath.join(MOCK_CWD, "link.txt"), nodePath.join(OUTSIDE_ROOT, "secret.txt"))
+
+		await webviewMessageHandler(mockProvider, {
+			type: "openFile",
+			text: "link.txt",
+			values: { fromMarkdown: true },
+		})
+
+		expect(openFile).not.toHaveBeenCalled()
+		expect(vscode.window.showErrorMessage).toHaveBeenCalledWith(cannotAccessPathError("link.txt"))
+	})
+
+	// A dangling symlink inside the workspace — an existing entry whose target
+	// is missing — must be rejected fail-closed: a creation flow (mkdir -p)
+	// would follow it and could escape the workspace.
+	it("rejects a tagged path that is a dangling symlink inside the workspace", async () => {
+		realWorld.dangling.add(nodePath.join(MOCK_CWD, "link-out"))
+
+		await webviewMessageHandler(mockProvider, {
+			type: "openFile",
+			text: "link-out",
+			values: { create: true, fromMarkdown: true },
+		})
+
+		expect(openFile).not.toHaveBeenCalled()
+		expect(vscode.window.showErrorMessage).toHaveBeenCalledWith(cannotAccessPathError("link-out"))
+	})
+
+	// A workspace root that is itself a symlink must be realized before the
+	// containment test: a target whose deepest existing ancestor resolves
+	// inside the real root is inside the workspace.
+	it("opens a markdown file when the workspace root is a symlink to the real root", async () => {
+		const realRoot = IS_WIN ? "C:\\mock\\workspace-real" : "/mock/workspace-real"
+		realWorld.existing.clear()
+		realWorld.existing.add(realRoot)
+		realWorld.symlinks.set(WORKSPACE_ROOT, realRoot)
+		realWorld.symlinks.set(MOCK_CWD, nodePath.join(realRoot, "project"))
+
+		await webviewMessageHandler(mockProvider, {
+			type: "openFile",
+			text: "src/index.ts",
+			values: { line: 3, fromMarkdown: true },
+		})
+
+		expect(openFile).toHaveBeenCalledWith(nodePath.join(MOCK_CWD, "src/index.ts"), { line: 3, fromMarkdown: true })
+		expect(vscode.window.showErrorMessage).not.toHaveBeenCalled()
+	})
+
+	// An unexpected lstat error on the containment walk fails closed.
+	it("fails closed when lstat errors during the realpath containment walk", async () => {
+		realWorld.lstatErrors.set(nodePath.join(MOCK_CWD, "note.txt"), "EACCES")
+
+		await webviewMessageHandler(mockProvider, {
+			type: "openFile",
+			text: "note.txt",
+			values: { fromMarkdown: true },
+		})
+
+		expect(openFile).not.toHaveBeenCalled()
+		expect(vscode.window.showErrorMessage).toHaveBeenCalledWith(cannotAccessPathError("note.txt"))
+	})
+
+	it("allows creating a new file under a new directory inside the workspace", async () => {
+		await webviewMessageHandler(mockProvider, {
+			type: "openFile",
+			text: "newdir/note.txt",
+			values: { create: true, fromMarkdown: true },
+		})
+
+		// The target does not exist yet, so containment is verified against its
+		// deepest existing ancestor (MOCK_CWD), which is inside the workspace.
+		expect(openFile).toHaveBeenCalledWith(nodePath.join(MOCK_CWD, "newdir/note.txt"), {
+			create: true,
+			fromMarkdown: true,
+		})
+		expect(vscode.window.showErrorMessage).not.toHaveBeenCalled()
+	})
+
+	it("accepts a tagged path inside a second workspace folder (multi-root)", async () => {
+		vscodeState.workspaceFolders = [{ uri: { fsPath: WORKSPACE_ROOT } }, { uri: { fsPath: OTHER_ROOT } }]
+		realWorld.existing.add(OTHER_ROOT)
+
+		await webviewMessageHandler(mockProvider, {
+			type: "openFile",
+			text: nodePath.join(OTHER_ROOT, "x.ts"),
+			values: { fromMarkdown: true },
+		})
+
+		expect(openFile).toHaveBeenCalledWith(nodePath.join(OTHER_ROOT, "x.ts"), { fromMarkdown: true })
+		expect(vscode.window.showErrorMessage).not.toHaveBeenCalled()
+	})
+
+	it("rejects a tagged request when no workspace folders are configured", async () => {
+		vscodeState.workspaceFolders = []
+
+		await webviewMessageHandler(mockProvider, {
+			type: "openFile",
+			text: "src/index.ts",
+			values: { fromMarkdown: true },
+		})
+
+		expect(openFile).not.toHaveBeenCalled()
+		expect(vscode.window.showErrorMessage).toHaveBeenCalledWith(cannotAccessPathError("src/index.ts"))
+	})
+
+	// First-party callers (slash-command settings, modes, MCP) are not flagged
+	// and keep the previous behavior, including global config files that live
+	// outside the workspace.
+	it("keeps legacy behavior for untagged callers opening paths outside the workspace", async () => {
+		await webviewMessageHandler(mockProvider, {
+			type: "openFile",
+			text: "/global/roo/commands/my-command.md",
+		})
+
+		expect(openFile).toHaveBeenCalledWith("/global/roo/commands/my-command.md", undefined)
+		expect(vscode.window.showErrorMessage).not.toHaveBeenCalled()
+	})
+
+	it("does nothing when no path is provided", async () => {
+		await webviewMessageHandler(mockProvider, {
+			type: "openFile",
+		})
+
+		expect(openFile).not.toHaveBeenCalled()
+		expect(vscode.window.showErrorMessage).not.toHaveBeenCalled()
+	})
+
+	it("shows an error when no workspace cwd is available", async () => {
+		vi.mocked(mockProvider.getCurrentTask).mockReturnValue(undefined)
+		;(mockProvider as { cwd?: string }).cwd = undefined
+
+		await webviewMessageHandler(mockProvider, {
+			type: "openFile",
+			text: "src/index.ts",
+			values: { fromMarkdown: true },
+		})
+
+		expect(openFile).not.toHaveBeenCalled()
+		expect(vscode.window.showErrorMessage).toHaveBeenCalledWith(
+			'common:errors.could_not_open_file:{"errorMessage":"common:errors.no_workspace"}',
+		)
+	})
+
+	// The boundary decodes tagged requests only: untagged callers keep the
+	// legacy path exactly, so openFile's later decode applies exactly once.
+	it("keeps untagged percent-encoded paths undecoded at the boundary", async () => {
+		await webviewMessageHandler(mockProvider, {
+			type: "openFile",
+			text: "src/a%20b.txt",
+		})
+
+		expect(openFile).toHaveBeenCalledWith(nodePath.join(MOCK_CWD, "src/a%20b.txt"), undefined)
+		expect(vscode.window.showErrorMessage).not.toHaveBeenCalled()
+	})
+
+	// A hostile encoding that never stabilizes inside the fixed-point bound is
+	// rejected at the boundary (pinned here and by the direct helper test).
+	it("rejects a tagged encoding that does not stabilize within the bound", async () => {
+		const spy = vi.spyOn(globalThis, "decodeURIComponent").mockImplementation((s: string) => `${s}x`)
+		try {
+			await webviewMessageHandler(mockProvider, {
+				type: "openFile",
+				text: "a",
+				values: { fromMarkdown: true },
+			})
+
+			expect(openFile).not.toHaveBeenCalled()
+			expect(vscode.window.showErrorMessage).toHaveBeenCalledWith(cannotAccessPathError("a"))
+		} finally {
+			spy.mockRestore()
+		}
+	})
+
+	// Defense in depth: a lexically outside path whose symlinked ancestor
+	// resolves inside the workspace is still rejected by the lexical check.
+	it("rejects a lexically outside path even when its symlinked ancestor resolves inside the workspace", async () => {
+		realWorld.symlinks.set(nodePath.join(OUTSIDE_ROOT, "link-in"), MOCK_CWD)
+
+		await webviewMessageHandler(mockProvider, {
+			type: "openFile",
+			text: nodePath.join(OUTSIDE_ROOT, "link-in", "f.txt"),
+			values: { fromMarkdown: true },
+		})
+
+		expect(openFile).not.toHaveBeenCalled()
+		expect(vscode.window.showErrorMessage).toHaveBeenCalledWith(
+			cannotAccessPathError(nodePath.join(OUTSIDE_ROOT, "link-in", "f.txt")),
+		)
+	})
+})
+
+describe("utils/pathUtils containment helpers", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+		vscodeState.workspaceFolders = [{ uri: { fsPath: WORKSPACE_ROOT } }]
+		realWorld.existing.clear()
+		realWorld.symlinks.clear()
+		realWorld.dangling.clear()
+		realWorld.lstatErrors.clear()
+		realWorld.existing.add(WORKSPACE_ROOT)
+		realWorld.existing.add(MOCK_CWD)
+		vi.spyOn(nodeFs.promises, "realpath").mockImplementation(async (p: PathLike) => {
+			const key = String(p)
+			// A dangling symlink's target is missing, so realpath fails with
+			// ENOENT exactly like a nonexistent path; lstat distinguishes it.
+			if (realWorld.dangling.has(key)) {
+				const err = new Error(`ENOENT: no such file or directory, realpath '${key}'`)
+				;(err as NodeJS.ErrnoException).code = "ENOENT"
+				throw err
+			}
+			const symlink = realWorld.symlinks.get(key)
+			if (symlink) {
+				return symlink
+			}
+			if (realWorld.existing.has(key)) {
+				return key
+			}
+			const err = new Error(`ENOENT: no such file or directory, realpath '${key}'`)
+			;(err as NodeJS.ErrnoException).code = "ENOENT"
+			throw err
+		})
+		// lstat does not follow the final entry: a dangling symlink is still a
+		// directory entry and reports as a symlink, while a genuinely absent
+		// entry is ENOENT.
+		vi.spyOn(nodeFs.promises, "lstat").mockImplementation(async (p: PathLike) => {
+			const key = String(p)
+			const code = realWorld.lstatErrors.get(key)
+			if (code) {
+				const err = new Error(`${code}: error, lstat '${key}'`)
+				;(err as NodeJS.ErrnoException).code = code
+				throw err
+			}
+			if (realWorld.dangling.has(key) || realWorld.symlinks.has(key) || realWorld.existing.has(key)) {
+				// Minimal test double; the containment code only reads isSymbolicLink().
+				return { isSymbolicLink: () => realWorld.dangling.has(key) || realWorld.symlinks.has(key) } as Stats
+			}
+			const err = new Error(`ENOENT: no such file or directory, lstat '${key}'`)
+			;(err as NodeJS.ErrnoException).code = "ENOENT"
+			throw err
+		})
+	})
+
+	describe("decodeUntrustedPathToStable", () => {
+		it("returns a stable path unchanged", () => {
+			expect(decodeUntrustedPathToStable("src/index.ts")).toBe("src/index.ts")
+		})
+
+		it("decodes to a fixed point", () => {
+			expect(decodeUntrustedPathToStable("./%2e%2e/%2e%2e/.env")).toBe("./../../.env")
+			expect(decodeUntrustedPathToStable("%252e%252e")).toBe("..")
+		})
+
+		it("leaves a bare percent that is not a valid escape unchanged", () => {
+			expect(decodeUntrustedPathToStable("report 50%.md")).toBe("report 50%.md")
+		})
+
+		it("returns null when the value does not stabilize within the bound", () => {
+			const spy = vi.spyOn(globalThis, "decodeURIComponent").mockImplementation((s: string) => `${s}x`)
+			try {
+				expect(decodeUntrustedPathToStable("a")).toBeNull()
+			} finally {
+				spy.mockRestore()
+			}
+		})
+	})
+
+	describe("isRealPathOutsideWorkspace", () => {
+		it("fails closed when no workspace folders are configured", async () => {
+			vscodeState.workspaceFolders = []
+			await expect(isRealPathOutsideWorkspace(nodePath.join(MOCK_CWD, "x.ts"))).resolves.toBe(true)
+		})
+
+		it("accepts an existing path inside the workspace", async () => {
+			realWorld.existing.add(nodePath.join(MOCK_CWD, "x.ts"))
+			await expect(isRealPathOutsideWorkspace(nodePath.join(MOCK_CWD, "x.ts"))).resolves.toBe(false)
+		})
+
+		it("accepts a missing file via its deepest existing in-workspace ancestor", async () => {
+			await expect(isRealPathOutsideWorkspace(nodePath.join(MOCK_CWD, "newdir", "x.ts"))).resolves.toBe(false)
+		})
+
+		it("rejects a symlink whose target is outside the workspace", async () => {
+			realWorld.symlinks.set(nodePath.join(MOCK_CWD, "link.txt"), nodePath.join(OUTSIDE_ROOT, "secret.txt"))
+			await expect(isRealPathOutsideWorkspace(nodePath.join(MOCK_CWD, "link.txt"))).resolves.toBe(true)
+		})
+
+		it("counts a dangling symlink as outside the workspace (fail-closed)", async () => {
+			realWorld.dangling.add(nodePath.join(MOCK_CWD, "gone"))
+			await expect(isRealPathOutsideWorkspace(nodePath.join(MOCK_CWD, "gone"))).resolves.toBe(true)
+		})
+
+		it("fails closed when lstat returns an unexpected error", async () => {
+			realWorld.lstatErrors.set(nodePath.join(MOCK_CWD, "blocked"), "EACCES")
+			await expect(isRealPathOutsideWorkspace(nodePath.join(MOCK_CWD, "blocked"))).resolves.toBe(true)
+		})
+
+		it("fails closed on an unexpected filesystem error", async () => {
+			const err = new Error("EACCES: permission denied")
+			;(err as NodeJS.ErrnoException).code = "EACCES"
+			const spy = vi.spyOn(nodeFs.promises, "realpath").mockRejectedValue(err)
+			try {
+				await expect(isRealPathOutsideWorkspace(nodePath.join(MOCK_CWD, "x.ts"))).resolves.toBe(true)
+			} finally {
+				spy.mockRestore()
+			}
+		})
+
+		it("fails closed when no ancestor exists down to the filesystem root", async () => {
+			// Nothing exists in the model: the ancestor walk reaches the root
+			// guard instead of an existing ancestor, and containment fails closed.
+			realWorld.existing.clear()
+			await expect(isRealPathOutsideWorkspace(nodePath.join(MOCK_CWD, "x.ts"))).resolves.toBe(true)
+		})
+
+		it("fails closed when a workspace folder cannot be realized", async () => {
+			realWorld.existing.add(nodePath.join(MOCK_CWD, "x.ts"))
+			const err = new Error("EACCES: permission denied")
+			;(err as NodeJS.ErrnoException).code = "EACCES"
+			vi.spyOn(nodeFs.promises, "realpath").mockImplementation(async (p: PathLike) => {
+				const key = String(p)
+				if (key === WORKSPACE_ROOT) {
+					throw err
+				}
+				const symlink = realWorld.symlinks.get(key)
+				if (symlink) {
+					return symlink
+				}
+				if (realWorld.existing.has(key)) {
+					return key
+				}
+				const enoent = new Error(`ENOENT: no such file or directory, realpath '${key}'`)
+				;(enoent as NodeJS.ErrnoException).code = "ENOENT"
+				throw enoent
+			})
+
+			await expect(isRealPathOutsideWorkspace(nodePath.join(MOCK_CWD, "x.ts"))).resolves.toBe(true)
+		})
+	})
+})
diff --git a/src/core/webview/__tests__/webviewMessageHandler.spec.ts b/src/core/webview/__tests__/webviewMessageHandler.spec.ts
index 4c2a301965..2735259e3e 100644
--- a/src/core/webview/__tests__/webviewMessageHandler.spec.ts
+++ b/src/core/webview/__tests__/webviewMessageHandler.spec.ts
@@ -10,6 +10,12 @@ vi.mock("../../../services/zoo-code-auth", () => ({
 vi.mock("../../../api/providers/fetchers/lmstudio", () => ({
 	getLMStudioModels: vi.fn(),
 }))
+// Partial mock: other provider modules import `OpenAiHandler` from here, so the
+// real exports must remain available.
+vi.mock("../../../api/providers/openai", async (importOriginal) => ({
+	...(await importOriginal<typeof import("../../../api/providers/openai")>()),
+	getOpenAiModels: vi.fn(),
+}))
 
 vi.mock("../../../integrations/theme/getTheme", () => ({
 	getTheme: vi.fn().mockResolvedValue({}),
@@ -75,6 +81,7 @@ import { webviewMessageHandler } from "../webviewMessageHandler"
 import type { ClineProvider } from "../ClineProvider"
 import { flushModels, getModels } from "../../../api/providers/fetchers/modelCache"
 import { getLMStudioModels } from "../../../api/providers/fetchers/lmstudio"
+import { getOpenAiModels } from "../../../api/providers/openai"
 import { getCommands } from "../../../services/command/commands"
 import { ensureDcgInstalled } from "../../../services/destructive-command-guard"
 import {
@@ -90,6 +97,7 @@ const { fetchOpenAiCodexRateLimitInfo } = await import("../../../integrations/op
 const mockGetModels = getModels as Mock<typeof getModels>
 const mockFlushModels = flushModels as Mock<typeof flushModels>
 const mockGetLMStudioModels = getLMStudioModels as Mock<typeof getLMStudioModels>
+const mockGetOpenAiModels = getOpenAiModels as Mock<typeof getOpenAiModels>
 const mockGetCommands = vi.mocked(getCommands)
 const mockGetAccessToken = vi.mocked(openAiCodexOAuthManager.getAccessToken)
 const mockGetAccountId = vi.mocked(openAiCodexOAuthManager.getAccountId)
@@ -125,6 +133,23 @@ const mockClineProvider = {
 	cwd: "/mock/workspace",
 } as unknown as ClineProvider
 
+// Structural overrides for the auth/profile tests below. Declaring the shape keeps the
+// collaborator swaps type-checked (no `as any`) — the same pattern as `providerForLaunch`
+// used by the telemetry tests.
+type MockProviderOverrides = {
+	contextProxy: {
+		getProviderSettings: ReturnType<typeof vi.fn>
+		getValues: ReturnType<typeof vi.fn>
+	}
+	providerSettingsManager: {
+		listConfig: ReturnType<typeof vi.fn>
+		getProfile: ReturnType<typeof vi.fn>
+		saveConfig: ReturnType<typeof vi.fn>
+	}
+	upsertProviderProfile: ReturnType<typeof vi.fn>
+	getState: (typeof mockClineProvider)["getState"]
+}
+
 describe("webviewMessageHandler - theme fixture probes", () => {
 	const originalProbeSetting = process.env.ROO_CODE_THEME_FIXTURE_PROBE
 	const themeFixture = {
@@ -178,6 +203,7 @@ vi.mock("vscode", () => {
 	const showTextDocument = vi.fn().mockResolvedValue(undefined)
 
 	return {
+		lm: { selectChatModels: vi.fn() },
 		window: {
 			showInformationMessage,
 			showErrorMessage,
@@ -273,38 +299,43 @@ describe("webviewMessageHandler - requestLmStudioModels", () => {
 		})
 	})
 
-	it("successfully fetches models from LMStudio", async () => {
-		const mockModels: ModelRecord = {
-			"model-1": {
-				maxTokens: 4096,
-				contextWindow: 8192,
-				supportsPromptCache: false,
-				description: "Test model 1",
-			},
-			"model-2": {
-				maxTokens: 8192,
-				contextWindow: 16384,
-				supportsPromptCache: false,
-				description: "Test model 2",
-			},
-		}
+	it.each([undefined, "models-request-123"])(
+		"successfully fetches models from LMStudio (requestId=%s)",
+		async (requestId) => {
+			const mockModels: ModelRecord = {
+				"model-1": {
+					maxTokens: 4096,
+					contextWindow: 8192,
+					supportsPromptCache: false,
+					description: "Test model 1",
+				},
+				"model-2": {
+					maxTokens: 8192,
+					contextWindow: 16384,
+					supportsPromptCache: false,
+					description: "Test model 2",
+				},
+			}
 
-		mockGetModels.mockResolvedValue(mockModels)
+			mockGetModels.mockResolvedValue(mockModels)
 
-		await webviewMessageHandler(mockClineProvider, {
-			type: "requestLmStudioModels",
-		})
+			await webviewMessageHandler(mockClineProvider, {
+				type: "requestLmStudioModels",
+				requestId,
+			})
 
-		expect(mockGetModels).toHaveBeenCalledWith({
-			provider: providerIdentifiers.lmstudio,
-			baseUrl: "http://localhost:1234",
-		})
+			expect(mockGetModels).toHaveBeenCalledWith({
+				provider: providerIdentifiers.lmstudio,
+				baseUrl: "http://localhost:1234",
+			})
 
-		expect(mockClineProvider.postMessageToWebview).toHaveBeenCalledWith({
-			type: "lmStudioModels",
-			lmStudioModels: mockModels,
-		})
-	})
+			expect(mockClineProvider.postMessageToWebview).toHaveBeenCalledWith({
+				type: "lmStudioModels",
+				requestId,
+				lmStudioModels: mockModels,
+			})
+		},
+	)
 
 	it("prefers the request payload base URL over persisted settings", async () => {
 		mockGetLMStudioModels.mockResolvedValue({})
@@ -376,38 +407,43 @@ describe("webviewMessageHandler - requestOllamaModels", () => {
 		})
 	})
 
-	it("successfully fetches models from Ollama", async () => {
-		const mockModels: ModelRecord = {
-			"model-1": {
-				maxTokens: 4096,
-				contextWindow: 8192,
-				supportsPromptCache: false,
-				description: "Test model 1",
-			},
-			"model-2": {
-				maxTokens: 8192,
-				contextWindow: 16384,
-				supportsPromptCache: false,
-				description: "Test model 2",
-			},
-		}
+	it.each([undefined, "models-request-123"])(
+		"successfully fetches models from Ollama (requestId=%s)",
+		async (requestId) => {
+			const mockModels: ModelRecord = {
+				"model-1": {
+					maxTokens: 4096,
+					contextWindow: 8192,
+					supportsPromptCache: false,
+					description: "Test model 1",
+				},
+				"model-2": {
+					maxTokens: 8192,
+					contextWindow: 16384,
+					supportsPromptCache: false,
+					description: "Test model 2",
+				},
+			}
 
-		mockGetModels.mockResolvedValue(mockModels)
+			mockGetModels.mockResolvedValue(mockModels)
 
-		await webviewMessageHandler(mockClineProvider, {
-			type: "requestOllamaModels",
-		})
+			await webviewMessageHandler(mockClineProvider, {
+				type: "requestOllamaModels",
+				requestId,
+			})
 
-		expect(mockGetModels).toHaveBeenCalledWith({
-			provider: providerIdentifiers.ollama,
-			baseUrl: "http://localhost:1234",
-		})
+			expect(mockGetModels).toHaveBeenCalledWith({
+				provider: providerIdentifiers.ollama,
+				baseUrl: "http://localhost:1234",
+			})
 
-		expect(mockClineProvider.postMessageToWebview).toHaveBeenCalledWith({
-			type: "ollamaModels",
-			ollamaModels: mockModels,
-		})
-	})
+			expect(mockClineProvider.postMessageToWebview).toHaveBeenCalledWith({
+				type: "ollamaModels",
+				requestId,
+				ollamaModels: mockModels,
+			})
+		},
+	)
 
 	it("posts empty models response when no models are found", async () => {
 		mockGetModels.mockResolvedValue({})
@@ -422,42 +458,52 @@ describe("webviewMessageHandler - requestOllamaModels", () => {
 		})
 	})
 
-	it("posts empty models response with error message and logs to output on fetch failure", async () => {
-		mockGetModels.mockRejectedValue(new Error("Connection refused"))
+	it.each([undefined, "models-request-123"])(
+		"posts empty models response with error message and logs to output on fetch failure (requestId=%s)",
+		async (requestId) => {
+			mockGetModels.mockRejectedValue(new Error("Connection refused"))
 
-		await webviewMessageHandler(mockClineProvider, {
-			type: "requestOllamaModels",
-		})
+			await webviewMessageHandler(mockClineProvider, {
+				type: "requestOllamaModels",
+				requestId,
+			})
 
-		expect(mockClineProvider.postMessageToWebview).toHaveBeenCalledWith({
-			type: "ollamaModels",
-			ollamaModels: {},
-			error: "Connection refused",
-		})
+			expect(mockClineProvider.postMessageToWebview).toHaveBeenCalledWith({
+				type: "ollamaModels",
+				requestId,
+				ollamaModels: {},
+				error: "Connection refused",
+			})
 
-		expect(mockClineProvider.log).toHaveBeenCalledWith(
-			"[requestOllamaModels] Failed to read models for http://localhost:1234: Connection refused",
-		)
-	})
+			expect(mockClineProvider.log).toHaveBeenCalledWith(
+				"[requestOllamaModels] Failed to read models for http://localhost:1234: Connection refused",
+			)
+		},
+	)
 
-	it("distinguishes a model cache refresh failure from a model read failure", async () => {
-		mockFlushModels.mockRejectedValue(new Error("Cache write failed"))
+	it.each([undefined, "models-request-123"])(
+		"distinguishes a model cache refresh failure from a model read failure (requestId=%s)",
+		async (requestId) => {
+			mockFlushModels.mockRejectedValue(new Error("Cache write failed"))
 
-		await webviewMessageHandler(mockClineProvider, {
-			type: "requestOllamaModels",
-			values: { baseUrl: "https://ollama.example.com" },
-		})
+			await webviewMessageHandler(mockClineProvider, {
+				type: "requestOllamaModels",
+				requestId,
+				values: { baseUrl: "https://ollama.example.com" },
+			})
 
-		expect(mockGetModels).not.toHaveBeenCalled()
-		expect(mockClineProvider.log).toHaveBeenCalledWith(
-			"[requestOllamaModels] Failed to refresh model cache for https://ollama.example.com: Cache write failed",
-		)
-		expect(mockClineProvider.postMessageToWebview).toHaveBeenCalledWith({
-			type: "ollamaModels",
-			ollamaModels: {},
-			error: "Cache write failed",
-		})
-	})
+			expect(mockGetModels).not.toHaveBeenCalled()
+			expect(mockClineProvider.log).toHaveBeenCalledWith(
+				"[requestOllamaModels] Failed to refresh model cache for https://ollama.example.com: Cache write failed",
+			)
+			expect(mockClineProvider.postMessageToWebview).toHaveBeenCalledWith({
+				type: "ollamaModels",
+				requestId,
+				ollamaModels: {},
+				error: "Cache write failed",
+			})
+		},
+	)
 
 	it("uses baseUrl from message values over saved state", async () => {
 		const mockModels: ModelRecord = {
@@ -501,6 +547,61 @@ describe("webviewMessageHandler - requestOllamaModels", () => {
 	})
 })
 
+describe("webviewMessageHandler - requestVsCodeLmModels", () => {
+	beforeEach(() => vi.clearAllMocks())
+
+	it.each([undefined, "vscode-request-123"])("echoes the optional requestId (%s)", async (requestId) => {
+		const models: vscode.LanguageModelChat[] = [
+			{
+				id: "test-model",
+				name: "Test model",
+				vendor: "test",
+				family: "test",
+				version: "1",
+				maxInputTokens: 8192,
+				countTokens: vi.fn(),
+				sendRequest: vi.fn(),
+			},
+		]
+		vi.mocked(vscode.lm.selectChatModels).mockResolvedValueOnce(models)
+		await webviewMessageHandler(mockClineProvider, { type: "requestVsCodeLmModels", requestId })
+		expect(mockClineProvider.postMessageToWebview).toHaveBeenCalledExactlyOnceWith({
+			type: "vsCodeLmModels",
+			vsCodeLmModels: models,
+			requestId,
+		})
+	})
+})
+
+describe("webviewMessageHandler - requestOpenAiModels", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+		mockGetOpenAiModels.mockReset()
+	})
+
+	it("echoes the caller's requestId on the openAiModels response", async () => {
+		mockGetOpenAiModels.mockResolvedValue(["gpt-4o", "gpt-4o-mini"])
+
+		await webviewMessageHandler(mockClineProvider, {
+			type: "requestOpenAiModels",
+			requestId: "req-123",
+			values: {
+				baseUrl: "https://api.example.com/v1",
+				apiKey: "test-api-key-not-real",
+				openAiHeaders: {},
+			},
+		})
+
+		// The request id must round-trip so the webview can correlate the
+		// response with the request it issued and drop stale replies.
+		expect(mockClineProvider.postMessageToWebview).toHaveBeenCalledWith({
+			type: "openAiModels",
+			openAiModels: ["gpt-4o", "gpt-4o-mini"],
+			requestId: "req-123",
+		})
+	})
+})
+
 describe("webviewMessageHandler - requestRouterModels", () => {
 	beforeEach(() => {
 		vi.clearAllMocks()
@@ -1796,13 +1897,14 @@ describe("zooCodeSignOut", () => {
 		const { disconnectZooCode } = await import("../../../services/zoo-code-auth")
 		const upsertProviderProfile = vi.fn().mockResolvedValue(undefined)
 		const saveConfig = vi.fn().mockResolvedValue(undefined)
+		const authProvider = mockClineProvider as unknown as MockProviderOverrides
 
-		;(mockClineProvider as any).contextProxy = {
+		authProvider.contextProxy = {
 			...mockClineProvider.contextProxy,
 			getProviderSettings: vi.fn().mockReturnValue({ apiProvider: providerIdentifiers.zooGateway }),
 			getValues: vi.fn().mockReturnValue({ currentApiConfigName: "Zoo Gateway" }),
 		}
-		;(mockClineProvider as any).providerSettingsManager = {
+		authProvider.providerSettingsManager = {
 			listConfig: vi.fn().mockResolvedValue([
 				{ name: "Zoo Gateway", apiProvider: providerIdentifiers.zooGateway },
 				{ name: "Backup Zoo", apiProvider: providerIdentifiers.zooGateway },
@@ -1820,7 +1922,7 @@ describe("zooCodeSignOut", () => {
 				}),
 			saveConfig,
 		}
-		;(mockClineProvider as any).upsertProviderProfile = upsertProviderProfile
+		authProvider.upsertProviderProfile = upsertProviderProfile
 
 		await webviewMessageHandler(mockClineProvider, { type: "zooCodeSignOut" })
 
@@ -1829,6 +1931,9 @@ describe("zooCodeSignOut", () => {
 			"Zoo Gateway",
 			expect.not.objectContaining({ zooSessionToken: expect.anything() }),
 			true,
+			// Internal auth write: bypasses the model allow-list (zoo-gateway has
+			// no model-id mapping).
+			{ bypassAllowList: true },
 		)
 		expect(saveConfig).toHaveBeenCalledWith(
 			"Backup Zoo",
@@ -1837,15 +1942,51 @@ describe("zooCodeSignOut", () => {
 		expect(mockClineProvider.postStateToWebview).toHaveBeenCalled()
 	})
 
+	it("reports a failure instead of clearing silently when the active profile write is rejected", async () => {
+		// `upsertProviderProfile` returns `undefined` when the write is rejected
+		// (e.g. the model-allow-list guard or a disk error). Sign-out must not
+		// log a successful cleanup in that case.
+		const upsertProviderProfile = vi.fn().mockResolvedValue(undefined)
+		const authProvider = mockClineProvider as unknown as MockProviderOverrides
+
+		authProvider.contextProxy = {
+			...mockClineProvider.contextProxy,
+			getProviderSettings: vi.fn().mockReturnValue({ apiProvider: providerIdentifiers.zooGateway }),
+			getValues: vi.fn().mockReturnValue({ currentApiConfigName: "Zoo Gateway" }),
+		}
+		authProvider.providerSettingsManager = {
+			listConfig: vi
+				.fn()
+				.mockResolvedValue([{ name: "Zoo Gateway", apiProvider: providerIdentifiers.zooGateway }]),
+			getProfile: vi.fn().mockResolvedValue({
+				apiProvider: providerIdentifiers.zooGateway,
+				zooSessionToken: "token-active",
+			}),
+			saveConfig: vi.fn(),
+		}
+		authProvider.upsertProviderProfile = upsertProviderProfile
+
+		await webviewMessageHandler(mockClineProvider, { type: "zooCodeSignOut" })
+
+		// The rejected write must be surfaced, not reported as a successful cleanup.
+		expect(mockClineProvider.log).toHaveBeenCalledWith(
+			expect.stringContaining('[zooCodeSignOut] Failed to clear profile token for "Zoo Gateway"'),
+		)
+		expect(mockClineProvider.log).not.toHaveBeenCalledWith(
+			expect.stringContaining('[zooCodeSignOut] Cleared zooSessionToken from "Zoo Gateway"'),
+		)
+	})
+
 	it("still clears the in-memory handler when the active profile token is already empty on disk", async () => {
 		const upsertProviderProfile = vi.fn().mockResolvedValue(undefined)
+		const authProvider = mockClineProvider as unknown as MockProviderOverrides
 
-		;(mockClineProvider as any).contextProxy = {
+		authProvider.contextProxy = {
 			...mockClineProvider.contextProxy,
 			getProviderSettings: vi.fn().mockReturnValue({ apiProvider: providerIdentifiers.zooGateway }),
 			getValues: vi.fn().mockReturnValue({ currentApiConfigName: "Zoo Gateway" }),
 		}
-		;(mockClineProvider as any).providerSettingsManager = {
+		authProvider.providerSettingsManager = {
 			listConfig: vi
 				.fn()
 				.mockResolvedValue([{ name: "Zoo Gateway", apiProvider: providerIdentifiers.zooGateway }]),
@@ -1855,7 +1996,7 @@ describe("zooCodeSignOut", () => {
 			}),
 			saveConfig: vi.fn(),
 		}
-		;(mockClineProvider as any).upsertProviderProfile = upsertProviderProfile
+		authProvider.upsertProviderProfile = upsertProviderProfile
 
 		await webviewMessageHandler(mockClineProvider, { type: "zooCodeSignOut" })
 
@@ -1863,10 +2004,42 @@ describe("zooCodeSignOut", () => {
 			"Zoo Gateway",
 			expect.not.objectContaining({ zooSessionToken: expect.anything() }),
 			true,
+			{ bypassAllowList: true },
 		)
 	})
 })
 
+describe("webviewMessageHandler - upsertApiConfiguration allow-list", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+	})
+
+	it("delegates to upsertProviderProfile without pre-validating (single enforcement point)", async () => {
+		const upsertProviderProfile = vi.fn().mockResolvedValue("profile-id")
+		const detailProvider = mockClineProvider as unknown as MockProviderOverrides
+		detailProvider.upsertProviderProfile = upsertProviderProfile
+		const getState = vi.fn().mockResolvedValue({
+			apiConfiguration: {},
+			organizationAllowList: { allowAll: false, providers: {} },
+		})
+		detailProvider.getState = getState
+
+		const apiConfiguration = { apiProvider: providerIdentifiers.anthropic, apiModelId: "not-allowed" }
+
+		await webviewMessageHandler(mockClineProvider, {
+			type: "upsertApiConfiguration",
+			text: "test-config",
+			apiConfiguration,
+		})
+
+		// The handler forwards the write and relies on `upsertProviderProfile` for
+		// enforcement; it does not call `getState()` or reject on its own.
+		expect(upsertProviderProfile).toHaveBeenCalledWith("test-config", apiConfiguration)
+		expect(getState).not.toHaveBeenCalled()
+		expect(vscode.window.showErrorMessage).not.toHaveBeenCalled()
+	})
+})
+
 describe("webviewMessageHandler - kimiCodeSignIn", () => {
 	beforeEach(() => {
 		vi.clearAllMocks()
diff --git a/src/core/webview/webviewMessageHandler.ts b/src/core/webview/webviewMessageHandler.ts
index 34a35ea3ca..cbd5268d24 100644
--- a/src/core/webview/webviewMessageHandler.ts
+++ b/src/core/webview/webviewMessageHandler.ts
@@ -83,7 +83,7 @@ import { openMention } from "../mentions"
 import { resolveImageMentions } from "../mentions/resolveImageMentions"
 import { RooIgnoreController } from "../ignore/RooIgnoreController"
 import { getWorkspacePath } from "../../utils/path"
-import { isPathOutsideWorkspace } from "../../utils/pathUtils"
+import { isPathOutsideWorkspace, decodeUntrustedPathToStable, isRealPathOutsideWorkspace } from "../../utils/pathUtils"
 import { Mode, defaultModeSlug } from "../../shared/modes"
 import { getModels, flushModels } from "../../api/providers/fetchers/modelCache"
 import { GetModelsOptions } from "../../shared/api"
@@ -1380,6 +1380,11 @@ export const webviewMessageHandler = async (
 			break
 		}
 		case OllamaModelsMessageType.requestOllamaModels: {
+			// Echo the caller's request id so the webview can correlate the
+			// response with the request it issued and drop stale replies that
+			// arrive after a provider/profile switch.
+			const requestId = message.requestId
+
 			// Specific handler for Ollama models only.
 			const { apiConfiguration: ollamaApiConfig } = await provider.getState()
 			// Prefer the baseUrl/apiKey from the message values (which reflect
@@ -1406,6 +1411,7 @@ export const webviewMessageHandler = async (
 					type: OllamaModelsMessageType.ollamaModels,
 					ollamaModels: {},
 					error: errorMsg,
+					requestId,
 				})
 				break
 			}
@@ -1415,7 +1421,11 @@ export const webviewMessageHandler = async (
 
 				// Always post a response so the webview refresh status can
 				// transition out of "loading" — even when no models are found.
-				await provider.postMessageToWebview({ type: OllamaModelsMessageType.ollamaModels, ollamaModels })
+				await provider.postMessageToWebview({
+					type: OllamaModelsMessageType.ollamaModels,
+					ollamaModels,
+					requestId,
+				})
 			} catch (error) {
 				const errorMsg = error instanceof Error ? error.message : String(error)
 				provider.log(`[requestOllamaModels] Failed to read models for ${logBaseUrl}: ${errorMsg}`)
@@ -1423,11 +1433,15 @@ export const webviewMessageHandler = async (
 					type: OllamaModelsMessageType.ollamaModels,
 					ollamaModels: {},
 					error: errorMsg,
+					requestId,
 				})
 			}
 			break
 		}
 		case LmStudioModelsMessageType.requestLmStudioModels: {
+			// Echo the caller's request id (see `requestOllamaModels` above).
+			const requestId = message.requestId
+
 			// Specific handler for LM Studio models only.
 			const { apiConfiguration: lmStudioApiConfig } = await provider.getState()
 			try {
@@ -1450,6 +1464,7 @@ export const webviewMessageHandler = async (
 					await provider.postMessageToWebview({
 						type: LmStudioModelsMessageType.lmStudioModels,
 						lmStudioModels: lmStudioModels,
+						requestId,
 					})
 				}
 			} catch (error) {
@@ -1475,14 +1490,26 @@ export const webviewMessageHandler = async (
 					message?.values?.openAiHeaders,
 				)
 
-				await provider.postMessageToWebview({ type: OpenAiModelsMessageType.openAiModels, openAiModels })
+				// Echo the caller's request id so the webview can correlate the
+				// response with the request it issued and drop stale replies
+				// that arrive after a provider/profile switch.
+				await provider.postMessageToWebview({
+					type: OpenAiModelsMessageType.openAiModels,
+					openAiModels,
+					requestId: message.requestId,
+				})
 			}
 
 			break
 		case VsCodeLmModelsMessageType.requestVsCodeLmModels:
 			const vsCodeLmModels = await getVsCodeLmModels()
 			// TODO: Cache like we do for OpenRouter, etc?
-			await provider.postMessageToWebview({ type: VsCodeLmModelsMessageType.vsCodeLmModels, vsCodeLmModels })
+			// Echo the caller's request id so stale replies can be discarded.
+			await provider.postMessageToWebview({
+				type: VsCodeLmModelsMessageType.vsCodeLmModels,
+				vsCodeLmModels,
+				requestId: message.requestId,
+			})
 			break
 		case "openImage":
 			await openImage(message.text!, { values: message.values })
@@ -1515,13 +1542,70 @@ export const webviewMessageHandler = async (
 				}
 			}
 			break
-		case "openFile":
-			let filePath: string = message.text!
+		case "openFile": {
+			const rawPath = message.text || ""
+			if (!rawPath) {
+				break
+			}
+			// Task markdown links are untrusted, so markdown-sourced openFile
+			// requests (flagged by the webview with fromMarkdown) must resolve
+			// inside the current workspace. First-party callers (modes, MCP,
+			// slash-command settings) may legitimately open global config files
+			// outside the workspace, so they keep the previous behavior.
+			const fromMarkdown = message.values?.fromMarkdown === true
+			const rejectOutsideWorkspace = () => {
+				void vscode.window.showErrorMessage(
+					t("common:errors.cannot_access_path", {
+						path: rawPath,
+						error: t("common:errors.path_outside_workspace"),
+					}),
+				)
+			}
+			let filePath = rawPath
+			// Markdown link targets are URL syntax: percent-decode to a fixed point
+			// here, at the containment boundary. openFile decodes AFTER this check,
+			// so a request like `%2e%2e/%2e%2e/.env` would otherwise pass
+			// containment as a literal and escape only after that later decode.
+			if (fromMarkdown) {
+				const decoded = decodeUntrustedPathToStable(rawPath)
+				// Stryker disable next-line ConditionalExpression,BlockStatement: hostile non-stabilizing encodings are unreachable from the webview (its posts are plain link targets); the bound is defensive
+				if (decoded === null) {
+					// Stryker disable next-line CallExpression: hostile non-stabilizing encodings are pinned by the direct decodeUntrustedPathToStable bound test; the webview never posts such values
+					rejectOutsideWorkspace()
+					break
+				}
+				filePath = decoded
+			}
 			if (!path.isAbsolute(filePath)) {
-				filePath = path.join(getCurrentCwd(), filePath)
+				const cwd = getCurrentCwd()
+				if (!cwd) {
+					void vscode.window.showErrorMessage(
+						t("common:errors.could_not_open_file", { errorMessage: t("common:errors.no_workspace") }),
+					)
+					break
+				}
+				filePath = path.resolve(cwd, filePath)
+			}
+			// Workspace-boundary validation (defense in depth): the webview already
+			// rejects traversal in markdown anchors, but refuse any markdown path
+			// that still resolves outside the workspace.
+			if (fromMarkdown && isPathOutsideWorkspace(filePath)) {
+				rejectOutsideWorkspace()
+				break
+			}
+			// Lexical containment cannot see symlinks: a link inside a workspace
+			// folder may resolve to a target outside the workspace. Re-check the
+			// real filesystem path (failing closed) before opening.
+			if (fromMarkdown && (await isRealPathOutsideWorkspace(filePath))) {
+				rejectOutsideWorkspace()
+				break
 			}
-			await openFile(filePath, message.values as { create?: boolean; content?: string; line?: number })
+			await openFile(
+				filePath,
+				message.values as { create?: boolean; content?: string; line?: number; fromMarkdown?: boolean },
+			)
 			break
+		}
 		case "readFileContent": {
 			const relPath = message.text || ""
 			if (!relPath) {
@@ -2223,6 +2307,13 @@ export const webviewMessageHandler = async (
 			break
 		case "upsertApiConfiguration":
 			if (message.text && message.apiConfiguration) {
+				// Allow-list enforcement lives solely in
+				// `ClineProvider.upsertProviderProfile`: it is not a trusted
+				// boundary either way (the webview can forge a model id), and
+				// keeping a single enforcement point means direct callers
+				// (OAuth callbacks, sign-out) get the same user notification
+				// instead of failing silently. Validating here as well would
+				// duplicate the work (including an extra `getState()`).
 				await provider.upsertProviderProfile(message.text, message.apiConfiguration)
 			}
 			break
@@ -2932,7 +3023,27 @@ export const webviewMessageHandler = async (
 							const isThisProfileActive = isZooGatewayActive && currentApiConfigName === entry.name
 
 							if (isThisProfileActive) {
-								await provider.upsertProviderProfile(entry.name, cleanedProfile, true)
+								// `bypassAllowList`: clearing a Zoo Gateway session token is an
+								// internal auth write, not a model selection. `ProfileValidator`
+								// cannot map zoo-gateway to a model id, so a restrictive
+								// allow-list would otherwise reject the cleanup and leave the
+								// stale token in the active handler.
+								const writeResult = await provider.upsertProviderProfile(
+									entry.name,
+									cleanedProfile,
+									true,
+									{ bypassAllowList: true },
+								)
+
+								// The write can still fail for other reasons (disk error,
+								// disabled profile enforcement). Never report a successful
+								// token cleanup in that case: surface it instead. The
+								// allow-list check is bypassed on this call, so a neutral
+								// message is used rather than an allow-list violation.
+								if (writeResult === undefined) {
+									throw new Error(`Failed to persist cleaned Zoo Gateway profile "${entry.name}"`)
+								}
+
 								provider.log(
 									`[zooCodeSignOut] Cleared zooSessionToken from "${entry.name}" profile and updated in-memory handler`,
 								)
@@ -3078,7 +3189,8 @@ export const webviewMessageHandler = async (
 				await provider.postStateToWebview()
 
 				// Then handle validation and initialization for the current workspace
-				const currentCodeIndexManager = provider.getCurrentWorkspaceCodeIndexManager()
+				const scope = provider.getCurrentWorkspaceCodeIndexScope()
+				const currentCodeIndexManager = scope?.codeIndexManager
 				if (currentCodeIndexManager) {
 					// If embedder provider changed, perform proactive validation
 					if (embedderProviderChanged) {
@@ -3157,7 +3269,8 @@ export const webviewMessageHandler = async (
 		}
 
 		case "requestIndexingStatus": {
-			const manager = provider.getCurrentWorkspaceCodeIndexManager()
+			const scope = provider.getCurrentWorkspaceCodeIndexScope()
+			const manager = scope?.codeIndexManager
 			if (!manager) {
 				// No workspace open - send error status
 				await provider.postMessageToWebview({
@@ -3221,7 +3334,8 @@ export const webviewMessageHandler = async (
 		}
 		case "startIndexing": {
 			try {
-				const manager = provider.getCurrentWorkspaceCodeIndexManager()
+				const scope = provider.getCurrentWorkspaceCodeIndexScope()
+				const manager = scope?.codeIndexManager
 				if (!manager) {
 					await provider.postMessageToWebview({
 						type: "indexingStatusUpdate",
@@ -3262,15 +3376,15 @@ export const webviewMessageHandler = async (
 		}
 		case "stopIndexing": {
 			try {
-				const manager = provider.getCurrentWorkspaceCodeIndexManager()
-				if (!manager) {
+				const scope = provider.getCurrentWorkspaceCodeIndexScope()
+				if (!scope) {
 					provider.log("Cannot stop indexing: No workspace folder open")
 					return
 				}
-				manager.stopIndexing()
+				scope.codeIndexManager.stopIndexing()
 				await provider.postMessageToWebview({
 					type: "indexingStatusUpdate",
-					values: manager.getCurrentStatus(),
+					values: scope.codeIndexManager.getCurrentStatus(),
 				})
 			} catch (error) {
 				provider.log(`Error stopping indexing: ${error instanceof Error ? error.message : String(error)}`)
@@ -3279,23 +3393,12 @@ export const webviewMessageHandler = async (
 		}
 		case "toggleWorkspaceIndexing": {
 			try {
-				const manager = provider.getCurrentWorkspaceCodeIndexManager()
-				if (!manager) {
+				const scope = provider.getCurrentWorkspaceCodeIndexScope()
+				if (!scope) {
 					provider.log("Cannot toggle workspace indexing: No workspace folder open")
 					return
 				}
-				const enabled = message.bool ?? false
-				await manager.setWorkspaceEnabled(enabled)
-				if (enabled && manager.isFeatureEnabled && manager.isFeatureConfigured) {
-					await manager.initialize(provider.contextProxy)
-					void manager.startIndexing().catch((err) => provider.log(`Indexing error: ${err}`))
-				} else if (!enabled) {
-					manager.stopIndexing()
-				}
-				await provider.postMessageToWebview({
-					type: "indexingStatusUpdate",
-					values: manager.getCurrentStatus(),
-				})
+				await scope.workspaceIndexingEnablementManager.setEnabled(message.bool ?? false, provider)
 			} catch (error) {
 				provider.log(
 					`Error toggling workspace indexing: ${error instanceof Error ? error.message : String(error)}`,
@@ -3305,7 +3408,8 @@ export const webviewMessageHandler = async (
 		}
 		case "setAutoEnableDefault": {
 			try {
-				const manager = provider.getCurrentWorkspaceCodeIndexManager()
+				const scope = provider.getCurrentWorkspaceCodeIndexScope()
+				const manager = scope?.codeIndexManager
 				if (!manager) {
 					provider.log("Cannot set auto-enable default: No workspace folder open")
 					return
@@ -3338,8 +3442,8 @@ export const webviewMessageHandler = async (
 		}
 		case "clearIndexData": {
 			try {
-				const manager = provider.getCurrentWorkspaceCodeIndexManager()
-				if (!manager) {
+				const scope = provider.getCurrentWorkspaceCodeIndexScope()
+				if (!scope) {
 					provider.log("Cannot clear index data: No workspace folder open")
 					await provider.postMessageToWebview({
 						type: "indexCleared",
@@ -3350,7 +3454,7 @@ export const webviewMessageHandler = async (
 					})
 					return
 				}
-				await manager.clearIndexData()
+				await scope.codeIndexManager.clearIndexData()
 				await provider.postMessageToWebview({ type: "indexCleared", values: { success: true } })
 			} catch (error) {
 				provider.log(`Error clearing index data: ${error instanceof Error ? error.message : String(error)}`)
diff --git a/src/eslint-suppressions.json b/src/eslint-suppressions.json
index 24db0bf433..88bd3b47c1 100644
--- a/src/eslint-suppressions.json
+++ b/src/eslint-suppressions.json
@@ -1121,7 +1121,7 @@
 	},
 	"core/webview/__tests__/webviewMessageHandler.spec.ts": {
 		"@typescript-eslint/no-explicit-any": {
-			"count": 35
+			"count": 29
 		}
 	},
 	"core/webview/messageEnhancer.ts": {
diff --git a/src/extension.ts b/src/extension.ts
index 8706de765b..1d71f834df 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -35,6 +35,7 @@ import { openAiCodexOAuthManager } from "./integrations/openai-codex/oauth"
 import { kimiCodeOAuthManager } from "./integrations/kimi-code/oauth"
 import { McpServerManager } from "./services/mcp/McpServerManager"
 import { CodeIndexManagerRegistry } from "./services/code-index/code-index-manager-registry"
+import { CodeIndexScope } from "./services/code-index/code-index-scope"
 import { MdmService } from "./services/mdm/MdmService"
 import { migrateSettings } from "./utils/migrateSettings"
 import { autoImportSettings } from "./utils/autoImportSettings"
@@ -195,6 +196,15 @@ export async function activate(context: vscode.ExtensionContext) {
 		}),
 	)
 
+	const codeIndexScope = new CodeIndexScope(context)
+	context.subscriptions.push(codeIndexScope)
+	try {
+		codeIndexScope.init()
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error)
+		outputChannel.appendLine(`[CodeIndexScope] Failed to initialize: ${message}`)
+	}
+
 	// Initialize code index managers for all workspace folders.
 	if (vscode.workspace.workspaceFolders) {
 		for (const folder of vscode.workspace.workspaceFolders) {
diff --git a/src/i18n/__tests__/locale-bundles.spec.ts b/src/i18n/__tests__/locale-bundles.spec.ts
new file mode 100644
index 0000000000..cb455e2d65
--- /dev/null
+++ b/src/i18n/__tests__/locale-bundles.spec.ts
@@ -0,0 +1,60 @@
+// npx vitest i18n/__tests__/locale-bundles.spec.ts
+//
+// The i18n setup loads locale bundles from disk outside the test environment,
+// so no other suite imports the bundle files. This spec imports every bundle
+// directly: it pins the completeness of the keys this unit adds, and it puts
+// the bundle files into the coverage report so changed-line coverage can
+// measure them.
+
+import { describe, it, expect } from "vitest"
+import ca from "../locales/ca/common.json"
+import de from "../locales/de/common.json"
+import en from "../locales/en/common.json"
+import es from "../locales/es/common.json"
+import fr from "../locales/fr/common.json"
+import hi from "../locales/hi/common.json"
+import id from "../locales/id/common.json"
+import itBundle from "../locales/it/common.json"
+import ja from "../locales/ja/common.json"
+import ko from "../locales/ko/common.json"
+import nl from "../locales/nl/common.json"
+import pl from "../locales/pl/common.json"
+import ptBr from "../locales/pt-BR/common.json"
+import ru from "../locales/ru/common.json"
+import tr from "../locales/tr/common.json"
+import vi from "../locales/vi/common.json"
+import zhCn from "../locales/zh-CN/common.json"
+import zhTw from "../locales/zh-TW/common.json"
+
+const bundles: Record<string, { errors: Record<string, unknown> }> = {
+	ca,
+	de,
+	en,
+	es,
+	fr,
+	hi,
+	id,
+	it: itBundle,
+	ja,
+	ko,
+	nl,
+	pl,
+	"pt-BR": ptBr,
+	ru,
+	tr,
+	vi,
+	"zh-CN": zhCn,
+	"zh-TW": zhTw,
+}
+
+// Keys this unit adds to the common namespace (the openFile workspace
+// containment error posted by webviewMessageHandler).
+const addedKeys = ["path_outside_workspace"]
+
+describe("common locale bundles", () => {
+	it.each(Object.keys(bundles))("%s defines every key this unit adds", (locale) => {
+		for (const key of addedKeys) {
+			expect(bundles[locale].errors[key]).toEqual(expect.any(String))
+		}
+	})
+})
diff --git a/src/i18n/locales/ca/common.json b/src/i18n/locales/ca/common.json
index 24ae3f310c..a85c19cec4 100644
--- a/src/i18n/locales/ca/common.json
+++ b/src/i18n/locales/ca/common.json
@@ -59,6 +59,7 @@
 		"failed_remove_directory": "Ha fallat l'eliminació del directori de tasques: {{error}}",
 		"custom_storage_path_unusable": "La ruta d'emmagatzematge personalitzada \"{{path}}\" no és utilitzable, s'utilitzarà la ruta predeterminada",
 		"cannot_access_path": "No es pot accedir a la ruta {{path}}: {{error}}",
+		"path_outside_workspace": "La ruta és fora de l'espai de treball",
 		"settings_import_failed": "Ha fallat la importació de la configuració: {{error}}.",
 		"mistake_limit_guidance": "Això pot indicar un error en el procés de pensament del model o la incapacitat d'utilitzar una eina correctament, que es pot mitigar amb orientació de l'usuari (p. ex. \"Prova de dividir la tasca en passos més petits\").",
 		"violated_organization_allowlist": "Ha fallat l'execució de la tasca: el perfil actual no és compatible amb la configuració de la teva organització",
diff --git a/src/i18n/locales/de/common.json b/src/i18n/locales/de/common.json
index 54fa0b3c22..9f2b6d2056 100644
--- a/src/i18n/locales/de/common.json
+++ b/src/i18n/locales/de/common.json
@@ -55,6 +55,7 @@
 		"failed_remove_directory": "Fehler beim Entfernen des Aufgabenverzeichnisses: {{error}}",
 		"custom_storage_path_unusable": "Benutzerdefinierter Speicherpfad \"{{path}}\" ist nicht verwendbar, Standardpfad wird verwendet",
 		"cannot_access_path": "Zugriff auf Pfad {{path}} nicht möglich: {{error}}",
+		"path_outside_workspace": "Pfad liegt außerhalb des Arbeitsbereichs",
 		"settings_import_failed": "Fehler beim Importieren der Einstellungen: {{error}}.",
 		"mistake_limit_guidance": "Dies kann auf einen Fehler im Denkprozess des Modells oder die Unfähigkeit hinweisen, ein Tool richtig zu verwenden, was durch Benutzerführung behoben werden kann (z.B. \"Versuche, die Aufgabe in kleinere Schritte zu unterteilen\").",
 		"violated_organization_allowlist": "Aufgabe konnte nicht ausgeführt werden: Das aktuelle Profil ist nicht kompatibel mit den Einstellungen deiner Organisation",
diff --git a/src/i18n/locales/en/common.json b/src/i18n/locales/en/common.json
index 516a3d4f88..507780366a 100644
--- a/src/i18n/locales/en/common.json
+++ b/src/i18n/locales/en/common.json
@@ -55,6 +55,7 @@
 		"failed_remove_directory": "Failed to remove task directory: {{error}}",
 		"custom_storage_path_unusable": "Custom storage path \"{{path}}\" is unusable, will use default path",
 		"cannot_access_path": "Cannot access path {{path}}: {{error}}",
+		"path_outside_workspace": "Path is outside the workspace",
 		"settings_import_failed": "Settings import failed: {{error}}.",
 		"mistake_limit_guidance": "This may indicate a failure in the model's thought process or inability to use a tool properly, which can be mitigated with some user guidance (e.g. \"Try breaking down the task into smaller steps\").",
 		"violated_organization_allowlist": "Failed to run task: the current profile isn't compatible with your organization settings",
diff --git a/src/i18n/locales/es/common.json b/src/i18n/locales/es/common.json
index 71dc994516..f646f5c4f3 100644
--- a/src/i18n/locales/es/common.json
+++ b/src/i18n/locales/es/common.json
@@ -55,6 +55,7 @@
 		"failed_remove_directory": "Error al eliminar el directorio de tareas: {{error}}",
 		"custom_storage_path_unusable": "La ruta de almacenamiento personalizada \"{{path}}\" no es utilizable, se usará la ruta predeterminada",
 		"cannot_access_path": "No se puede acceder a la ruta {{path}}: {{error}}",
+		"path_outside_workspace": "La ruta está fuera del espacio de trabajo",
 		"settings_import_failed": "Error al importar la configuración: {{error}}.",
 		"mistake_limit_guidance": "Esto puede indicar un fallo en el proceso de pensamiento del modelo o la incapacidad de usar una herramienta correctamente, lo cual puede mitigarse con orientación del usuario (ej. \"Intenta dividir la tarea en pasos más pequeños\").",
 		"violated_organization_allowlist": "Error al ejecutar la tarea: el perfil actual no es compatible con la configuración de tu organización",
diff --git a/src/i18n/locales/fr/common.json b/src/i18n/locales/fr/common.json
index 87009ee988..0e5f59ca1e 100644
--- a/src/i18n/locales/fr/common.json
+++ b/src/i18n/locales/fr/common.json
@@ -55,6 +55,7 @@
 		"failed_remove_directory": "Échec de la suppression du répertoire de tâches : {{error}}",
 		"custom_storage_path_unusable": "Le chemin de stockage personnalisé \"{{path}}\" est inutilisable, le chemin par défaut sera utilisé",
 		"cannot_access_path": "Impossible d'accéder au chemin {{path}} : {{error}}",
+		"path_outside_workspace": "Le chemin est à l'extérieur de l'espace de travail",
 		"settings_import_failed": "Échec de l'importation des paramètres : {{error}}",
 		"mistake_limit_guidance": "Cela peut indiquer un échec dans le processus de réflexion du modèle ou une incapacité à utiliser un outil correctement, ce qui peut être atténué avec des conseils de l'utilisateur (par ex. \"Essaie de diviser la tâche en étapes plus petites\").",
 		"violated_organization_allowlist": "Échec de l'exécution de la tâche : le profil actuel n'est pas compatible avec les paramètres de votre organisation",
diff --git a/src/i18n/locales/hi/common.json b/src/i18n/locales/hi/common.json
index f4bd1c3055..59cf0f0657 100644
--- a/src/i18n/locales/hi/common.json
+++ b/src/i18n/locales/hi/common.json
@@ -55,6 +55,7 @@
 		"failed_remove_directory": "टास्क डायरेक्टरी हटाने में विफल: {{error}}",
 		"custom_storage_path_unusable": "कस्टम स्टोरेज पाथ \"{{path}}\" उपयोग योग्य नहीं है, डिफ़ॉल्ट पाथ का उपयोग किया जाएगा",
 		"cannot_access_path": "पाथ {{path}} तक पहुंच नहीं पा रहे हैं: {{error}}",
+		"path_outside_workspace": "पथ वर्कस्पेस से बाहर है",
 		"settings_import_failed": "सेटिंग्स इम्पोर्ट करने में विफल: {{error}}।",
 		"mistake_limit_guidance": "यह मॉडल की सोच प्रक्रिया में विफलता या किसी टूल का सही उपयोग न कर पाने का संकेत हो सकता है, जिसे उपयोगकर्ता के मार्गदर्शन से ठीक किया जा सकता है (जैसे \"कार्य को छोटे चरणों में बांटने की कोशिश करें\")।",
 		"violated_organization_allowlist": "कार्य चलाने में विफल: वर्तमान प्रोफ़ाइल आपके संगठन की सेटिंग्स के साथ संगत नहीं है",
diff --git a/src/i18n/locales/id/common.json b/src/i18n/locales/id/common.json
index bcee321af5..87ce78d209 100644
--- a/src/i18n/locales/id/common.json
+++ b/src/i18n/locales/id/common.json
@@ -55,6 +55,7 @@
 		"failed_remove_directory": "Gagal menghapus direktori tugas: {{error}}",
 		"custom_storage_path_unusable": "Path penyimpanan kustom \"{{path}}\" tidak dapat digunakan, akan menggunakan path default",
 		"cannot_access_path": "Tidak dapat mengakses path {{path}}: {{error}}",
+		"path_outside_workspace": "Path berada di luar workspace",
 		"settings_import_failed": "Impor pengaturan gagal: {{error}}.",
 		"mistake_limit_guidance": "Ini mungkin menunjukkan kegagalan dalam proses pemikiran model atau ketidakmampuan untuk menggunakan tool dengan benar, yang dapat diatasi dengan beberapa panduan pengguna (misalnya \"Coba bagi tugas menjadi langkah-langkah yang lebih kecil\").",
 		"violated_organization_allowlist": "Gagal menjalankan tugas: profil saat ini tidak kompatibel dengan pengaturan organisasi kamu",
diff --git a/src/i18n/locales/it/common.json b/src/i18n/locales/it/common.json
index 395be16b84..ce7ffce090 100644
--- a/src/i18n/locales/it/common.json
+++ b/src/i18n/locales/it/common.json
@@ -55,6 +55,7 @@
 		"failed_remove_directory": "Impossibile rimuovere la directory delle attività: {{error}}",
 		"custom_storage_path_unusable": "Il percorso di archiviazione personalizzato \"{{path}}\" non è utilizzabile, verrà utilizzato il percorso predefinito",
 		"cannot_access_path": "Impossibile accedere al percorso {{path}}: {{error}}",
+		"path_outside_workspace": "Il percorso è fuori dall'area di lavoro",
 		"settings_import_failed": "Importazione delle impostazioni fallita: {{error}}.",
 		"mistake_limit_guidance": "Questo può indicare un fallimento nel processo di pensiero del modello o l'incapacità di utilizzare correttamente uno strumento, che può essere mitigato con la guida dell'utente (ad es. \"Prova a suddividere l'attività in passaggi più piccoli\").",
 		"violated_organization_allowlist": "Impossibile eseguire l'attività: il profilo corrente non è compatibile con le impostazioni della tua organizzazione",
diff --git a/src/i18n/locales/ja/common.json b/src/i18n/locales/ja/common.json
index 7dccfcd837..d412e8f8e0 100644
--- a/src/i18n/locales/ja/common.json
+++ b/src/i18n/locales/ja/common.json
@@ -55,6 +55,7 @@
 		"failed_remove_directory": "タスクディレクトリの削除に失敗しました：{{error}}",
 		"custom_storage_path_unusable": "カスタムストレージパス \"{{path}}\" が使用できないため、デフォルトパスを使用します",
 		"cannot_access_path": "パス {{path}} にアクセスできません：{{error}}",
+		"path_outside_workspace": "パスはワークスペースの外にあります",
 		"settings_import_failed": "設定のインポートに失敗しました：{{error}}",
 		"mistake_limit_guidance": "これは、モデルの思考プロセスの失敗やツールを適切に使用できないことを示している可能性があり、ユーザーのガイダンスによって軽減できます（例：「タスクをより小さなステップに分割してみてください」）。",
 		"violated_organization_allowlist": "タスクの実行に失敗しました: 現在のプロファイルは組織の設定と互換性がありません",
diff --git a/src/i18n/locales/ko/common.json b/src/i18n/locales/ko/common.json
index 0ca65be687..ff2fcb10d9 100644
--- a/src/i18n/locales/ko/common.json
+++ b/src/i18n/locales/ko/common.json
@@ -55,6 +55,7 @@
 		"failed_remove_directory": "작업 디렉토리 제거 실패: {{error}}",
 		"custom_storage_path_unusable": "사용자 지정 저장 경로 \"{{path}}\"를 사용할 수 없어 기본 경로를 사용합니다",
 		"cannot_access_path": "경로 {{path}}에 접근할 수 없습니다: {{error}}",
+		"path_outside_workspace": "경로가 작업 영역 밖에 있습니다",
 		"settings_import_failed": "설정 가져오기 실패: {{error}}.",
 		"mistake_limit_guidance": "이는 모델의 사고 과정 실패나 도구를 제대로 사용하지 못하는 것을 나타낼 수 있으며, 사용자 가이드를 통해 완화할 수 있습니다 (예: \"작업을 더 작은 단계로 나누어 시도해보세요\").",
 		"violated_organization_allowlist": "작업 실행 실패: 현재 프로필이 조직 설정과 호환되지 않습니다",
diff --git a/src/i18n/locales/nl/common.json b/src/i18n/locales/nl/common.json
index a38415edfd..e8b639af5d 100644
--- a/src/i18n/locales/nl/common.json
+++ b/src/i18n/locales/nl/common.json
@@ -55,6 +55,7 @@
 		"failed_remove_directory": "Verwijderen van taakmap mislukt: {{error}}",
 		"custom_storage_path_unusable": "Aangepast opslagpad \"{{path}}\" is onbruikbaar, standaardpad wordt gebruikt",
 		"cannot_access_path": "Kan pad {{path}} niet openen: {{error}}",
+		"path_outside_workspace": "Pad is buiten de werkomgeving",
 		"settings_import_failed": "Importeren van instellingen mislukt: {{error}}.",
 		"mistake_limit_guidance": "Dit kan duiden op een fout in het denkproces van het model of het onvermogen om een tool correct te gebruiken, wat kan worden verminderd met gebruikersbegeleiding (bijv. \"Probeer de taak op te delen in kleinere stappen\").",
 		"violated_organization_allowlist": "Taak uitvoeren mislukt: het huidige profiel is niet compatibel met de instellingen van uw organisatie",
diff --git a/src/i18n/locales/pl/common.json b/src/i18n/locales/pl/common.json
index ff898e8987..73e2293a10 100644
--- a/src/i18n/locales/pl/common.json
+++ b/src/i18n/locales/pl/common.json
@@ -55,6 +55,7 @@
 		"failed_remove_directory": "Nie udało się usunąć katalogu zadania: {{error}}",
 		"custom_storage_path_unusable": "Niestandardowa ścieżka przechowywania \"{{path}}\" nie jest użyteczna, zostanie użyta domyślna ścieżka",
 		"cannot_access_path": "Nie można uzyskać dostępu do ścieżki {{path}}: {{error}}",
+		"path_outside_workspace": "Ścieżka znajduje się poza obszarem roboczym",
 		"settings_import_failed": "Nie udało się zaimportować ustawień: {{error}}.",
 		"mistake_limit_guidance": "To może wskazywać na błąd w procesie myślowym modelu lub niezdolność do prawidłowego użycia narzędzia, co można złagodzić poprzez wskazówki użytkownika (np. \"Spróbuj podzielić zadanie na mniejsze kroki\").",
 		"violated_organization_allowlist": "Nie udało się uruchomić zadania: bieżący profil nie jest kompatybilny z ustawieniami Twojej organizacji",
diff --git a/src/i18n/locales/pt-BR/common.json b/src/i18n/locales/pt-BR/common.json
index d3c31ed2dd..82654929b4 100644
--- a/src/i18n/locales/pt-BR/common.json
+++ b/src/i18n/locales/pt-BR/common.json
@@ -59,6 +59,7 @@
 		"failed_remove_directory": "Falha ao remover o diretório de tarefas: {{error}}",
 		"custom_storage_path_unusable": "O caminho de armazenamento personalizado \"{{path}}\" não pode ser usado, será usado o caminho padrão",
 		"cannot_access_path": "Não é possível acessar o caminho {{path}}: {{error}}",
+		"path_outside_workspace": "O caminho está fora do espaço de trabalho",
 		"settings_import_failed": "Falha ao importar configurações: {{error}}",
 		"mistake_limit_guidance": "Isso pode indicar uma falha no processo de pensamento do modelo ou incapacidade de usar uma ferramenta adequadamente, o que pode ser mitigado com orientação do usuário (ex. \"Tente dividir a tarefa em etapas menores\").",
 		"violated_organization_allowlist": "Falha ao executar a tarefa: o perfil atual não é compatível com as configurações da sua organização",
diff --git a/src/i18n/locales/ru/common.json b/src/i18n/locales/ru/common.json
index 08d2e2aa2c..5857b1290f 100644
--- a/src/i18n/locales/ru/common.json
+++ b/src/i18n/locales/ru/common.json
@@ -55,6 +55,7 @@
 		"failed_remove_directory": "Не удалось удалить директорию задачи: {{error}}",
 		"custom_storage_path_unusable": "Пользовательский путь хранения \"{{path}}\" непригоден, будет использован путь по умолчанию",
 		"cannot_access_path": "Невозможно получить доступ к пути {{path}}: {{error}}",
+		"path_outside_workspace": "Путь находится вне рабочего пространства",
 		"settings_import_failed": "Не удалось импортировать настройки: {{error}}.",
 		"mistake_limit_guidance": "Это может указывать на сбой в процессе мышления модели или неспособность правильно использовать инструмент, что можно смягчить с помощью руководства пользователя (например, \"Попробуйте разбить задачу на более мелкие шаги\").",
 		"violated_organization_allowlist": "Не удалось выполнить задачу: текущий профиль несовместим с настройками вашей организации",
diff --git a/src/i18n/locales/tr/common.json b/src/i18n/locales/tr/common.json
index 716ccbc6de..48faf7d03c 100644
--- a/src/i18n/locales/tr/common.json
+++ b/src/i18n/locales/tr/common.json
@@ -55,6 +55,7 @@
 		"failed_remove_directory": "Görev dizini kaldırılamadı: {{error}}",
 		"custom_storage_path_unusable": "Özel depolama yolu \"{{path}}\" kullanılamıyor, varsayılan yol kullanılacak",
 		"cannot_access_path": "{{path}} yoluna erişilemiyor: {{error}}",
+		"path_outside_workspace": "Yol çalışma alanının dışında",
 		"settings_import_failed": "Ayarlar içe aktarılamadı: {{error}}.",
 		"mistake_limit_guidance": "Bu, modelin düşünce sürecindeki bir başarısızlığı veya bir aracı düzgün kullanamama durumunu gösterebilir, bu da kullanıcı rehberliği ile hafifletilebilir (örn. \"Görevi daha küçük adımlara bölmeyi deneyin\").",
 		"violated_organization_allowlist": "Görev yürütülemedi: Geçerli profil kuruluşunuzun ayarlarıyla uyumlu değil",
diff --git a/src/i18n/locales/vi/common.json b/src/i18n/locales/vi/common.json
index 69c6343c31..5651e0eb3b 100644
--- a/src/i18n/locales/vi/common.json
+++ b/src/i18n/locales/vi/common.json
@@ -55,6 +55,7 @@
 		"failed_remove_directory": "Không thể xóa thư mục nhiệm vụ: {{error}}",
 		"custom_storage_path_unusable": "Đường dẫn lưu trữ tùy chỉnh \"{{path}}\" không thể sử dụng được, sẽ sử dụng đường dẫn mặc định",
 		"cannot_access_path": "Không thể truy cập đường dẫn {{path}}: {{error}}",
+		"path_outside_workspace": "Đường dẫn nằm ngoài không gian làm việc",
 		"settings_import_failed": "Nhập cài đặt thất bại: {{error}}.",
 		"mistake_limit_guidance": "Điều này có thể cho thấy sự thất bại trong quá trình suy nghĩ của mô hình hoặc không thể sử dụng công cụ đúng cách, có thể được giảm thiểu bằng hướng dẫn của người dùng (ví dụ: \"Hãy thử chia nhỏ nhiệm vụ thành các bước nhỏ hơn\").",
 		"violated_organization_allowlist": "Không thể chạy tác vụ: hồ sơ hiện tại không tương thích với cài đặt của tổ chức của bạn",
diff --git a/src/i18n/locales/zh-CN/common.json b/src/i18n/locales/zh-CN/common.json
index 3600f0aa7c..e5ecf86da2 100644
--- a/src/i18n/locales/zh-CN/common.json
+++ b/src/i18n/locales/zh-CN/common.json
@@ -60,6 +60,7 @@
 		"failed_remove_directory": "删除任务目录失败：{{error}}",
 		"custom_storage_path_unusable": "自定义存储路径 \"{{path}}\" 不可用，将使用默认路径",
 		"cannot_access_path": "无法访问路径 {{path}}：{{error}}",
+		"path_outside_workspace": "路径位于工作区之外",
 		"settings_import_failed": "设置导入失败：{{error}}。",
 		"mistake_limit_guidance": "这可能表明模型思维过程失败或无法正确使用工具，可通过用户指导来缓解（例如\"尝试将任务分解为更小的步骤\"）。",
 		"violated_organization_allowlist": "执行任务失败：当前配置文件与您的组织设置不兼容",
diff --git a/src/i18n/locales/zh-TW/common.json b/src/i18n/locales/zh-TW/common.json
index c635769891..e70c464da0 100644
--- a/src/i18n/locales/zh-TW/common.json
+++ b/src/i18n/locales/zh-TW/common.json
@@ -55,6 +55,7 @@
 		"failed_remove_directory": "刪除工作目錄失敗：{{error}}",
 		"custom_storage_path_unusable": "自訂儲存路徑 \"{{path}}\" 無法使用，將使用預設路徑",
 		"cannot_access_path": "無法存取路徑 {{path}}：{{error}}",
+		"path_outside_workspace": "路徑位於工作區之外",
 		"settings_import_failed": "設定匯入失敗：{{error}}。",
 		"mistake_limit_guidance": "這可能表明模型思維過程失敗或無法正確使用工具，可透過使用者指導來緩解（例如「嘗試將工作分解為更小的步驟」）。",
 		"violated_organization_allowlist": "執行工作失敗：目前設定檔與您的組織設定不相容",
diff --git a/src/services/__tests__/pr-review-state-workflow.test.ts b/src/services/__tests__/pr-review-state-workflow.test.ts
index 6e43b8ec5a..486112adf0 100644
--- a/src/services/__tests__/pr-review-state-workflow.test.ts
+++ b/src/services/__tests__/pr-review-state-workflow.test.ts
@@ -26,6 +26,7 @@ interface HarnessOptions {
 	mergeable?: boolean | null
 	mergeableState?: string
 	mergeabilitySequence?: Array<{ mergeable: boolean | null; mergeableState: string }>
+	headShaSequence?: string[]
 	fork?: boolean
 	eventName?: string
 	issueCommentActor?: string
@@ -55,6 +56,7 @@ interface HarnessOptions {
 		submittedAt: number
 		commitId?: string
 		id?: number
+		ghost?: boolean
 	}>
 	timelineEvents?: Array<{
 		event: string
@@ -65,6 +67,7 @@ interface HarnessOptions {
 	}>
 	timelineErrorStatus?: number
 	permissions?: Record<string, string>
+	permissionErrors?: Record<string, number>
 	permissionErrorStatus?: number
 	requiredContexts?: string[]
 	requiredIntegrationId?: number | null
@@ -154,7 +157,7 @@ async function runWorkflow(options: HarnessOptions = {}) {
 		state: review.state,
 		commit_id: review.commitId ?? SHA,
 		submitted_at: new Date(review.submittedAt).toISOString(),
-		user: { login: review.login, type: review.type },
+		user: review.ghost ? null : { login: review.login, type: review.type },
 	}))
 	const existingComments = [
 		...(options.existingGuide || options.existingGuideHead || options.existingGuidePendingHead
@@ -249,6 +252,10 @@ async function runWorkflow(options: HarnessOptions = {}) {
 	})
 	const setFailed = vi.fn()
 	const permissionFor = vi.fn(async ({ username }: { username: string }) => {
+		const perUserStatus = options.permissionErrors?.[username] ?? options.permissionErrors?.[username.toLowerCase()]
+		if (perUserStatus) {
+			throw Object.assign(new Error("Permission lookup failed"), { status: perUserStatus })
+		}
 		if (options.permissionErrorStatus) {
 			throw Object.assign(new Error("Permission lookup failed"), { status: options.permissionErrorStatus })
 		}
@@ -269,14 +276,19 @@ async function runWorkflow(options: HarnessOptions = {}) {
 		}
 		return [pr]
 	})
-	let mergeabilityIndex = 0
+	let pullRequestGetIndex = 0
 	const getPullRequest = vi.fn(async () => {
-		const mergeability = options.mergeabilitySequence?.[mergeabilityIndex++]
-		return {
-			data: mergeability
-				? { ...pr, mergeable: mergeability.mergeable, mergeable_state: mergeability.mergeableState }
-				: pr,
+		const index = pullRequestGetIndex++
+		const mergeability = options.mergeabilitySequence?.[index]
+		const headSha = options.headShaSequence?.[index]
+		let data = pr
+		if (mergeability) {
+			data = { ...data, mergeable: mergeability.mergeable, mergeable_state: mergeability.mergeableState }
+		}
+		if (headSha) {
+			data = { ...data, head: { ...data.head, sha: headSha } }
 		}
+		return { data }
 	})
 
 	const github = {
@@ -542,7 +554,12 @@ describe("PR review-state workflow", () => {
 	it("creates missing workflow labels", async () => {
 		const result = await runWorkflow({ labelLookupStatus: 404 })
 
-		expect(result.createLabel).toHaveBeenCalledTimes(4)
+		expect(result.createLabel).toHaveBeenCalledTimes(5)
+		const communityApproved = result.createLabel.mock.calls
+			.map(([args]) => args as { name: string; description: string })
+			.find((label) => label.name === "community-approved")
+		expect(communityApproved).toBeDefined()
+		expect(communityApproved?.description.length).toBeLessThanOrEqual(100)
 	})
 
 	it("fails closed when a managed label cannot be created", async () => {
@@ -2235,4 +2252,570 @@ describe("PR review-state workflow", () => {
 			expect(result.setFailed).not.toHaveBeenCalled()
 		})
 	})
+
+	describe("community-approved label (#1872)", () => {
+		const coderabbitApproval = {
+			login: "coderabbitai[bot]",
+			type: "Bot" as const,
+			state: "APPROVED" as const,
+			submittedAt: REVIEWED_AT,
+		}
+		const communityApproval = {
+			login: "community-reviewer",
+			type: "User" as const,
+			state: "APPROVED" as const,
+			submittedAt: REVIEWED_AT + 1_000,
+		}
+		const NEW_SHA = "c".repeat(40)
+
+		it("reconciles draft conversions through pull_request_target", () => {
+			expect(workflow.on.pull_request_target.types).toContain("converted_to_draft")
+		})
+
+		it("adds the label for a fresh community approval in the maintainer queue", async () => {
+			const result = await runWorkflow({
+				reviews: [coderabbitApproval, communityApproval],
+			})
+
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["awaiting-maintainer"] }))
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["community-approved"] }))
+			expect(latestGuide(result)).toContain("community-approved")
+			expect(latestGuide(result)).toContain("do not add or remove it manually")
+			expect(result.setFailed).not.toHaveBeenCalled()
+		})
+
+		it("retains an existing label on repeated runs without re-adding it", async () => {
+			const result = await runWorkflow({
+				labels: ["community-approved"],
+				reviews: [coderabbitApproval, communityApproval],
+			})
+
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["awaiting-maintainer"] }))
+			expect(result.addLabels).not.toHaveBeenCalledWith(
+				expect.objectContaining({ labels: ["community-approved"] }),
+			)
+			expect(result.removeLabel).not.toHaveBeenCalledWith(expect.objectContaining({ name: "community-approved" }))
+		})
+
+		it("removes the label when the approval is for an older head", async () => {
+			const result = await runWorkflow({
+				labels: ["community-approved"],
+				reviews: [coderabbitApproval, { ...communityApproval, commitId: OLD_SHA }],
+			})
+
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["awaiting-maintainer"] }))
+			expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "community-approved" }))
+			expect(result.addLabels).not.toHaveBeenCalledWith(
+				expect.objectContaining({ labels: ["community-approved"] }),
+			)
+		})
+
+		it("removes the label when the approval is dismissed", async () => {
+			const result = await runWorkflow({
+				labels: ["community-approved"],
+				reviews: [
+					coderabbitApproval,
+					{ ...communityApproval, id: 1 },
+					{
+						login: "community-reviewer",
+						type: "User",
+						state: "DISMISSED",
+						submittedAt: REVIEWED_AT + 2_000,
+						id: 2,
+					},
+				],
+			})
+
+			expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "community-approved" }))
+			expect(result.addLabels).not.toHaveBeenCalledWith(
+				expect.objectContaining({ labels: ["community-approved"] }),
+			)
+		})
+
+		it("adds the label when a newer approval replaces a community change request", async () => {
+			const result = await runWorkflow({
+				reviews: [
+					coderabbitApproval,
+					{
+						login: "community-reviewer",
+						type: "User",
+						state: "CHANGES_REQUESTED",
+						submittedAt: REVIEWED_AT + 1_000,
+						id: 1,
+					},
+					{ ...communityApproval, submittedAt: REVIEWED_AT + 2_000, id: 2 },
+				],
+			})
+
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["awaiting-maintainer"] }))
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["community-approved"] }))
+		})
+
+		it("selects the decisive community review by review id, not array order", async () => {
+			const result = await runWorkflow({
+				reviews: [
+					coderabbitApproval,
+					{ ...communityApproval, id: 2 },
+					{
+						login: "community-reviewer",
+						type: "User",
+						state: "DISMISSED",
+						submittedAt: REVIEWED_AT + 2_000,
+						id: 1,
+					},
+				],
+			})
+
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["community-approved"] }))
+		})
+
+		it("qualifies a reviewer whose permission lookup returns 404", async () => {
+			const result = await runWorkflow({
+				reviews: [coderabbitApproval, communityApproval],
+			})
+
+			expect(result.permissionFor).toHaveBeenCalledWith(
+				expect.objectContaining({ username: "community-reviewer" }),
+			)
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["community-approved"] }))
+			expect(result.setFailed).not.toHaveBeenCalled()
+		})
+
+		it("does not qualify ghost accounts", async () => {
+			const result = await runWorkflow({
+				reviews: [
+					coderabbitApproval,
+					{ login: "ghost", type: "User", state: "APPROVED", submittedAt: REVIEWED_AT + 1_000, ghost: true },
+				],
+			})
+
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["awaiting-maintainer"] }))
+			expect(result.addLabels).not.toHaveBeenCalledWith(
+				expect.objectContaining({ labels: ["community-approved"] }),
+			)
+			expect(result.setFailed).not.toHaveBeenCalled()
+		})
+
+		it("does not qualify bot reviewers", async () => {
+			const result = await runWorkflow({
+				reviews: [
+					coderabbitApproval,
+					{ login: "helper-bot", type: "Bot", state: "APPROVED", submittedAt: REVIEWED_AT + 1_000 },
+				],
+			})
+
+			expect(result.addLabels).not.toHaveBeenCalledWith(
+				expect.objectContaining({ labels: ["community-approved"] }),
+			)
+		})
+
+		it("does not qualify the PR author's own approval", async () => {
+			const result = await runWorkflow({
+				reviews: [
+					coderabbitApproval,
+					{ login: "Contributor", type: "User", state: "APPROVED", submittedAt: REVIEWED_AT + 1_000 },
+				],
+			})
+
+			expect(result.addLabels).not.toHaveBeenCalledWith(
+				expect.objectContaining({ labels: ["community-approved"] }),
+			)
+		})
+
+		it("does not qualify reviewers with maintainer permissions", async () => {
+			const result = await runWorkflow({
+				labels: ["community-approved"],
+				permissions: { maintainer: "write" },
+				reviews: [
+					coderabbitApproval,
+					{ login: "maintainer", type: "User", state: "APPROVED", submittedAt: REVIEWED_AT + 1_000 },
+				],
+			})
+
+			expect(result.addLabels).not.toHaveBeenCalledWith(
+				expect.objectContaining({ labels: ["community-approved"] }),
+			)
+			expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "community-approved" }))
+			expect(latestGateStatus(result)?.description).toContain("required review sequence passed")
+		})
+
+		it("applies the same rule to bot-authored PRs without a CodeRabbit requirement", async () => {
+			const result = await runWorkflow({
+				prAuthor: { login: "dependabot[bot]", type: "Bot" },
+				reviews: [communityApproval],
+			})
+
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["awaiting-maintainer"] }))
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["community-approved"] }))
+			expect(result.info).toHaveBeenCalledWith(expect.stringContaining("coderabbit=optional"))
+		})
+
+		it("keeps the fail-closed behavior when a per-user permission failure blocks maintainer classification", async () => {
+			const result = await runWorkflow({
+				labels: ["community-approved"],
+				permissionErrors: { "community-reviewer": 500 },
+				reviews: [coderabbitApproval, communityApproval],
+			})
+
+			expect(result.setFailed).toHaveBeenCalled()
+			expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "community-approved" }))
+			expect(result.addLabels).not.toHaveBeenCalledWith(
+				expect.objectContaining({ labels: ["awaiting-maintainer"] }),
+			)
+		})
+
+		it("preserves an existing label when only the community permission lookup is uncertain", async () => {
+			const result = await runWorkflow({
+				labels: ["community-approved"],
+				permissionErrors: { "community-reviewer": 500 },
+				reviews: [
+					coderabbitApproval,
+					{ ...communityApproval, id: 2 },
+					{
+						login: "community-reviewer",
+						type: "User",
+						state: "DISMISSED",
+						submittedAt: REVIEWED_AT + 2_000,
+						id: 1,
+					},
+				],
+			})
+
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["awaiting-maintainer"] }))
+			expect(result.removeLabel).not.toHaveBeenCalledWith(expect.objectContaining({ name: "community-approved" }))
+			expect(result.addLabels).not.toHaveBeenCalledWith(
+				expect.objectContaining({ labels: ["community-approved"] }),
+			)
+			expect(result.setFailed).not.toHaveBeenCalled()
+		})
+
+		it("does not add the label when only the community permission lookup is uncertain", async () => {
+			const result = await runWorkflow({
+				permissionErrors: { "community-reviewer": 500 },
+				reviews: [
+					coderabbitApproval,
+					{ ...communityApproval, id: 2 },
+					{
+						login: "community-reviewer",
+						type: "User",
+						state: "DISMISSED",
+						submittedAt: REVIEWED_AT + 2_000,
+						id: 1,
+					},
+				],
+			})
+
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["awaiting-maintainer"] }))
+			expect(result.addLabels).not.toHaveBeenCalledWith(
+				expect.objectContaining({ labels: ["community-approved"] }),
+			)
+			expect(result.setFailed).not.toHaveBeenCalled()
+		})
+
+		it("removes the label when a known invalidation coexists with lookup uncertainty", async () => {
+			const result = await runWorkflow({
+				labels: ["community-approved"],
+				permissionErrors: { "reviewer-b": 500 },
+				reviews: [
+					coderabbitApproval,
+					{
+						login: "reviewer-a",
+						type: "User",
+						state: "APPROVED",
+						submittedAt: REVIEWED_AT + 1_000,
+						id: 1,
+					},
+					{
+						login: "reviewer-a",
+						type: "User",
+						state: "DISMISSED",
+						submittedAt: REVIEWED_AT + 2_000,
+						id: 2,
+					},
+					{ login: "reviewer-b", type: "User", state: "APPROVED", submittedAt: REVIEWED_AT + 3_000, id: 4 },
+					{ login: "reviewer-b", type: "User", state: "DISMISSED", submittedAt: REVIEWED_AT + 4_000, id: 3 },
+				],
+			})
+
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["awaiting-maintainer"] }))
+			expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "community-approved" }))
+			expect(result.addLabels).not.toHaveBeenCalledWith(
+				expect.objectContaining({ labels: ["community-approved"] }),
+			)
+			expect(result.setFailed).not.toHaveBeenCalled()
+		})
+
+		it("removes the label when the head changes during reconciliation", async () => {
+			const result = await runWorkflow({
+				labels: ["community-approved"],
+				headShaSequence: [SHA, NEW_SHA],
+				reviews: [coderabbitApproval, communityApproval],
+			})
+
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["awaiting-maintainer"] }))
+			expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "community-approved" }))
+			expect(result.addLabels).not.toHaveBeenCalledWith(
+				expect.objectContaining({ labels: ["community-approved"] }),
+			)
+		})
+
+		it("preserves the label while mergeability is unknown and the head is unchanged", async () => {
+			const result = await runWorkflow({
+				eventName: "push",
+				labels: ["awaiting-maintainer", "community-approved"],
+				mergeabilitySequence: [
+					{ mergeable: null, mergeableState: "unknown" },
+					{ mergeable: null, mergeableState: "unknown" },
+				],
+				reviews: [coderabbitApproval, communityApproval],
+			})
+
+			expect(result.removeLabel).not.toHaveBeenCalledWith(expect.objectContaining({ name: "community-approved" }))
+			expect(result.removeLabel).not.toHaveBeenCalledWith(
+				expect.objectContaining({ name: "awaiting-maintainer" }),
+			)
+			expect(result.addLabels).not.toHaveBeenCalledWith(
+				expect.objectContaining({ labels: ["community-approved"] }),
+			)
+			expect(latestGateStatus(result)?.description).toContain("calculating mergeability")
+		})
+
+		it("removes the label when the head changes while mergeability is unknown", async () => {
+			const result = await runWorkflow({
+				eventName: "push",
+				labels: ["community-approved"],
+				mergeabilitySequence: [
+					{ mergeable: null, mergeableState: "unknown" },
+					{ mergeable: null, mergeableState: "unknown" },
+				],
+				headShaSequence: [SHA, NEW_SHA],
+				reviews: [coderabbitApproval, communityApproval],
+			})
+
+			expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "community-approved" }))
+			expect(result.addLabels).not.toHaveBeenCalledWith(
+				expect.objectContaining({ labels: ["community-approved"] }),
+			)
+		})
+
+		it("removes the label when the PR leaves the maintainer queue", async () => {
+			const result = await runWorkflow({
+				labels: ["awaiting-maintainer", "community-approved"],
+				permissions: { maintainer: "write" },
+				reviews: [
+					coderabbitApproval,
+					communityApproval,
+					{
+						login: "maintainer",
+						type: "User",
+						state: "CHANGES_REQUESTED",
+						submittedAt: REVIEWED_AT + 2_000,
+					},
+				],
+			})
+
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["awaiting-author"] }))
+			expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "awaiting-maintainer" }))
+			expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "community-approved" }))
+		})
+
+		it("removes the label when a ready PR converts back to draft", async () => {
+			const result = await runWorkflow({
+				draft: true,
+				labels: ["awaiting-maintainer", "community-approved"],
+				reviews: [coderabbitApproval, communityApproval],
+			})
+
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["awaiting-ready"] }))
+			expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "awaiting-maintainer" }))
+			expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "community-approved" }))
+		})
+
+		it("makes no label changes for read-only fork review events", async () => {
+			const result = await runWorkflow({
+				eventName: "pull_request_review",
+				fork: true,
+				labels: ["awaiting-maintainer", "community-approved"],
+				reviews: [coderabbitApproval, communityApproval],
+			})
+
+			expect(result.addLabels).not.toHaveBeenCalled()
+			expect(result.removeLabel).not.toHaveBeenCalled()
+			expect(result.setFailed).not.toHaveBeenCalled()
+		})
+
+		it("does not route community change requests to awaiting-author", async () => {
+			const result = await runWorkflow({
+				reviews: [
+					coderabbitApproval,
+					{
+						login: "community-reviewer",
+						type: "User",
+						state: "CHANGES_REQUESTED",
+						submittedAt: REVIEWED_AT + 1_000,
+					},
+				],
+			})
+
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["awaiting-maintainer"] }))
+			expect(result.addLabels).not.toHaveBeenCalledWith(expect.objectContaining({ labels: ["awaiting-author"] }))
+			expect(result.addLabels).not.toHaveBeenCalledWith(
+				expect.objectContaining({ labels: ["community-approved"] }),
+			)
+			expect(result.setFailed).not.toHaveBeenCalled()
+		})
+
+		it("keeps the advisory gate unchanged when the community label is added", async () => {
+			const result = await runWorkflow({
+				reviews: [coderabbitApproval, communityApproval],
+			})
+
+			for (const [status] of result.createCommitStatus.mock.calls) {
+				expect(status.context).toBe("Zoo Code / PR review gate")
+			}
+			expect(latestGateStatus(result)?.state).toBe("success")
+			expect(latestGateStatus(result)?.description).toContain("Awaiting fresh human maintainer")
+		})
+
+		it("does not clear the queue label or fail the gate when the community label update fails", async () => {
+			const result = await runWorkflow({
+				addLabelsFailOnceName: "community-approved",
+				reviews: [coderabbitApproval, communityApproval],
+			})
+
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["awaiting-maintainer"] }))
+			expect(result.warning).toHaveBeenCalledWith(expect.stringContaining("could not add community-approved"))
+			expect(latestGateStatus(result)?.state).toBe("success")
+			expect(result.setFailed).not.toHaveBeenCalled()
+		})
+
+		it.each([
+			{ name: "a configuration error", options: { requiredContexts: ["Zoo Code / PR review gate"] } },
+			{ name: "a merge conflict", options: { conflict: true } },
+			{ name: "pending required CI", options: { requiredStatus: "in_progress" as const } },
+			{ name: "failing required CI", options: { requiredConclusion: "failure" as const } },
+			{
+				name: "a merge conflict found on the mergeability recheck",
+				options: {
+					eventName: "push",
+					labels: ["awaiting-maintainer", "community-approved"],
+					mergeabilitySequence: [
+						{ mergeable: null, mergeableState: "unknown" },
+						{ mergeable: false, mergeableState: "dirty" },
+					],
+				},
+			},
+		])("removes the label on $name", async ({ options }) => {
+			const result = await runWorkflow({
+				labels: ["community-approved"],
+				reviews: [coderabbitApproval, communityApproval],
+				...options,
+			})
+
+			expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "community-approved" }))
+			expect(result.addLabels).not.toHaveBeenCalledWith(
+				expect.objectContaining({ labels: ["community-approved"] }),
+			)
+		})
+
+		it("treats a 404 when removing the label as already removed", async () => {
+			const result = await runWorkflow({
+				labels: ["community-approved"],
+				removeLabelStatus: 404,
+				reviews: [coderabbitApproval, { ...communityApproval, commitId: OLD_SHA }],
+			})
+
+			expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "community-approved" }))
+			expect(result.warning).not.toHaveBeenCalledWith(expect.stringContaining("could not remove"))
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["awaiting-maintainer"] }))
+			expect(result.setFailed).not.toHaveBeenCalled()
+		})
+
+		it("does not fail the review gate when removing the community label fails", async () => {
+			const result = await runWorkflow({
+				labels: ["community-approved"],
+				removeLabelFailOnceName: "community-approved",
+				reviews: [coderabbitApproval, { ...communityApproval, commitId: OLD_SHA }],
+			})
+
+			expect(result.warning).toHaveBeenCalledWith(expect.stringContaining("could not remove community-approved"))
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["awaiting-maintainer"] }))
+			expect(latestGateStatus(result)?.state).toBe("success")
+			expect(result.setFailed).not.toHaveBeenCalled()
+		})
+
+		it.each(["read", "triage"])("qualifies a reviewer with %s permission", async (permission) => {
+			const result = await runWorkflow({
+				permissions: { "community-reviewer": permission },
+				reviews: [coderabbitApproval, communityApproval],
+			})
+
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["community-approved"] }))
+		})
+
+		it("removes the label when mergeability is unknown and an approval was invalidated", async () => {
+			const result = await runWorkflow({
+				eventName: "push",
+				labels: ["awaiting-maintainer", "community-approved"],
+				mergeabilitySequence: [
+					{ mergeable: null, mergeableState: "unknown" },
+					{ mergeable: null, mergeableState: "unknown" },
+				],
+				reviews: [
+					coderabbitApproval,
+					{ ...communityApproval, id: 1 },
+					{
+						login: "community-reviewer",
+						type: "User",
+						state: "DISMISSED",
+						submittedAt: REVIEWED_AT + 2_000,
+						id: 2,
+					},
+				],
+			})
+
+			expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "community-approved" }))
+			expect(result.removeLabel).not.toHaveBeenCalledWith(
+				expect.objectContaining({ name: "awaiting-maintainer" }),
+			)
+		})
+
+		it("adds the label when one approval is invalidated and another is fresh", async () => {
+			const result = await runWorkflow({
+				reviews: [
+					coderabbitApproval,
+					{ login: "reviewer-a", type: "User", state: "APPROVED", submittedAt: REVIEWED_AT + 1_000, id: 1 },
+					{ login: "reviewer-a", type: "User", state: "DISMISSED", submittedAt: REVIEWED_AT + 2_000, id: 2 },
+					{ ...communityApproval, id: 3 },
+				],
+			})
+
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["community-approved"] }))
+		})
+
+		it("does not qualify a CodeRabbit login that has the User type", async () => {
+			const result = await runWorkflow({
+				labels: ["community-approved"],
+				reviews: [{ login: "coderabbitai", type: "User", state: "APPROVED", submittedAt: REVIEWED_AT }],
+			})
+
+			expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["awaiting-maintainer"] }))
+			expect(result.permissionFor).not.toHaveBeenCalledWith(expect.objectContaining({ username: "coderabbitai" }))
+			expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "community-approved" }))
+		})
+
+		it("removes the label and skips the permission lookup for ghost accounts", async () => {
+			const result = await runWorkflow({
+				labels: ["community-approved"],
+				reviews: [
+					coderabbitApproval,
+					{ login: "ghost", type: "User", state: "APPROVED", submittedAt: REVIEWED_AT + 1_000, ghost: true },
+				],
+			})
+
+			expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "community-approved" }))
+			expect(result.permissionFor).not.toHaveBeenCalledWith(expect.objectContaining({ username: undefined }))
+			expect(result.setFailed).not.toHaveBeenCalled()
+		})
+	})
 })
diff --git a/src/services/code-index/__tests__/code-index-manager-registry.spec.ts b/src/services/code-index/__tests__/code-index-manager-registry.spec.ts
index 9879ff8ea9..0d5012a641 100644
--- a/src/services/code-index/__tests__/code-index-manager-registry.spec.ts
+++ b/src/services/code-index/__tests__/code-index-manager-registry.spec.ts
@@ -2,6 +2,10 @@ import * as vscode from "vscode"
 import { makeExtensionContext, makeTextDocument, makeTextEditor, makeUri } from "../../../test-utils/vscode"
 import { CodeIndexManager } from "../manager"
 import { CodeIndexManagerRegistry } from "../code-index-manager-registry"
+import { CodeIndexWorkspaceScope } from "../code-index-workspace-scope"
+import { CodeIndexStateManager } from "../state-manager"
+
+vi.mock("../state-manager")
 
 vi.mock("vscode", () => ({
 	workspace: { workspaceFolders: undefined, getWorkspaceFolder: vi.fn() },
@@ -39,12 +43,24 @@ describe("CodeIndexManagerRegistry", () => {
 	it.each([{ folders: undefined }, { folders: [] }])("returns no manager with folders=$folders", ({ folders }) => {
 		Object.defineProperty(vscode.workspace, "workspaceFolders", { configurable: true, value: folders })
 		expect(CodeIndexManagerRegistry.getOrCreate(context)).toBeUndefined()
+		expect(CodeIndexManagerRegistry.getOrCreateScope(context)).toBeUndefined()
 		expect(CodeIndexManager).not.toHaveBeenCalled()
 	})
 
+	it("returns the complete cached scope shared with the manager API", () => {
+		const scope = CodeIndexManagerRegistry.getOrCreateScope(context)!
+		expect(scope).toBeInstanceOf(CodeIndexWorkspaceScope)
+		expect(scope.workspaceIndexingEnablementManager).toBeDefined()
+		expect(CodeIndexManagerRegistry.getOrCreateScope(context, "/first")).toBe(scope)
+		expect(CodeIndexManagerRegistry.getOrCreate(context)).toBe(scope.codeIndexManager)
+		expect(CodeIndexManagerRegistry.getOrCreateScope(context, "/second")).not.toBe(scope)
+		CodeIndexManagerRegistry.disposeAll()
+		expect(CodeIndexManagerRegistry.getOrCreateScope(context)).not.toBe(scope)
+	})
+
 	it("uses the first workspace when there is no active editor", () => {
 		CodeIndexManagerRegistry.getOrCreate(context)
-		expect(CodeIndexManager).toHaveBeenCalledWith("/first", first.uri, context)
+		expect(CodeIndexManager).toHaveBeenCalledWith("/first", first.uri, context, expect.any(CodeIndexStateManager))
 	})
 
 	it("prefers the active editor's workspace", () => {
@@ -52,20 +68,20 @@ describe("CodeIndexManagerRegistry", () => {
 		Object.defineProperty(vscode.window, "activeTextEditor", { configurable: true, value: editor })
 		vi.mocked(vscode.workspace.getWorkspaceFolder).mockReturnValue(second)
 		expect(CodeIndexManagerRegistry.getOrCreate(context)).toBeDefined()
-		expect(CodeIndexManager).toHaveBeenCalledWith("/second", second.uri, context)
+		expect(CodeIndexManager).toHaveBeenCalledWith("/second", second.uri, context, expect.any(CodeIndexStateManager))
 	})
 
 	it("falls back to the first workspace for an editor outside all folders", () => {
 		Object.defineProperty(vscode.window, "activeTextEditor", { configurable: true, value: makeTextEditor() })
 		CodeIndexManagerRegistry.getOrCreate(context)
-		expect(CodeIndexManager).toHaveBeenCalledWith("/first", first.uri, context)
+		expect(CodeIndexManager).toHaveBeenCalledWith("/first", first.uri, context, expect.any(CodeIndexStateManager))
 	})
 
 	it("gives an explicit path priority over the active editor", () => {
 		Object.defineProperty(vscode.window, "activeTextEditor", { configurable: true, value: makeTextEditor() })
 		vi.mocked(vscode.workspace.getWorkspaceFolder).mockReturnValue(first)
 		expect(CodeIndexManagerRegistry.getOrCreate(context, "/second")).toBeDefined()
-		expect(CodeIndexManager).toHaveBeenCalledWith("/second", second.uri, context)
+		expect(CodeIndexManager).toHaveBeenCalledWith("/second", second.uri, context, expect.any(CodeIndexStateManager))
 	})
 
 	it("preserves the actual remote workspace URI", () => {
@@ -75,7 +91,7 @@ describe("CodeIndexManagerRegistry", () => {
 			value: [{ uri, name: "remote", index: 0 }],
 		})
 		CodeIndexManagerRegistry.getOrCreate(context, "/remote")
-		expect(CodeIndexManager).toHaveBeenCalledWith("/remote", uri, context)
+		expect(CodeIndexManager).toHaveBeenCalledWith("/remote", uri, context, expect.any(CodeIndexStateManager))
 		expect(vi.mocked(CodeIndexManager).mock.calls[0][1]).toBe(uri)
 		expect(vscode.Uri.file).not.toHaveBeenCalled()
 	})
@@ -86,7 +102,7 @@ describe("CodeIndexManagerRegistry", () => {
 		vi.mocked(vscode.Uri.file).mockReturnValue(uri)
 		CodeIndexManagerRegistry.getOrCreate(context, uri.fsPath)
 		expect(vscode.Uri.file).toHaveBeenCalledWith(uri.fsPath)
-		expect(CodeIndexManager).toHaveBeenCalledWith(uri.fsPath, uri, context)
+		expect(CodeIndexManager).toHaveBeenCalledWith(uri.fsPath, uri, context, expect.any(CodeIndexStateManager))
 	})
 
 	it("constructs a file URI for an explicit path not matching any open workspace folder", () => {
@@ -95,7 +111,12 @@ describe("CodeIndexManagerRegistry", () => {
 		vi.mocked(vscode.Uri.file).mockReturnValue(uri)
 		CodeIndexManagerRegistry.getOrCreate(context, "/outside/project")
 		expect(vscode.Uri.file).toHaveBeenCalledWith("/outside/project")
-		expect(CodeIndexManager).toHaveBeenCalledWith("/outside/project", uri, context)
+		expect(CodeIndexManager).toHaveBeenCalledWith(
+			"/outside/project",
+			uri,
+			context,
+			expect.any(CodeIndexStateManager),
+		)
 	})
 
 	it("reuses the same path and keeps different paths isolated", () => {
@@ -107,6 +128,22 @@ describe("CodeIndexManagerRegistry", () => {
 		expect(CodeIndexManagerRegistry.getAllInstances()).toEqual([a, b])
 	})
 
+	it("does not cache a scope when manager construction fails and permits retry for the same path", () => {
+		const error = new Error("construction failed")
+		vi.mocked(CodeIndexManager).mockImplementationOnce(function () {
+			throw error
+		})
+
+		expect(() => CodeIndexManagerRegistry.getOrCreate(context, "/first")).toThrow(error)
+		expect(CodeIndexManagerRegistry.getAllInstances()).toEqual([])
+
+		const manager = CodeIndexManagerRegistry.getOrCreate(context, "/first")
+		expect(manager).toBe(vi.mocked(CodeIndexManager).mock.results[1].value)
+		expect(CodeIndexManagerRegistry.getAllInstances()).toEqual([manager])
+		expect(CodeIndexManagerRegistry.getOrCreate(context, "/first")).toBe(manager)
+		expect(CodeIndexManager).toHaveBeenCalledTimes(2)
+	})
+
 	it("returns a snapshot that cannot mutate the cache", () => {
 		expect(CodeIndexManagerRegistry.getAllInstances()).toEqual([])
 		const manager = CodeIndexManagerRegistry.getOrCreate(context)
@@ -114,11 +151,48 @@ describe("CodeIndexManagerRegistry", () => {
 		expect(CodeIndexManagerRegistry.getAllInstances()).toEqual([manager])
 	})
 
+	it("logs each disposal failure, continues cleanup and permits recreation", () => {
+		const logError = vi.spyOn(console, "error").mockImplementation(() => {})
+		const first = CodeIndexManagerRegistry.getOrCreate(context, "/first")!
+		const second = CodeIndexManagerRegistry.getOrCreate(context, "/second")!
+		const third = CodeIndexManagerRegistry.getOrCreate(context, "/third")!
+		const error = new Error("cleanup failed")
+		vi.mocked(first.dispose).mockImplementationOnce(() => {
+			throw error
+		})
+		vi.mocked(second.dispose).mockImplementationOnce(() => {
+			throw "second cleanup failed"
+		})
+
+		expect(() => CodeIndexManagerRegistry.disposeAll()).not.toThrow()
+		for (const manager of [first, second, third]) {
+			expect(manager.dispose).toHaveBeenCalledExactlyOnceWith()
+		}
+		expect(logError).toHaveBeenCalledTimes(2)
+		expect(logError).toHaveBeenNthCalledWith(
+			1,
+			"[CodeIndexManagerRegistry] Failed to dispose workspace scope for /first:",
+			error,
+		)
+		expect(logError).toHaveBeenNthCalledWith(
+			2,
+			"[CodeIndexManagerRegistry] Failed to dispose workspace scope for /second:",
+			"second cleanup failed",
+		)
+		expect(CodeIndexManagerRegistry.getAllInstances()).toEqual([])
+		CodeIndexManagerRegistry.disposeAll()
+		expect(logError).toHaveBeenCalledTimes(2)
+		expect(first.dispose).toHaveBeenCalledTimes(1)
+		expect(CodeIndexManagerRegistry.getOrCreate(context, "/first")).not.toBe(first)
+	})
+
 	it("disposes every manager, supports repeated cleanup and recreates instances", () => {
+		const disposeScope = vi.spyOn(CodeIndexWorkspaceScope.prototype, "dispose")
 		const a = CodeIndexManagerRegistry.getOrCreate(context, "/first")!
 		const b = CodeIndexManagerRegistry.getOrCreate(context, "/second")!
 		CodeIndexManagerRegistry.disposeAll()
 		CodeIndexManagerRegistry.disposeAll()
+		expect(disposeScope).toHaveBeenCalledTimes(2)
 		expect(a.dispose).toHaveBeenCalledTimes(1)
 		expect(b.dispose).toHaveBeenCalledTimes(1)
 		expect(CodeIndexManagerRegistry.getAllInstances()).toEqual([])
diff --git a/src/services/code-index/__tests__/code-index-scan-executor.spec.ts b/src/services/code-index/__tests__/code-index-scan-executor.spec.ts
new file mode 100644
index 0000000000..33b71584ff
--- /dev/null
+++ b/src/services/code-index/__tests__/code-index-scan-executor.spec.ts
@@ -0,0 +1,149 @@
+import { CodeIndexScanExecutor } from "../code-index-scan-executor"
+import type { IDirectoryScanner } from "../interfaces"
+
+vi.mock("../../../i18n", () => ({ t: (key: string) => key }))
+
+function setup() {
+	const scanner = { scanDirectory: vi.fn<IDirectoryScanner["scanDirectory"]>() }
+	const vectorStore = { markIndexingIncomplete: vi.fn().mockResolvedValue(undefined) }
+	const stateManager = { setSystemState: vi.fn(), reportBlockIndexingProgress: vi.fn() }
+	return {
+		scanner,
+		vectorStore,
+		stateManager,
+		executor: new CodeIndexScanExecutor("/workspace", scanner, vectorStore, stateManager),
+	}
+}
+
+describe("CodeIndexScanExecutor", () => {
+	it.each(["runFullScan", "runIncrementalScan"] as const)(
+		"%s skips failure validation when cancellation occurs during the scan",
+		async (method) => {
+			const { executor, scanner } = setup()
+			const controller = new AbortController()
+			scanner.scanDirectory.mockImplementation(async (_path, onError, _onIndexed, onParsed) => {
+				onParsed?.(3)
+				onError?.(new Error("batch failure"))
+				controller.abort()
+				return { stats: { processed: 0, skipped: 0 }, totalBlockCount: 3 }
+			})
+			await expect(executor[method](controller.signal)).resolves.toBe(false)
+		},
+	)
+
+	it("completes an incremental scan with no changed files", async () => {
+		const { executor, scanner } = setup()
+		scanner.scanDirectory.mockResolvedValue({ stats: { processed: 0, skipped: 2 }, totalBlockCount: 0 })
+		await expect(executor.runIncrementalScan(new AbortController().signal)).resolves.toBe(true)
+	})
+
+	it.each(["runFullScan", "runIncrementalScan"] as const)(
+		"%s preserves progress and signal wiring",
+		async (method) => {
+			const { executor, scanner, vectorStore, stateManager } = setup()
+			const signal = new AbortController().signal
+			scanner.scanDirectory.mockImplementation(async (path, _onError, onIndexed, onParsed, receivedSignal) => {
+				expect(path).toBe("/workspace")
+				expect(receivedSignal).toBe(signal)
+				expect(vectorStore.markIndexingIncomplete).toHaveBeenCalledOnce()
+				onParsed?.(2)
+				onIndexed?.(1)
+				onParsed?.(1)
+				onIndexed?.(2)
+				return { stats: { processed: 2, skipped: 0 }, totalBlockCount: 3 }
+			})
+			await expect(executor[method](signal)).resolves.toBe(true)
+			expect(stateManager.reportBlockIndexingProgress.mock.calls).toEqual([
+				[0, 2],
+				[1, 2],
+				[1, 3],
+				[3, 3],
+			])
+			expect(stateManager.setSystemState).toHaveBeenCalledExactlyOnceWith(
+				"Indexing",
+				method === "runFullScan"
+					? "Services ready. Starting workspace scan..."
+					: "Checking for new or modified files...",
+			)
+		},
+	)
+
+	it.each(["runFullScan", "runIncrementalScan"] as const)("%s rejects missing results", async (method) => {
+		const { executor } = setup()
+		// An unconfigured mock simulates a scanner violating its return contract.
+		await expect(executor[method](new AbortController().signal)).rejects.toThrow(
+			method === "runFullScan"
+				? "Scan failed, is scanner initialized?"
+				: "Incremental scan failed, is scanner initialized?",
+		)
+	})
+
+	it.each(["runFullScan", "runIncrementalScan"] as const)(
+		"%s returns cancellation before validating results",
+		async (method) => {
+			const { executor, scanner } = setup()
+			const controller = new AbortController()
+			// Abort before the unconfigured scanner returns a missing result.
+			controller.abort()
+			await expect(executor[method](controller.signal)).resolves.toBe(false)
+			expect(scanner.scanDirectory).toHaveBeenCalledOnce()
+		},
+	)
+
+	it.each(["runFullScan", "runIncrementalScan"] as const)(
+		"%s propagates scanner and marker failures unchanged",
+		async (method) => {
+			const { executor, scanner, vectorStore } = setup()
+			const signal = new AbortController().signal
+			const failure = new Error("scan failed")
+			scanner.scanDirectory.mockRejectedValueOnce(failure)
+			await expect(executor[method](signal)).rejects.toBe(failure)
+			const abort = new DOMException("stopped", "AbortError")
+			scanner.scanDirectory.mockRejectedValueOnce(abort)
+			await expect(executor[method](signal)).rejects.toBe(abort)
+			vectorStore.markIndexingIncomplete.mockRejectedValueOnce(failure)
+			await expect(executor[method](signal)).rejects.toBe(failure)
+			expect(scanner.scanDirectory).toHaveBeenCalledTimes(2)
+		},
+	)
+
+	it.each([
+		{ found: 0, indexed: 0, error: false, message: undefined },
+		{ found: 3, indexed: 0, error: false, message: "embeddings:orchestrator.indexingFailedNoBlocks" },
+		{ found: 3, indexed: 0, error: true, message: "Indexing failed: batch failure" },
+		{ found: 0, indexed: 0, error: true, message: "Indexing failed completely: batch failure" },
+		{ found: 10, indexed: 9, error: true, message: undefined },
+		{
+			found: 10,
+			indexed: 8,
+			error: true,
+			message: "Indexing partially failed: Only 8 of 10 blocks were indexed. batch failure",
+		},
+		{ found: 10, indexed: 8, error: false, message: undefined },
+	])(
+		"preserves full-scan policy for $indexed/$found blocks, error=$error",
+		async ({ found, indexed, error, message }) => {
+			const { executor, scanner } = setup()
+			scanner.scanDirectory.mockImplementation(async (_path, onError, onIndexed, onParsed) => {
+				onParsed?.(found)
+				onIndexed?.(indexed)
+				if (error) onError?.(new Error("batch failure"))
+				return { stats: { processed: 1, skipped: 0 }, totalBlockCount: found }
+			})
+			const result = executor.runFullScan(new AbortController().signal)
+			if (message) await expect(result).rejects.toThrow(message)
+			else await expect(result).resolves.toBe(true)
+		},
+	)
+
+	it.each([0, 2])("preserves incremental batch-error tolerance with %s indexed blocks", async (indexed) => {
+		const { executor, scanner } = setup()
+		scanner.scanDirectory.mockImplementation(async (_path, onError, onIndexed, onParsed) => {
+			onParsed?.(3)
+			onIndexed?.(indexed)
+			onError?.(new Error("batch failure"))
+			return { stats: { processed: 1, skipped: 0 }, totalBlockCount: 3 }
+		})
+		await expect(executor.runIncrementalScan(new AbortController().signal)).resolves.toBe(true)
+	})
+})
diff --git a/src/services/code-index/__tests__/code-index-scope.spec.ts b/src/services/code-index/__tests__/code-index-scope.spec.ts
new file mode 100644
index 0000000000..0ad986e540
--- /dev/null
+++ b/src/services/code-index/__tests__/code-index-scope.spec.ts
@@ -0,0 +1,50 @@
+import { makeExtensionContext } from "../../../test-utils/vscode"
+import { CodeIndexScope } from "../code-index-scope"
+import { CodeIndexStatusManager } from "../code-index-status-manager"
+import { CodeIndexManagerRegistry } from "../code-index-manager-registry"
+
+vi.mock("../code-index-status-manager")
+vi.mock("../code-index-manager-registry", () => ({
+	CodeIndexManagerRegistry: { getOrCreate: vi.fn() },
+}))
+
+describe("CodeIndexScope", () => {
+	beforeEach(() => vi.clearAllMocks())
+
+	it("creates, initializes and disposes its status manager", () => {
+		const context = makeExtensionContext()
+		const scope = new CodeIndexScope(context)
+		expect(scope["_isInitialized"]).toBe(false)
+		expect(CodeIndexStatusManager).not.toHaveBeenCalled()
+		scope.init()
+		expect(scope["_isInitialized"]).toBe(true)
+		const manager = vi.mocked(CodeIndexStatusManager).mock.instances[0]
+		const [resolve] = vi.mocked(CodeIndexStatusManager).mock.calls[0]
+		resolve("/first")
+		expect(CodeIndexManagerRegistry.getOrCreate).toHaveBeenCalledExactlyOnceWith(context, "/first")
+		expect(manager.init).toHaveBeenCalledExactlyOnceWith()
+		expect(() => scope.init()).toThrow("already initialized")
+		scope.dispose()
+		expect(scope["_isInitialized"]).toBe(false)
+		scope.dispose()
+		expect(manager.dispose).toHaveBeenCalledExactlyOnceWith()
+		scope.init()
+		expect(CodeIndexStatusManager).toHaveBeenCalledTimes(2)
+		scope.dispose()
+	})
+
+	it("can dispose before initialization and retry failed initialization", () => {
+		const scope = new CodeIndexScope(makeExtensionContext())
+		scope.dispose()
+		expect(CodeIndexStatusManager).not.toHaveBeenCalled()
+		vi.mocked(CodeIndexStatusManager.prototype.init).mockImplementationOnce(() => {
+			throw new Error("init failed")
+		})
+		expect(() => scope.init()).toThrow("init failed")
+		expect(scope["_isInitialized"]).toBe(false)
+		expect(vi.mocked(CodeIndexStatusManager).mock.instances[0].dispose).toHaveBeenCalledExactlyOnceWith()
+		expect(() => scope.init()).not.toThrow()
+		expect(scope["_isInitialized"]).toBe(true)
+		scope.dispose()
+	})
+})
diff --git a/src/services/code-index/__tests__/code-index-status-manager.spec.ts b/src/services/code-index/__tests__/code-index-status-manager.spec.ts
new file mode 100644
index 0000000000..d695f8e523
--- /dev/null
+++ b/src/services/code-index/__tests__/code-index-status-manager.spec.ts
@@ -0,0 +1,335 @@
+import * as vscode from "vscode"
+import {
+	makeUri,
+	makeTextDocument,
+	makeTextEditor,
+	makeExtensionContext,
+	makeWorkspaceConfiguration,
+} from "../../../test-utils/vscode"
+import { CodeIndexScope } from "../code-index-scope"
+import { CodeIndexManagerRegistry } from "../code-index-manager-registry"
+import { CodeIndexManager } from "../manager"
+import { CodeIndexStateManager } from "../state-manager"
+import { CodeIndexStatusManager, type CodeIndexStatus } from "../code-index-status-manager"
+
+// Reload the real workspace resolver against this suite's VS Code mock,
+// rather than the VS Code instance cached by the global test setup.
+vi.hoisted(() => vi.resetModules())
+
+vi.mock("../../../core/webview/ClineProvider", () => ({ ClineProvider: { getAllInstances: vi.fn(() => []) } }))
+vi.mock("../code-index-manager-registry", () => ({ CodeIndexManagerRegistry: { getOrCreate: vi.fn() } }))
+vi.mock("../manager")
+vi.mock("../state-manager")
+
+vi.mock("vscode", () => ({
+	window: { onDidChangeActiveTextEditor: vi.fn(), activeTextEditor: undefined },
+	workspace: { workspaceFolders: undefined, getWorkspaceFolder: vi.fn(), getConfiguration: vi.fn() },
+}))
+
+function makeSource(workspacePath: string) {
+	const status: CodeIndexStatus = {
+		systemStatus: "Standby",
+		message: "Ready",
+		processedItems: 0,
+		totalItems: 0,
+		currentItemUnit: "blocks",
+		workspacePath,
+		workspaceEnabled: true,
+		autoEnableDefault: true,
+	}
+	let emit = () => {}
+	const subscription = { dispose: vi.fn() }
+	const event: CodeIndexManager["onProgressUpdate"] = (listener) => {
+		emit = () => listener(status)
+		return subscription
+	}
+	const manager = new CodeIndexManager(
+		workspacePath,
+		makeUri(workspacePath),
+		makeExtensionContext(),
+		new CodeIndexStateManager(),
+	)
+	Object.defineProperty(manager, "onProgressUpdate", { value: vi.fn(event), configurable: true })
+	return Object.assign(manager, {
+		getCurrentStatus: vi.fn(() => status),
+		dispose: vi.fn(),
+		subscription,
+		emit: () => emit(),
+		status,
+	})
+}
+
+describe("CodeIndexStatusManager", () => {
+	let editorChanged: () => void
+	let disposeEditor: ReturnType<typeof vi.fn<() => void>>
+
+	beforeEach(() => {
+		vi.clearAllMocks()
+		vi.mocked(vscode.workspace.getConfiguration).mockReturnValue(makeWorkspaceConfiguration())
+		Object.defineProperty(vscode.window, "activeTextEditor", { configurable: true, value: undefined })
+		Object.defineProperty(vscode.workspace, "workspaceFolders", {
+			configurable: true,
+			value: [{ uri: makeUri("/first"), name: "first", index: 0 }],
+		})
+		vi.mocked(vscode.workspace.getWorkspaceFolder).mockReturnValue(undefined)
+		disposeEditor = vi.fn()
+		vi.mocked(vscode.window.onDidChangeActiveTextEditor).mockImplementation((listener) => {
+			editorChanged = () => listener(undefined)
+			return { dispose: disposeEditor }
+		})
+	})
+
+	it("resolves the workspace before requesting its manager", () => {
+		const resolve = vi.fn(() => makeSource("/first"))
+		const manager = new CodeIndexStatusManager(resolve)
+		manager.init()
+		expect(resolve).toHaveBeenLastCalledWith("/first")
+		const uri = makeUri("/second/file.ts")
+		Object.defineProperty(vscode.window, "activeTextEditor", {
+			configurable: true,
+			value: makeTextEditor({ document: makeTextDocument({ uri }) }),
+		})
+		vi.mocked(vscode.workspace.getWorkspaceFolder).mockReturnValue({
+			uri: makeUri("/second"),
+			name: "second",
+			index: 1,
+		})
+		editorChanged()
+		expect(vscode.workspace.getWorkspaceFolder).toHaveBeenCalledWith(uri)
+		expect(resolve).toHaveBeenLastCalledWith("/second")
+		vi.mocked(vscode.workspace.getWorkspaceFolder).mockReturnValue(undefined)
+		editorChanged()
+		expect(resolve).toHaveBeenLastCalledWith("/first")
+		manager.dispose()
+	})
+
+	it.each([
+		["firstFolder", "/first"],
+		["activeEditor", "/second"],
+	])("publishes status for the configured %s workspace", (strategy, expectedPath) => {
+		vi.mocked(vscode.workspace.getConfiguration).mockReturnValue(
+			makeWorkspaceConfiguration({ "workspace.rootResolution": strategy }),
+		)
+		const firstFolder = { uri: makeUri("/first"), name: "first", index: 0 }
+		const secondFolder = { uri: makeUri("/second"), name: "second", index: 1 }
+		Object.defineProperty(vscode.workspace, "workspaceFolders", {
+			configurable: true,
+			value: [firstFolder, secondFolder],
+		})
+		Object.defineProperty(vscode.window, "activeTextEditor", {
+			configurable: true,
+			value: makeTextEditor({ document: makeTextDocument({ uri: makeUri("/second/file.ts") }) }),
+		})
+		vi.mocked(vscode.workspace.getWorkspaceFolder).mockReturnValue(secondFolder)
+		const first = makeSource("/first")
+		const second = makeSource("/second")
+		const resolve = vi.fn((path: string) => (path === "/first" ? first : second))
+		const publish = vi.fn()
+		const manager = new CodeIndexStatusManager(resolve)
+		manager["publishStatus"] = publish
+		try {
+			manager.init()
+			expect(resolve).toHaveBeenLastCalledWith(expectedPath)
+			const selected = expectedPath === "/first" ? first : second
+			const other = selected === first ? second : first
+			expect(publish).toHaveBeenCalledExactlyOnceWith(selected.status)
+			expect(other.onProgressUpdate).not.toHaveBeenCalled()
+			editorChanged()
+			selected.status.message = "Updated"
+			selected.emit()
+			expect(publish).toHaveBeenLastCalledWith(selected.status)
+			expect(publish).toHaveBeenCalledTimes(2)
+			expect(selected.onProgressUpdate).toHaveBeenCalledTimes(1)
+		} finally {
+			manager.dispose()
+		}
+	})
+
+	it.each([undefined, []])("does not request a manager without a workspace: %s", (folders) => {
+		Object.defineProperty(vscode.workspace, "workspaceFolders", { configurable: true, value: folders })
+		const resolve = vi.fn()
+		const publish = vi.fn()
+		const manager = new CodeIndexStatusManager(resolve)
+		manager["publishStatus"] = publish
+		manager.init()
+		editorChanged()
+		expect(resolve).not.toHaveBeenCalled()
+		expect(publish).not.toHaveBeenCalled()
+		manager.dispose()
+	})
+
+	it("publishes initial and full updated status without resubscribing in the same workspace", () => {
+		const source = makeSource("/first")
+		const publish = vi.fn()
+		const manager = new CodeIndexStatusManager(() => source)
+		manager["publishStatus"] = publish
+		expect(source.onProgressUpdate).not.toHaveBeenCalled()
+		manager.init()
+		expect(publish).toHaveBeenCalledExactlyOnceWith(source.status)
+		source.status.message = "Updated"
+		source.emit()
+		expect(publish).toHaveBeenLastCalledWith(source.status)
+		expect(publish).toHaveBeenCalledTimes(2)
+		editorChanged()
+		expect(source.onProgressUpdate).toHaveBeenCalledTimes(1)
+		expect(publish).toHaveBeenCalledTimes(2)
+		manager.dispose()
+	})
+
+	it("switches subscriptions and rejects stale events before and after switching", () => {
+		const first = makeSource("/first")
+		const second = makeSource("/second")
+		let current = first
+		const publish = vi.fn()
+		const manager = new CodeIndexStatusManager(() => current)
+		manager["publishStatus"] = publish
+		manager.init()
+		current = second
+		first.emit()
+		expect(publish).toHaveBeenCalledTimes(1)
+		editorChanged()
+		expect(first.subscription.dispose).toHaveBeenCalledTimes(1)
+		expect(publish).toHaveBeenLastCalledWith(second.status)
+		first.emit()
+		expect(publish).toHaveBeenCalledTimes(2)
+		second.emit()
+		expect(publish).toHaveBeenCalledTimes(3)
+		manager.dispose()
+		expect(first.dispose).not.toHaveBeenCalled()
+		expect(second.dispose).not.toHaveBeenCalled()
+	})
+
+	it("handles missing workspaces and releases the subscription when a workspace disappears", () => {
+		const source = makeSource("/first")
+		let current: typeof source | undefined
+		const publish = vi.fn()
+		const manager = new CodeIndexStatusManager(() => current)
+		manager["publishStatus"] = publish
+		manager.init()
+		expect(publish).not.toHaveBeenCalled()
+		current = source
+		editorChanged()
+		expect(publish).toHaveBeenCalledExactlyOnceWith(source.status)
+		current = undefined
+		editorChanged()
+		expect(source.subscription.dispose).toHaveBeenCalledTimes(1)
+		source.emit()
+		expect(publish).toHaveBeenCalledTimes(1)
+		manager.dispose()
+	})
+
+	it("disposes idempotently, ignores stale progress and supports reinitialization", () => {
+		const source = makeSource("/first")
+		const publish = vi.fn()
+		const manager = new CodeIndexStatusManager(() => source)
+		manager["publishStatus"] = publish
+		manager.dispose()
+		manager.init()
+		manager.dispose()
+		manager.dispose()
+		expect(disposeEditor).toHaveBeenCalledTimes(1)
+		expect(source.subscription.dispose).toHaveBeenCalledTimes(1)
+		source.emit()
+		expect(publish).toHaveBeenCalledTimes(1)
+		manager.init()
+		expect(publish).toHaveBeenCalledTimes(2)
+		manager.dispose()
+	})
+
+	it("logs both unsubscribe failures and keeps disposal idempotent", () => {
+		const source = makeSource("/first")
+		const manager = new CodeIndexStatusManager(() => source)
+		const editorError = new Error("editor cleanup failed")
+		const progressError = new Error("progress cleanup failed")
+		const log = vi.spyOn(console, "error").mockImplementation(() => {})
+		try {
+			manager.init()
+			disposeEditor.mockImplementationOnce(() => {
+				throw editorError
+			})
+			source.subscription.dispose.mockImplementationOnce(() => {
+				throw progressError
+			})
+			expect(() => manager.dispose()).not.toThrow()
+			expect(log).toHaveBeenNthCalledWith(
+				1,
+				"[CodeIndexStatusManager] Failed to dispose active editor subscription:",
+				editorError,
+			)
+			expect(log).toHaveBeenNthCalledWith(
+				2,
+				"[CodeIndexStatusManager] Failed to dispose progress subscription:",
+				progressError,
+			)
+			manager.dispose()
+			expect(disposeEditor).toHaveBeenCalledTimes(1)
+			expect(source.subscription.dispose).toHaveBeenCalledTimes(1)
+			expect(log).toHaveBeenCalledTimes(2)
+		} finally {
+			log.mockRestore()
+		}
+	})
+
+	it("logs an unsubscribe failure and still subscribes to the next workspace", () => {
+		const first = makeSource("/first")
+		const second = makeSource("/second")
+		let current = first
+		const publish = vi.fn()
+		const manager = new CodeIndexStatusManager(() => current)
+		manager["publishStatus"] = publish
+		const log = vi.spyOn(console, "error").mockImplementation(() => {})
+		try {
+			manager.init()
+			first.subscription.dispose.mockImplementationOnce(() => {
+				throw "cleanup failed"
+			})
+			current = second
+			expect(() => editorChanged()).not.toThrow()
+			expect(log).toHaveBeenCalledExactlyOnceWith(
+				"[CodeIndexStatusManager] Failed to dispose progress subscription:",
+				"cleanup failed",
+			)
+			expect(second.onProgressUpdate).toHaveBeenCalledTimes(1)
+			expect(publish).toHaveBeenLastCalledWith(second.status)
+			first.emit()
+			expect(publish).toHaveBeenCalledTimes(2)
+		} finally {
+			manager.dispose()
+			log.mockRestore()
+		}
+	})
+
+	it.each(["lookup", "publication"])("cleans up failed %s initialization through the scope", (failure) => {
+		const source = makeSource("/first")
+		if (failure === "lookup") {
+			vi.mocked(CodeIndexManagerRegistry.getOrCreate).mockImplementationOnce(() => {
+				throw new Error("lookup failed")
+			})
+		} else {
+			vi.mocked(CodeIndexManagerRegistry.getOrCreate).mockReturnValueOnce(source)
+			source.getCurrentStatus.mockImplementationOnce(() => {
+				throw new Error("publication failed")
+			})
+		}
+		const scope = new CodeIndexScope(makeExtensionContext())
+		expect(() => scope.init()).toThrow(`${failure} failed`)
+		expect(disposeEditor).toHaveBeenCalledTimes(1)
+		scope.dispose()
+		expect(disposeEditor).toHaveBeenCalledTimes(1)
+		if (failure === "publication") expect(source.subscription.dispose).toHaveBeenCalledTimes(1)
+		expect(source.dispose).not.toHaveBeenCalled()
+	})
+
+	it("propagates initialization failure without automatic cleanup", () => {
+		const source = makeSource("/first")
+		const publish = vi.fn().mockImplementationOnce(() => {
+			throw new Error("publish failed")
+		})
+		const manager = new CodeIndexStatusManager(() => source)
+		manager["publishStatus"] = publish
+		expect(() => manager.init()).toThrow("publish failed")
+		expect(disposeEditor).not.toHaveBeenCalled()
+		expect(source.subscription.dispose).not.toHaveBeenCalled()
+		manager.dispose()
+	})
+})
diff --git a/src/services/code-index/__tests__/code-index-workspace-scope.spec.ts b/src/services/code-index/__tests__/code-index-workspace-scope.spec.ts
new file mode 100644
index 0000000000..417d7284c1
--- /dev/null
+++ b/src/services/code-index/__tests__/code-index-workspace-scope.spec.ts
@@ -0,0 +1,146 @@
+import { makeExtensionContext, makeUri } from "../../../test-utils/vscode"
+import { CodeIndexManager } from "../manager"
+import { CodeIndexWorkspaceScope } from "../code-index-workspace-scope"
+import { CodeIndexStateManager } from "../state-manager"
+import { WorkspaceIndexingEnablementManager } from "../workspace-indexing-enablement-manager"
+
+vi.mock("../state-manager")
+
+vi.mock("../manager", () => ({
+	CodeIndexManager: vi.fn().mockImplementation(function () {
+		return { initialize: vi.fn(), dispose: vi.fn() }
+	}),
+}))
+
+describe("CodeIndexWorkspaceScope", () => {
+	beforeEach(() => vi.clearAllMocks())
+
+	it("owns a guarded workspace indexing manager and recreates it after disposal", () => {
+		const scope = new CodeIndexWorkspaceScope("/workspace", makeUri("/workspace"), makeExtensionContext())
+		expect(() => scope.workspaceIndexingEnablementManager).toThrow("not initialized")
+		scope.init()
+		const indexing = scope.workspaceIndexingEnablementManager
+		expect(indexing).toBeInstanceOf(WorkspaceIndexingEnablementManager)
+		expect(indexing["manager"]).toBe(scope.codeIndexManager)
+		scope.dispose()
+		expect(() => scope.workspaceIndexingEnablementManager).toThrow("not initialized")
+		scope.init()
+		expect(scope.workspaceIndexingEnablementManager).not.toBe(indexing)
+	})
+
+	it("guards generic values and preserves defined falsy values", () => {
+		const scope = new CodeIndexWorkspaceScope("/workspace", makeUri("/workspace"), makeExtensionContext())
+		expect(() => scope["ensureInitialized"](42)).toThrow("Code index workspace scope is not initialized")
+		scope.init()
+		expect(() => scope["ensureInitialized"](undefined)).toThrow("Code index workspace scope is not initialized")
+		expect(scope["ensureInitialized"](false)).toBe(false)
+		expect(scope["ensureInitialized"](0)).toBe(0)
+		expect(scope["ensureInitialized"]("")).toBe("")
+	})
+
+	it("creates its manager only on init without starting configuration initialization", () => {
+		const context = makeExtensionContext()
+		const uri = makeUri("/workspace")
+		const scope = new CodeIndexWorkspaceScope(uri.fsPath, uri, context)
+
+		expect(CodeIndexManager).not.toHaveBeenCalled()
+		expect(CodeIndexStateManager).not.toHaveBeenCalled()
+		expect(scope["_stateManager"]).toBeUndefined()
+		expect(() => scope.codeIndexManager).toThrow("Code index workspace scope is not initialized")
+		expect(scope.init()).toBeUndefined()
+		const manager = scope.codeIndexManager
+
+		expect(CodeIndexStateManager).toHaveBeenCalledExactlyOnceWith()
+		expect(scope["_stateManager"]).toBe(vi.mocked(CodeIndexStateManager).mock.instances[0])
+		expect(CodeIndexManager).toHaveBeenCalledExactlyOnceWith(
+			uri.fsPath,
+			uri,
+			context,
+			vi.mocked(CodeIndexStateManager).mock.instances[0],
+		)
+		expect(scope.codeIndexManager).toBe(manager)
+		expect(() => scope.init()).toThrow("Code index workspace scope is already initialized")
+		expect(scope.codeIndexManager).toBe(manager)
+		expect(CodeIndexManager).toHaveBeenCalledTimes(1)
+		expect(manager.initialize).not.toHaveBeenCalled()
+	})
+
+	it("synchronously disposes its manager", () => {
+		const scope = new CodeIndexWorkspaceScope("/workspace", makeUri("/workspace"), makeExtensionContext())
+		scope.init()
+		const manager = scope.codeIndexManager
+
+		expect(scope.dispose()).toBeUndefined()
+		expect(scope["_stateManager"]).toBeUndefined()
+		expect(() => scope.codeIndexManager).toThrow("Code index workspace scope is not initialized")
+		scope.dispose()
+		expect(manager.dispose).toHaveBeenCalledExactlyOnceWith()
+	})
+
+	it("can dispose before dependency creation without constructing a manager", () => {
+		const scope = new CodeIndexWorkspaceScope("/workspace", makeUri("/workspace"), makeExtensionContext())
+		scope.dispose()
+		expect(() => scope.codeIndexManager).toThrow("Code index workspace scope is not initialized")
+		expect(CodeIndexManager).not.toHaveBeenCalled()
+	})
+
+	it("creates a fresh manager when initialized after disposal", () => {
+		const scope = new CodeIndexWorkspaceScope("/workspace", makeUri("/workspace"), makeExtensionContext())
+		scope.init()
+		const previous = scope.codeIndexManager
+		scope.dispose()
+		scope.init()
+		const current = scope.codeIndexManager
+		expect(current).not.toBe(previous)
+		expect(scope.codeIndexManager).toBe(current)
+		expect(CodeIndexManager).toHaveBeenCalledTimes(2)
+		expect(current.dispose).not.toHaveBeenCalled()
+		const calls = vi.mocked(CodeIndexManager).mock.calls
+		expect(CodeIndexStateManager).toHaveBeenCalledTimes(2)
+		expect(calls[1][3]).not.toBe(calls[0][3])
+		expect(scope["_stateManager"]).toBe(calls[1][3])
+	})
+
+	it("creates separate state managers for different workspace scopes", () => {
+		const context = makeExtensionContext()
+		const first = new CodeIndexWorkspaceScope("/first", makeUri("/first"), context)
+		const second = new CodeIndexWorkspaceScope("/second", makeUri("/second"), context)
+		first.init()
+		second.init()
+
+		const calls = vi.mocked(CodeIndexManager).mock.calls
+		expect(CodeIndexStateManager).toHaveBeenCalledTimes(2)
+		expect(calls[0][3]).toBe(vi.mocked(CodeIndexStateManager).mock.instances[0])
+		expect(calls[1][3]).toBe(vi.mocked(CodeIndexStateManager).mock.instances[1])
+		expect(calls[1][3]).not.toBe(calls[0][3])
+	})
+
+	it("clears its reference even when manager disposal throws", () => {
+		const scope = new CodeIndexWorkspaceScope("/workspace", makeUri("/workspace"), makeExtensionContext())
+		scope.init()
+		const manager = scope.codeIndexManager
+		const error = new Error("disposal failed")
+		vi.mocked(manager.dispose).mockImplementationOnce(() => {
+			throw error
+		})
+		expect(() => scope.dispose()).toThrow(error)
+		expect(scope["_stateManager"]).toBeUndefined()
+		expect(() => scope.codeIndexManager).toThrow("Code index workspace scope is not initialized")
+		scope.dispose()
+		expect(manager.dispose).toHaveBeenCalledTimes(1)
+	})
+
+	it("remains uninitialized when construction fails and permits retry", () => {
+		const scope = new CodeIndexWorkspaceScope("/workspace", makeUri("/workspace"), makeExtensionContext())
+		const error = new Error("construction failed")
+		vi.mocked(CodeIndexManager).mockImplementationOnce(function () {
+			throw error
+		})
+
+		expect(() => scope.init()).toThrow(error)
+		expect(() => scope.codeIndexManager).toThrow("Code index workspace scope is not initialized")
+		expect(scope.init()).toBeUndefined()
+		expect(scope.codeIndexManager).toBe(vi.mocked(CodeIndexManager).mock.results[1].value)
+		expect(CodeIndexManager).toHaveBeenCalledTimes(2)
+	})
+})
diff --git a/src/services/code-index/__tests__/config-manager.spec.ts b/src/services/code-index/__tests__/config-manager.spec.ts
index 71b6e79e61..9855f301cb 100644
--- a/src/services/code-index/__tests__/config-manager.spec.ts
+++ b/src/services/code-index/__tests__/config-manager.spec.ts
@@ -60,6 +60,10 @@ describe("CodeIndexConfigManager", () => {
 			expect(configManager.currentEmbedderProvider).toBe("openai")
 		})
 
+		it("returns the original context proxy", () => {
+			expect(configManager.getContextProxy()).toBe(mockContextProxy)
+		})
+
 		it("loads Bedrock as the embedder provider with its optional profile", () => {
 			mockContextProxy.getGlobalState.mockReturnValue({
 				codebaseIndexEnabled: true,
@@ -81,6 +85,34 @@ describe("CodeIndexConfigManager", () => {
 		})
 	})
 
+	describe("model dimension parsing", () => {
+		it.each([
+			{ raw: undefined, expected: undefined, warns: false },
+			{ raw: null, expected: undefined, warns: false },
+			{ raw: 1536, expected: 1536, warns: false },
+			{ raw: "768", expected: 768, warns: false },
+			{ raw: 0, expected: undefined, warns: true },
+			{ raw: -1, expected: undefined, warns: true },
+			{ raw: "invalid", expected: undefined, warns: true },
+			{ raw: NaN, expected: undefined, warns: true },
+		])("parses $raw with warning=$warns", async ({ raw, expected, warns }) => {
+			const warn = vi.spyOn(console, "warn").mockImplementation(() => {})
+			try {
+				mockContextProxy.getGlobalState.mockReturnValue({ codebaseIndexEmbedderModelDimension: raw })
+				const { currentConfig } = await configManager.loadConfiguration()
+				expect(currentConfig.modelDimension).toBe(expected)
+				expect(warn).toHaveBeenCalledTimes(warns ? 1 : 0)
+				if (warns) {
+					expect(warn).toHaveBeenCalledWith(
+						`Invalid codebaseIndexEmbedderModelDimension value: ${raw}. Must be a positive number.`,
+					)
+				}
+			} finally {
+				warn.mockRestore()
+			}
+		})
+	})
+
 	describe("isFeatureEnabled", () => {
 		it("should return false when codebaseIndexEnabled is false", async () => {
 			mockContextProxy.getGlobalState.mockReturnValue({
@@ -192,6 +224,7 @@ describe("CodeIndexConfigManager", () => {
 				qdrantUrl: "http://localhost:6333",
 				qdrantApiKey: "",
 				searchMinScore: 0.4,
+				searchMaxResults: 50,
 			})
 			expect(result.requiresRestart).toBe(false)
 		})
@@ -1553,6 +1586,59 @@ describe("CodeIndexConfigManager", () => {
 	})
 
 	describe("doesConfigChangeRequireRestart", () => {
+		it.each([
+			{ missing: "enabled", expected: true },
+			{ missing: "configured", expected: true },
+			{ missing: "embedderProvider", expected: false },
+		] as const)(
+			"defaults missing previous $missing when comparing a ready configuration",
+			async ({ missing, expected }) => {
+				mockContextProxy.getGlobalState.mockReturnValue({
+					codebaseIndexEnabled: true,
+					codebaseIndexEmbedderProvider: providerIdentifiers.openai,
+					codebaseIndexQdrantUrl: "http://localhost:6333",
+				})
+				setupSecretMocks({ codeIndexOpenAiKey: "test-key" })
+				configManager = new CodeIndexConfigManager(mockContextProxy)
+				const { configSnapshot } = await configManager.loadConfiguration()
+				const previous = { ...configSnapshot }
+				// Required in the type, but the comparison deliberately tolerates incomplete runtime snapshots.
+				Reflect.deleteProperty(previous, missing)
+
+				expect(configManager.doesConfigChangeRequireRestart(previous)).toBe(expected)
+			},
+		)
+
+		it("normalizes absent connection values on either side of a defensive comparison", () => {
+			const previous: PreviousConfigSnapshot = {
+				enabled: true,
+				configured: true,
+				embedderProvider: providerIdentifiers.openai,
+			}
+			// Normal loads fill every connection value; exercise the helper's defensive defaults directly.
+			expect(configManager["_hasConnectionSettingsChanged"](previous, { ...previous, openAiKey: "" })).toBe(false)
+			expect(configManager["_hasConnectionSettingsChanged"]({ ...previous, openAiKey: "" }, previous)).toBe(false)
+			expect(
+				configManager["_hasConnectionSettingsChanged"](previous, { ...previous, qdrantApiKey: "new-key" }),
+			).toBe(true)
+		})
+
+		it("normalizes missing optional snapshot credentials in the previous load result", async () => {
+			// The snapshot type permits absent credentials even though normal readers initialize them.
+			configManager["config"] = Object.freeze({
+				...configManager["config"],
+				openAiOptions: undefined,
+				qdrantApiKey: undefined,
+			})
+
+			const { configSnapshot, requiresRestart } = await configManager.loadConfiguration()
+
+			expect(configSnapshot.openAiKey).toBe("")
+			expect(configSnapshot.qdrantApiKey).toBe("")
+			expect(configSnapshot.configured).toBe(false)
+			expect(requiresRestart).toBe(false)
+		})
+
 		it("should return true when enabling the feature", async () => {
 			// Initial state: disabled
 			mockContextProxy.getGlobalState.mockReturnValue({
@@ -1773,6 +1859,69 @@ describe("CodeIndexConfigManager", () => {
 	})
 
 	describe("getConfig", () => {
+		it("publishes frozen configuration and options for every provider", async () => {
+			mockContextProxy.getGlobalState.mockReturnValue({
+				codebaseIndexEnabled: true,
+				codebaseIndexEmbedderProvider: providerIdentifiers.openai,
+				codebaseIndexQdrantUrl: "http://localhost:6333",
+				codebaseIndexOpenAiCompatibleBaseUrl: "https://example.com/v1",
+				codebaseIndexSearchMaxResults: 23,
+			})
+			mockContextProxy.getSecret.mockReturnValue("test-key")
+
+			const { currentConfig } = await configManager.loadConfiguration()
+			expect(currentConfig).toEqual(configManager.getConfig())
+			expect(currentConfig.searchMaxResults).toBe(23)
+			expect(Object.isFrozen(currentConfig)).toBe(true)
+			expect(Reflect.set(currentConfig, "modelId", "changed")).toBe(false)
+			for (const options of [
+				currentConfig.openAiOptions,
+				currentConfig.ollamaOptions,
+				currentConfig.openAiCompatibleOptions,
+				currentConfig.geminiOptions,
+				currentConfig.mistralOptions,
+				currentConfig.vercelAiGatewayOptions,
+				currentConfig.bedrockOptions,
+				currentConfig.openRouterOptions,
+			]) {
+				expect(options).toBeDefined()
+				if (!options) throw new Error("Expected provider options")
+				expect(Object.isFrozen(options)).toBe(true)
+				for (const key of Object.keys(options)) {
+					expect(Reflect.set(options, key, "changed")).toBe(false)
+				}
+			}
+			expect(configManager.getConfig()).toEqual(currentConfig)
+		})
+
+		it("preserves previously returned snapshots across reloads", async () => {
+			mockContextProxy.getSecret.mockReturnValue("old-key")
+			const { currentConfig: previous } = await configManager.loadConfiguration()
+			mockContextProxy.getSecret.mockReturnValue("new-key")
+			const { currentConfig: current, configSnapshot } = await configManager.loadConfiguration()
+
+			expect(previous.openAiOptions?.openAiNativeApiKey).toBe("old-key")
+			expect(current.openAiOptions?.openAiNativeApiKey).toBe("new-key")
+			expect(current.openAiOptions).not.toBe(previous.openAiOptions)
+			expect(configSnapshot.openAiKey).toBe("old-key")
+		})
+
+		it("keeps the current snapshot when building the next snapshot fails", async () => {
+			const previous = configManager.getConfig()
+			mockContextProxy.getGlobalState.mockReturnValue({
+				codebaseIndexEnabled: true,
+				codebaseIndexQdrantUrl: "http://changed:6333",
+				get codebaseIndexEmbedderModelDimension(): number {
+					throw new Error("Invalid stored dimension")
+				},
+			})
+
+			await expect(configManager.loadConfiguration()).rejects.toThrow("Invalid stored dimension")
+			expect(configManager.getConfig()).toEqual(previous)
+			expect(configManager.isFeatureEnabled).toBe(false)
+			expect(configManager.getConfig().openAiOptions).toBe(previous.openAiOptions)
+		})
+
 		it("should return the current configuration", () => {
 			mockContextProxy.getGlobalState.mockReturnValue({
 				codebaseIndexEnabled: true,
@@ -2240,6 +2389,32 @@ describe("CodeIndexConfigManager", () => {
 			expect(result.currentConfig.isConfigured).toBe(true)
 		})
 
+		it("keeps an explicitly empty Bedrock region unconfigured and restarts when restored", async () => {
+			const settings = {
+				codebaseIndexEnabled: true,
+				codebaseIndexQdrantUrl: "http://qdrant.local",
+				codebaseIndexEmbedderProvider: providerIdentifiers.bedrock,
+				codebaseIndexBedrockRegion: "",
+				codebaseIndexBedrockProfile: "test-profile",
+			}
+			mockContextProxy.getGlobalState.mockReturnValue(settings)
+			configManager = new CodeIndexConfigManager(mockContextProxy)
+
+			const unchanged = await configManager.loadConfiguration()
+			expect(unchanged.currentConfig.bedrockOptions).toBeUndefined()
+			expect(unchanged.currentConfig.isConfigured).toBe(false)
+			expect(unchanged.configSnapshot.bedrockRegion).toBe("")
+			expect(unchanged.configSnapshot.bedrockProfile).toBe("")
+			expect(unchanged.requiresRestart).toBe(false)
+
+			mockContextProxy.getGlobalState.mockReturnValue({ ...settings, codebaseIndexBedrockRegion: "eu-west-1" })
+			const restored = await configManager.loadConfiguration()
+			expect(restored.currentConfig.bedrockOptions).toEqual({ region: "eu-west-1", profile: "test-profile" })
+			expect(restored.currentConfig.isConfigured).toBe(true)
+			expect(restored.requiresRestart).toBe(true)
+			expect(unchanged.currentConfig.bedrockOptions).toBeUndefined()
+		})
+
 		it("should return false from isConfigured for Bedrock when the Qdrant URL is missing", () => {
 			mockContextProxy.getGlobalState.mockReturnValue({
 				codebaseIndexEnabled: true,
@@ -2288,17 +2463,14 @@ describe("CodeIndexConfigManager", () => {
 			// private field to a value outside the union.
 			mockContextProxy.getGlobalState.mockReturnValue({
 				codebaseIndexEnabled: true,
+				codebaseIndexQdrantUrl: "http://localhost:6333",
 			})
 			mockContextProxy.getSecret.mockReturnValue(undefined)
 
 			configManager = new CodeIndexConfigManager(mockContextProxy)
-			// The defensive `return false` is unreachable through the public API because
-			// EmbedderProvider is a closed union, so exercise it by forcing the private field
-			// to a value outside the union. `embedderProvider` is TypeScript `private`, not
-			// `#`-private, so a runtime property write reaches it. The double assertion is a
-			// last resort: the private field is not part of the public type surface, and
-			// `as any` is avoided to keep the file's no-explicit-any suppression budget flat.
-			;(configManager as unknown as Record<string, unknown>)["embedderProvider"] = "not-a-provider"
+			// Replace the snapshot with deliberately invalid runtime data to exercise
+			// the defensive branch without mutating the frozen production snapshot.
+			Reflect.set(configManager, "config", { ...configManager["config"], embedderProvider: "not-a-provider" })
 			expect(configManager.isConfigured()).toBe(false)
 		})
 	})
diff --git a/src/services/code-index/__tests__/orchestrator.spec.ts b/src/services/code-index/__tests__/orchestrator.spec.ts
index 86b0f94808..bad3d69be3 100644
--- a/src/services/code-index/__tests__/orchestrator.spec.ts
+++ b/src/services/code-index/__tests__/orchestrator.spec.ts
@@ -107,6 +107,72 @@ describe("CodeIndexOrchestrator - error path cleanup gating", () => {
 		}
 	})
 
+	it.each([false, true])(
+		"keeps watcher startup and completion after scanning (incremental: %s)",
+		async (incremental) => {
+			const events: string[] = []
+			vectorStore.initialize.mockResolvedValue(false)
+			vectorStore.hasIndexedData.mockResolvedValue(incremental)
+			vectorStore.markIndexingIncomplete.mockImplementation(async () => {
+				events.push("incomplete")
+			})
+			scanner.scanDirectory.mockImplementation(async () => {
+				events.push("scan")
+				return { stats: { processed: 0, skipped: 0 }, totalBlockCount: 0 }
+			})
+			fileWatcher.initialize.mockImplementation(async () => {
+				events.push("watcher")
+			})
+			vectorStore.markIndexingComplete.mockImplementation(async () => {
+				events.push("complete")
+			})
+			const orchestrator = new CodeIndexOrchestrator(
+				configManager,
+				stateManager,
+				workspacePath,
+				cacheManager,
+				vectorStore,
+				scanner,
+				fileWatcher,
+			)
+			await orchestrator.startIndexing()
+			expect(events).toEqual(["incomplete", "scan", "watcher", "complete"])
+			expect(orchestrator.state).toBe("Indexed")
+			expect(cacheManager.clearCacheFile).not.toHaveBeenCalled()
+			expect(vectorStore.clearCollection).not.toHaveBeenCalled()
+		},
+	)
+
+	it.each([false, true])(
+		"keeps returned cancellation cleanup in the owner (incremental: %s)",
+		async (incremental) => {
+			vectorStore.initialize.mockResolvedValue(false)
+			vectorStore.hasIndexedData.mockResolvedValue(incremental)
+			const orchestrator = new CodeIndexOrchestrator(
+				configManager,
+				stateManager,
+				workspacePath,
+				cacheManager,
+				vectorStore,
+				scanner,
+				fileWatcher,
+			)
+			scanner.scanDirectory.mockImplementation(async () => {
+				orchestrator.stopIndexing()
+				return { stats: { processed: 0, skipped: 0 }, totalBlockCount: 0 }
+			})
+			// Preserve the original normal-return path: a failed flush is retried by the catch handler.
+			cacheManager.flush.mockRejectedValueOnce(new Error("flush failed"))
+			await orchestrator.startIndexing()
+			expect(cacheManager.flush).toHaveBeenCalledTimes(2)
+			expect(orchestrator.state).toBe("Standby")
+			expect(fileWatcher.initialize).not.toHaveBeenCalled()
+			expect(vectorStore.markIndexingComplete).not.toHaveBeenCalled()
+			expect(vectorStore.clearCollection).not.toHaveBeenCalled()
+			expect(cacheManager.clearCacheFile).not.toHaveBeenCalled()
+		},
+	)
+
 	it("should not call clearCollection() or clear cache when initialize() fails (indexing not started)", async () => {
 		// Arrange: fail at initialize()
 		vectorStore.initialize.mockRejectedValue(new Error("Qdrant unreachable"))
diff --git a/src/services/code-index/__tests__/service-factory.spec.ts b/src/services/code-index/__tests__/service-factory.spec.ts
index d264d93fd5..bc1d619af2 100644
--- a/src/services/code-index/__tests__/service-factory.spec.ts
+++ b/src/services/code-index/__tests__/service-factory.spec.ts
@@ -1,5 +1,7 @@
 import type { MockedClass, MockedFunction } from "vitest"
 import { CodeIndexServiceFactory } from "../service-factory"
+import { EmbedderFactory } from "../embedders/embedder-factory"
+import { VectorStoreFactory } from "../vector-store/vector-store-factory"
 import { OpenAiEmbedder } from "../embedders/openai"
 import { CodeIndexOllamaEmbedder } from "../embedders/ollama"
 import { OpenAICompatibleEmbedder } from "../embedders/openai-compatible"
@@ -9,6 +11,7 @@ import { MistralEmbedder } from "../embedders/mistral"
 import { VercelAiGatewayEmbedder } from "../embedders/vercel-ai-gateway"
 import { BedrockEmbedder } from "../embedders/bedrock"
 import { OpenRouterEmbedder } from "../embedders/openrouter"
+import type { CodeIndexConfig } from "../interfaces/config"
 
 import { clearAllMocks } from "../../../test-utils/reset"
 
@@ -56,11 +59,15 @@ const mockGetModelDimension = getModelDimension as MockedFunction<typeof getMode
 
 describe("CodeIndexServiceFactory", () => {
 	let factory: CodeIndexServiceFactory
+	let embedderFactory: EmbedderFactory
+	let vectorStoreFactory: VectorStoreFactory
 	let mockConfigManager: any
 	let mockCacheManager: any
 
 	beforeEach(() => {
 		clearAllMocks()
+		embedderFactory = new EmbedderFactory()
+		vectorStoreFactory = new VectorStoreFactory()
 
 		mockConfigManager = {
 			getConfig: vitest.fn(),
@@ -72,6 +79,110 @@ describe("CodeIndexServiceFactory", () => {
 	})
 
 	describe("createEmbedder", () => {
+		it("uses the current configuration and creates a fresh embedder on every call", () => {
+			const config: CodeIndexConfig = {
+				isConfigured: true,
+				embedderProvider: providerIdentifiers.openai,
+				openAiOptions: { openAiNativeApiKey: "test-key" },
+				modelId: "first-model",
+			}
+			mockConfigManager.getConfig.mockReturnValueOnce(config).mockReturnValueOnce({
+				...config,
+				modelId: "second-model",
+			})
+
+			const first = embedderFactory.create(mockConfigManager.getConfig())
+			const second = embedderFactory.create(mockConfigManager.getConfig())
+
+			expect(first).not.toBe(second)
+			expect(MockedOpenAiEmbedder).toHaveBeenNthCalledWith(1, {
+				openAiNativeApiKey: "test-key",
+				openAiEmbeddingModelId: "first-model",
+			})
+			expect(MockedOpenAiEmbedder).toHaveBeenNthCalledWith(2, {
+				openAiNativeApiKey: "test-key",
+				openAiEmbeddingModelId: "second-model",
+			})
+		})
+
+		const requiredSettings = [
+			["openai", "openAiOptions", "openAiNativeApiKey", "openAiConfigMissing"],
+			["ollama", "ollamaOptions", "ollamaBaseUrl", "ollamaConfigMissing"],
+			["gemini", "geminiOptions", "apiKey", "geminiConfigMissing"],
+			["mistral", "mistralOptions", "apiKey", "mistralConfigMissing"],
+			["vercel-ai-gateway", "vercelAiGatewayOptions", "apiKey", "vercelAiGatewayConfigMissing"],
+			["bedrock", "bedrockOptions", "region", "bedrockConfigMissing"],
+			["openrouter", "openRouterOptions", "apiKey", "openRouterConfigMissing"],
+		] as const
+
+		it.each(requiredSettings)("rejects missing options for %s (%s.%s)", (provider, _options, _setting, error) => {
+			mockConfigManager.getConfig.mockReturnValue({ embedderProvider: provider })
+
+			expect(() => embedderFactory.create(mockConfigManager.getConfig())).toThrow(`serviceFactory.${error}`)
+		})
+
+		it.each(requiredSettings)("rejects empty %s setting %s.%s", (provider, options, setting, error) => {
+			mockConfigManager.getConfig.mockReturnValue({
+				embedderProvider: provider,
+				[options]: { baseUrl: "https://example.com", apiKey: "test-key", [setting]: "" },
+			})
+
+			expect(() => embedderFactory.create(mockConfigManager.getConfig())).toThrow(`serviceFactory.${error}`)
+		})
+
+		it.each(["constructor", "toString", "__proto__"])("rejects prototype key %s as a provider", (provider) => {
+			mockConfigManager.getConfig.mockReturnValue({ embedderProvider: provider })
+
+			expect(() => embedderFactory.create(mockConfigManager.getConfig())).toThrow(
+				"serviceFactory.invalidEmbedderType",
+			)
+		})
+
+		it("preserves OpenAI options and overrides the embedded model without mutating config", () => {
+			const openAiOptions = Object.freeze({
+				openAiNativeApiKey: "test-key",
+				openAiEmbeddingModelId: "old-model",
+				openAiBaseUrl: "https://example.com/v1",
+			})
+			const config: CodeIndexConfig = Object.freeze({
+				isConfigured: true,
+				embedderProvider: providerIdentifiers.openai,
+				modelId: "new-model",
+				openAiOptions,
+			})
+			mockConfigManager.getConfig.mockReturnValue(config)
+
+			const embedder = embedderFactory.create(mockConfigManager.getConfig())
+
+			expect(embedder).toBeInstanceOf(OpenAiEmbedder)
+			expect(MockedOpenAiEmbedder).toHaveBeenCalledWith({
+				...openAiOptions,
+				openAiEmbeddingModelId: "new-model",
+			})
+			expect(openAiOptions.openAiEmbeddingModelId).toBe("old-model")
+		})
+
+		it("preserves Ollama options and overrides the embedded model without mutating config", () => {
+			const ollamaOptions = Object.freeze({
+				ollamaBaseUrl: "http://localhost:11434",
+				ollamaModelId: "old-model",
+				ollamaApiKey: "test-key",
+			})
+			const config: CodeIndexConfig = Object.freeze({
+				isConfigured: true,
+				embedderProvider: providerIdentifiers.ollama,
+				modelId: "new-model",
+				ollamaOptions,
+			})
+			mockConfigManager.getConfig.mockReturnValue(config)
+
+			const embedder = embedderFactory.create(mockConfigManager.getConfig())
+
+			expect(embedder).toBeInstanceOf(CodeIndexOllamaEmbedder)
+			expect(MockedCodeIndexOllamaEmbedder).toHaveBeenCalledWith({ ...ollamaOptions, ollamaModelId: "new-model" })
+			expect(ollamaOptions.ollamaModelId).toBe("old-model")
+		})
+
 		it("should pass model ID to OpenAI embedder when using OpenAI provider", () => {
 			// Arrange
 			const testModelId = "text-embedding-3-large"
@@ -85,7 +196,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig as any)
 
 			// Act
-			factory.createEmbedder()
+			embedderFactory.create(mockConfigManager.getConfig())
 
 			// Assert
 			expect(MockedOpenAiEmbedder).toHaveBeenCalledWith({
@@ -107,7 +218,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig as any)
 
 			// Act
-			factory.createEmbedder()
+			embedderFactory.create(mockConfigManager.getConfig())
 
 			// Assert
 			expect(MockedCodeIndexOllamaEmbedder).toHaveBeenCalledWith({
@@ -128,7 +239,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig as any)
 
 			// Act
-			factory.createEmbedder()
+			embedderFactory.create(mockConfigManager.getConfig())
 
 			// Assert
 			expect(MockedOpenAiEmbedder).toHaveBeenCalledWith({
@@ -149,7 +260,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig as any)
 
 			// Act
-			factory.createEmbedder()
+			embedderFactory.create(mockConfigManager.getConfig())
 
 			// Assert
 			expect(MockedCodeIndexOllamaEmbedder).toHaveBeenCalledWith({
@@ -170,7 +281,9 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig as any)
 
 			// Act & Assert
-			expect(() => factory.createEmbedder()).toThrow("serviceFactory.openAiConfigMissing")
+			expect(() => embedderFactory.create(mockConfigManager.getConfig())).toThrow(
+				"serviceFactory.openAiConfigMissing",
+			)
 		})
 
 		it("should throw error when Ollama base URL is missing", () => {
@@ -185,7 +298,9 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig as any)
 
 			// Act & Assert
-			expect(() => factory.createEmbedder()).toThrow("serviceFactory.ollamaConfigMissing")
+			expect(() => embedderFactory.create(mockConfigManager.getConfig())).toThrow(
+				"serviceFactory.ollamaConfigMissing",
+			)
 		})
 
 		it("should pass model ID to OpenAI Compatible embedder when using OpenAI Compatible provider", () => {
@@ -202,7 +317,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig as any)
 
 			// Act
-			factory.createEmbedder()
+			embedderFactory.create(mockConfigManager.getConfig())
 
 			// Assert
 			expect(MockedOpenAICompatibleEmbedder).toHaveBeenCalledWith(
@@ -225,7 +340,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig as any)
 
 			// Act
-			factory.createEmbedder()
+			embedderFactory.create(mockConfigManager.getConfig())
 
 			// Assert
 			expect(MockedOpenAICompatibleEmbedder).toHaveBeenCalledWith(
@@ -235,36 +350,36 @@ describe("CodeIndexServiceFactory", () => {
 			)
 		})
 
-		it("should throw error when OpenAI Compatible base URL is missing", () => {
+		it.each([undefined, ""])("rejects missing or empty OpenAI Compatible base URL: %s", (baseUrl) => {
 			// Arrange
 			const testConfig = {
 				embedderProvider: "openai-compatible",
 				modelId: "text-embedding-3-large",
 				openAiCompatibleOptions: {
-					baseUrl: undefined,
+					baseUrl,
 					apiKey: "test-api-key",
 				},
 			}
 			mockConfigManager.getConfig.mockReturnValue(testConfig as any)
 
 			// Act & Assert
-			expect(() => factory.createEmbedder()).toThrow("serviceFactory.openAiCompatibleConfigMissing")
+			expect(() => embedderFactory.create(mockConfigManager.getConfig())).toThrow("validation.baseUrlRequired")
 		})
 
-		it("should throw error when OpenAI Compatible API key is missing", () => {
+		it.each([undefined, ""])("rejects missing or empty OpenAI Compatible API key: %s", (apiKey) => {
 			// Arrange
 			const testConfig = {
 				embedderProvider: "openai-compatible",
 				modelId: "text-embedding-3-large",
 				openAiCompatibleOptions: {
 					baseUrl: "https://api.example.com/v1",
-					apiKey: undefined,
+					apiKey,
 				},
 			}
 			mockConfigManager.getConfig.mockReturnValue(testConfig as any)
 
 			// Act & Assert
-			expect(() => factory.createEmbedder()).toThrow("serviceFactory.openAiCompatibleConfigMissing")
+			expect(() => embedderFactory.create(mockConfigManager.getConfig())).toThrow("validation.apiKeyRequired")
 		})
 
 		it("should throw error when OpenAI Compatible options are missing", () => {
@@ -277,7 +392,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig as any)
 
 			// Act & Assert
-			expect(() => factory.createEmbedder()).toThrow("serviceFactory.openAiCompatibleConfigMissing")
+			expect(() => embedderFactory.create(mockConfigManager.getConfig())).toThrow("validation.baseUrlRequired")
 		})
 
 		it("should create GeminiEmbedder with default model when no modelId specified", () => {
@@ -291,7 +406,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig as any)
 
 			// Act
-			factory.createEmbedder()
+			embedderFactory.create(mockConfigManager.getConfig())
 
 			// Assert
 			expect(MockedGeminiEmbedder).toHaveBeenCalledWith("test-gemini-api-key", undefined)
@@ -309,7 +424,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig as any)
 
 			// Act
-			factory.createEmbedder()
+			embedderFactory.create(mockConfigManager.getConfig())
 
 			// Assert
 			expect(MockedGeminiEmbedder).toHaveBeenCalledWith("test-gemini-api-key", "gemini-embedding-001")
@@ -328,7 +443,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig as any)
 
 			// Act
-			factory.createEmbedder()
+			embedderFactory.create(mockConfigManager.getConfig())
 
 			// Assert - factory passes the original modelId; GeminiEmbedder migrates it internally
 			expect(MockedGeminiEmbedder).toHaveBeenCalledWith("test-gemini-api-key", "text-embedding-004")
@@ -345,7 +460,9 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig as any)
 
 			// Act & Assert
-			expect(() => factory.createEmbedder()).toThrow("serviceFactory.geminiConfigMissing")
+			expect(() => embedderFactory.create(mockConfigManager.getConfig())).toThrow(
+				"serviceFactory.geminiConfigMissing",
+			)
 		})
 
 		it("should throw error when Gemini options are missing", () => {
@@ -357,7 +474,9 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig as any)
 
 			// Act & Assert
-			expect(() => factory.createEmbedder()).toThrow("serviceFactory.geminiConfigMissing")
+			expect(() => embedderFactory.create(mockConfigManager.getConfig())).toThrow(
+				"serviceFactory.geminiConfigMissing",
+			)
 		})
 
 		it("should pass model ID to Mistral embedder when using Mistral provider", () => {
@@ -373,7 +492,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig)
 
 			// Act
-			factory.createEmbedder()
+			embedderFactory.create(mockConfigManager.getConfig())
 
 			// Assert
 			expect(MockedMistralEmbedder).toHaveBeenCalledWith("test-mistral-key", testModelId)
@@ -391,7 +510,9 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig)
 
 			// Act & Assert
-			expect(() => factory.createEmbedder()).toThrow("serviceFactory.mistralConfigMissing")
+			expect(() => embedderFactory.create(mockConfigManager.getConfig())).toThrow(
+				"serviceFactory.mistralConfigMissing",
+			)
 		})
 
 		it("should handle undefined model ID for Mistral embedder", () => {
@@ -406,7 +527,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig)
 
 			// Act
-			factory.createEmbedder()
+			embedderFactory.create(mockConfigManager.getConfig())
 
 			// Assert — modelId omitted so the embedder selects its documented default model.
 			expect(MockedMistralEmbedder).toHaveBeenCalledWith("test-mistral-key", undefined)
@@ -425,7 +546,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig)
 
 			// Act
-			factory.createEmbedder()
+			embedderFactory.create(mockConfigManager.getConfig())
 
 			// Assert
 			expect(MockedVercelAiGatewayEmbedder).toHaveBeenCalledWith("test-vercel-key", testModelId)
@@ -443,7 +564,9 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig)
 
 			// Act & Assert
-			expect(() => factory.createEmbedder()).toThrow("serviceFactory.vercelAiGatewayConfigMissing")
+			expect(() => embedderFactory.create(mockConfigManager.getConfig())).toThrow(
+				"serviceFactory.vercelAiGatewayConfigMissing",
+			)
 		})
 
 		it("should handle undefined model ID for Vercel AI Gateway embedder", () => {
@@ -458,7 +581,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig)
 
 			// Act
-			factory.createEmbedder()
+			embedderFactory.create(mockConfigManager.getConfig())
 
 			// Assert — modelId omitted so the embedder selects its documented default model.
 			expect(MockedVercelAiGatewayEmbedder).toHaveBeenCalledWith("test-vercel-key", undefined)
@@ -478,7 +601,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig)
 
 			// Act
-			factory.createEmbedder()
+			embedderFactory.create(mockConfigManager.getConfig())
 
 			// Assert
 			expect(MockedBedrockEmbedder).toHaveBeenCalledWith("eu-west-1", "test-profile", testModelId)
@@ -497,7 +620,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig)
 
 			// Act
-			factory.createEmbedder()
+			embedderFactory.create(mockConfigManager.getConfig())
 
 			// Assert — profile omitted so the embedder falls back to the default credential chain.
 			expect(MockedBedrockEmbedder).toHaveBeenCalledWith("us-east-1", undefined, testModelId)
@@ -516,7 +639,9 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig)
 
 			// Act & Assert
-			expect(() => factory.createEmbedder()).toThrow("serviceFactory.bedrockConfigMissing")
+			expect(() => embedderFactory.create(mockConfigManager.getConfig())).toThrow(
+				"serviceFactory.bedrockConfigMissing",
+			)
 		})
 
 		it("should handle undefined model ID for Bedrock embedder", () => {
@@ -532,7 +657,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig)
 
 			// Act
-			factory.createEmbedder()
+			embedderFactory.create(mockConfigManager.getConfig())
 
 			// Assert — modelId omitted so the embedder selects its documented default model.
 			expect(MockedBedrockEmbedder).toHaveBeenCalledWith("us-east-1", "test-profile", undefined)
@@ -552,7 +677,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig)
 
 			// Act
-			factory.createEmbedder()
+			embedderFactory.create(mockConfigManager.getConfig())
 
 			// Assert
 			expect(MockedOpenRouterEmbedder).toHaveBeenCalledWith(
@@ -576,7 +701,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig)
 
 			// Act
-			factory.createEmbedder()
+			embedderFactory.create(mockConfigManager.getConfig())
 
 			// Assert — specificProvider omitted so the embedder routes to its default provider.
 			expect(MockedOpenRouterEmbedder).toHaveBeenCalledWith(
@@ -599,7 +724,9 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig)
 
 			// Act & Assert
-			expect(() => factory.createEmbedder()).toThrow("serviceFactory.openRouterConfigMissing")
+			expect(() => embedderFactory.create(mockConfigManager.getConfig())).toThrow(
+				"serviceFactory.openRouterConfigMissing",
+			)
 		})
 
 		it("should handle undefined model ID for OpenRouter embedder", () => {
@@ -615,7 +742,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig)
 
 			// Act
-			factory.createEmbedder()
+			embedderFactory.create(mockConfigManager.getConfig())
 
 			// Assert — modelId omitted so the embedder selects its documented default model.
 			expect(MockedOpenRouterEmbedder).toHaveBeenCalledWith("test-openrouter-key", undefined, undefined, "openai")
@@ -630,7 +757,9 @@ describe("CodeIndexServiceFactory", () => {
 			mockConfigManager.getConfig.mockReturnValue(testConfig as any)
 
 			// Act & Assert
-			expect(() => factory.createEmbedder()).toThrow("serviceFactory.invalidEmbedderType")
+			expect(() => embedderFactory.create(mockConfigManager.getConfig())).toThrow(
+				"serviceFactory.invalidEmbedderType",
+			)
 		})
 
 		it("should throw when provider is semble (semble handles its own embedding)", () => {
@@ -639,7 +768,7 @@ describe("CodeIndexServiceFactory", () => {
 			}
 			mockConfigManager.getConfig.mockReturnValue(testConfig as any)
 
-			expect(() => factory.createEmbedder()).toThrow(
+			expect(() => embedderFactory.create(mockConfigManager.getConfig())).toThrow(
 				"Semble provider handles its own embedding. Do not call createEmbedder() for semble",
 			)
 		})
@@ -664,7 +793,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockGetModelDimension.mockReturnValue(3072)
 
 			// Act
-			factory.createVectorStore()
+			vectorStoreFactory.create(mockConfigManager.getConfig(), "/test/workspace")
 
 			// Assert
 			expect(mockGetModelDimension).toHaveBeenCalledWith("openai", testModelId)
@@ -689,7 +818,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockGetModelDimension.mockReturnValue(768)
 
 			// Act
-			factory.createVectorStore()
+			vectorStoreFactory.create(mockConfigManager.getConfig(), "/test/workspace")
 
 			// Assert
 			expect(mockGetModelDimension).toHaveBeenCalledWith("ollama", testModelId)
@@ -714,7 +843,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockGetModelDimension.mockReturnValue(3072)
 
 			// Act
-			factory.createVectorStore()
+			vectorStoreFactory.create(mockConfigManager.getConfig(), "/test/workspace")
 
 			// Assert
 			expect(mockGetModelDimension).toHaveBeenCalledWith("openai-compatible", testModelId)
@@ -746,7 +875,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockGetModelDimension.mockReturnValue(modelDimension) // This should be used
 
 			// Act
-			factory.createVectorStore()
+			vectorStoreFactory.create(mockConfigManager.getConfig(), "/test/workspace")
 
 			// Assert
 			expect(mockGetModelDimension).toHaveBeenCalledWith("openai-compatible", testModelId)
@@ -777,7 +906,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockGetModelDimension.mockReturnValue(undefined) // Model has no built-in dimension
 
 			// Act
-			factory.createVectorStore()
+			vectorStoreFactory.create(mockConfigManager.getConfig(), "/test/workspace")
 
 			// Assert
 			expect(mockGetModelDimension).toHaveBeenCalledWith("openai-compatible", testModelId)
@@ -806,7 +935,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockGetModelDimension.mockReturnValue(768)
 
 			// Act
-			factory.createVectorStore()
+			vectorStoreFactory.create(mockConfigManager.getConfig(), "/test/workspace")
 
 			// Assert
 			expect(mockGetModelDimension).toHaveBeenCalledWith("openai-compatible", testModelId)
@@ -836,7 +965,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockGetModelDimension.mockReturnValue(undefined)
 
 			// Act & Assert
-			expect(() => factory.createVectorStore()).toThrow(
+			expect(() => vectorStoreFactory.create(mockConfigManager.getConfig(), "/test/workspace")).toThrow(
 				"serviceFactory.vectorDimensionNotDeterminedOpenAiCompatible",
 			)
 		})
@@ -858,7 +987,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockGetModelDimension.mockReturnValue(undefined)
 
 			// Act & Assert
-			expect(() => factory.createVectorStore()).toThrow(
+			expect(() => vectorStoreFactory.create(mockConfigManager.getConfig(), "/test/workspace")).toThrow(
 				"serviceFactory.vectorDimensionNotDeterminedOpenAiCompatible",
 			)
 		})
@@ -875,7 +1004,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockGetModelDimension.mockReturnValue(3072)
 
 			// Act
-			factory.createVectorStore()
+			vectorStoreFactory.create(mockConfigManager.getConfig(), "/test/workspace")
 
 			// Assert
 			expect(mockGetModelDimension).toHaveBeenCalledWith("gemini", "gemini-embedding-001")
@@ -899,7 +1028,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockGetModelDimension.mockReturnValue(3072)
 
 			// Act
-			factory.createVectorStore()
+			vectorStoreFactory.create(mockConfigManager.getConfig(), "/test/workspace")
 
 			// Assert
 			expect(mockGetDefaultModelId).toHaveBeenCalledWith("gemini")
@@ -924,7 +1053,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockGetModelDimension.mockReturnValue(1536)
 
 			// Act
-			factory.createVectorStore()
+			vectorStoreFactory.create(mockConfigManager.getConfig(), "/test/workspace")
 
 			// Assert
 			expect(mockGetModelDimension).toHaveBeenCalledWith("openai", "default-model")
@@ -948,7 +1077,9 @@ describe("CodeIndexServiceFactory", () => {
 			mockGetModelDimension.mockReturnValue(undefined)
 
 			// Act & Assert
-			expect(() => factory.createVectorStore()).toThrow("serviceFactory.vectorDimensionNotDetermined")
+			expect(() => vectorStoreFactory.create(mockConfigManager.getConfig(), "/test/workspace")).toThrow(
+				"serviceFactory.vectorDimensionNotDetermined",
+			)
 		})
 
 		it("should throw error when Qdrant URL is missing", () => {
@@ -963,7 +1094,9 @@ describe("CodeIndexServiceFactory", () => {
 			mockGetModelDimension.mockReturnValue(1536)
 
 			// Act & Assert
-			expect(() => factory.createVectorStore()).toThrow("serviceFactory.qdrantUrlMissing")
+			expect(() => vectorStoreFactory.create(mockConfigManager.getConfig(), "/test/workspace")).toThrow(
+				"serviceFactory.qdrantUrlMissing",
+			)
 		})
 
 		it("should throw when provider is semble (semble handles its own vector storage)", () => {
@@ -972,7 +1105,7 @@ describe("CodeIndexServiceFactory", () => {
 			}
 			mockConfigManager.getConfig.mockReturnValue(testConfig as any)
 
-			expect(() => factory.createVectorStore()).toThrow(
+			expect(() => vectorStoreFactory.create(mockConfigManager.getConfig(), "/test/workspace")).toThrow(
 				"Semble provider handles its own vector storage. Do not call createVectorStore() for semble",
 			)
 		})
@@ -1003,7 +1136,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockEmbedderInstance.validateConfiguration.mockResolvedValue({ valid: true })
 
 			// Act
-			const embedder = factory.createEmbedder()
+			const embedder = embedderFactory.create(mockConfigManager.getConfig())
 			const result = await factory.validateEmbedder(embedder)
 
 			// Assert
@@ -1030,7 +1163,7 @@ describe("CodeIndexServiceFactory", () => {
 			})
 
 			// Act
-			const embedder = factory.createEmbedder()
+			const embedder = embedderFactory.create(mockConfigManager.getConfig())
 			const result = await factory.validateEmbedder(embedder)
 
 			// Assert
@@ -1056,7 +1189,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockEmbedderInstance.validateConfiguration.mockResolvedValue({ valid: true })
 
 			// Act
-			const embedder = factory.createEmbedder()
+			const embedder = embedderFactory.create(mockConfigManager.getConfig())
 			const result = await factory.validateEmbedder(embedder)
 
 			// Assert
@@ -1081,7 +1214,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockEmbedderInstance.validateConfiguration.mockResolvedValue({ valid: true })
 
 			// Act
-			const embedder = factory.createEmbedder()
+			const embedder = embedderFactory.create(mockConfigManager.getConfig())
 			const result = await factory.validateEmbedder(embedder)
 
 			// Assert
@@ -1104,7 +1237,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockEmbedderInstance.validateConfiguration.mockResolvedValue({ valid: true })
 
 			// Act
-			const embedder = factory.createEmbedder()
+			const embedder = embedderFactory.create(mockConfigManager.getConfig())
 			const result = await factory.validateEmbedder(embedder)
 
 			// Assert
@@ -1129,7 +1262,7 @@ describe("CodeIndexServiceFactory", () => {
 			mockEmbedderInstance.validateConfiguration.mockRejectedValue(networkError)
 
 			// Act
-			const embedder = factory.createEmbedder()
+			const embedder = embedderFactory.create(mockConfigManager.getConfig())
 			const result = await factory.validateEmbedder(embedder)
 
 			// Assert
@@ -1154,7 +1287,7 @@ describe("CodeIndexServiceFactory", () => {
 			// Act & Assert
 			// This should throw when trying to create the embedder
 			await expect(async () => {
-				const embedder = factory.createEmbedder()
+				const embedder = embedderFactory.create(mockConfigManager.getConfig())
 				await factory.validateEmbedder(embedder)
 			}).rejects.toThrow("serviceFactory.openAiConfigMissing")
 		})
@@ -1169,7 +1302,9 @@ describe("CodeIndexServiceFactory", () => {
 
 			// Act & Assert
 			// This should throw when trying to create the embedder
-			expect(() => factory.createEmbedder()).toThrow("serviceFactory.invalidEmbedderType")
+			expect(() => embedderFactory.create(mockConfigManager.getConfig())).toThrow(
+				"serviceFactory.invalidEmbedderType",
+			)
 		})
 	})
 })
diff --git a/src/services/code-index/__tests__/workspace-indexing-enablement-manager.spec.ts b/src/services/code-index/__tests__/workspace-indexing-enablement-manager.spec.ts
new file mode 100644
index 0000000000..838fffdc6e
--- /dev/null
+++ b/src/services/code-index/__tests__/workspace-indexing-enablement-manager.spec.ts
@@ -0,0 +1,103 @@
+import type { CodeIndexManager } from "../manager"
+import { ContextProxy } from "../../../core/config/ContextProxy"
+import { makeExtensionContext } from "../../../test-utils/vscode"
+import { WorkspaceIndexingEnablementManager } from "../workspace-indexing-enablement-manager"
+
+describe("WorkspaceIndexingEnablementManager", () => {
+	const setup = () => {
+		const manager = {
+			setWorkspaceEnabled: vi.fn().mockResolvedValue(undefined),
+			isFeatureEnabled: true,
+			isFeatureConfigured: true,
+			initialize: vi.fn().mockResolvedValue({ requiresRestart: false }),
+			startIndexing: vi.fn().mockResolvedValue(undefined),
+			stopIndexing: vi.fn(),
+			getCurrentStatus: vi.fn<CodeIndexManager["getCurrentStatus"]>().mockReturnValue({
+				systemStatus: "Standby",
+				message: "Ready",
+				processedItems: 0,
+				totalItems: 0,
+				currentItemUnit: "blocks",
+				workspacePath: "/workspace",
+				workspaceEnabled: true,
+				autoEnableDefault: false,
+			}),
+		}
+		return {
+			manager,
+			indexing: new WorkspaceIndexingEnablementManager(manager),
+			provider: {
+				contextProxy: new ContextProxy(makeExtensionContext()),
+				log: vi.fn(),
+				postMessageToWebview: vi.fn().mockResolvedValue(undefined),
+			},
+		}
+	}
+
+	it("persists enablement, initializes and starts in order without awaiting indexing", async () => {
+		const { manager, indexing, provider } = setup()
+		manager.startIndexing.mockReturnValue(new Promise<void>(() => {}))
+		await indexing.setEnabled(true, provider)
+		expect(manager.setWorkspaceEnabled).toHaveBeenCalledWith(true)
+		expect(manager.initialize).toHaveBeenCalledWith(provider.contextProxy)
+		expect(manager.setWorkspaceEnabled).toHaveBeenCalledBefore(manager.initialize)
+		expect(manager.initialize).toHaveBeenCalledBefore(manager.startIndexing)
+		expect(manager.stopIndexing).not.toHaveBeenCalled()
+	})
+
+	it("persists disablement before stopping", async () => {
+		const { manager, indexing, provider } = setup()
+		await indexing.setEnabled(false, provider)
+		expect(manager.setWorkspaceEnabled).toHaveBeenCalledWith(false)
+		expect(manager.setWorkspaceEnabled).toHaveBeenCalledBefore(manager.stopIndexing)
+		expect(manager.stopIndexing).toHaveBeenCalledOnce()
+		expect(manager.initialize).not.toHaveBeenCalled()
+		expect(manager.startIndexing).not.toHaveBeenCalled()
+	})
+
+	it.each(["isFeatureEnabled", "isFeatureConfigured"] as const)("does not start when %s is false", async (flag) => {
+		const { manager, indexing, provider } = setup()
+		manager[flag] = false
+		await indexing.setEnabled(true, provider)
+		expect(manager.setWorkspaceEnabled).toHaveBeenCalledWith(true)
+		expect(manager.initialize).not.toHaveBeenCalled()
+		expect(manager.startIndexing).not.toHaveBeenCalled()
+		expect(manager.stopIndexing).not.toHaveBeenCalled()
+	})
+
+	it("logs background indexing failures", async () => {
+		const { manager, indexing, provider } = setup()
+		manager.startIndexing.mockRejectedValue(new Error("failed"))
+		await expect(indexing.setEnabled(true, provider)).resolves.toBeUndefined()
+		expect(provider.log).toHaveBeenCalledWith("Indexing error: Error: failed")
+	})
+
+	it.each([true, false])("publishes the current status after setting enabled=%s", async (enabled) => {
+		const { manager, indexing, provider } = setup()
+		await indexing.setEnabled(enabled, provider)
+		expect(provider.postMessageToWebview).toHaveBeenCalledExactlyOnceWith({
+			type: "indexingStatusUpdate",
+			values: manager.getCurrentStatus.mock.results[0].value,
+		})
+		expect(enabled ? manager.startIndexing : manager.stopIndexing).toHaveBeenCalledBefore(manager.getCurrentStatus)
+	})
+
+	it("propagates status publication failures", async () => {
+		const { indexing, provider } = setup()
+		const error = new Error("post failed")
+		provider.postMessageToWebview.mockRejectedValue(error)
+		await expect(indexing.setEnabled(false, provider)).rejects.toBe(error)
+	})
+
+	it.each(["setWorkspaceEnabled", "initialize"] as const)(
+		"propagates %s failures without starting",
+		async (method) => {
+			const { manager, indexing, provider } = setup()
+			const error = new Error("failed")
+			manager[method].mockRejectedValue(error)
+			await expect(indexing.setEnabled(true, provider)).rejects.toBe(error)
+			expect(manager.startIndexing).not.toHaveBeenCalled()
+			expect(provider.postMessageToWebview).not.toHaveBeenCalled()
+		},
+	)
+})
diff --git a/src/services/code-index/code-index-manager-registry.ts b/src/services/code-index/code-index-manager-registry.ts
index 635ec62647..4a7ecc1f53 100644
--- a/src/services/code-index/code-index-manager-registry.ts
+++ b/src/services/code-index/code-index-manager-registry.ts
@@ -1,38 +1,55 @@
 import * as vscode from "vscode"
-import { CodeIndexManager } from "./manager"
+import type { CodeIndexManager } from "./manager"
+import { CodeIndexWorkspaceScope } from "./code-index-workspace-scope"
 
-/** Resolves workspaces and owns their cached CodeIndexManager instances. */
+/** Owns workspace scopes while preserving the manager-facing API. */
 export class CodeIndexManagerRegistry {
-	private static instances = new Map<string, CodeIndexManager>()
+	private static codeIndexWorkspaceScopes = new Map<string, CodeIndexWorkspaceScope>()
 
 	public static getOrCreate(context: vscode.ExtensionContext, workspacePath?: string): CodeIndexManager | undefined {
+		return this.getOrCreateScope(context, workspacePath)?.codeIndexManager
+	}
+
+	/** Returns the complete, initialized service scope for the resolved workspace. */
+	public static getOrCreateScope(
+		context: vscode.ExtensionContext,
+		workspacePath?: string,
+	): CodeIndexWorkspaceScope | undefined {
 		const folder = this.resolveWorkspaceFolder(workspacePath)
 		const resolvedPath = workspacePath || folder?.uri.fsPath
 		if (!resolvedPath) {
 			return undefined
 		}
 
-		const existing = this.instances.get(resolvedPath)
+		const existing = this.codeIndexWorkspaceScopes.get(resolvedPath)
 		if (existing) {
 			return existing
 		}
 
 		// Preserve real workspace URIs, including remote schemes and authorities.
 		const folderUri = folder?.uri ?? vscode.Uri.file(resolvedPath)
-		const manager = new CodeIndexManager(resolvedPath, folderUri, context)
-		this.instances.set(resolvedPath, manager)
-		return manager
+		const codeIndexWorkspaceScope = new CodeIndexWorkspaceScope(resolvedPath, folderUri, context)
+		codeIndexWorkspaceScope.init()
+		this.codeIndexWorkspaceScopes.set(resolvedPath, codeIndexWorkspaceScope)
+		return codeIndexWorkspaceScope
 	}
 
 	public static getAllInstances(): CodeIndexManager[] {
-		return Array.from(this.instances.values())
+		return Array.from(this.codeIndexWorkspaceScopes.values(), (scope) => scope.codeIndexManager)
 	}
 
 	public static disposeAll(): void {
-		for (const instance of this.instances.values()) {
-			instance.dispose()
+		for (const [workspacePath, codeIndexWorkspaceScope] of this.codeIndexWorkspaceScopes) {
+			try {
+				codeIndexWorkspaceScope.dispose()
+			} catch (error) {
+				console.error(
+					`[CodeIndexManagerRegistry] Failed to dispose workspace scope for ${workspacePath}:`,
+					error,
+				)
+			}
 		}
-		this.instances.clear()
+		this.codeIndexWorkspaceScopes.clear()
 	}
 
 	private static resolveWorkspaceFolder(workspacePath?: string): vscode.WorkspaceFolder | undefined {
diff --git a/src/services/code-index/code-index-scan-executor.ts b/src/services/code-index/code-index-scan-executor.ts
new file mode 100644
index 0000000000..2ff55454d9
--- /dev/null
+++ b/src/services/code-index/code-index-scan-executor.ts
@@ -0,0 +1,101 @@
+import type { IDirectoryScanner, IVectorStore } from "./interfaces"
+import type { CodeIndexStateManager } from "./state-manager"
+import { t } from "../../i18n"
+
+/** Executes scans; cancellation cleanup, watcher startup and completion remain with the orchestrator. */
+export class CodeIndexScanExecutor {
+	constructor(
+		private readonly workspacePath: string,
+		private readonly scanner: IDirectoryScanner,
+		private readonly vectorStore: Pick<IVectorStore, "markIndexingIncomplete">,
+		private readonly stateManager: Pick<CodeIndexStateManager, "setSystemState" | "reportBlockIndexingProgress">,
+	) {}
+
+	/** Returns false when the scanner returns after cancellation, preserving the owner's normal-return path. */
+	async runIncrementalScan(signal: AbortSignal): Promise<boolean> {
+		console.log(
+			"[CodeIndexOrchestrator] Collection already has indexed data. Running incremental scan for new/changed files...",
+		)
+		this.stateManager.setSystemState("Indexing", "Checking for new or modified files...")
+		const summary = await this.scanWorkspace(signal, "incremental")
+		if (!summary) return false
+
+		// Preserve the existing incremental policy: reported batch errors do not prevent completion.
+		if (summary.found > 0) {
+			console.log(
+				`[CodeIndexOrchestrator] Incremental scan completed: ${summary.indexed} blocks indexed from new/changed files`,
+			)
+		} else {
+			console.log("[CodeIndexOrchestrator] No new or changed files found")
+		}
+		return true
+	}
+
+	/** Returns false on returned cancellation; scanner rejections propagate unchanged. */
+	async runFullScan(signal: AbortSignal): Promise<boolean> {
+		this.stateManager.setSystemState("Indexing", "Services ready. Starting workspace scan...")
+		const summary = await this.scanWorkspace(signal, "full")
+		if (!summary) return false
+		this.validateFullScan(summary.indexed, summary.found, summary.batchErrors)
+		return true
+	}
+
+	private async scanWorkspace(
+		signal: AbortSignal,
+		kind: "full" | "incremental",
+	): Promise<{ indexed: number; found: number; batchErrors: Error[] } | undefined> {
+		await this.vectorStore.markIndexingIncomplete()
+		let indexed = 0
+		let found = 0
+		const batchErrors: Error[] = []
+		const result = await this.scanner.scanDirectory(
+			this.workspacePath,
+			(batchError: Error) => {
+				console.error(
+					`[CodeIndexOrchestrator] Error during ${kind === "full" ? "initial" : "incremental"} scan batch: ${batchError.message}`,
+					batchError,
+				)
+				batchErrors.push(batchError)
+			},
+			(count: number) => {
+				indexed += count
+				this.stateManager.reportBlockIndexingProgress(indexed, found)
+			},
+			(count: number) => {
+				found += count
+				this.stateManager.reportBlockIndexingProgress(indexed, found)
+			},
+			signal,
+		)
+
+		// Cancellation precedes missing-result checks and validation, just as in the orchestrator.
+		if (signal.aborted) return undefined
+		if (!result) {
+			throw new Error(
+				kind === "full"
+					? "Scan failed, is scanner initialized?"
+					: "Incremental scan failed, is scanner initialized?",
+			)
+		}
+		return { indexed, found, batchErrors }
+	}
+
+	private validateFullScan(indexed: number, found: number, batchErrors: Error[]): void {
+		const firstError = batchErrors[0]
+		if (indexed === 0 && found > 0) {
+			throw new Error(
+				firstError
+					? `Indexing failed: ${firstError.message}`
+					: t("embeddings:orchestrator.indexingFailedNoBlocks"),
+			)
+		}
+		if (firstError && (found - indexed) / found > 0.1) {
+			throw new Error(
+				`Indexing partially failed: Only ${indexed} of ${found} blocks were indexed. ${firstError.message}`,
+			)
+		}
+		if (firstError && indexed === 0) {
+			throw new Error(`Indexing failed completely: ${firstError.message}`)
+		}
+	}
+}
diff --git a/src/services/code-index/code-index-scope.ts b/src/services/code-index/code-index-scope.ts
new file mode 100644
index 0000000000..263130487d
--- /dev/null
+++ b/src/services/code-index/code-index-scope.ts
@@ -0,0 +1,34 @@
+import type * as vscode from "vscode"
+import { CodeIndexManagerRegistry } from "./code-index-manager-registry"
+import { CodeIndexStatusManager } from "./code-index-status-manager"
+
+export class CodeIndexScope implements vscode.Disposable {
+	private statusManager?: CodeIndexStatusManager
+	private _isInitialized = false
+
+	public constructor(private readonly context: vscode.ExtensionContext) {}
+
+	public init(): void {
+		if (this._isInitialized) {
+			throw new Error("Code index scope is already initialized")
+		}
+		const manager = new CodeIndexStatusManager((workspacePath) =>
+			CodeIndexManagerRegistry.getOrCreate(this.context, workspacePath),
+		)
+		this.statusManager = manager
+		try {
+			manager.init()
+			this._isInitialized = true
+		} catch (error) {
+			this.dispose()
+			throw error
+		}
+	}
+
+	public dispose(): void {
+		const manager = this.statusManager
+		this.statusManager = undefined
+		this._isInitialized = false
+		manager?.dispose()
+	}
+}
diff --git a/src/services/code-index/code-index-status-manager.ts b/src/services/code-index/code-index-status-manager.ts
new file mode 100644
index 0000000000..2461630eaa
--- /dev/null
+++ b/src/services/code-index/code-index-status-manager.ts
@@ -0,0 +1,79 @@
+import * as vscode from "vscode"
+import { ClineProvider } from "../../core/webview/ClineProvider"
+import { getWorkspacePath } from "../../utils/path"
+import type { CodeIndexManager } from "./manager"
+
+export type CodeIndexStatus = ReturnType<CodeIndexManager["getCurrentStatus"]>
+
+/** Tracks the active workspace; owns subscriptions, never workspace managers. */
+export class CodeIndexStatusManager implements vscode.Disposable {
+	private currentManager?: CodeIndexManager
+	private progressSubscription?: vscode.Disposable
+	private editorSubscription?: vscode.Disposable
+
+	public constructor(
+		private readonly getManagerForWorkspace: (workspacePath: string) => CodeIndexManager | undefined,
+	) {}
+
+	public init(): void {
+		this.editorSubscription = vscode.window.onDidChangeActiveTextEditor(() => this.updateSubscription())
+		this.updateSubscription()
+	}
+
+	private getCurrentManager(): CodeIndexManager | undefined {
+		const workspacePath = getWorkspacePath()
+		return workspacePath ? this.getManagerForWorkspace(workspacePath) : undefined
+	}
+
+	private updateSubscription(): void {
+		const manager = this.getCurrentManager()
+		if (manager === this.currentManager) return
+
+		this.disposeSubscription(this.progressSubscription, "progress")
+		this.progressSubscription = undefined
+		this.currentManager = manager
+		if (!manager) return
+
+		this.progressSubscription = manager.onProgressUpdate(() => {
+			if (manager === this.currentManager && manager === this.getCurrentManager()) {
+				this.publishStatus(manager.getCurrentStatus())
+			}
+		})
+		this.publishStatus(manager.getCurrentStatus())
+	}
+
+	private publishStatus(status: CodeIndexStatus): void {
+		for (const provider of ClineProvider.getAllInstances()) {
+			void this.publishStatusToProvider(provider, status)
+		}
+	}
+
+	private async publishStatusToProvider(provider: ClineProvider, status: CodeIndexStatus): Promise<void> {
+		try {
+			const workspacePath = provider.workspacePath
+			if (workspacePath && workspacePath !== status.workspacePath) return
+
+			await provider.postMessageToWebview({ type: "indexingStatusUpdate", values: status })
+		} catch (error) {
+			console.error("[CodeIndexStatusManager] Failed to publish indexing status:", error)
+		}
+	}
+
+	private disposeSubscription(subscription: vscode.Disposable | undefined, name: string): void {
+		try {
+			subscription?.dispose()
+		} catch (error) {
+			console.error(`[CodeIndexStatusManager] Failed to dispose ${name} subscription:`, error)
+		}
+	}
+
+	public dispose(): void {
+		const editorSubscription = this.editorSubscription
+		const progressSubscription = this.progressSubscription
+		this.currentManager = undefined
+		this.editorSubscription = undefined
+		this.progressSubscription = undefined
+		this.disposeSubscription(editorSubscription, "active editor")
+		this.disposeSubscription(progressSubscription, "progress")
+	}
+}
diff --git a/src/services/code-index/code-index-workspace-scope.ts b/src/services/code-index/code-index-workspace-scope.ts
new file mode 100644
index 0000000000..c8481f6595
--- /dev/null
+++ b/src/services/code-index/code-index-workspace-scope.ts
@@ -0,0 +1,59 @@
+import type * as vscode from "vscode"
+
+import { CodeIndexManager } from "./manager"
+import { CodeIndexStateManager } from "./state-manager"
+import { WorkspaceIndexingEnablementManager } from "./workspace-indexing-enablement-manager"
+
+/** Owns code-index services for one workspace; initialization remains with existing callers. */
+export class CodeIndexWorkspaceScope implements vscode.Disposable {
+	private _codeIndexManager?: CodeIndexManager
+	private _stateManager?: CodeIndexStateManager
+	private _workspaceIndexingEnablementManager?: WorkspaceIndexingEnablementManager
+	private _isInitialized = false
+
+	public constructor(
+		private readonly workspacePath: string,
+		private readonly folderUri: vscode.Uri,
+		private readonly context: vscode.ExtensionContext,
+	) {}
+
+	public get codeIndexManager(): CodeIndexManager {
+		return this.ensureInitialized(this._codeIndexManager)
+	}
+
+	public get workspaceIndexingEnablementManager(): WorkspaceIndexingEnablementManager {
+		return this.ensureInitialized(this._workspaceIndexingEnablementManager)
+	}
+
+	private ensureInitialized<T>(value: T | undefined): T {
+		if (!this._isInitialized || value === undefined) {
+			throw new Error("Code index workspace scope is not initialized")
+		}
+		return value
+	}
+
+	/** Creates the manager without loading configuration or starting indexing. */
+	public init(): void {
+		if (this._isInitialized) {
+			throw new Error("Code index workspace scope is already initialized")
+		}
+		this._stateManager = new CodeIndexStateManager()
+		this._codeIndexManager = new CodeIndexManager(
+			this.workspacePath,
+			this.folderUri,
+			this.context,
+			this._stateManager,
+		)
+		this._workspaceIndexingEnablementManager = new WorkspaceIndexingEnablementManager(this._codeIndexManager)
+		this._isInitialized = true
+	}
+
+	public dispose(): void {
+		const manager = this._codeIndexManager
+		this._codeIndexManager = undefined
+		this._workspaceIndexingEnablementManager = undefined
+		this._stateManager = undefined
+		this._isInitialized = false
+		manager?.dispose()
+	}
+}
diff --git a/src/services/code-index/config-manager.ts b/src/services/code-index/config-manager.ts
index 5b2b2c63e2..3d8121476d 100644
--- a/src/services/code-index/config-manager.ts
+++ b/src/services/code-index/config-manager.ts
@@ -1,7 +1,12 @@
-import { ApiHandlerOptions } from "../../shared/api"
 import { ContextProxy } from "../../core/config/ContextProxy"
+import type { CodebaseIndexConfig } from "@roo-code/types"
 import { EmbedderProvider } from "./interfaces/manager"
-import { CodeIndexConfig, PreviousConfigSnapshot } from "./interfaces/config"
+import {
+	CodeIndexConfig,
+	CodeIndexConfigSnapshot,
+	PreviousConfigSnapshot,
+	freezeCodeIndexConfigSnapshot,
+} from "./interfaces/config"
 import { DEFAULT_SEARCH_MIN_SCORE, DEFAULT_MAX_SEARCH_RESULTS } from "./constants"
 import { getDefaultModelId, getModelDimension, getModelScoreThreshold } from "../../shared/embeddingModels"
 import { providerIdentifiers } from "@roo-code/types/provider-identifiers"
@@ -12,34 +17,20 @@ import { providerIdentifiers } from "@roo-code/types/provider-identifiers"
  */
 export class CodeIndexConfigManager {
 	private _isConfigurationLoaded = false
+	private config: CodeIndexConfigSnapshot
+	private readonly contextProxy: ContextProxy
+
+	constructor(contextProxy: ContextProxy) {
+		this.contextProxy = contextProxy
+		// Initialize with current configuration to avoid false restart triggers
+		this.config = this._readConfiguration()
+	}
 
 	/** Whether at least one full asynchronous configuration load has succeeded. */
 	public get isConfigurationLoaded(): boolean {
 		return this._isConfigurationLoaded
 	}
 
-	private codebaseIndexEnabled: boolean = false
-	private embedderProvider: EmbedderProvider = providerIdentifiers.openai
-	private modelId?: string
-	private modelDimension?: number
-	private openAiOptions?: ApiHandlerOptions
-	private ollamaOptions?: ApiHandlerOptions
-	private openAiCompatibleOptions?: { baseUrl: string; apiKey: string }
-	private geminiOptions?: { apiKey: string }
-	private mistralOptions?: { apiKey: string }
-	private vercelAiGatewayOptions?: { apiKey: string }
-	private bedrockOptions?: { region: string; profile?: string }
-	private openRouterOptions?: { apiKey: string; specificProvider?: string }
-	private qdrantUrl?: string = "http://localhost:6333"
-	private qdrantApiKey?: string
-	private searchMinScore?: number
-	private searchMaxResults?: number
-
-	constructor(private readonly contextProxy: ContextProxy) {
-		// Initialize with current configuration to avoid false restart triggers
-		this._loadAndSetConfiguration()
-	}
-
 	/**
 	 * Gets the context proxy instance
 	 */
@@ -48,12 +39,13 @@ export class CodeIndexConfigManager {
 	}
 
 	/**
-	 * Private method that handles loading configuration from storage and updating instance variables.
-	 * This eliminates code duplication between initializeWithCurrentConfig() and loadConfiguration().
+	 * Builds a complete immutable snapshot without changing the current configuration.
 	 */
-	private _loadAndSetConfiguration(): void {
+	private _readConfiguration(): CodeIndexConfigSnapshot {
 		// Load configuration from storage
-		const codebaseIndexConfig = this.contextProxy?.getGlobalState("codebaseIndexConfig") ?? {
+		const codebaseIndexConfig: Readonly<CodebaseIndexConfig> = this.contextProxy?.getGlobalState(
+			"codebaseIndexConfig",
+		) ?? {
 			codebaseIndexEnabled: false,
 			codebaseIndexQdrantUrl: "http://localhost:6333",
 			codebaseIndexEmbedderProvider: providerIdentifiers.openai,
@@ -65,99 +57,133 @@ export class CodeIndexConfigManager {
 			codebaseIndexBedrockProfile: "",
 		}
 
-		const {
-			codebaseIndexEnabled,
-			codebaseIndexQdrantUrl,
-			codebaseIndexEmbedderProvider,
-			codebaseIndexEmbedderBaseUrl,
-			codebaseIndexEmbedderModelId,
-			codebaseIndexSearchMinScore,
-			codebaseIndexSearchMaxResults,
-		} = codebaseIndexConfig
-
-		const openAiKey = this.contextProxy?.getSecret("codeIndexOpenAiKey") ?? ""
 		const qdrantApiKey = this.contextProxy?.getSecret("codeIndexQdrantApiKey") ?? ""
-		// Fix: Read OpenAI Compatible settings from the correct location within codebaseIndexConfig
-		const openAiCompatibleBaseUrl = codebaseIndexConfig.codebaseIndexOpenAiCompatibleBaseUrl ?? ""
-		const openAiCompatibleApiKey = this.contextProxy?.getSecret("codebaseIndexOpenAiCompatibleApiKey") ?? ""
-		const geminiApiKey = this.contextProxy?.getSecret("codebaseIndexGeminiApiKey") ?? ""
-		const mistralApiKey = this.contextProxy?.getSecret("codebaseIndexMistralApiKey") ?? ""
-		const vercelAiGatewayApiKey = this.contextProxy?.getSecret("codebaseIndexVercelAiGatewayApiKey") ?? ""
-		const bedrockRegion = codebaseIndexConfig.codebaseIndexBedrockRegion ?? "us-east-1"
-		const bedrockProfile = codebaseIndexConfig.codebaseIndexBedrockProfile ?? ""
-		const openRouterApiKey = this.contextProxy?.getSecret("codebaseIndexOpenRouterApiKey") ?? ""
-		const openRouterSpecificProvider = codebaseIndexConfig.codebaseIndexOpenRouterSpecificProvider ?? ""
-
-		// Update instance variables with configuration
-		this.codebaseIndexEnabled = codebaseIndexEnabled ?? false
-		this.qdrantUrl = codebaseIndexQdrantUrl
-		this.qdrantApiKey = qdrantApiKey ?? ""
-		this.searchMinScore = codebaseIndexSearchMinScore
-		this.searchMaxResults = codebaseIndexSearchMaxResults
-
-		// Validate and set model dimension
-		const rawDimension = codebaseIndexConfig.codebaseIndexEmbedderModelDimension
-		if (rawDimension !== undefined && rawDimension !== null) {
-			const dimension = Number(rawDimension)
-			if (!isNaN(dimension) && dimension > 0) {
-				this.modelDimension = dimension
-			} else {
-				console.warn(
-					`Invalid codebaseIndexEmbedderModelDimension value: ${rawDimension}. Must be a positive number.`,
-				)
-				this.modelDimension = undefined
-			}
-		} else {
-			this.modelDimension = undefined
-		}
 
-		this.openAiOptions = { openAiNativeApiKey: openAiKey }
+		// Build locally so a failed read cannot partially update the published snapshot.
+		const modelDimension = this._parseModelDimension(codebaseIndexConfig.codebaseIndexEmbedderModelDimension)
 
 		// Set embedder provider with support for openai-compatible
-		if (codebaseIndexEmbedderProvider === providerIdentifiers.ollama) {
-			this.embedderProvider = providerIdentifiers.ollama
-		} else if (codebaseIndexEmbedderProvider === "openai-compatible") {
-			this.embedderProvider = "openai-compatible"
-		} else if (codebaseIndexEmbedderProvider === providerIdentifiers.gemini) {
-			this.embedderProvider = providerIdentifiers.gemini
-		} else if (codebaseIndexEmbedderProvider === providerIdentifiers.mistral) {
-			this.embedderProvider = providerIdentifiers.mistral
-		} else if (codebaseIndexEmbedderProvider === providerIdentifiers.vercelAiGateway) {
-			this.embedderProvider = providerIdentifiers.vercelAiGateway
-		} else if ((codebaseIndexEmbedderProvider as string) === providerIdentifiers.bedrock) {
-			this.embedderProvider = providerIdentifiers.bedrock
-		} else if (codebaseIndexEmbedderProvider === providerIdentifiers.openrouter) {
-			this.embedderProvider = providerIdentifiers.openrouter
-		} else if (codebaseIndexEmbedderProvider === "semble") {
-			this.embedderProvider = "semble"
-		} else {
-			this.embedderProvider = providerIdentifiers.openai
+		const embedderProvider = this._resolveEmbedderProvider(codebaseIndexConfig.codebaseIndexEmbedderProvider)
+
+		const modelId = codebaseIndexConfig.codebaseIndexEmbedderModelId || undefined
+
+		return freezeCodeIndexConfigSnapshot({
+			codebaseIndexEnabled: codebaseIndexConfig.codebaseIndexEnabled ?? false,
+			qdrantUrl: codebaseIndexConfig.codebaseIndexQdrantUrl,
+			qdrantApiKey,
+			searchMinScore: codebaseIndexConfig.codebaseIndexSearchMinScore,
+			searchMaxResults: codebaseIndexConfig.codebaseIndexSearchMaxResults,
+			embedderProvider,
+			modelId,
+			modelDimension,
+			openAiOptions: this._readOpenAiOptions(),
+			ollamaOptions: this._readOllamaOptions(),
+			openAiCompatibleOptions: this._readOpenAiCompatibleOptions(),
+			geminiOptions: this._readGeminiOptions(),
+			mistralOptions: this._readMistralOptions(),
+			vercelAiGatewayOptions: this._readVercelAiGatewayOptions(),
+			bedrockOptions: this._readBedrockOptions(),
+			openRouterOptions: this._readOpenRouterOptions(),
+		})
+	}
+
+	private _readOpenAiOptions(): CodeIndexConfig["openAiOptions"] {
+		return { openAiNativeApiKey: this.contextProxy?.getSecret("codeIndexOpenAiKey") ?? "" }
+	}
+
+	private _readOllamaOptions(): CodeIndexConfig["ollamaOptions"] {
+		const config = this.contextProxy?.getGlobalState("codebaseIndexConfig")
+		return { ollamaBaseUrl: config == null ? "" : config.codebaseIndexEmbedderBaseUrl }
+	}
+
+	private _readGeminiOptions(): CodeIndexConfig["geminiOptions"] {
+		const apiKey = this.contextProxy?.getSecret("codebaseIndexGeminiApiKey") ?? ""
+		if (!apiKey) {
+			return undefined
+		}
+
+		return { apiKey }
+	}
+
+	private _readMistralOptions(): CodeIndexConfig["mistralOptions"] {
+		const apiKey = this.contextProxy?.getSecret("codebaseIndexMistralApiKey") ?? ""
+		if (!apiKey) {
+			return undefined
+		}
+
+		return { apiKey }
+	}
+
+	private _readVercelAiGatewayOptions(): CodeIndexConfig["vercelAiGatewayOptions"] {
+		const apiKey = this.contextProxy?.getSecret("codebaseIndexVercelAiGatewayApiKey") ?? ""
+		if (!apiKey) {
+			return undefined
 		}
 
-		this.modelId = codebaseIndexEmbedderModelId || undefined
+		return { apiKey }
+	}
 
-		this.ollamaOptions = {
-			ollamaBaseUrl: codebaseIndexEmbedderBaseUrl,
+	private _readBedrockOptions(): CodeIndexConfig["bedrockOptions"] {
+		const config = this.contextProxy?.getGlobalState("codebaseIndexConfig")
+		const region = config?.codebaseIndexBedrockRegion ?? "us-east-1"
+		if (!region) {
+			return undefined
 		}
 
-		this.openAiCompatibleOptions =
-			openAiCompatibleBaseUrl && openAiCompatibleApiKey
-				? {
-						baseUrl: openAiCompatibleBaseUrl,
-						apiKey: openAiCompatibleApiKey,
-					}
-				: undefined
-
-		this.geminiOptions = geminiApiKey ? { apiKey: geminiApiKey } : undefined
-		this.mistralOptions = mistralApiKey ? { apiKey: mistralApiKey } : undefined
-		this.vercelAiGatewayOptions = vercelAiGatewayApiKey ? { apiKey: vercelAiGatewayApiKey } : undefined
-		this.openRouterOptions = openRouterApiKey
-			? { apiKey: openRouterApiKey, specificProvider: openRouterSpecificProvider || undefined }
-			: undefined
-		// Set bedrockOptions if region is provided (profile is optional)
-		this.bedrockOptions = bedrockRegion
-			? { region: bedrockRegion, profile: bedrockProfile || undefined }
-			: undefined
+		return { region, profile: config?.codebaseIndexBedrockProfile || undefined }
+	}
+
+	private _readOpenRouterOptions(): CodeIndexConfig["openRouterOptions"] {
+		const apiKey = this.contextProxy?.getSecret("codebaseIndexOpenRouterApiKey") ?? ""
+		if (!apiKey) {
+			return undefined
+		}
+
+		const specificProvider =
+			this.contextProxy?.getGlobalState("codebaseIndexConfig")?.codebaseIndexOpenRouterSpecificProvider
+		return { apiKey, specificProvider: specificProvider || undefined }
+	}
+
+	private _readOpenAiCompatibleOptions(): CodeIndexConfig["openAiCompatibleOptions"] {
+		const baseUrl =
+			this.contextProxy?.getGlobalState("codebaseIndexConfig")?.codebaseIndexOpenAiCompatibleBaseUrl ?? ""
+		const apiKey = this.contextProxy?.getSecret("codebaseIndexOpenAiCompatibleApiKey") ?? ""
+
+		if (!baseUrl || !apiKey) {
+			return undefined
+		}
+
+		return { baseUrl, apiKey }
+	}
+
+	private _resolveEmbedderProvider(provider: unknown): EmbedderProvider {
+		switch (provider) {
+			case providerIdentifiers.ollama:
+			case "openai-compatible":
+			case providerIdentifiers.gemini:
+			case providerIdentifiers.mistral:
+			case providerIdentifiers.vercelAiGateway:
+			case providerIdentifiers.bedrock:
+			case providerIdentifiers.openrouter:
+			case "semble":
+				return provider
+			default:
+				return providerIdentifiers.openai
+		}
+	}
+
+	private _parseModelDimension(rawDimension: unknown): number | undefined {
+		if (rawDimension === undefined || rawDimension === null) {
+			return undefined
+		}
+
+		const dimension = Number(rawDimension)
+		if (dimension > 0) {
+			return dimension
+		}
+
+		console.warn(`Invalid codebaseIndexEmbedderModelDimension value: ${rawDimension}. Must be a positive number.`)
+		return undefined
 	}
 
 	/**
@@ -165,132 +191,87 @@ export class CodeIndexConfigManager {
 	 */
 	public async loadConfiguration(): Promise<{
 		configSnapshot: PreviousConfigSnapshot
-		currentConfig: {
-			isConfigured: boolean
-			embedderProvider: EmbedderProvider
-			modelId?: string
-			modelDimension?: number
-			openAiOptions?: ApiHandlerOptions
-			ollamaOptions?: ApiHandlerOptions
-			openAiCompatibleOptions?: { baseUrl: string; apiKey: string }
-			geminiOptions?: { apiKey: string }
-			mistralOptions?: { apiKey: string }
-			vercelAiGatewayOptions?: { apiKey: string }
-			bedrockOptions?: { region: string; profile?: string }
-			openRouterOptions?: { apiKey: string }
-			qdrantUrl?: string
-			qdrantApiKey?: string
-			searchMinScore?: number
-		}
+		currentConfig: CodeIndexConfig
 		requiresRestart: boolean
 	}> {
 		// Capture the ACTUAL previous state before loading new configuration
-		const previousConfigSnapshot: PreviousConfigSnapshot = {
-			enabled: this.codebaseIndexEnabled,
-			configured: this.isConfigured(),
-			embedderProvider: this.embedderProvider,
-			modelId: this.modelId,
-			modelDimension: this.modelDimension,
-			openAiKey: this.openAiOptions?.openAiNativeApiKey ?? "",
-			ollamaBaseUrl: this.ollamaOptions?.ollamaBaseUrl ?? "",
-			openAiCompatibleBaseUrl: this.openAiCompatibleOptions?.baseUrl ?? "",
-			openAiCompatibleApiKey: this.openAiCompatibleOptions?.apiKey ?? "",
-			geminiApiKey: this.geminiOptions?.apiKey ?? "",
-			mistralApiKey: this.mistralOptions?.apiKey ?? "",
-			vercelAiGatewayApiKey: this.vercelAiGatewayOptions?.apiKey ?? "",
-			bedrockRegion: this.bedrockOptions?.region ?? "",
-			bedrockProfile: this.bedrockOptions?.profile ?? "",
-			openRouterApiKey: this.openRouterOptions?.apiKey ?? "",
-			openRouterSpecificProvider: this.openRouterOptions?.specificProvider ?? "",
-			qdrantUrl: this.qdrantUrl ?? "",
-			qdrantApiKey: this.qdrantApiKey ?? "",
-		}
+		const previousConfigSnapshot = this._getRestartComparisonSnapshot()
 
 		// Refresh secrets from VSCode storage to ensure we have the latest values
 		await this.contextProxy.refreshSecrets()
 
-		// Load new configuration from storage and update instance variables
-		this._loadAndSetConfiguration()
+		// Publish only after the complete snapshot has been built.
+		this.config = this._readConfiguration()
 
 		const requiresRestart = this.doesConfigChangeRequireRestart(previousConfigSnapshot)
 
 		const result = {
 			configSnapshot: previousConfigSnapshot,
-			currentConfig: {
-				isConfigured: this.isConfigured(),
-				embedderProvider: this.embedderProvider,
-				modelId: this.modelId,
-				modelDimension: this.modelDimension,
-				openAiOptions: this.openAiOptions,
-				ollamaOptions: this.ollamaOptions,
-				openAiCompatibleOptions: this.openAiCompatibleOptions,
-				geminiOptions: this.geminiOptions,
-				mistralOptions: this.mistralOptions,
-				vercelAiGatewayOptions: this.vercelAiGatewayOptions,
-				bedrockOptions: this.bedrockOptions,
-				openRouterOptions: this.openRouterOptions,
-				qdrantUrl: this.qdrantUrl,
-				qdrantApiKey: this.qdrantApiKey,
-				searchMinScore: this.currentSearchMinScore,
-			},
+			currentConfig: this.getConfig(),
 			requiresRestart,
 		}
 		this._isConfigurationLoaded = true
 		return result
 	}
 
+	private _getRestartComparisonSnapshot(): PreviousConfigSnapshot {
+		return {
+			enabled: this.config.codebaseIndexEnabled,
+			configured: this.isConfigured(),
+			embedderProvider: this.config.embedderProvider,
+			modelId: this.config.modelId,
+			modelDimension: this.config.modelDimension,
+			openAiKey: this.config.openAiOptions?.openAiNativeApiKey ?? "",
+			ollamaBaseUrl: this.config.ollamaOptions?.ollamaBaseUrl ?? "",
+			openAiCompatibleBaseUrl: this.config.openAiCompatibleOptions?.baseUrl ?? "",
+			openAiCompatibleApiKey: this.config.openAiCompatibleOptions?.apiKey ?? "",
+			geminiApiKey: this.config.geminiOptions?.apiKey ?? "",
+			mistralApiKey: this.config.mistralOptions?.apiKey ?? "",
+			vercelAiGatewayApiKey: this.config.vercelAiGatewayOptions?.apiKey ?? "",
+			bedrockRegion: this.config.bedrockOptions?.region ?? "",
+			bedrockProfile: this.config.bedrockOptions?.profile ?? "",
+			openRouterApiKey: this.config.openRouterOptions?.apiKey ?? "",
+			openRouterSpecificProvider: this.config.openRouterOptions?.specificProvider ?? "",
+			qdrantUrl: this.config.qdrantUrl ?? "",
+			qdrantApiKey: this.config.qdrantApiKey ?? "",
+		}
+	}
+
 	/**
 	 * Checks if the service is properly configured based on the embedder type.
 	 */
 	public isConfigured(): boolean {
-		if (this.embedderProvider === "semble") {
-			// Semble requires no API keys or Qdrant — it's always configured
+		if (this.config.embedderProvider === "semble") {
+			// Semble requires no API keys or Qdrant.
 			return true
 		}
 
-		if (this.embedderProvider === providerIdentifiers.openai) {
-			const openAiKey = this.openAiOptions?.openAiNativeApiKey
-			const qdrantUrl = this.qdrantUrl
-			return !!(openAiKey && qdrantUrl)
-		} else if (this.embedderProvider === providerIdentifiers.ollama) {
-			// Ollama model ID has a default, so only base URL is strictly required for config
-			const ollamaBaseUrl = this.ollamaOptions?.ollamaBaseUrl
-			const qdrantUrl = this.qdrantUrl
-			return !!(ollamaBaseUrl && qdrantUrl)
-		} else if (this.embedderProvider === "openai-compatible") {
-			const baseUrl = this.openAiCompatibleOptions?.baseUrl
-			const apiKey = this.openAiCompatibleOptions?.apiKey
-			const qdrantUrl = this.qdrantUrl
-			const isConfigured = !!(baseUrl && apiKey && qdrantUrl)
-			return isConfigured
-		} else if (this.embedderProvider === providerIdentifiers.gemini) {
-			const apiKey = this.geminiOptions?.apiKey
-			const qdrantUrl = this.qdrantUrl
-			const isConfigured = !!(apiKey && qdrantUrl)
-			return isConfigured
-		} else if (this.embedderProvider === providerIdentifiers.mistral) {
-			const apiKey = this.mistralOptions?.apiKey
-			const qdrantUrl = this.qdrantUrl
-			const isConfigured = !!(apiKey && qdrantUrl)
-			return isConfigured
-		} else if (this.embedderProvider === providerIdentifiers.vercelAiGateway) {
-			const apiKey = this.vercelAiGatewayOptions?.apiKey
-			const qdrantUrl = this.qdrantUrl
-			const isConfigured = !!(apiKey && qdrantUrl)
-			return isConfigured
-		} else if (this.embedderProvider === providerIdentifiers.bedrock) {
-			// Only region is required for Bedrock (profile is optional)
-			const region = this.bedrockOptions?.region
-			const qdrantUrl = this.qdrantUrl
-			const isConfigured = !!(region && qdrantUrl)
-			return isConfigured
-		} else if (this.embedderProvider === providerIdentifiers.openrouter) {
-			const apiKey = this.openRouterOptions?.apiKey
-			const qdrantUrl = this.qdrantUrl
-			const isConfigured = !!(apiKey && qdrantUrl)
-			return isConfigured
+		if (!this.config.qdrantUrl) {
+			return false
+		}
+
+		switch (this.config.embedderProvider) {
+			case providerIdentifiers.openai:
+				return !!this.config.openAiOptions?.openAiNativeApiKey
+			case providerIdentifiers.ollama:
+				// The model ID has a default, so only the base URL is required.
+				return !!this.config.ollamaOptions?.ollamaBaseUrl
+			case "openai-compatible":
+				return !!(this.config.openAiCompatibleOptions?.baseUrl && this.config.openAiCompatibleOptions?.apiKey)
+			case providerIdentifiers.gemini:
+				return !!this.config.geminiOptions?.apiKey
+			case providerIdentifiers.mistral:
+				return !!this.config.mistralOptions?.apiKey
+			case providerIdentifiers.vercelAiGateway:
+				return !!this.config.vercelAiGatewayOptions?.apiKey
+			case providerIdentifiers.bedrock:
+				// The profile is optional.
+				return !!this.config.bedrockOptions?.region
+			case providerIdentifiers.openrouter:
+				return !!this.config.openRouterOptions?.apiKey
+			default:
+				return false
 		}
-		return false // Should not happen if embedderProvider is always set correctly
 	}
 
 	/**
@@ -310,132 +291,60 @@ export class CodeIndexConfigManager {
 	 * - Non-functional configuration tweaks
 	 */
 	doesConfigChangeRequireRestart(prev: PreviousConfigSnapshot): boolean {
-		const nowConfigured = this.isConfigured()
-
-		// Handle null/undefined values safely
-		const prevEnabled = prev?.enabled ?? false
-		const prevConfigured = prev?.configured ?? false
-		const prevProvider = prev?.embedderProvider ?? providerIdentifiers.openai
-		const prevOpenAiKey = prev?.openAiKey ?? ""
-		const prevOllamaBaseUrl = prev?.ollamaBaseUrl ?? ""
-		const prevOpenAiCompatibleBaseUrl = prev?.openAiCompatibleBaseUrl ?? ""
-		const prevOpenAiCompatibleApiKey = prev?.openAiCompatibleApiKey ?? ""
-		const prevModelDimension = prev?.modelDimension
-		const prevGeminiApiKey = prev?.geminiApiKey ?? ""
-		const prevMistralApiKey = prev?.mistralApiKey ?? ""
-		const prevVercelAiGatewayApiKey = prev?.vercelAiGatewayApiKey ?? ""
-		const prevBedrockRegion = prev?.bedrockRegion ?? ""
-		const prevBedrockProfile = prev?.bedrockProfile ?? ""
-		const prevOpenRouterApiKey = prev?.openRouterApiKey ?? ""
-		const prevOpenRouterSpecificProvider = prev?.openRouterSpecificProvider ?? ""
-		const prevQdrantUrl = prev?.qdrantUrl ?? ""
-		const prevQdrantApiKey = prev?.qdrantApiKey ?? ""
-
-		// 1. Transition from disabled/unconfigured to enabled/configured
-		if ((!prevEnabled || !prevConfigured) && this.codebaseIndexEnabled && nowConfigured) {
-			return true
-		}
-
-		// 2. Transition from enabled to disabled
-		if (prevEnabled && !this.codebaseIndexEnabled) {
-			return true
-		}
-
-		// 3. If wasn't ready before and isn't ready now, no restart needed
-		if ((!prevEnabled || !prevConfigured) && (!this.codebaseIndexEnabled || !nowConfigured)) {
-			return false
-		}
-
-		// 4. CRITICAL CHANGES - Always restart for these
-		// Only check for critical changes if feature is enabled
-		if (!this.codebaseIndexEnabled) {
-			return false
-		}
-
-		// Provider change
-		if (prevProvider !== this.embedderProvider) {
-			return true
-		}
-
-		// Authentication changes (API keys)
-		const currentOpenAiKey = this.openAiOptions?.openAiNativeApiKey ?? ""
-		const currentOllamaBaseUrl = this.ollamaOptions?.ollamaBaseUrl ?? ""
-		const currentOpenAiCompatibleBaseUrl = this.openAiCompatibleOptions?.baseUrl ?? ""
-		const currentOpenAiCompatibleApiKey = this.openAiCompatibleOptions?.apiKey ?? ""
-		const currentModelDimension = this.modelDimension
-		const currentGeminiApiKey = this.geminiOptions?.apiKey ?? ""
-		const currentMistralApiKey = this.mistralOptions?.apiKey ?? ""
-		const currentVercelAiGatewayApiKey = this.vercelAiGatewayOptions?.apiKey ?? ""
-		const currentBedrockRegion = this.bedrockOptions?.region ?? ""
-		const currentBedrockProfile = this.bedrockOptions?.profile ?? ""
-		const currentOpenRouterApiKey = this.openRouterOptions?.apiKey ?? ""
-		const currentOpenRouterSpecificProvider = this.openRouterOptions?.specificProvider ?? ""
-		const currentQdrantUrl = this.qdrantUrl ?? ""
-		const currentQdrantApiKey = this.qdrantApiKey ?? ""
-
-		if (prevOpenAiKey !== currentOpenAiKey) {
-			return true
-		}
-
-		if (prevOllamaBaseUrl !== currentOllamaBaseUrl) {
-			return true
-		}
-
-		if (
-			prevOpenAiCompatibleBaseUrl !== currentOpenAiCompatibleBaseUrl ||
-			prevOpenAiCompatibleApiKey !== currentOpenAiCompatibleApiKey
-		) {
-			return true
-		}
-
-		if (prevGeminiApiKey !== currentGeminiApiKey) {
-			return true
-		}
-
-		if (prevMistralApiKey !== currentMistralApiKey) {
-			return true
-		}
+		const current = this._getRestartComparisonSnapshot()
+		const wasEnabled = prev?.enabled ?? false
+		const wasReady = wasEnabled && (prev?.configured ?? false)
+		const isReady = current.enabled && current.configured
 
-		if (prevVercelAiGatewayApiKey !== currentVercelAiGatewayApiKey) {
+		if (!wasReady && isReady) {
 			return true
 		}
 
-		if (prevBedrockRegion !== currentBedrockRegion || prevBedrockProfile !== currentBedrockProfile) {
+		if (wasEnabled && !current.enabled) {
 			return true
 		}
 
-		if (prevOpenRouterApiKey !== currentOpenRouterApiKey) {
-			return true
-		}
-
-		// OpenRouter specific provider change
-		if (prevOpenRouterSpecificProvider !== currentOpenRouterSpecificProvider) {
-			return true
-		}
-
-		// Check for model dimension changes (generic for all providers)
-		if (prevModelDimension !== currentModelDimension) {
-			return true
+		if (!current.enabled || (!wasReady && !isReady)) {
+			return false
 		}
 
-		if (prevQdrantUrl !== currentQdrantUrl || prevQdrantApiKey !== currentQdrantApiKey) {
+		const previousProvider = prev?.embedderProvider ?? providerIdentifiers.openai
+		if (previousProvider !== current.embedderProvider || prev?.modelDimension !== current.modelDimension) {
 			return true
 		}
 
-		// Vector dimension changes (still important for compatibility)
-		if (this._hasVectorDimensionChanged(prevProvider, prev?.modelId)) {
-			return true
-		}
+		return (
+			this._hasConnectionSettingsChanged(prev, current) ||
+			this._hasVectorDimensionChanged(previousProvider, prev?.modelId)
+		)
+	}
 
-		return false
+	private _hasConnectionSettingsChanged(prev: PreviousConfigSnapshot, current: PreviousConfigSnapshot): boolean {
+		const keys = [
+			"openAiKey",
+			"ollamaBaseUrl",
+			"openAiCompatibleBaseUrl",
+			"openAiCompatibleApiKey",
+			"geminiApiKey",
+			"mistralApiKey",
+			"vercelAiGatewayApiKey",
+			"bedrockRegion",
+			"bedrockProfile",
+			"openRouterApiKey",
+			"openRouterSpecificProvider",
+			"qdrantUrl",
+			"qdrantApiKey",
+		] as const satisfies readonly (keyof PreviousConfigSnapshot)[]
+
+		return keys.some((key) => (prev?.[key] ?? "") !== (current[key] ?? ""))
 	}
 
 	/**
 	 * Checks if model changes result in vector dimension changes that require restart.
 	 */
 	private _hasVectorDimensionChanged(prevProvider: EmbedderProvider, prevModelId?: string): boolean {
-		const currentProvider = this.embedderProvider
-		const currentModelId = this.modelId ?? getDefaultModelId(currentProvider)
+		const currentProvider = this.config.embedderProvider
+		const currentModelId = this.config.modelId ?? getDefaultModelId(currentProvider)
 		const resolvedPrevModelId = prevModelId ?? getDefaultModelId(prevProvider)
 
 		// If model IDs are the same and provider is the same, no dimension change
@@ -460,31 +369,31 @@ export class CodeIndexConfigManager {
 	 * Gets the current configuration state.
 	 */
 	public getConfig(): CodeIndexConfig {
-		return {
+		return Object.freeze({
 			isConfigured: this.isConfigured(),
-			embedderProvider: this.embedderProvider,
-			modelId: this.modelId,
-			modelDimension: this.modelDimension,
-			openAiOptions: this.openAiOptions,
-			ollamaOptions: this.ollamaOptions,
-			openAiCompatibleOptions: this.openAiCompatibleOptions,
-			geminiOptions: this.geminiOptions,
-			mistralOptions: this.mistralOptions,
-			vercelAiGatewayOptions: this.vercelAiGatewayOptions,
-			bedrockOptions: this.bedrockOptions,
-			openRouterOptions: this.openRouterOptions,
-			qdrantUrl: this.qdrantUrl,
-			qdrantApiKey: this.qdrantApiKey,
+			embedderProvider: this.config.embedderProvider,
+			modelId: this.config.modelId,
+			modelDimension: this.config.modelDimension,
+			openAiOptions: this.config.openAiOptions,
+			ollamaOptions: this.config.ollamaOptions,
+			openAiCompatibleOptions: this.config.openAiCompatibleOptions,
+			geminiOptions: this.config.geminiOptions,
+			mistralOptions: this.config.mistralOptions,
+			vercelAiGatewayOptions: this.config.vercelAiGatewayOptions,
+			bedrockOptions: this.config.bedrockOptions,
+			openRouterOptions: this.config.openRouterOptions,
+			qdrantUrl: this.config.qdrantUrl,
+			qdrantApiKey: this.config.qdrantApiKey,
 			searchMinScore: this.currentSearchMinScore,
 			searchMaxResults: this.currentSearchMaxResults,
-		}
+		})
 	}
 
 	/**
 	 * Gets whether the code indexing feature is enabled
 	 */
 	public get isFeatureEnabled(): boolean {
-		return this.codebaseIndexEnabled
+		return this.config.codebaseIndexEnabled
 	}
 
 	/**
@@ -495,10 +404,10 @@ export class CodeIndexConfigManager {
 	}
 
 	/**
-	 * Gets the current embedder type (openai or ollama)
+	 * Gets the current embedder provider
 	 */
 	public get currentEmbedderProvider(): EmbedderProvider {
-		return this.embedderProvider
+		return this.config.embedderProvider
 	}
 
 	/**
@@ -506,8 +415,8 @@ export class CodeIndexConfigManager {
 	 */
 	public get qdrantConfig(): { url?: string; apiKey?: string } {
 		return {
-			url: this.qdrantUrl,
-			apiKey: this.qdrantApiKey,
+			url: this.config.qdrantUrl,
+			apiKey: this.config.qdrantApiKey,
 		}
 	}
 
@@ -515,7 +424,7 @@ export class CodeIndexConfigManager {
 	 * Gets the current model ID being used for embeddings.
 	 */
 	public get currentModelId(): string | undefined {
-		return this.modelId
+		return this.config.modelId
 	}
 
 	/**
@@ -524,12 +433,12 @@ export class CodeIndexConfigManager {
 	 */
 	public get currentModelDimension(): number | undefined {
 		// First try to get the model-specific dimension
-		const modelId = this.modelId ?? getDefaultModelId(this.embedderProvider)
-		const modelDimension = getModelDimension(this.embedderProvider, modelId)
+		const modelId = this.config.modelId ?? getDefaultModelId(this.config.embedderProvider)
+		const modelDimension = getModelDimension(this.config.embedderProvider, modelId)
 
 		// Only use custom dimension if model doesn't have a built-in dimension
-		if (!modelDimension && this.modelDimension && this.modelDimension > 0) {
-			return this.modelDimension
+		if (!modelDimension && this.config.modelDimension && this.config.modelDimension > 0) {
+			return this.config.modelDimension
 		}
 
 		return modelDimension
@@ -541,13 +450,13 @@ export class CodeIndexConfigManager {
 	 */
 	public get currentSearchMinScore(): number {
 		// First check if user has configured a custom score threshold
-		if (this.searchMinScore !== undefined) {
-			return this.searchMinScore
+		if (this.config.searchMinScore !== undefined) {
+			return this.config.searchMinScore
 		}
 
 		// Fall back to model-specific threshold
-		const currentModelId = this.modelId ?? getDefaultModelId(this.embedderProvider)
-		const modelSpecificThreshold = getModelScoreThreshold(this.embedderProvider, currentModelId)
+		const currentModelId = this.config.modelId ?? getDefaultModelId(this.config.embedderProvider)
+		const modelSpecificThreshold = getModelScoreThreshold(this.config.embedderProvider, currentModelId)
 		return modelSpecificThreshold ?? DEFAULT_SEARCH_MIN_SCORE
 	}
 
@@ -556,6 +465,6 @@ export class CodeIndexConfigManager {
 	 * Returns user setting if configured, otherwise returns default.
 	 */
 	public get currentSearchMaxResults(): number {
-		return this.searchMaxResults ?? DEFAULT_MAX_SEARCH_RESULTS
+		return this.config.searchMaxResults ?? DEFAULT_MAX_SEARCH_RESULTS
 	}
 }
diff --git a/src/services/code-index/embedders/__tests__/embedder-validation-manager.spec.ts b/src/services/code-index/embedders/__tests__/embedder-validation-manager.spec.ts
new file mode 100644
index 0000000000..6ff11f8fa7
--- /dev/null
+++ b/src/services/code-index/embedders/__tests__/embedder-validation-manager.spec.ts
@@ -0,0 +1,59 @@
+import { TelemetryService } from "@roo-code/telemetry"
+import { TelemetryEventName } from "@roo-code/types"
+import { t } from "../../../../i18n"
+import embeddings from "../../../../i18n/locales/en/embeddings.json"
+import { OpenAiEmbedder } from "../openai"
+import { EmbedderValidationManager } from "../embedder-validation-manager"
+
+vi.mock("../openai")
+vi.mock("../../../../i18n", () => ({ t: vi.fn() }))
+vi.mock("@roo-code/telemetry", () => ({
+	TelemetryService: { instance: { captureEvent: vi.fn() } },
+}))
+
+describe("EmbedderValidationManager", () => {
+	const manager = new EmbedderValidationManager()
+
+	beforeEach(() => vi.clearAllMocks())
+
+	it.each([{ valid: true }, { valid: false, error: "Invalid credentials" }])(
+		"preserves the validation result %j without reporting an exception",
+		async (result) => {
+			const embedder = new OpenAiEmbedder({ openAiNativeApiKey: "test-key" })
+			vi.mocked(embedder.validateConfiguration).mockResolvedValue(result)
+
+			expect(await manager.validateEmbedder(embedder)).toBe(result)
+			expect(embedder.validateConfiguration).toHaveBeenCalledExactlyOnceWith()
+			expect(TelemetryService.instance.captureEvent).not.toHaveBeenCalled()
+		},
+	)
+
+	it("preserves an exception's message and reports its stack", async () => {
+		const embedder = new OpenAiEmbedder({ openAiNativeApiKey: "test-key" })
+		const error = new Error("Connection failed")
+		vi.mocked(embedder.validateConfiguration).mockRejectedValue(error)
+
+		expect(await manager.validateEmbedder(embedder)).toEqual({ valid: false, error: error.message })
+		expect(t).not.toHaveBeenCalled()
+		expect(TelemetryService.instance.captureEvent).toHaveBeenCalledExactlyOnceWith(
+			TelemetryEventName.CODE_INDEX_ERROR,
+			{ error: error.message, stack: error.stack, location: "validateEmbedder" },
+		)
+	})
+
+	it.each(["unavailable", null, undefined])("handles non-Error rejection %s", async (error) => {
+		const embedder = new OpenAiEmbedder({ openAiNativeApiKey: "test-key" })
+		vi.mocked(embedder.validateConfiguration).mockRejectedValue(error)
+		vi.mocked(t).mockReturnValue(embeddings.validation.configurationError)
+
+		expect(await manager.validateEmbedder(embedder)).toEqual({
+			valid: false,
+			error: embeddings.validation.configurationError,
+		})
+		expect(t).toHaveBeenCalledExactlyOnceWith("embeddings:validation.configurationError")
+		expect(TelemetryService.instance.captureEvent).toHaveBeenCalledExactlyOnceWith(
+			TelemetryEventName.CODE_INDEX_ERROR,
+			{ error: String(error), stack: undefined, location: "validateEmbedder" },
+		)
+	})
+})
diff --git a/src/services/code-index/embedders/embedder-factory.ts b/src/services/code-index/embedders/embedder-factory.ts
new file mode 100644
index 0000000000..31d6e8a754
--- /dev/null
+++ b/src/services/code-index/embedders/embedder-factory.ts
@@ -0,0 +1,51 @@
+import { providerIdentifiers } from "@roo-code/types/provider-identifiers"
+
+import { t } from "../../../i18n"
+import type { CodeIndexConfig } from "../interfaces/config"
+import type { IEmbedder } from "../interfaces"
+import type { IEmbedderFactory } from "../interfaces/embedder-factory"
+import { OpenAiEmbedderFactory } from "./factories/openai-embedder-factory"
+import { OllamaEmbedderFactory } from "./factories/ollama-embedder-factory"
+import { OpenAICompatibleEmbedderFactory } from "./factories/openai-compatible-embedder-factory"
+import { GeminiEmbedderFactory } from "./factories/gemini-embedder-factory"
+import { MistralEmbedderFactory } from "./factories/mistral-embedder-factory"
+import { VercelAiGatewayEmbedderFactory } from "./factories/vercel-ai-gateway-embedder-factory"
+import { BedrockEmbedderFactory } from "./factories/bedrock-embedder-factory"
+import { OpenRouterEmbedderFactory } from "./factories/openrouter-embedder-factory"
+
+type VectorEmbedderProvider = Exclude<CodeIndexConfig["embedderProvider"], "semble">
+
+export class EmbedderFactory implements IEmbedderFactory {
+	// Each provider owns its constructor arguments and validation. The record requires
+	// an entry for every vector embedder provider when the supported union changes.
+	// TODO: Inject the provider factory registry via DI instead of constructing factories here.
+	// https://github.com/Zoo-Code-Org/Zoo-Code/issues/1817
+	private readonly embedderFactories: Readonly<Record<VectorEmbedderProvider, IEmbedderFactory>> = {
+		[providerIdentifiers.openai]: new OpenAiEmbedderFactory(),
+		[providerIdentifiers.ollama]: new OllamaEmbedderFactory(),
+		"openai-compatible": new OpenAICompatibleEmbedderFactory(),
+		[providerIdentifiers.gemini]: new GeminiEmbedderFactory(),
+		[providerIdentifiers.mistral]: new MistralEmbedderFactory(),
+		[providerIdentifiers.vercelAiGateway]: new VercelAiGatewayEmbedderFactory(),
+		[providerIdentifiers.bedrock]: new BedrockEmbedderFactory(),
+		[providerIdentifiers.openrouter]: new OpenRouterEmbedderFactory(),
+	}
+
+	public create(config: CodeIndexConfig): IEmbedder {
+		const provider = config.embedderProvider
+
+		// Semble is a self-contained search binary, not a vector embedder.
+		if (provider === "semble") {
+			throw new Error(
+				"Semble provider handles its own embedding. Do not call createEmbedder() for semble — use SembleProvider instead.",
+			)
+		}
+
+		// Keep a runtime guard for invalid persisted configuration, including prototype keys.
+		if (!Object.prototype.hasOwnProperty.call(this.embedderFactories, provider)) {
+			throw new Error(t("embeddings:serviceFactory.invalidEmbedderType", { embedderProvider: provider }))
+		}
+
+		return this.embedderFactories[provider].create(config)
+	}
+}
diff --git a/src/services/code-index/embedders/embedder-validation-manager.ts b/src/services/code-index/embedders/embedder-validation-manager.ts
new file mode 100644
index 0000000000..84dd73aac6
--- /dev/null
+++ b/src/services/code-index/embedders/embedder-validation-manager.ts
@@ -0,0 +1,23 @@
+import { TelemetryService } from "@roo-code/telemetry"
+import { TelemetryEventName } from "@roo-code/types"
+import { t } from "../../../i18n"
+import type { IEmbedder } from "../interfaces"
+
+export class EmbedderValidationManager {
+	public async validateEmbedder(embedder: IEmbedder): Promise<{ valid: boolean; error?: string }> {
+		try {
+			return await embedder.validateConfiguration()
+		} catch (error) {
+			TelemetryService.instance.captureEvent(TelemetryEventName.CODE_INDEX_ERROR, {
+				error: error instanceof Error ? error.message : String(error),
+				stack: error instanceof Error ? error.stack : undefined,
+				location: "validateEmbedder",
+			})
+
+			return {
+				valid: false,
+				error: error instanceof Error ? error.message : t("embeddings:validation.configurationError"),
+			}
+		}
+	}
+}
diff --git a/src/services/code-index/embedders/factories/bedrock-embedder-factory.ts b/src/services/code-index/embedders/factories/bedrock-embedder-factory.ts
new file mode 100644
index 0000000000..5a93c5619b
--- /dev/null
+++ b/src/services/code-index/embedders/factories/bedrock-embedder-factory.ts
@@ -0,0 +1,14 @@
+import type { CodeIndexConfig } from "../../interfaces/config"
+import type { IEmbedderFactory } from "../../interfaces/embedder-factory"
+import { BedrockEmbedder } from "../bedrock"
+import { requireSetting } from "./require-setting"
+
+export class BedrockEmbedderFactory implements IEmbedderFactory {
+	create({ bedrockOptions, modelId }: CodeIndexConfig): BedrockEmbedder {
+		return new BedrockEmbedder(
+			requireSetting(bedrockOptions?.region, "embeddings:serviceFactory.bedrockConfigMissing"),
+			bedrockOptions?.profile,
+			modelId,
+		)
+	}
+}
diff --git a/src/services/code-index/embedders/factories/gemini-embedder-factory.ts b/src/services/code-index/embedders/factories/gemini-embedder-factory.ts
new file mode 100644
index 0000000000..71cd2018aa
--- /dev/null
+++ b/src/services/code-index/embedders/factories/gemini-embedder-factory.ts
@@ -0,0 +1,13 @@
+import type { CodeIndexConfig } from "../../interfaces/config"
+import type { IEmbedderFactory } from "../../interfaces/embedder-factory"
+import { GeminiEmbedder } from "../gemini"
+import { requireSetting } from "./require-setting"
+
+export class GeminiEmbedderFactory implements IEmbedderFactory {
+	create({ geminiOptions, modelId }: CodeIndexConfig): GeminiEmbedder {
+		return new GeminiEmbedder(
+			requireSetting(geminiOptions?.apiKey, "embeddings:serviceFactory.geminiConfigMissing"),
+			modelId,
+		)
+	}
+}
diff --git a/src/services/code-index/embedders/factories/mistral-embedder-factory.ts b/src/services/code-index/embedders/factories/mistral-embedder-factory.ts
new file mode 100644
index 0000000000..38fa041a8b
--- /dev/null
+++ b/src/services/code-index/embedders/factories/mistral-embedder-factory.ts
@@ -0,0 +1,13 @@
+import type { CodeIndexConfig } from "../../interfaces/config"
+import type { IEmbedderFactory } from "../../interfaces/embedder-factory"
+import { MistralEmbedder } from "../mistral"
+import { requireSetting } from "./require-setting"
+
+export class MistralEmbedderFactory implements IEmbedderFactory {
+	create({ mistralOptions, modelId }: CodeIndexConfig): MistralEmbedder {
+		return new MistralEmbedder(
+			requireSetting(mistralOptions?.apiKey, "embeddings:serviceFactory.mistralConfigMissing"),
+			modelId,
+		)
+	}
+}
diff --git a/src/services/code-index/embedders/factories/ollama-embedder-factory.ts b/src/services/code-index/embedders/factories/ollama-embedder-factory.ts
new file mode 100644
index 0000000000..4329cbbf42
--- /dev/null
+++ b/src/services/code-index/embedders/factories/ollama-embedder-factory.ts
@@ -0,0 +1,17 @@
+import type { CodeIndexConfig } from "../../interfaces/config"
+import type { IEmbedderFactory } from "../../interfaces/embedder-factory"
+import { CodeIndexOllamaEmbedder } from "../ollama"
+import { requireSetting } from "./require-setting"
+
+export class OllamaEmbedderFactory implements IEmbedderFactory {
+	create({ ollamaOptions, modelId }: CodeIndexConfig): CodeIndexOllamaEmbedder {
+		return new CodeIndexOllamaEmbedder({
+			...ollamaOptions,
+			ollamaBaseUrl: requireSetting(
+				ollamaOptions?.ollamaBaseUrl,
+				"embeddings:serviceFactory.ollamaConfigMissing",
+			),
+			ollamaModelId: modelId,
+		})
+	}
+}
diff --git a/src/services/code-index/embedders/factories/openai-compatible-embedder-factory.ts b/src/services/code-index/embedders/factories/openai-compatible-embedder-factory.ts
new file mode 100644
index 0000000000..827e171696
--- /dev/null
+++ b/src/services/code-index/embedders/factories/openai-compatible-embedder-factory.ts
@@ -0,0 +1,14 @@
+import type { CodeIndexConfig } from "../../interfaces/config"
+import type { IEmbedderFactory } from "../../interfaces/embedder-factory"
+import { OpenAICompatibleEmbedder } from "../openai-compatible"
+import { requireSetting } from "./require-setting"
+
+export class OpenAICompatibleEmbedderFactory implements IEmbedderFactory {
+	create({ openAiCompatibleOptions, modelId }: CodeIndexConfig): OpenAICompatibleEmbedder {
+		return new OpenAICompatibleEmbedder(
+			requireSetting(openAiCompatibleOptions?.baseUrl, "embeddings:validation.baseUrlRequired"),
+			requireSetting(openAiCompatibleOptions?.apiKey, "embeddings:validation.apiKeyRequired"),
+			modelId,
+		)
+	}
+}
diff --git a/src/services/code-index/embedders/factories/openai-embedder-factory.ts b/src/services/code-index/embedders/factories/openai-embedder-factory.ts
new file mode 100644
index 0000000000..e5d0cba5db
--- /dev/null
+++ b/src/services/code-index/embedders/factories/openai-embedder-factory.ts
@@ -0,0 +1,17 @@
+import type { CodeIndexConfig } from "../../interfaces/config"
+import type { IEmbedderFactory } from "../../interfaces/embedder-factory"
+import { OpenAiEmbedder } from "../openai"
+import { requireSetting } from "./require-setting"
+
+export class OpenAiEmbedderFactory implements IEmbedderFactory {
+	create({ openAiOptions, modelId }: CodeIndexConfig): OpenAiEmbedder {
+		return new OpenAiEmbedder({
+			...openAiOptions,
+			openAiNativeApiKey: requireSetting(
+				openAiOptions?.openAiNativeApiKey,
+				"embeddings:serviceFactory.openAiConfigMissing",
+			),
+			openAiEmbeddingModelId: modelId,
+		})
+	}
+}
diff --git a/src/services/code-index/embedders/factories/openrouter-embedder-factory.ts b/src/services/code-index/embedders/factories/openrouter-embedder-factory.ts
new file mode 100644
index 0000000000..7ec8338aa9
--- /dev/null
+++ b/src/services/code-index/embedders/factories/openrouter-embedder-factory.ts
@@ -0,0 +1,15 @@
+import type { CodeIndexConfig } from "../../interfaces/config"
+import type { IEmbedderFactory } from "../../interfaces/embedder-factory"
+import { OpenRouterEmbedder } from "../openrouter"
+import { requireSetting } from "./require-setting"
+
+export class OpenRouterEmbedderFactory implements IEmbedderFactory {
+	create({ openRouterOptions, modelId }: CodeIndexConfig): OpenRouterEmbedder {
+		return new OpenRouterEmbedder(
+			requireSetting(openRouterOptions?.apiKey, "embeddings:serviceFactory.openRouterConfigMissing"),
+			modelId,
+			undefined, // maxItemTokens
+			openRouterOptions?.specificProvider,
+		)
+	}
+}
diff --git a/src/services/code-index/embedders/factories/require-setting.ts b/src/services/code-index/embedders/factories/require-setting.ts
new file mode 100644
index 0000000000..56c31dad62
--- /dev/null
+++ b/src/services/code-index/embedders/factories/require-setting.ts
@@ -0,0 +1,8 @@
+import { t } from "../../../../i18n"
+
+export function requireSetting(value: string | undefined, errorKey: string): string {
+	if (!value) {
+		throw new Error(t(errorKey))
+	}
+	return value
+}
diff --git a/src/services/code-index/embedders/factories/vercel-ai-gateway-embedder-factory.ts b/src/services/code-index/embedders/factories/vercel-ai-gateway-embedder-factory.ts
new file mode 100644
index 0000000000..1f340b3a21
--- /dev/null
+++ b/src/services/code-index/embedders/factories/vercel-ai-gateway-embedder-factory.ts
@@ -0,0 +1,13 @@
+import type { CodeIndexConfig } from "../../interfaces/config"
+import type { IEmbedderFactory } from "../../interfaces/embedder-factory"
+import { VercelAiGatewayEmbedder } from "../vercel-ai-gateway"
+import { requireSetting } from "./require-setting"
+
+export class VercelAiGatewayEmbedderFactory implements IEmbedderFactory {
+	create({ vercelAiGatewayOptions, modelId }: CodeIndexConfig): VercelAiGatewayEmbedder {
+		return new VercelAiGatewayEmbedder(
+			requireSetting(vercelAiGatewayOptions?.apiKey, "embeddings:serviceFactory.vercelAiGatewayConfigMissing"),
+			modelId,
+		)
+	}
+}
diff --git a/src/services/code-index/interfaces/config.ts b/src/services/code-index/interfaces/config.ts
index f52f98aaa0..dc6986d3c6 100644
--- a/src/services/code-index/interfaces/config.ts
+++ b/src/services/code-index/interfaces/config.ts
@@ -1,48 +1,65 @@
-import { ApiHandlerOptions } from "../../../shared/api" // Adjust path if needed
 import { EmbedderProvider } from "./manager"
 
 /**
  * Configuration state for the code indexing feature
  */
 export interface CodeIndexConfig {
-	isConfigured: boolean
-	embedderProvider: EmbedderProvider
-	modelId?: string
-	modelDimension?: number // Generic dimension property for all providers
-	openAiOptions?: ApiHandlerOptions
-	ollamaOptions?: ApiHandlerOptions
-	openAiCompatibleOptions?: { baseUrl: string; apiKey: string }
-	geminiOptions?: { apiKey: string }
-	mistralOptions?: { apiKey: string }
-	vercelAiGatewayOptions?: { apiKey: string }
-	bedrockOptions?: { region: string; profile?: string }
-	openRouterOptions?: { apiKey: string; specificProvider?: string }
-	qdrantUrl?: string
-	qdrantApiKey?: string
-	searchMinScore?: number
-	searchMaxResults?: number
+	readonly isConfigured: boolean
+	readonly embedderProvider: EmbedderProvider
+	readonly modelId?: string
+	readonly modelDimension?: number // Generic dimension property for all providers
+	readonly openAiOptions?: Readonly<{ openAiNativeApiKey?: string }>
+	readonly ollamaOptions?: Readonly<{ ollamaBaseUrl?: string }>
+	readonly openAiCompatibleOptions?: Readonly<{ baseUrl: string; apiKey: string }>
+	readonly geminiOptions?: Readonly<{ apiKey: string }>
+	readonly mistralOptions?: Readonly<{ apiKey: string }>
+	readonly vercelAiGatewayOptions?: Readonly<{ apiKey: string }>
+	readonly bedrockOptions?: Readonly<{ region: string; profile?: string }>
+	readonly openRouterOptions?: Readonly<{ apiKey: string; specificProvider?: string }>
+	readonly qdrantUrl?: string
+	readonly qdrantApiKey?: string
+	readonly searchMinScore?: number
+	readonly searchMaxResults?: number
+}
+
+/**
+ * Stored configuration snapshot. Search defaults and readiness are derived by the manager.
+ * Every nested options object contains only scalar values and is readonly as well.
+ */
+export interface CodeIndexConfigSnapshot extends Omit<CodeIndexConfig, "isConfigured"> {
+	readonly codebaseIndexEnabled: boolean
+}
+
+/** Freeze the snapshot and its flat options objects before publishing it. */
+export function freezeCodeIndexConfigSnapshot(snapshot: CodeIndexConfigSnapshot): CodeIndexConfigSnapshot {
+	for (const value of Object.values(snapshot)) {
+		if (value !== null && typeof value === "object") {
+			Object.freeze(value)
+		}
+	}
+	return Object.freeze(snapshot)
 }
 
 /**
  * Snapshot of previous configuration used to determine if a restart is required
  */
 export type PreviousConfigSnapshot = {
-	enabled: boolean
-	configured: boolean
-	embedderProvider: EmbedderProvider
-	modelId?: string
-	modelDimension?: number // Generic dimension property
-	openAiKey?: string
-	ollamaBaseUrl?: string
-	openAiCompatibleBaseUrl?: string
-	openAiCompatibleApiKey?: string
-	geminiApiKey?: string
-	mistralApiKey?: string
-	vercelAiGatewayApiKey?: string
-	bedrockRegion?: string
-	bedrockProfile?: string
-	openRouterApiKey?: string
-	openRouterSpecificProvider?: string
-	qdrantUrl?: string
-	qdrantApiKey?: string
+	readonly enabled: boolean
+	readonly configured: boolean
+	readonly embedderProvider: EmbedderProvider
+	readonly modelId?: string
+	readonly modelDimension?: number // Generic dimension property
+	readonly openAiKey?: string
+	readonly ollamaBaseUrl?: string
+	readonly openAiCompatibleBaseUrl?: string
+	readonly openAiCompatibleApiKey?: string
+	readonly geminiApiKey?: string
+	readonly mistralApiKey?: string
+	readonly vercelAiGatewayApiKey?: string
+	readonly bedrockRegion?: string
+	readonly bedrockProfile?: string
+	readonly openRouterApiKey?: string
+	readonly openRouterSpecificProvider?: string
+	readonly qdrantUrl?: string
+	readonly qdrantApiKey?: string
 }
diff --git a/src/services/code-index/interfaces/directory-scanner-factory.ts b/src/services/code-index/interfaces/directory-scanner-factory.ts
new file mode 100644
index 0000000000..0e55a220bb
--- /dev/null
+++ b/src/services/code-index/interfaces/directory-scanner-factory.ts
@@ -0,0 +1,15 @@
+import type { Ignore } from "ignore"
+import type { CacheManager } from "../cache-manager"
+import type { ICodeParser, IDirectoryScanner, IEmbedder, IVectorStore } from "./index"
+
+export interface DirectoryScannerFactoryOptions {
+	embedder: IEmbedder
+	vectorStore: IVectorStore
+	parser: ICodeParser
+	cacheManager: CacheManager
+	ignoreInstance: Ignore
+}
+
+export interface IDirectoryScannerFactory {
+	create(options: DirectoryScannerFactoryOptions): IDirectoryScanner
+}
diff --git a/src/services/code-index/interfaces/embedder-factory.ts b/src/services/code-index/interfaces/embedder-factory.ts
new file mode 100644
index 0000000000..013b3f372b
--- /dev/null
+++ b/src/services/code-index/interfaces/embedder-factory.ts
@@ -0,0 +1,7 @@
+import type { CodeIndexConfig } from "./config"
+import type { IEmbedder } from "./index"
+
+/** Creates a vector embedder, validating the provider's required configuration. */
+export interface IEmbedderFactory {
+	create(config: CodeIndexConfig): IEmbedder
+}
diff --git a/src/services/code-index/interfaces/file-watcher-factory.ts b/src/services/code-index/interfaces/file-watcher-factory.ts
new file mode 100644
index 0000000000..94fc8882fc
--- /dev/null
+++ b/src/services/code-index/interfaces/file-watcher-factory.ts
@@ -0,0 +1,19 @@
+import type * as vscode from "vscode"
+import type { Ignore } from "ignore"
+import type { RooIgnoreController } from "../../../core/ignore/RooIgnoreController"
+import type { CacheManager } from "../cache-manager"
+import type { IEmbedder, IFileWatcher, IVectorStore } from "./index"
+
+export interface FileWatcherFactoryOptions {
+	workspacePath: string
+	context: vscode.ExtensionContext
+	embedder: IEmbedder
+	vectorStore: IVectorStore
+	cacheManager: CacheManager
+	ignoreInstance: Ignore
+	rooIgnoreController?: RooIgnoreController
+}
+
+export interface IFileWatcherFactory {
+	create(options: FileWatcherFactoryOptions): IFileWatcher
+}
diff --git a/src/services/code-index/interfaces/vector-store-factory.ts b/src/services/code-index/interfaces/vector-store-factory.ts
new file mode 100644
index 0000000000..4a4361ef35
--- /dev/null
+++ b/src/services/code-index/interfaces/vector-store-factory.ts
@@ -0,0 +1,6 @@
+import type { CodeIndexConfig } from "./config"
+import type { IVectorStore } from "./index"
+
+export interface IVectorStoreFactory {
+	create(config: CodeIndexConfig, workspacePath: string): IVectorStore
+}
diff --git a/src/services/code-index/manager.ts b/src/services/code-index/manager.ts
index ee181b17d6..bb186dc105 100644
--- a/src/services/code-index/manager.ts
+++ b/src/services/code-index/manager.ts
@@ -3,7 +3,7 @@ import { ContextProxy } from "../../core/config/ContextProxy"
 import { VectorStoreSearchResult } from "./interfaces"
 import { IndexingState } from "./interfaces/manager"
 import { CodeIndexConfigManager } from "./config-manager"
-import { CodeIndexStateManager } from "./state-manager"
+import type { CodeIndexStateManager } from "./state-manager"
 import { CodeIndexServiceFactory } from "./service-factory"
 import { CodeIndexSearchService } from "./search-service"
 import { CodeIndexOrchestrator } from "./orchestrator"
@@ -35,11 +35,16 @@ export class CodeIndexManager {
 	private readonly context: vscode.ExtensionContext
 
 	/** @internal — construct only via {@link CodeIndexManagerRegistry} */
-	public constructor(workspacePath: string, folderUri: vscode.Uri, context: vscode.ExtensionContext) {
+	public constructor(
+		workspacePath: string,
+		folderUri: vscode.Uri,
+		context: vscode.ExtensionContext,
+		stateManager: CodeIndexStateManager,
+	) {
 		this.workspacePath = workspacePath
 		this._folderUri = folderUri
 		this.context = context
-		this._stateManager = new CodeIndexStateManager()
+		this._stateManager = stateManager
 	}
 
 	// --- Public API ---
diff --git a/src/services/code-index/orchestrator.ts b/src/services/code-index/orchestrator.ts
index 1efe647be9..c055fff370 100644
--- a/src/services/code-index/orchestrator.ts
+++ b/src/services/code-index/orchestrator.ts
@@ -5,6 +5,7 @@ import { CodeIndexStateManager, IndexingState } from "./state-manager"
 import { IFileWatcher, IVectorStore, BatchProcessingSummary } from "./interfaces"
 import { DirectoryScanner } from "./processors"
 import { CacheManager } from "./cache-manager"
+import { CodeIndexScanExecutor } from "./code-index-scan-executor"
 import { TelemetryService } from "@roo-code/telemetry"
 import { TelemetryEventName } from "@roo-code/types"
 import { t } from "../../i18n"
@@ -16,16 +17,19 @@ export class CodeIndexOrchestrator {
 	private _fileWatcherSubscriptions: vscode.Disposable[] = []
 	private _isProcessing: boolean = false
 	private _abortController: AbortController | null = null
+	private readonly scanExecutor: CodeIndexScanExecutor
 
 	constructor(
 		private readonly configManager: CodeIndexConfigManager,
 		private readonly stateManager: CodeIndexStateManager,
-		private readonly workspacePath: string,
+		workspacePath: string,
 		private readonly cacheManager: CacheManager,
 		private readonly vectorStore: IVectorStore,
-		private readonly scanner: DirectoryScanner,
+		scanner: DirectoryScanner,
 		private readonly fileWatcher: IFileWatcher,
-	) {}
+	) {
+		this.scanExecutor = new CodeIndexScanExecutor(workspacePath, scanner, vectorStore, stateManager)
+	}
 
 	/**
 	 * Starts the file watcher if not already running.
@@ -145,65 +149,13 @@ export class CodeIndexOrchestrator {
 			const hasExistingData = await this.vectorStore.hasIndexedData()
 
 			if (hasExistingData && !collectionCreated) {
-				// Collection exists with data - run incremental scan to catch any new/changed files
-				// This handles files added while workspace was closed or Qdrant was inactive
-				console.log(
-					"[CodeIndexOrchestrator] Collection already has indexed data. Running incremental scan for new/changed files...",
-				)
-				this.stateManager.setSystemState("Indexing", "Checking for new or modified files...")
-
-				// Mark as incomplete at the start of incremental scan
-				await this.vectorStore.markIndexingIncomplete()
-
-				let cumulativeBlocksIndexed = 0
-				let cumulativeBlocksFoundSoFar = 0
-				const batchErrors: Error[] = []
-
-				const handleFileParsed = (fileBlockCount: number) => {
-					cumulativeBlocksFoundSoFar += fileBlockCount
-					this.stateManager.reportBlockIndexingProgress(cumulativeBlocksIndexed, cumulativeBlocksFoundSoFar)
-				}
-
-				const handleBlocksIndexed = (indexedCount: number) => {
-					cumulativeBlocksIndexed += indexedCount
-					this.stateManager.reportBlockIndexingProgress(cumulativeBlocksIndexed, cumulativeBlocksFoundSoFar)
-				}
-
-				// Run incremental scan - scanner will skip unchanged files using cache
-				const result = await this.scanner.scanDirectory(
-					this.workspacePath,
-					(batchError: Error) => {
-						console.error(
-							`[CodeIndexOrchestrator] Error during incremental scan batch: ${batchError.message}`,
-							batchError,
-						)
-						batchErrors.push(batchError)
-					},
-					handleBlocksIndexed,
-					handleFileParsed,
-					signal,
-				)
-
-				if (signal.aborted) {
+				if (!(await this.scanExecutor.runIncrementalScan(signal))) {
 					await this.cacheManager.flush()
 					this.stopWatcher()
 					this.stateManager.setSystemState("Standby", t("embeddings:orchestrator.indexingStopped"))
 					return
 				}
 
-				if (!result) {
-					throw new Error("Incremental scan failed, is scanner initialized?")
-				}
-
-				// If new files were found and indexed, log the results
-				if (cumulativeBlocksFoundSoFar > 0) {
-					console.log(
-						`[CodeIndexOrchestrator] Incremental scan completed: ${cumulativeBlocksIndexed} blocks indexed from new/changed files`,
-					)
-				} else {
-					console.log("[CodeIndexOrchestrator] No new or changed files found")
-				}
-
 				await this._startWatcher()
 
 				// Mark indexing as complete after successful incremental scan
@@ -211,88 +163,13 @@ export class CodeIndexOrchestrator {
 
 				this.stateManager.setSystemState("Indexed", t("embeddings:orchestrator.fileWatcherStarted"))
 			} else {
-				// No existing data or collection was just created - do a full scan
-				this.stateManager.setSystemState("Indexing", "Services ready. Starting workspace scan...")
-
-				// Mark as incomplete at the start of full scan
-				await this.vectorStore.markIndexingIncomplete()
-
-				let cumulativeBlocksIndexed = 0
-				let cumulativeBlocksFoundSoFar = 0
-				const batchErrors: Error[] = []
-
-				const handleFileParsed = (fileBlockCount: number) => {
-					cumulativeBlocksFoundSoFar += fileBlockCount
-					this.stateManager.reportBlockIndexingProgress(cumulativeBlocksIndexed, cumulativeBlocksFoundSoFar)
-				}
-
-				const handleBlocksIndexed = (indexedCount: number) => {
-					cumulativeBlocksIndexed += indexedCount
-					this.stateManager.reportBlockIndexingProgress(cumulativeBlocksIndexed, cumulativeBlocksFoundSoFar)
-				}
-
-				const result = await this.scanner.scanDirectory(
-					this.workspacePath,
-					(batchError: Error) => {
-						console.error(
-							`[CodeIndexOrchestrator] Error during initial scan batch: ${batchError.message}`,
-							batchError,
-						)
-						batchErrors.push(batchError)
-					},
-					handleBlocksIndexed,
-					handleFileParsed,
-					signal,
-				)
-
-				if (signal.aborted) {
+				if (!(await this.scanExecutor.runFullScan(signal))) {
 					await this.cacheManager.flush()
 					this.stopWatcher()
 					this.stateManager.setSystemState("Standby", t("embeddings:orchestrator.indexingStopped"))
 					return
 				}
 
-				if (!result) {
-					throw new Error("Scan failed, is scanner initialized?")
-				}
-
-				const { stats } = result
-
-				// Check if any blocks were actually indexed successfully
-				// If no blocks were indexed but blocks were found, it means all batches failed
-				if (cumulativeBlocksIndexed === 0 && cumulativeBlocksFoundSoFar > 0) {
-					if (batchErrors.length > 0) {
-						// Use the first batch error as it's likely representative of the main issue
-						const firstError = batchErrors[0]
-						throw new Error(`Indexing failed: ${firstError.message}`)
-					} else {
-						throw new Error(t("embeddings:orchestrator.indexingFailedNoBlocks"))
-					}
-				}
-
-				// Check for partial failures - if a significant portion of blocks failed
-				const failureRate = (cumulativeBlocksFoundSoFar - cumulativeBlocksIndexed) / cumulativeBlocksFoundSoFar
-				if (batchErrors.length > 0 && failureRate > 0.1) {
-					// More than 10% of blocks failed to index
-					const firstError = batchErrors[0]
-					throw new Error(
-						`Indexing partially failed: Only ${cumulativeBlocksIndexed} of ${cumulativeBlocksFoundSoFar} blocks were indexed. ${firstError.message}`,
-					)
-				}
-
-				// CRITICAL: If there were ANY batch errors and NO blocks were successfully indexed,
-				// this is a complete failure regardless of the failure rate calculation
-				if (batchErrors.length > 0 && cumulativeBlocksIndexed === 0) {
-					const firstError = batchErrors[0]
-					throw new Error(`Indexing failed completely: ${firstError.message}`)
-				}
-
-				// Final sanity check: If we found blocks but indexed none and somehow no errors were reported,
-				// this is still a failure
-				if (cumulativeBlocksFoundSoFar > 0 && cumulativeBlocksIndexed === 0) {
-					throw new Error(t("embeddings:orchestrator.indexingFailedCritical"))
-				}
-
 				await this._startWatcher()
 
 				// Mark indexing as complete after successful full scan
diff --git a/src/services/code-index/processors/__tests__/file-preparation.spec.ts b/src/services/code-index/processors/__tests__/file-preparation.spec.ts
new file mode 100644
index 0000000000..22020a9fdd
--- /dev/null
+++ b/src/services/code-index/processors/__tests__/file-preparation.spec.ts
@@ -0,0 +1,327 @@
+import { createHash } from "crypto"
+import path from "path"
+import { FileType, Uri } from "vscode"
+import { v5 as uuidv5 } from "uuid"
+import type { CodeBlock, ICodeParser, IEmbedder } from "../../interfaces"
+import { MAX_FILE_SIZE_BYTES, QDRANT_CODE_BLOCK_NAMESPACE } from "../../constants"
+import { FilePreparation } from "../file-preparation"
+import type { FilePreparationDependencies } from "../file-preparation-dependencies"
+
+// Keep path spies local to the modules under test, not Node or the test runner.
+vi.mock("path", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("path")>()
+	return { ...actual, default: { ...actual } }
+})
+
+describe.each(["posix", "win32"] as const)("FilePreparation (%s paths)", (platform) => {
+	beforeEach(() => {
+		vi.spyOn(path, "resolve").mockImplementation(path[platform].resolve)
+		vi.spyOn(path, "relative").mockImplementation(path[platform].relative)
+		vi.spyOn(path, "normalize").mockImplementation(path[platform].normalize)
+	})
+
+	afterEach(() => vi.restoreAllMocks())
+
+	const filePath = "/workspace/src/file.ts"
+	const relativeFilePath = path[platform].join("src", "file.ts")
+	const normalizedFilePath = path[platform].resolve(filePath)
+	const content = "test content"
+	const hash = createHash("sha256").update(content).digest("hex")
+	const block: CodeBlock = {
+		file_path: filePath,
+		identifier: null,
+		type: "function",
+		start_line: 2,
+		end_line: 5,
+		content,
+		fileHash: hash,
+		segmentHash: "segment",
+	}
+
+	function setup() {
+		return {
+			workspacePath: "/workspace",
+			ignoreController: {
+				validateAccess: vi
+					.fn<FilePreparationDependencies["ignoreController"]["validateAccess"]>()
+					.mockReturnValue(true),
+			},
+			ignoreInstance: { ignores: vi.fn<(path: string) => boolean>().mockReturnValue(false) },
+			fileSystem: {
+				stat: vi
+					.fn<FilePreparationDependencies["fileSystem"]["stat"]>()
+					.mockResolvedValue({ type: FileType.File, ctime: 0, mtime: 0, size: 100 }),
+				readFile: vi
+					.fn<FilePreparationDependencies["fileSystem"]["readFile"]>()
+					.mockResolvedValue(Buffer.from(content)),
+			},
+			cacheManager: { getHash: vi.fn<FilePreparationDependencies["cacheManager"]["getHash"]>() },
+			parser: { parseFile: vi.fn<ICodeParser["parseFile"]>().mockResolvedValue([{ ...block }]) },
+			embedder: {
+				createEmbeddings: vi
+					.fn<IEmbedder["createEmbeddings"]>()
+					.mockResolvedValue({ embeddings: [[0.1, 0.2]] }),
+			},
+		} satisfies FilePreparationDependencies
+	}
+
+	it.each([".git/config", ".hidden/file.ts", "node_modules/pkg/file.ts", "dist/file.js"])(
+		"skips excluded directory %s before access or file reads",
+		async (relativePath) => {
+			const dependencies = setup()
+			const path = `/workspace/${relativePath}`
+			expect(await new FilePreparation(dependencies).prepareFile(path)).toEqual({
+				path,
+				status: "skipped",
+				reason: "File is in an ignored directory",
+			})
+			expect(dependencies.ignoreController.validateAccess).not.toHaveBeenCalled()
+			expect(dependencies.ignoreInstance.ignores).not.toHaveBeenCalled()
+			expect(dependencies.fileSystem.stat).not.toHaveBeenCalled()
+			expect(dependencies.fileSystem.readFile).not.toHaveBeenCalled()
+			expect(dependencies.cacheManager.getHash).not.toHaveBeenCalled()
+			expect(dependencies.parser.parseFile).not.toHaveBeenCalled()
+			expect(dependencies.embedder.createEmbeddings).not.toHaveBeenCalled()
+		},
+	)
+
+	it.each(["access", "gitignore"])("skips %s exclusions before reading", async (source) => {
+		const dependencies = setup()
+		dependencies.ignoreController.validateAccess.mockReturnValue(source !== "access")
+		dependencies.ignoreInstance.ignores.mockReturnValue(source === "gitignore")
+		expect(await new FilePreparation(dependencies).prepareFile(filePath)).toEqual({
+			path: filePath,
+			status: "skipped",
+			reason: "File is ignored by .rooignore or .gitignore",
+		})
+		expect(dependencies.ignoreController.validateAccess).toHaveBeenCalledWith(filePath)
+		if (source === "access") {
+			expect(dependencies.ignoreInstance.ignores).not.toHaveBeenCalled()
+		} else {
+			expect(dependencies.ignoreInstance.ignores).toHaveBeenCalledWith(relativeFilePath)
+		}
+		expect(dependencies.fileSystem.stat).not.toHaveBeenCalled()
+		expect(dependencies.fileSystem.readFile).not.toHaveBeenCalled()
+		expect(dependencies.cacheManager.getHash).not.toHaveBeenCalled()
+		expect(dependencies.parser.parseFile).not.toHaveBeenCalled()
+		expect(dependencies.embedder.createEmbeddings).not.toHaveBeenCalled()
+	})
+
+	it("skips oversized files without reading them", async () => {
+		const dependencies = setup()
+		dependencies.fileSystem.stat.mockResolvedValue({
+			type: FileType.File,
+			ctime: 0,
+			mtime: 0,
+			size: MAX_FILE_SIZE_BYTES + 1,
+		})
+		expect(await new FilePreparation(dependencies).prepareFile(filePath)).toEqual({
+			path: filePath,
+			status: "skipped",
+			reason: "File is too large",
+		})
+		expect(dependencies.fileSystem.readFile).not.toHaveBeenCalled()
+		expect(dependencies.cacheManager.getHash).not.toHaveBeenCalled()
+		expect(dependencies.parser.parseFile).not.toHaveBeenCalled()
+		expect(dependencies.embedder.createEmbeddings).not.toHaveBeenCalled()
+	})
+
+	it("skips unchanged content before parsing or embedding", async () => {
+		const dependencies = setup()
+		dependencies.cacheManager.getHash.mockReturnValue(hash)
+		expect(await new FilePreparation(dependencies).prepareFile(filePath)).toEqual({
+			path: filePath,
+			status: "skipped",
+			reason: "File has not changed",
+		})
+		expect(dependencies.cacheManager.getHash).toHaveBeenCalledWith(filePath)
+		expect(dependencies.parser.parseFile).not.toHaveBeenCalled()
+		expect(dependencies.embedder.createEmbeddings).not.toHaveBeenCalled()
+	})
+
+	it("returns the hash and empty points when parsing produces no blocks", async () => {
+		const dependencies = setup()
+		dependencies.parser.parseFile.mockResolvedValue([])
+		expect(await new FilePreparation(dependencies).prepareFile(filePath)).toEqual({
+			path: filePath,
+			status: "processed_for_batching",
+			newHash: hash,
+			pointsToUpsert: [],
+		})
+		expect(dependencies.embedder.createEmbeddings).not.toHaveBeenCalled()
+	})
+
+	it("still parses and returns the hash without an embedder or gitignore", async () => {
+		const dependencies = setup()
+		expect(
+			await new FilePreparation({ ...dependencies, embedder: undefined, ignoreInstance: undefined }).prepareFile(
+				filePath,
+			),
+		).toEqual({
+			path: filePath,
+			status: "processed_for_batching",
+			newHash: hash,
+			pointsToUpsert: [],
+		})
+		expect(dependencies.parser.parseFile).toHaveBeenCalledWith(filePath, { content, fileHash: hash })
+	})
+
+	it("preserves normalized paths, stable IDs and embedding order at the size limit", async () => {
+		const dependencies = setup()
+		dependencies.fileSystem.stat.mockResolvedValue({
+			type: FileType.File,
+			ctime: 0,
+			mtime: 0,
+			size: MAX_FILE_SIZE_BYTES,
+		})
+		dependencies.parser.parseFile.mockResolvedValue([
+			{ ...block, file_path: "src/../src/file.ts" },
+			{ ...block, start_line: 8, end_line: 10, content: "second" },
+		])
+		dependencies.embedder.createEmbeddings.mockResolvedValue({
+			embeddings: [
+				[0.1, 0.2],
+				[0.3, 0.4],
+			],
+		})
+		expect(await new FilePreparation(dependencies).prepareFile(filePath)).toEqual({
+			path: filePath,
+			status: "processed_for_batching",
+			newHash: hash,
+			pointsToUpsert: [
+				{
+					id: uuidv5(`${normalizedFilePath}:2`, QDRANT_CODE_BLOCK_NAMESPACE),
+					vector: [0.1, 0.2],
+					payload: { filePath: relativeFilePath, codeChunk: content, startLine: 2, endLine: 5 },
+				},
+				{
+					id: uuidv5(`${normalizedFilePath}:8`, QDRANT_CODE_BLOCK_NAMESPACE),
+					vector: [0.3, 0.4],
+					payload: { filePath: relativeFilePath, codeChunk: "second", startLine: 8, endLine: 10 },
+				},
+			],
+		})
+		expect(dependencies.fileSystem.stat).toHaveBeenCalledWith(Uri.file(filePath))
+		expect(dependencies.fileSystem.readFile).toHaveBeenCalledWith(Uri.file(filePath))
+		expect(dependencies.parser.parseFile).toHaveBeenCalledWith(filePath, { content, fileHash: hash })
+		expect(dependencies.embedder.createEmbeddings).toHaveBeenCalledWith([content, "second"])
+	})
+
+	it("calls service methods with their original receivers", async () => {
+		const dependencies = setup()
+		expect((await new FilePreparation(dependencies).prepareFile(filePath)).status).toBe("processed_for_batching")
+		expect(dependencies.ignoreController.validateAccess).toHaveBeenCalledOnce()
+		expect(dependencies.ignoreController.validateAccess.mock.contexts[0]).toBe(dependencies.ignoreController)
+		expect(dependencies.ignoreInstance.ignores).toHaveBeenCalledOnce()
+		expect(dependencies.ignoreInstance.ignores.mock.contexts[0]).toBe(dependencies.ignoreInstance)
+		expect(dependencies.fileSystem.stat).toHaveBeenCalledOnce()
+		expect(dependencies.fileSystem.stat.mock.contexts[0]).toBe(dependencies.fileSystem)
+		expect(dependencies.fileSystem.readFile).toHaveBeenCalledOnce()
+		expect(dependencies.fileSystem.readFile.mock.contexts[0]).toBe(dependencies.fileSystem)
+		expect(dependencies.cacheManager.getHash).toHaveBeenCalledOnce()
+		expect(dependencies.cacheManager.getHash.mock.contexts[0]).toBe(dependencies.cacheManager)
+		expect(dependencies.parser.parseFile).toHaveBeenCalledOnce()
+		expect(dependencies.parser.parseFile.mock.contexts[0]).toBe(dependencies.parser)
+		expect(dependencies.embedder.createEmbeddings).toHaveBeenCalledOnce()
+		expect(dependencies.embedder.createEmbeddings.mock.contexts[0]).toBe(dependencies.embedder)
+	})
+
+	it("does not treat a hidden workspace ancestor as an excluded directory", async () => {
+		const dependencies = setup()
+		dependencies.workspacePath = "/.hidden/workspace"
+		expect((await new FilePreparation(dependencies).prepareFile("/.hidden/workspace/src/file.ts")).status).toBe(
+			"processed_for_batching",
+		)
+		expect(dependencies.ignoreInstance.ignores).toHaveBeenCalledWith(relativeFilePath)
+	})
+
+	describe.each(["Buffer", "Uint8Array"] as const)("UTF-8 decoding from %s", (representation) => {
+		it.each([
+			{ name: "ASCII", bytes: [65, 66], expectedContent: "AB" },
+			{
+				name: "Cyrillic, Spanish, CJK and emoji",
+				bytes: [...Buffer.from("Привет, español 中文 😀", "utf-8")],
+				expectedContent: "Привет, español 中文 😀",
+			},
+			{ name: "preserved BOM", bytes: [0xef, 0xbb, 0xbf, 65, 66], expectedContent: "\uFEFFAB" },
+			{ name: "empty content", bytes: [], expectedContent: "" },
+			{
+				name: "invalid and truncated UTF-8 sequences",
+				bytes: [65, 0xc3, 0x28, 0xff, 0xe2, 0x82],
+				expectedContent: "A\uFFFD(\uFFFD\uFFFD",
+			},
+			{
+				name: "sliced view with nonzero byteOffset",
+				bytes: [0x58, 65, 0xc3, 0xb1, 0x59],
+				expectedContent: "Añ",
+				sliced: true,
+			},
+		])("decodes and hashes $name, then skips the cached content", async ({ bytes, expectedContent, sliced }) => {
+			const dependencies = setup()
+			const backing = representation === "Buffer" ? Buffer.from(bytes) : new Uint8Array(bytes)
+			const fileContent = sliced ? backing.subarray(1, backing.length - 1) : backing
+			if (sliced) {
+				expect(fileContent.byteOffset).toBeGreaterThan(0)
+				expect(fileContent.byteLength).toBeLessThan(backing.byteLength)
+			}
+			dependencies.fileSystem.readFile.mockResolvedValue(fileContent)
+			dependencies.parser.parseFile.mockResolvedValue([])
+			// Hash the literal expected text, not the input bytes or the production decoder's output.
+			const expectedHash = createHash("sha256").update(expectedContent).digest("hex")
+			const preparation = new FilePreparation(dependencies)
+
+			expect(await preparation.prepareFile(filePath)).toEqual({
+				path: filePath,
+				status: "processed_for_batching",
+				newHash: expectedHash,
+				pointsToUpsert: [],
+			})
+			expect(dependencies.parser.parseFile).toHaveBeenCalledWith(filePath, {
+				content: expectedContent,
+				fileHash: expectedHash,
+			})
+
+			dependencies.parser.parseFile.mockClear()
+			dependencies.cacheManager.getHash.mockReturnValue(expectedHash)
+			expect(await preparation.prepareFile(filePath)).toEqual({
+				path: filePath,
+				status: "skipped",
+				reason: "File has not changed",
+			})
+			expect(dependencies.cacheManager.getHash).toHaveBeenCalledWith(filePath)
+			expect(dependencies.parser.parseFile).not.toHaveBeenCalled()
+			expect(dependencies.embedder.createEmbeddings).not.toHaveBeenCalled()
+		})
+	})
+
+	it.each(["access", "ignore", "stat", "read", "cache", "parse", "embed"])(
+		"returns the original %s error as a local error",
+		async (stage) => {
+			const dependencies = setup()
+			const error = new Error(`${stage} failed`)
+			const fail = () => {
+				throw error
+			}
+			if (stage === "access") dependencies.ignoreController.validateAccess.mockImplementation(fail)
+			if (stage === "ignore") dependencies.ignoreInstance.ignores.mockImplementation(fail)
+			if (stage === "stat") dependencies.fileSystem.stat.mockRejectedValue(error)
+			if (stage === "read") dependencies.fileSystem.readFile.mockRejectedValue(error)
+			if (stage === "cache") dependencies.cacheManager.getHash.mockImplementation(fail)
+			if (stage === "parse") dependencies.parser.parseFile.mockRejectedValue(error)
+			if (stage === "embed") dependencies.embedder.createEmbeddings.mockRejectedValue(error)
+			const result = await new FilePreparation(dependencies).prepareFile(filePath)
+			expect(result).toEqual({ path: filePath, status: "local_error", error })
+			expect(result.error).toBe(error)
+		},
+	)
+
+	it("does not wrap non-Error rejections", async () => {
+		const dependencies = setup()
+		dependencies.fileSystem.readFile.mockRejectedValue("read failed")
+		expect(await new FilePreparation(dependencies).prepareFile(filePath)).toEqual({
+			path: filePath,
+			status: "local_error",
+			error: "read failed",
+		})
+	})
+})
diff --git a/src/services/code-index/processors/__tests__/file-watcher.spec.ts b/src/services/code-index/processors/__tests__/file-watcher.spec.ts
index fc61e687bd..736cca0806 100644
--- a/src/services/code-index/processors/__tests__/file-watcher.spec.ts
+++ b/src/services/code-index/processors/__tests__/file-watcher.spec.ts
@@ -3,6 +3,7 @@
 import * as vscode from "vscode"
 
 import { FileWatcher } from "../file-watcher"
+import { FilePreparation } from "../file-preparation"
 
 import { clearAllMocks } from "../../../../test-utils/reset"
 
@@ -182,6 +183,38 @@ describe("FileWatcher", () => {
 		vi.useRealTimers()
 	})
 
+	it("reuses constructor-created preparation for public processFile without writing points or cache", async () => {
+		const prepare = vi.spyOn(FilePreparation.prototype, "prepareFile")
+		try {
+			const preparation = fileWatcher["filePreparation"]
+			expect(preparation).toBeInstanceOf(FilePreparation)
+			expect(preparation["dependencies"].fileSystem).toBe(vscode.workspace.fs)
+			expect(preparation["dependencies"].cacheManager).toBe(mockCacheManager)
+			expect(preparation["dependencies"].ignoreController).toBe(fileWatcher["ignoreController"])
+			const path = "/mock/workspace/src/file.ts"
+			const result = await fileWatcher.processFile(path)
+			expect(prepare).toHaveBeenNthCalledWith(1, path)
+			expect(result).toBe(await prepare.mock.results[0].value)
+			expect(result.status).toBe("processed_for_batching")
+			expect(result.pointsToUpsert).toHaveLength(1)
+			expect(vscode.workspace.fs.stat).toHaveBeenCalledWith(vscode.Uri.file(path))
+			expect(vscode.workspace.fs.readFile).toHaveBeenCalledWith(vscode.Uri.file(path))
+			const secondPath = "/mock/workspace/src/second.ts"
+			const secondResult = await fileWatcher.processFile(secondPath)
+			expect(prepare).toHaveBeenCalledTimes(2)
+			expect(prepare).toHaveBeenNthCalledWith(2, secondPath)
+			expect(prepare.mock.contexts[0]).toBe(preparation)
+			expect(prepare.mock.contexts[1]).toBe(preparation)
+			expect(secondResult).toBe(await prepare.mock.results[1].value)
+			expect(secondResult.status).toBe("processed_for_batching")
+			expect(mockVectorStore.upsertPoints).not.toHaveBeenCalled()
+			expect(mockCacheManager.updateHash).not.toHaveBeenCalled()
+			expect(mockCacheManager.deleteHash).not.toHaveBeenCalled()
+		} finally {
+			prepare.mockRestore()
+		}
+	})
+
 	describe("file filtering", () => {
 		it("should ignore files in hidden directories on create events", async () => {
 			// Initialize the file watcher
diff --git a/src/services/code-index/processors/__tests__/processor-factories.spec.ts b/src/services/code-index/processors/__tests__/processor-factories.spec.ts
new file mode 100644
index 0000000000..4af92c14cd
--- /dev/null
+++ b/src/services/code-index/processors/__tests__/processor-factories.spec.ts
@@ -0,0 +1,186 @@
+import * as vscode from "vscode"
+import ignore from "ignore"
+import { makeExtensionContext } from "../../../../test-utils/vscode"
+import { Package } from "../../../../shared/package"
+import { CacheManager } from "../../cache-manager"
+import { BATCH_SEGMENT_THRESHOLD } from "../../constants"
+import { OpenAiEmbedder } from "../../embedders/openai"
+import { QdrantVectorStore } from "../../vector-store/qdrant-client"
+import { CodeIndexServiceFactory } from "../../service-factory"
+import { CodeIndexConfigManager } from "../../config-manager"
+import { EmbedderFactory } from "../../embedders/embedder-factory"
+import { VectorStoreFactory } from "../../vector-store/vector-store-factory"
+import type { CodeIndexConfig } from "../../interfaces/config"
+import { DirectoryScannerFactory } from "../directory-scanner-factory"
+import { FileWatcherFactory } from "../file-watcher-factory"
+import { getEmbeddingBatchSize } from "../get-embedding-batch-size"
+import { codeParser } from "../parser"
+import { DirectoryScanner } from "../scanner"
+import { FileWatcher } from "../file-watcher"
+
+vi.mock("vscode", () => ({
+	workspace: { getConfiguration: vi.fn(() => ({ get: vi.fn() })) },
+}))
+vi.mock("../../cache-manager")
+vi.mock("../../embedders/openai")
+vi.mock("../../vector-store/qdrant-client")
+vi.mock("../../config-manager")
+vi.mock("../parser", () => ({ codeParser: { parseFile: vi.fn() } }))
+vi.mock("../scanner")
+vi.mock("../file-watcher")
+
+describe("processor factories", () => {
+	beforeEach(() => vi.clearAllMocks())
+	afterEach(() => vi.restoreAllMocks())
+
+	function dependencies() {
+		const context = makeExtensionContext()
+		return {
+			context,
+			workspacePath: "/workspace",
+			cacheManager: new CacheManager(context, "/workspace"),
+			embedder: new OpenAiEmbedder({ openAiNativeApiKey: "test-key" }),
+			vectorStore: new QdrantVectorStore("/workspace", "http://localhost:6333", 512),
+			parser: codeParser,
+			ignoreInstance: ignore(),
+		}
+	}
+
+	it.each([32, BATCH_SEGMENT_THRESHOLD])(
+		"passes batch size %s and dependencies to both constructors",
+		(batchSize) => {
+			const configuration = vscode.workspace.getConfiguration()
+			vi.mocked(configuration.get).mockReturnValue(batchSize)
+			vi.mocked(vscode.workspace.getConfiguration).mockReturnValue(configuration)
+			const options = dependencies()
+
+			const scanner = new DirectoryScannerFactory().create(options)
+			const watcher = new FileWatcherFactory().create(options)
+
+			expect(scanner).toBeInstanceOf(DirectoryScanner)
+			expect(watcher).toBeInstanceOf(FileWatcher)
+			expect(DirectoryScanner).toHaveBeenCalledWith(
+				options.embedder,
+				options.vectorStore,
+				options.parser,
+				options.cacheManager,
+				options.ignoreInstance,
+				batchSize,
+			)
+			expect(FileWatcher).toHaveBeenCalledWith(
+				options.workspacePath,
+				options.context,
+				options.cacheManager,
+				options.embedder,
+				options.vectorStore,
+				options.ignoreInstance,
+				undefined,
+				batchSize,
+			)
+			expect(vscode.workspace.getConfiguration).toHaveBeenCalledWith(Package.name)
+			expect(configuration.get).toHaveBeenCalledWith("codeIndex.embeddingBatchSize", BATCH_SEGMENT_THRESHOLD)
+		},
+	)
+
+	it("reads settings again for each creation and returns fresh instances", () => {
+		const configuration = vscode.workspace.getConfiguration()
+		vi.mocked(configuration.get)
+			.mockReturnValueOnce(32)
+			.mockReturnValueOnce(64)
+			.mockReturnValueOnce(128)
+			.mockReturnValueOnce(256)
+		vi.mocked(vscode.workspace.getConfiguration).mockReturnValue(configuration)
+		const options = dependencies()
+		const scanners = new DirectoryScannerFactory()
+		const watchers = new FileWatcherFactory()
+
+		expect(scanners.create(options)).not.toBe(scanners.create(options))
+		expect(watchers.create(options)).not.toBe(watchers.create(options))
+		expect(vi.mocked(DirectoryScanner).mock.calls.map((args) => args[5])).toEqual([32, 64])
+		expect(vi.mocked(FileWatcher).mock.calls.map((args) => args[7])).toEqual([128, 256])
+	})
+
+	it("uses the fallback when retrieving configuration throws", () => {
+		const warn = vi.spyOn(console, "warn").mockImplementation(() => {})
+		const error = new Error("unavailable")
+		vi.mocked(vscode.workspace.getConfiguration).mockImplementationOnce(() => {
+			throw error
+		})
+		expect(getEmbeddingBatchSize()).toBe(BATCH_SEGMENT_THRESHOLD)
+		expect(warn).toHaveBeenCalledExactlyOnceWith(
+			`[getEmbeddingBatchSize] Failed to read codeIndex.embeddingBatchSize; using default ${BATCH_SEGMENT_THRESHOLD}.`,
+			error,
+		)
+	})
+
+	it("uses the fallback when reading the setting throws", () => {
+		const warn = vi.spyOn(console, "warn").mockImplementation(() => {})
+		const error = new Error("unavailable")
+		const configuration = vscode.workspace.getConfiguration()
+		vi.mocked(configuration.get).mockImplementationOnce(() => {
+			throw error
+		})
+		vi.mocked(vscode.workspace.getConfiguration).mockReturnValue(configuration)
+		expect(getEmbeddingBatchSize()).toBe(BATCH_SEGMENT_THRESHOLD)
+		expect(warn).toHaveBeenCalledExactlyOnceWith(
+			`[getEmbeddingBatchSize] Failed to read codeIndex.embeddingBatchSize; using default ${BATCH_SEGMENT_THRESHOLD}.`,
+			error,
+		)
+	})
+
+	it("does not log a warning when reading the setting succeeds", () => {
+		const warn = vi.spyOn(console, "warn").mockImplementation(() => {})
+		const configuration = vscode.workspace.getConfiguration()
+		vi.mocked(configuration.get).mockReturnValue(32)
+		vi.mocked(vscode.workspace.getConfiguration).mockReturnValue(configuration)
+
+		expect(getEmbeddingBatchSize()).toBe(32)
+		expect(warn).not.toHaveBeenCalled()
+	})
+
+	it("preserves service factory wiring, including the explicitly supplied watcher cache", () => {
+		const options = dependencies()
+		const watcherCache = new CacheManager(options.context, "/workspace")
+		const configManager = Object.create(CodeIndexConfigManager.prototype) as CodeIndexConfigManager
+		const config: CodeIndexConfig = { isConfigured: true, embedderProvider: "openai-compatible" }
+		Object.defineProperty(configManager, "isFeatureConfigured", { value: true })
+		vi.mocked(configManager.getConfig).mockReturnValue(config)
+		const createEmbedder = vi.spyOn(EmbedderFactory.prototype, "create").mockReturnValue(options.embedder)
+		const createVectorStore = vi.spyOn(VectorStoreFactory.prototype, "create").mockReturnValue(options.vectorStore)
+		const factory = new CodeIndexServiceFactory(configManager, options.workspacePath, options.cacheManager)
+
+		const services = factory.createServices(options.context, watcherCache, options.ignoreInstance)
+
+		expect(configManager.getConfig).toHaveBeenCalledTimes(1)
+		expect(createEmbedder).toHaveBeenCalledExactlyOnceWith(config)
+		expect(createVectorStore).toHaveBeenCalledExactlyOnceWith(config, options.workspacePath)
+		expect(services).toEqual({
+			embedder: options.embedder,
+			vectorStore: options.vectorStore,
+			parser: codeParser,
+			scanner: vi.mocked(DirectoryScanner).mock.instances[0],
+			fileWatcher: vi.mocked(FileWatcher).mock.instances[0],
+		})
+		expect(vi.mocked(DirectoryScanner).mock.calls[0][3]).toBe(options.cacheManager)
+		expect(vi.mocked(FileWatcher).mock.calls[0][2]).toBe(watcherCache)
+		expect(vi.mocked(FileWatcher).mock.calls[0][0]).toBe(options.workspacePath)
+	})
+
+	it("does not create services when indexing is not configured", () => {
+		const options = dependencies()
+		const configManager = Object.create(CodeIndexConfigManager.prototype) as CodeIndexConfigManager
+		Object.defineProperty(configManager, "isFeatureConfigured", { value: false })
+		const createEmbedder = vi.spyOn(EmbedderFactory.prototype, "create")
+		const createVectorStore = vi.spyOn(VectorStoreFactory.prototype, "create")
+		const factory = new CodeIndexServiceFactory(configManager, options.workspacePath, options.cacheManager)
+
+		expect(() => factory.createServices(options.context, options.cacheManager, options.ignoreInstance)).toThrow(
+			"serviceFactory.codeIndexingNotConfigured",
+		)
+		expect(configManager.getConfig).not.toHaveBeenCalled()
+		expect(createEmbedder).not.toHaveBeenCalled()
+		expect(createVectorStore).not.toHaveBeenCalled()
+		expect(DirectoryScanner).not.toHaveBeenCalled()
+		expect(FileWatcher).not.toHaveBeenCalled()
+	})
+})
diff --git a/src/services/code-index/processors/directory-scanner-factory.ts b/src/services/code-index/processors/directory-scanner-factory.ts
new file mode 100644
index 0000000000..099aa6d261
--- /dev/null
+++ b/src/services/code-index/processors/directory-scanner-factory.ts
@@ -0,0 +1,22 @@
+import type { DirectoryScannerFactoryOptions, IDirectoryScannerFactory } from "../interfaces/directory-scanner-factory"
+import { DirectoryScanner } from "./scanner"
+import { getEmbeddingBatchSize } from "./get-embedding-batch-size"
+
+export class DirectoryScannerFactory implements IDirectoryScannerFactory {
+	public create({
+		embedder,
+		vectorStore,
+		parser,
+		cacheManager,
+		ignoreInstance,
+	}: DirectoryScannerFactoryOptions): DirectoryScanner {
+		return new DirectoryScanner(
+			embedder,
+			vectorStore,
+			parser,
+			cacheManager,
+			ignoreInstance,
+			getEmbeddingBatchSize(),
+		)
+	}
+}
diff --git a/src/services/code-index/processors/file-preparation-dependencies.ts b/src/services/code-index/processors/file-preparation-dependencies.ts
new file mode 100644
index 0000000000..001da428d7
--- /dev/null
+++ b/src/services/code-index/processors/file-preparation-dependencies.ts
@@ -0,0 +1,15 @@
+import type { Ignore } from "ignore"
+import type { FileSystem } from "vscode"
+import type { RooIgnoreController } from "../../../core/ignore/RooIgnoreController"
+import type { CacheManager } from "../cache-manager"
+import type { ICodeParser, IEmbedder } from "../interfaces"
+
+export interface FilePreparationDependencies {
+	workspacePath: string
+	ignoreController: Pick<RooIgnoreController, "validateAccess">
+	ignoreInstance?: Pick<Ignore, "ignores">
+	fileSystem: Pick<FileSystem, "stat" | "readFile">
+	cacheManager: Pick<CacheManager, "getHash">
+	parser: ICodeParser
+	embedder?: Pick<IEmbedder, "createEmbeddings">
+}
diff --git a/src/services/code-index/processors/file-preparation.ts b/src/services/code-index/processors/file-preparation.ts
new file mode 100644
index 0000000000..a99ff6b56a
--- /dev/null
+++ b/src/services/code-index/processors/file-preparation.ts
@@ -0,0 +1,100 @@
+import { createHash } from "crypto"
+import { Uri } from "vscode"
+import { v5 as uuidv5 } from "uuid"
+import type { CodeBlock, FileProcessingResult, PointStruct } from "../interfaces"
+import type { FilePreparationDependencies } from "./file-preparation-dependencies"
+import { MAX_FILE_SIZE_BYTES, QDRANT_CODE_BLOCK_NAMESPACE } from "../constants"
+import { generateNormalizedAbsolutePath, generateRelativeFilePath } from "../shared/get-relative-path"
+import { isPathInIgnoredDirectory } from "../../glob/ignore-utils"
+
+/** Prepares one file for batching without writing points or mutating the hash cache. */
+export class FilePreparation {
+	constructor(private readonly dependencies: FilePreparationDependencies) {}
+
+	public async prepareFile(filePath: string): Promise<FileProcessingResult> {
+		const dependencies = this.dependencies
+		try {
+			const skipReason = await this.getSkipReason(filePath)
+			if (skipReason !== undefined) {
+				return this.skippedResult(filePath, skipReason)
+			}
+
+			const fileContent = await dependencies.fileSystem.readFile(Uri.file(filePath))
+			const content = Buffer.from(fileContent).toString("utf-8")
+			const newHash = createHash("sha256").update(content).digest("hex")
+
+			if (dependencies.cacheManager.getHash(filePath) === newHash) {
+				return this.skippedResult(filePath, "File has not changed")
+			}
+
+			const blocks = await dependencies.parser.parseFile(filePath, { content, fileHash: newHash })
+			const pointsToUpsert = await this.preparePoints(blocks)
+
+			return {
+				path: filePath,
+				status: "processed_for_batching",
+				newHash,
+				pointsToUpsert,
+			}
+		} catch (error) {
+			return {
+				path: filePath,
+				status: "local_error",
+				error: error as Error,
+			}
+		}
+	}
+
+	private async getSkipReason(filePath: string): Promise<string | undefined> {
+		const dependencies = this.dependencies
+		// Use relative paths so ignored directories outside the workspace do not exclude the file.
+		const relativeFilePath = generateRelativeFilePath(filePath, dependencies.workspacePath)
+		if (isPathInIgnoredDirectory(relativeFilePath)) {
+			return "File is in an ignored directory"
+		}
+
+		if (
+			!dependencies.ignoreController.validateAccess(filePath) ||
+			dependencies.ignoreInstance?.ignores(relativeFilePath)
+		) {
+			return "File is ignored by .rooignore or .gitignore"
+		}
+
+		const fileStat = await dependencies.fileSystem.stat(Uri.file(filePath))
+		if (fileStat.size > MAX_FILE_SIZE_BYTES) {
+			return "File is too large"
+		}
+		return undefined
+	}
+
+	private skippedResult(filePath: string, reason: string): FileProcessingResult {
+		return { path: filePath, status: "skipped", reason }
+	}
+
+	private async preparePoints(blocks: CodeBlock[]): Promise<PointStruct[]> {
+		const dependencies = this.dependencies
+		if (!dependencies.embedder || blocks.length === 0) {
+			return []
+		}
+
+		const texts = blocks.map((block) => block.content)
+		const { embeddings } = await dependencies.embedder.createEmbeddings(texts)
+
+		return blocks.map((block, index) => {
+			const normalizedAbsolutePath = generateNormalizedAbsolutePath(block.file_path, dependencies.workspacePath)
+			const stableName = `${normalizedAbsolutePath}:${block.start_line}`
+			const pointId = uuidv5(stableName, QDRANT_CODE_BLOCK_NAMESPACE)
+
+			return {
+				id: pointId,
+				vector: embeddings[index],
+				payload: {
+					filePath: generateRelativeFilePath(normalizedAbsolutePath, dependencies.workspacePath),
+					codeChunk: block.content,
+					startLine: block.start_line,
+					endLine: block.end_line,
+				},
+			}
+		})
+	}
+}
diff --git a/src/services/code-index/processors/file-watcher-factory.ts b/src/services/code-index/processors/file-watcher-factory.ts
new file mode 100644
index 0000000000..2f4cc227b6
--- /dev/null
+++ b/src/services/code-index/processors/file-watcher-factory.ts
@@ -0,0 +1,27 @@
+import type { IFileWatcher } from "../interfaces"
+import type { FileWatcherFactoryOptions, IFileWatcherFactory } from "../interfaces/file-watcher-factory"
+import { FileWatcher } from "./file-watcher"
+import { getEmbeddingBatchSize } from "./get-embedding-batch-size"
+
+export class FileWatcherFactory implements IFileWatcherFactory {
+	public create({
+		workspacePath,
+		context,
+		cacheManager,
+		embedder,
+		vectorStore,
+		ignoreInstance,
+		rooIgnoreController,
+	}: FileWatcherFactoryOptions): IFileWatcher {
+		return new FileWatcher(
+			workspacePath,
+			context,
+			cacheManager,
+			embedder,
+			vectorStore,
+			ignoreInstance,
+			rooIgnoreController,
+			getEmbeddingBatchSize(),
+		)
+	}
+}
diff --git a/src/services/code-index/processors/file-watcher.ts b/src/services/code-index/processors/file-watcher.ts
index a6a3122c36..933947bbe2 100644
--- a/src/services/code-index/processors/file-watcher.ts
+++ b/src/services/code-index/processors/file-watcher.ts
@@ -1,14 +1,6 @@
 import * as vscode from "vscode"
-import {
-	QDRANT_CODE_BLOCK_NAMESPACE,
-	MAX_FILE_SIZE_BYTES,
-	BATCH_SEGMENT_THRESHOLD,
-	MAX_BATCH_RETRIES,
-	INITIAL_RETRY_DELAY_MS,
-} from "../constants"
-import { createHash } from "crypto"
+import { BATCH_SEGMENT_THRESHOLD, MAX_BATCH_RETRIES, INITIAL_RETRY_DELAY_MS } from "../constants"
 import { RooIgnoreController } from "../../../core/ignore/RooIgnoreController"
-import { v5 as uuidv5 } from "uuid"
 import { Ignore } from "ignore"
 import { scannerExtensions } from "../shared/supported-extensions"
 import {
@@ -20,9 +12,8 @@ import {
 	BatchProcessingSummary,
 } from "../interfaces"
 import { codeParser } from "./parser"
+import { FilePreparation } from "./file-preparation"
 import { CacheManager } from "../cache-manager"
-import { generateNormalizedAbsolutePath, generateRelativeFilePath } from "../shared/get-relative-path"
-import { isPathInIgnoredDirectory } from "../../glob/ignore-utils"
 import { TelemetryService } from "@roo-code/telemetry"
 import { TelemetryEventName } from "@roo-code/types"
 import { sanitizeErrorMessage } from "../shared/validation-helpers"
@@ -32,6 +23,7 @@ import { Package } from "../../../shared/package"
  * Implementation of the file watcher interface
  */
 export class FileWatcher implements IFileWatcher {
+	private readonly filePreparation: FilePreparation
 	private ignoreInstance?: Ignore
 	private fileWatcher?: vscode.FileSystemWatcher
 	private ignoreController: RooIgnoreController
@@ -86,6 +78,15 @@ export class FileWatcher implements IFileWatcher {
 		if (ignoreInstance) {
 			this.ignoreInstance = ignoreInstance
 		}
+		this.filePreparation = new FilePreparation({
+			workspacePath: this.workspacePath,
+			ignoreController: this.ignoreController,
+			ignoreInstance: this.ignoreInstance,
+			fileSystem: vscode.workspace.fs,
+			cacheManager: this.cacheManager,
+			parser: codeParser,
+			embedder: this.embedder,
+		})
 		// Get the configurable batch size from VSCode settings, fallback to default
 		// If not provided in constructor, try to get from VSCode settings
 		if (batchSegmentThreshold !== undefined) {
@@ -507,97 +508,6 @@ export class FileWatcher implements IFileWatcher {
 	 * @returns Promise resolving to processing result
 	 */
 	async processFile(filePath: string): Promise<FileProcessingResult> {
-		try {
-			// Get relative path for ignore checks
-			const relativeFilePath = generateRelativeFilePath(filePath, this.workspacePath)
-
-			// Check if file is in an ignored directory
-			// Use relative path to avoid matching parent directories outside the workspace
-			if (isPathInIgnoredDirectory(relativeFilePath)) {
-				return {
-					path: filePath,
-					status: "skipped" as const,
-					reason: "File is in an ignored directory",
-				}
-			}
-
-			// Check if file should be ignored
-			if (
-				!this.ignoreController.validateAccess(filePath) ||
-				(this.ignoreInstance && this.ignoreInstance.ignores(relativeFilePath))
-			) {
-				return {
-					path: filePath,
-					status: "skipped" as const,
-					reason: "File is ignored by .rooignore or .gitignore",
-				}
-			}
-
-			// Check file size
-			const fileStat = await vscode.workspace.fs.stat(vscode.Uri.file(filePath))
-			if (fileStat.size > MAX_FILE_SIZE_BYTES) {
-				return {
-					path: filePath,
-					status: "skipped" as const,
-					reason: "File is too large",
-				}
-			}
-
-			// Read file content
-			const fileContent = await vscode.workspace.fs.readFile(vscode.Uri.file(filePath))
-			const content = fileContent.toString()
-
-			// Calculate hash
-			const newHash = createHash("sha256").update(content).digest("hex")
-
-			// Check if file has changed
-			if (this.cacheManager.getHash(filePath) === newHash) {
-				return {
-					path: filePath,
-					status: "skipped" as const,
-					reason: "File has not changed",
-				}
-			}
-
-			// Parse file
-			const blocks = await codeParser.parseFile(filePath, { content, fileHash: newHash })
-
-			// Prepare points for batch processing
-			let pointsToUpsert: PointStruct[] = []
-			if (this.embedder && blocks.length > 0) {
-				const texts = blocks.map((block) => block.content)
-				const { embeddings } = await this.embedder.createEmbeddings(texts)
-
-				pointsToUpsert = blocks.map((block, index) => {
-					const normalizedAbsolutePath = generateNormalizedAbsolutePath(block.file_path, this.workspacePath)
-					const stableName = `${normalizedAbsolutePath}:${block.start_line}`
-					const pointId = uuidv5(stableName, QDRANT_CODE_BLOCK_NAMESPACE)
-
-					return {
-						id: pointId,
-						vector: embeddings[index],
-						payload: {
-							filePath: generateRelativeFilePath(normalizedAbsolutePath, this.workspacePath),
-							codeChunk: block.content,
-							startLine: block.start_line,
-							endLine: block.end_line,
-						},
-					}
-				})
-			}
-
-			return {
-				path: filePath,
-				status: "processed_for_batching" as const,
-				newHash,
-				pointsToUpsert,
-			}
-		} catch (error) {
-			return {
-				path: filePath,
-				status: "local_error" as const,
-				error: error as Error,
-			}
-		}
+		return this.filePreparation.prepareFile(filePath)
 	}
 }
diff --git a/src/services/code-index/processors/get-embedding-batch-size.ts b/src/services/code-index/processors/get-embedding-batch-size.ts
new file mode 100644
index 0000000000..c5c5b28c6a
--- /dev/null
+++ b/src/services/code-index/processors/get-embedding-batch-size.ts
@@ -0,0 +1,17 @@
+import * as vscode from "vscode"
+import { Package } from "../../../shared/package"
+import { BATCH_SEGMENT_THRESHOLD } from "../constants"
+
+export function getEmbeddingBatchSize(): number {
+	try {
+		return vscode.workspace
+			.getConfiguration(Package.name)
+			.get<number>("codeIndex.embeddingBatchSize", BATCH_SEGMENT_THRESHOLD)
+	} catch (error) {
+		console.warn(
+			`[getEmbeddingBatchSize] Failed to read codeIndex.embeddingBatchSize; using default ${BATCH_SEGMENT_THRESHOLD}.`,
+			error,
+		)
+		return BATCH_SEGMENT_THRESHOLD
+	}
+}
diff --git a/src/services/code-index/service-factory.ts b/src/services/code-index/service-factory.ts
index beab32ad02..d2bbe43f2a 100644
--- a/src/services/code-index/service-factory.ts
+++ b/src/services/code-index/service-factory.ts
@@ -1,249 +1,48 @@
-import * as vscode from "vscode"
+import type * as vscode from "vscode"
 import { Ignore } from "ignore"
 
-import type { EmbedderProvider } from "@roo-code/types"
-import { TelemetryService } from "@roo-code/telemetry"
-import { TelemetryEventName } from "@roo-code/types"
-
 import { t } from "../../i18n"
 
-import { getDefaultModelId, getModelDimension } from "../../shared/embeddingModels"
-import { Package } from "../../shared/package"
-
 import { RooIgnoreController } from "../../core/ignore/RooIgnoreController"
 
-import { OpenAiEmbedder } from "./embedders/openai"
-import { CodeIndexOllamaEmbedder } from "./embedders/ollama"
-import { OpenAICompatibleEmbedder } from "./embedders/openai-compatible"
-import { GeminiEmbedder } from "./embedders/gemini"
-import { MistralEmbedder } from "./embedders/mistral"
-import { VercelAiGatewayEmbedder } from "./embedders/vercel-ai-gateway"
-import { BedrockEmbedder } from "./embedders/bedrock"
-import { OpenRouterEmbedder } from "./embedders/openrouter"
-import { QdrantVectorStore } from "./vector-store/qdrant-client"
-import { codeParser, DirectoryScanner, FileWatcher } from "./processors"
+import { EmbedderFactory } from "./embedders/embedder-factory"
+import { EmbedderValidationManager } from "./embedders/embedder-validation-manager"
+import { VectorStoreFactory } from "./vector-store/vector-store-factory"
+import { codeParser, DirectoryScanner } from "./processors"
+import { DirectoryScannerFactory } from "./processors/directory-scanner-factory"
+import { FileWatcherFactory } from "./processors/file-watcher-factory"
 import { ICodeParser, IEmbedder, IFileWatcher, IVectorStore } from "./interfaces"
 import { CodeIndexConfigManager } from "./config-manager"
 import { CacheManager } from "./cache-manager"
-import { BATCH_SEGMENT_THRESHOLD } from "./constants"
-import { providerIdentifiers } from "@roo-code/types/provider-identifiers"
 
 /**
  * Factory class responsible for creating and configuring code indexing service dependencies.
  */
 export class CodeIndexServiceFactory {
+	// TODO: Remove all factory and validation manager dependencies below once the workspace scope
+	// supplies them to CodeIndexManager via DI and it calls them directly.
+	// https://github.com/Zoo-Code-Org/Zoo-Code/issues/1817
+	private readonly embedderFactory = new EmbedderFactory()
+	private readonly vectorStoreFactory = new VectorStoreFactory()
+	private readonly directoryScannerFactory = new DirectoryScannerFactory()
+	private readonly fileWatcherFactory = new FileWatcherFactory()
+	private readonly embedderValidationManager = new EmbedderValidationManager()
+
 	constructor(
 		private readonly configManager: CodeIndexConfigManager,
 		private readonly workspacePath: string,
 		private readonly cacheManager: CacheManager,
 	) {}
 
-	/**
-	 * Creates an embedder instance based on the current configuration.
-	 */
-	public createEmbedder(): IEmbedder {
-		const config = this.configManager.getConfig()
-
-		const provider = config.embedderProvider as EmbedderProvider
-
-		if (provider === "semble") {
-			// Semble is a self-contained search binary that doesn't produce embedding
-			// vectors. The manager branches before reaching this factory (see
-			// _recreateServices). This guard prevents accidental misuse if the factory
-			// is ever called directly with a semble config.
-			throw new Error(
-				"Semble provider handles its own embedding. Do not call createEmbedder() for semble — use SembleProvider instead.",
-			)
-		}
-
-		if (provider === providerIdentifiers.openai) {
-			const apiKey = config.openAiOptions?.openAiNativeApiKey
-
-			if (!apiKey) {
-				throw new Error(t("embeddings:serviceFactory.openAiConfigMissing"))
-			}
-			return new OpenAiEmbedder({
-				...config.openAiOptions,
-				openAiEmbeddingModelId: config.modelId,
-			})
-		} else if (provider === providerIdentifiers.ollama) {
-			if (!config.ollamaOptions?.ollamaBaseUrl) {
-				throw new Error(t("embeddings:serviceFactory.ollamaConfigMissing"))
-			}
-			return new CodeIndexOllamaEmbedder({
-				...config.ollamaOptions,
-				ollamaModelId: config.modelId,
-			})
-		} else if (provider === "openai-compatible") {
-			if (!config.openAiCompatibleOptions?.baseUrl || !config.openAiCompatibleOptions?.apiKey) {
-				throw new Error(t("embeddings:serviceFactory.openAiCompatibleConfigMissing"))
-			}
-			return new OpenAICompatibleEmbedder(
-				config.openAiCompatibleOptions.baseUrl,
-				config.openAiCompatibleOptions.apiKey,
-				config.modelId,
-			)
-		} else if (provider === providerIdentifiers.gemini) {
-			if (!config.geminiOptions?.apiKey) {
-				throw new Error(t("embeddings:serviceFactory.geminiConfigMissing"))
-			}
-			return new GeminiEmbedder(config.geminiOptions.apiKey, config.modelId)
-		} else if (provider === providerIdentifiers.mistral) {
-			if (!config.mistralOptions?.apiKey) {
-				throw new Error(t("embeddings:serviceFactory.mistralConfigMissing"))
-			}
-			return new MistralEmbedder(config.mistralOptions.apiKey, config.modelId)
-		} else if (provider === providerIdentifiers.vercelAiGateway) {
-			if (!config.vercelAiGatewayOptions?.apiKey) {
-				throw new Error(t("embeddings:serviceFactory.vercelAiGatewayConfigMissing"))
-			}
-			return new VercelAiGatewayEmbedder(config.vercelAiGatewayOptions.apiKey, config.modelId)
-		} else if (provider === providerIdentifiers.bedrock) {
-			// Only region is required for Bedrock (profile is optional)
-			if (!config.bedrockOptions?.region) {
-				throw new Error(t("embeddings:serviceFactory.bedrockConfigMissing"))
-			}
-			return new BedrockEmbedder(config.bedrockOptions.region, config.bedrockOptions.profile, config.modelId)
-		} else if (provider === providerIdentifiers.openrouter) {
-			if (!config.openRouterOptions?.apiKey) {
-				throw new Error(t("embeddings:serviceFactory.openRouterConfigMissing"))
-			}
-			return new OpenRouterEmbedder(
-				config.openRouterOptions.apiKey,
-				config.modelId,
-				undefined, // maxItemTokens
-				config.openRouterOptions.specificProvider,
-			)
-		}
-
-		throw new Error(
-			t("embeddings:serviceFactory.invalidEmbedderType", { embedderProvider: config.embedderProvider }),
-		)
-	}
-
 	/**
 	 * Validates an embedder instance to ensure it's properly configured.
 	 * @param embedder The embedder instance to validate
 	 * @returns Promise resolving to validation result
 	 */
-	public async validateEmbedder(embedder: IEmbedder): Promise<{ valid: boolean; error?: string }> {
-		try {
-			return await embedder.validateConfiguration()
-		} catch (error) {
-			// Capture telemetry for the error
-			TelemetryService.instance.captureEvent(TelemetryEventName.CODE_INDEX_ERROR, {
-				error: error instanceof Error ? error.message : String(error),
-				stack: error instanceof Error ? error.stack : undefined,
-				location: "validateEmbedder",
-			})
-
-			// If validation throws an exception, preserve the original error message
-			return {
-				valid: false,
-				error: error instanceof Error ? error.message : "embeddings:validation.configurationError",
-			}
-		}
-	}
-
-	/**
-	 * Creates a vector store instance using the current configuration.
-	 */
-	public createVectorStore(): IVectorStore {
-		const config = this.configManager.getConfig()
-
-		const provider = config.embedderProvider as EmbedderProvider
-
-		if (provider === "semble") {
-			throw new Error(
-				"Semble provider handles its own vector storage. Do not call createVectorStore() for semble — use SembleProvider instead.",
-			)
-		}
-
-		const defaultModel = getDefaultModelId(provider)
-		// Use the embedding model ID from config, not the chat model IDs
-		const modelId = config.modelId ?? defaultModel
-
-		let vectorSize: number | undefined
-
-		// First try to get the model-specific dimension from profiles
-		vectorSize = getModelDimension(provider, modelId)
-
-		// Only use manual dimension if model doesn't have a built-in dimension
-		if (!vectorSize && config.modelDimension && config.modelDimension > 0) {
-			vectorSize = config.modelDimension
-		}
-
-		if (vectorSize === undefined || vectorSize <= 0) {
-			if (provider === "openai-compatible") {
-				throw new Error(
-					t("embeddings:serviceFactory.vectorDimensionNotDeterminedOpenAiCompatible", { modelId, provider }),
-				)
-			} else {
-				throw new Error(t("embeddings:serviceFactory.vectorDimensionNotDetermined", { modelId, provider }))
-			}
-		}
-
-		if (!config.qdrantUrl) {
-			throw new Error(t("embeddings:serviceFactory.qdrantUrlMissing"))
-		}
-
-		// Assuming constructor is updated: new QdrantVectorStore(workspacePath, url, vectorSize, apiKey?)
-		return new QdrantVectorStore(this.workspacePath, config.qdrantUrl, vectorSize, config.qdrantApiKey)
-	}
-
-	/**
-	 * Creates a directory scanner instance with its required dependencies.
-	 */
-	public createDirectoryScanner(
-		embedder: IEmbedder,
-		vectorStore: IVectorStore,
-		parser: ICodeParser,
-		ignoreInstance: Ignore,
-	): DirectoryScanner {
-		// Get the configurable batch size from VSCode settings
-		let batchSize: number
-		try {
-			batchSize = vscode.workspace
-				.getConfiguration(Package.name)
-				.get<number>("codeIndex.embeddingBatchSize", BATCH_SEGMENT_THRESHOLD)
-		} catch {
-			// In test environment, vscode.workspace might not be available
-			batchSize = BATCH_SEGMENT_THRESHOLD
-		}
-		return new DirectoryScanner(embedder, vectorStore, parser, this.cacheManager, ignoreInstance, batchSize)
-	}
-
-	/**
-	 * Creates a file watcher instance with its required dependencies.
-	 */
-	public createFileWatcher(
-		context: vscode.ExtensionContext,
-		embedder: IEmbedder,
-		vectorStore: IVectorStore,
-		cacheManager: CacheManager,
-		ignoreInstance: Ignore,
-		rooIgnoreController?: RooIgnoreController,
-	): IFileWatcher {
-		// Get the configurable batch size from VSCode settings
-		let batchSize: number
-		try {
-			batchSize = vscode.workspace
-				.getConfiguration(Package.name)
-				.get<number>("codeIndex.embeddingBatchSize", BATCH_SEGMENT_THRESHOLD)
-		} catch {
-			// In test environment, vscode.workspace might not be available
-			batchSize = BATCH_SEGMENT_THRESHOLD
-		}
-		return new FileWatcher(
-			this.workspacePath,
-			context,
-			cacheManager,
-			embedder,
-			vectorStore,
-			ignoreInstance,
-			rooIgnoreController,
-			batchSize,
-		)
+	// TODO: Remove this proxy and have CodeIndexManager call the injected validation manager directly.
+	// https://github.com/Zoo-Code-Org/Zoo-Code/issues/1817
+	public validateEmbedder(embedder: IEmbedder): Promise<{ valid: boolean; error?: string }> {
+		return this.embedderValidationManager.validateEmbedder(embedder)
 	}
 
 	/**
@@ -266,18 +65,26 @@ export class CodeIndexServiceFactory {
 			throw new Error(t("embeddings:serviceFactory.codeIndexingNotConfigured"))
 		}
 
-		const embedder = this.createEmbedder()
-		const vectorStore = this.createVectorStore()
+		const config = this.configManager.getConfig()
+		const embedder = this.embedderFactory.create(config)
+		const vectorStore = this.vectorStoreFactory.create(config, this.workspacePath)
 		const parser = codeParser
-		const scanner = this.createDirectoryScanner(embedder, vectorStore, parser, ignoreInstance)
-		const fileWatcher = this.createFileWatcher(
+		const scanner = this.directoryScannerFactory.create({
+			embedder,
+			vectorStore,
+			parser,
+			cacheManager: this.cacheManager,
+			ignoreInstance,
+		})
+		const fileWatcher = this.fileWatcherFactory.create({
+			workspacePath: this.workspacePath,
 			context,
 			embedder,
 			vectorStore,
 			cacheManager,
 			ignoreInstance,
 			rooIgnoreController,
-		)
+		})
 
 		return {
 			embedder,
diff --git a/src/services/code-index/vector-store/__tests__/vector-store-factory.spec.ts b/src/services/code-index/vector-store/__tests__/vector-store-factory.spec.ts
new file mode 100644
index 0000000000..d9f9ae4b50
--- /dev/null
+++ b/src/services/code-index/vector-store/__tests__/vector-store-factory.spec.ts
@@ -0,0 +1,75 @@
+import { providerIdentifiers } from "@roo-code/types/provider-identifiers"
+import { getDefaultModelId, getModelDimension } from "../../../../shared/embeddingModels"
+import type { CodeIndexConfig } from "../../interfaces/config"
+import { QdrantVectorStore } from "../qdrant-client"
+import { VectorStoreFactory } from "../vector-store-factory"
+
+vi.mock("../qdrant-client")
+vi.mock("../../../../shared/embeddingModels", () => ({
+	getDefaultModelId: vi.fn(),
+	getModelDimension: vi.fn(),
+}))
+
+describe("VectorStoreFactory", () => {
+	let factory: VectorStoreFactory
+	let config: CodeIndexConfig
+
+	beforeEach(() => {
+		vi.clearAllMocks()
+		vi.mocked(getDefaultModelId).mockReturnValue("default-model")
+		vi.mocked(getModelDimension).mockReturnValue(undefined)
+		factory = new VectorStoreFactory()
+		config = {
+			isConfigured: true,
+			embedderProvider: providerIdentifiers.openai,
+			modelId: "custom-model",
+			modelDimension: 512,
+			qdrantUrl: "http://localhost:6333",
+		}
+	})
+
+	it.each([undefined, 0])("uses the manual dimension when the built-in dimension is %s", (dimension) => {
+		vi.mocked(getModelDimension).mockReturnValue(dimension)
+
+		expect(factory.create(config, "/workspace")).toBeInstanceOf(QdrantVectorStore)
+		expect(QdrantVectorStore).toHaveBeenCalledWith("/workspace", config.qdrantUrl, 512, undefined)
+	})
+
+	it("does not override an invalid negative built-in dimension with the manual dimension", () => {
+		vi.mocked(getModelDimension).mockReturnValue(-1)
+
+		expect(() => factory.create(config, "/workspace")).toThrow("serviceFactory.vectorDimensionNotDetermined")
+		expect(QdrantVectorStore).not.toHaveBeenCalled()
+	})
+
+	it.each([undefined, 0, -1])("rejects an unavailable or invalid manual dimension: %s", (dimension) => {
+		config = { ...config, modelDimension: dimension }
+
+		expect(() => factory.create(config, "/workspace")).toThrow("serviceFactory.vectorDimensionNotDetermined")
+		expect(QdrantVectorStore).not.toHaveBeenCalled()
+	})
+
+	it("rejects Semble before resolving dimensions or creating a store", () => {
+		config = { ...config, embedderProvider: "semble" }
+
+		expect(() => factory.create(config, "/workspace")).toThrow("Semble provider handles its own vector storage")
+		expect(getModelDimension).not.toHaveBeenCalled()
+		expect(getDefaultModelId).not.toHaveBeenCalled()
+		expect(QdrantVectorStore).not.toHaveBeenCalled()
+	})
+
+	it("uses current configuration and workspace on every call without caching stores", () => {
+		const first = factory.create(config, "/first")
+		const second = factory.create({ ...config, modelDimension: 1024 }, "/second")
+
+		expect(first).not.toBe(second)
+		expect(QdrantVectorStore).toHaveBeenNthCalledWith(1, "/first", config.qdrantUrl, 512, undefined)
+		expect(QdrantVectorStore).toHaveBeenNthCalledWith(2, "/second", config.qdrantUrl, 1024, undefined)
+	})
+
+	it("reports the dimension error before a missing Qdrant URL", () => {
+		config = { ...config, modelDimension: undefined, qdrantUrl: undefined }
+
+		expect(() => factory.create(config, "/workspace")).toThrow("serviceFactory.vectorDimensionNotDetermined")
+	})
+})
diff --git a/src/services/code-index/vector-store/vector-store-factory.ts b/src/services/code-index/vector-store/vector-store-factory.ts
new file mode 100644
index 0000000000..174f217108
--- /dev/null
+++ b/src/services/code-index/vector-store/vector-store-factory.ts
@@ -0,0 +1,45 @@
+import { t } from "../../../i18n"
+import { getDefaultModelId, getModelDimension } from "../../../shared/embeddingModels"
+import type { CodeIndexConfig } from "../interfaces/config"
+import type { IVectorStore } from "../interfaces"
+import type { IVectorStoreFactory } from "../interfaces/vector-store-factory"
+import { QdrantVectorStore } from "./qdrant-client"
+
+export class VectorStoreFactory implements IVectorStoreFactory {
+	public create(config: CodeIndexConfig, workspacePath: string): IVectorStore {
+		if (config.embedderProvider === "semble") {
+			throw new Error(
+				"Semble provider handles its own vector storage. Do not call createVectorStore() for semble — use SembleProvider instead.",
+			)
+		}
+
+		const vectorSize = this.resolveVectorSize(config)
+
+		if (!config.qdrantUrl) {
+			throw new Error(t("embeddings:serviceFactory.qdrantUrlMissing"))
+		}
+
+		return new QdrantVectorStore(workspacePath, config.qdrantUrl, vectorSize, config.qdrantApiKey)
+	}
+
+	private resolveVectorSize(config: CodeIndexConfig): number {
+		const provider = config.embedderProvider
+		const modelId = config.modelId ?? getDefaultModelId(provider)
+		let vectorSize = getModelDimension(provider, modelId)
+
+		// A manual dimension is only a fallback for models without a built-in dimension.
+		if (!vectorSize && config.modelDimension && config.modelDimension > 0) {
+			vectorSize = config.modelDimension
+		}
+
+		if (vectorSize === undefined || vectorSize <= 0) {
+			const errorKey =
+				provider === "openai-compatible"
+					? "embeddings:serviceFactory.vectorDimensionNotDeterminedOpenAiCompatible"
+					: "embeddings:serviceFactory.vectorDimensionNotDetermined"
+			throw new Error(t(errorKey, { modelId, provider }))
+		}
+
+		return vectorSize
+	}
+}
diff --git a/src/services/code-index/workspace-indexing-enablement-manager.ts b/src/services/code-index/workspace-indexing-enablement-manager.ts
new file mode 100644
index 0000000000..78f179ad4a
--- /dev/null
+++ b/src/services/code-index/workspace-indexing-enablement-manager.ts
@@ -0,0 +1,35 @@
+import type { ClineProvider } from "../../core/webview/ClineProvider"
+import type { CodeIndexManager } from "./manager"
+
+/** Coordinates workspace enablement without owning the underlying indexing services. */
+export class WorkspaceIndexingEnablementManager {
+	public constructor(
+		private readonly manager: Pick<
+			CodeIndexManager,
+			| "setWorkspaceEnabled"
+			| "isFeatureEnabled"
+			| "isFeatureConfigured"
+			| "initialize"
+			| "startIndexing"
+			| "stopIndexing"
+			| "getCurrentStatus"
+		>,
+	) {}
+
+	public async setEnabled(
+		enabled: boolean,
+		provider: Pick<ClineProvider, "contextProxy" | "log" | "postMessageToWebview">,
+	): Promise<void> {
+		await this.manager.setWorkspaceEnabled(enabled)
+		if (enabled && this.manager.isFeatureEnabled && this.manager.isFeatureConfigured) {
+			await this.manager.initialize(provider.contextProxy)
+			void this.manager.startIndexing().catch((error) => provider.log(`Indexing error: ${error}`))
+		} else if (!enabled) {
+			this.manager.stopIndexing()
+		}
+		await provider.postMessageToWebview({
+			type: "indexingStatusUpdate",
+			values: this.manager.getCurrentStatus(),
+		})
+	}
+}
diff --git a/src/shared/ProfileValidator.ts b/src/shared/ProfileValidator.ts
index 923582bd06..ed0a7ccedf 100644
--- a/src/shared/ProfileValidator.ts
+++ b/src/shared/ProfileValidator.ts
@@ -80,6 +80,8 @@ export class ProfileValidator {
 				return profile.requestyModelId
 			case providerIdentifiers.unbound:
 				return profile.unboundModelId
+			case providerIdentifiers.zooGateway:
+				return profile.zooGatewayModelId
 			case providerIdentifiers.fakeAi:
 			default:
 				return undefined
diff --git a/src/shared/__tests__/ProfileValidator.spec.ts b/src/shared/__tests__/ProfileValidator.spec.ts
index 865fa5cf51..1eaad49d87 100644
--- a/src/shared/__tests__/ProfileValidator.spec.ts
+++ b/src/shared/__tests__/ProfileValidator.spec.ts
@@ -341,6 +341,42 @@ describe("ProfileValidator", () => {
 			expect(ProfileValidator.isProfileAllowed(profile, allowList)).toBe(true)
 		})
 
+		it("should extract zooGatewayModelId for zoo-gateway provider", () => {
+			const allowList: OrganizationAllowList = {
+				allowAll: false,
+				providers: {
+					[providerIdentifiers.zooGateway]: {
+						allowAll: false,
+						models: ["anthropic/claude-sonnet-4"],
+					},
+				},
+			}
+			const profile: ProviderSettings = {
+				apiProvider: providerIdentifiers.zooGateway,
+				zooGatewayModelId: "anthropic/claude-sonnet-4",
+			}
+
+			expect(ProfileValidator.isProfileAllowed(profile, allowList)).toBe(true)
+		})
+
+		it("should reject a zoo-gateway profile whose model is not on the allow-list", () => {
+			const allowList: OrganizationAllowList = {
+				allowAll: false,
+				providers: {
+					[providerIdentifiers.zooGateway]: {
+						allowAll: false,
+						models: ["anthropic/claude-sonnet-4"],
+					},
+				},
+			}
+			const profile: ProviderSettings = {
+				apiProvider: providerIdentifiers.zooGateway,
+				zooGatewayModelId: "anthropic/claude-opus-4",
+			}
+
+			expect(ProfileValidator.isProfileAllowed(profile, allowList)).toBe(false)
+		})
+
 		it("should handle providers with undefined models list gracefully", () => {
 			const allowList: OrganizationAllowList = {
 				allowAll: false,
diff --git a/src/utils/pathUtils.ts b/src/utils/pathUtils.ts
index dae300f8f3..c433d4737d 100644
--- a/src/utils/pathUtils.ts
+++ b/src/utils/pathUtils.ts
@@ -1,5 +1,6 @@
 import * as vscode from "vscode"
 import * as path from "path"
+import * as fs from "fs"
 
 /**
  * Checks if a file path is outside all workspace folders
@@ -22,3 +23,122 @@ export function isPathOutsideWorkspace(filePath: string): boolean {
 		return absolutePath === folderPath || absolutePath.startsWith(folderPath + path.sep)
 	})
 }
+
+/**
+ * Percent-decode an untrusted path to a fixed point.
+ *
+ * Markdown link targets are URL syntax and may be percent-encoded, while the
+ * downstream openFile helper (src/integrations/misc/open-file.ts) decodes the
+ * path AFTER workspace validation. Decoding here, at the containment
+ * boundary, closes the hole where a request like `%2e%2e/%2e%2e/.env` passes
+ * containment as a literal and escapes only after the later decode. Decoding
+ * repeats until the value is stable so double-encoded payloads
+ * (`%252e%252e`) are caught as well.
+ *
+ * Values containing a bare `%` that is not a valid escape (e.g.
+ * `report 50%.md`) are returned unchanged — the same lenient semantics
+ * openFile already applies. A value that does not stabilize within
+ * `maxIterations` is a hostile encoding and rejected with `null`.
+ */
+export function decodeUntrustedPathToStable(filePath: string, maxIterations = 8): string | null {
+	let current = filePath
+	// Stryker disable next-line EqualityOperator,UpdateOperator,ConditionalExpression: defensive iteration bound; valid percent-encoding strictly reduces escape depth per decode, so the bound is never hit for production input (pinned by the direct bound test)
+	for (let i = 0; i < maxIterations; i++) {
+		let decoded: string
+		try {
+			decoded = decodeURIComponent(current)
+		} catch {
+			// Not a valid escape sequence: the value is stable as-is.
+			return current
+		}
+		if (decoded === current) {
+			return current
+		}
+		current = decoded
+	}
+	// Stryker disable next-line EqualityOperator,ConditionalExpression,BlockStatement: defensive bound; valid percent-encoding strictly reduces escape depth per iteration, so non-stabilization is unreachable for real input
+	return null
+}
+
+// Realpath of the deepest existing ancestor of `filePath` (the path itself
+// when it exists). A dangling symlink — an entry that exists but whose target
+// cannot be resolved — fails realpath with ENOENT without being a
+// nonexistent path: creation flows (mkdir -p) would follow it and could
+// escape the workspace, so such entries fail closed. Returns null on
+// unexpected errors: containment for untrusted paths fails closed.
+async function realPathOfExistingAncestor(filePath: string): Promise<string | null> {
+	let current = filePath
+	for (;;) {
+		try {
+			return await fs.promises.realpath(current)
+		} catch (error) {
+			const code = (error as NodeJS.ErrnoException).code
+			// Stryker disable next-line EqualityOperator,ConditionalExpression,BlockStatement: ENOENT is the only expected code on a walk toward an existing ancestor; anything else (EACCES, EIO, ...) must fail closed
+			if (code !== "ENOENT") {
+				return null
+			}
+			// ENOENT from realpath is ambiguous: the entry may simply not exist
+			// yet, or it may be a dangling symlink whose target is missing.
+			// lstat does not follow the final entry, so it distinguishes the two.
+			// A dangling symlink must fail closed (a creation flow would follow
+			// it and could escape the workspace); a genuinely absent entry keeps
+			// walking to its deepest existing ancestor.
+			try {
+				const stat = await fs.promises.lstat(current)
+				// Stryker disable next-line ConditionalExpression: equivalent - lstat succeeding on an entry whose realpath just failed with ENOENT means the entry is a dangling symlink (a real non-symlink entry would make realpath succeed), so the condition is always true at every reachable point and the true/false replacements are unobservable; the symlink reject is pinned by the dangling-symlink tests
+				if (stat.isSymbolicLink()) {
+					return null
+				}
+			} catch (lstatError) {
+				const lstatCode = (lstatError as NodeJS.ErrnoException).code
+				// Stryker disable next-line EqualityOperator,ConditionalExpression,BlockStatement: only ENOENT means the entry is genuinely absent and the walk may continue; any other lstat error (EACCES, EIO, ...) must fail closed
+				if (lstatCode !== "ENOENT") {
+					return null
+				}
+			}
+			const parent = path.dirname(current)
+			// Stryker disable next-line EqualityOperator,ConditionalExpression,BlockStatement: root guard against a non-terminating walk (path.dirname stabilizes at the filesystem root)
+			if (parent === current) {
+				return null
+			}
+			current = parent
+		}
+	}
+}
+
+/**
+ * Realpath-based containment for untrusted paths: resolves the filesystem's
+ * real targets before checking containment, so a symlink inside a workspace
+ * folder cannot point at a file outside it. Paths that do not exist yet (the
+ * openFile creation flow) are checked via their deepest existing ancestor.
+ * Workspace folders are realized the same way, since a workspace root may
+ * itself be a symlink. Fails closed: no workspace folders, or an unexpected
+ * fs error, counts as outside.
+ */
+export async function isRealPathOutsideWorkspace(filePath: string): Promise<boolean> {
+	const folders = vscode.workspace.workspaceFolders
+	// Stryker disable next-line ConditionalExpression,LogicalOperator: equivalent - with no folders the realFolders set stays empty and the empty-set fail-closed below returns the same result
+	if (!folders || folders.length === 0) {
+		// Stryker disable next-line BlockStatement: no workspace means no allowed root; everything is outside (mirrors isPathOutsideWorkspace)
+		return true
+	}
+	const target = await realPathOfExistingAncestor(filePath)
+	// Stryker disable next-line ConditionalExpression,BlockStatement: unresolvable target (unexpected fs error) fails closed
+	if (!target) {
+		return true
+	}
+	// Stryker disable next-line ArrayDeclaration: equivalent - the array is always populated (or fails closed at the empty check) before the containment test, so the initial literal is unobservable
+	const realFolders: string[] = []
+	for (const folder of folders) {
+		const real = await realPathOfExistingAncestor(folder.uri.fsPath)
+		// Stryker disable next-line ConditionalExpression: equivalent - a null real can never match a resolved target, and the empty-set fail-closed is unaffected by an extra null entry
+		if (real) {
+			realFolders.push(real)
+		}
+	}
+	// Stryker disable next-line EqualityOperator,ConditionalExpression,BlockStatement: if no folder could be realized the containment set is empty, so fail closed
+	if (realFolders.length === 0) {
+		return true
+	}
+	return !realFolders.some((folderPath) => target === folderPath || target.startsWith(folderPath + path.sep))
+}
diff --git a/turbo.json b/turbo.json
index 2d8f8a2f98..185020e5f2 100644
--- a/turbo.json
+++ b/turbo.json
@@ -15,6 +15,7 @@
 			"cache": false
 		},
 		"build": {
+			"dependsOn": ["^build"],
 			"outputs": ["dist/**"],
 			"inputs": ["src/**", "package.json", "tsconfig.json", "tsup.config.ts", "vite.config.ts"]
 		},
diff --git a/webview-ui/src/components/chat/ChatModelSelector.tsx b/webview-ui/src/components/chat/ChatModelSelector.tsx
new file mode 100644
index 0000000000..0dccecd9da
--- /dev/null
+++ b/webview-ui/src/components/chat/ChatModelSelector.tsx
@@ -0,0 +1,193 @@
+import { useMemo, useState, useCallback } from "react"
+
+import { cn } from "@/lib/utils"
+import { useRooPortal } from "@/components/ui/hooks/useRooPortal"
+import { Popover, PopoverContent, PopoverTrigger, StandardTooltip } from "@/components/ui"
+import { useAppTranslation } from "@/i18n/TranslationContext"
+import { vscode } from "@/utils/vscode"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useSelectedModel } from "@/components/ui/hooks/useSelectedModel"
+import { filterModels } from "@/components/settings/utils/organizationFilters"
+import { useChatModelSelector } from "./hooks/useChatModelSelector"
+
+interface ChatModelSelectorProps {
+	disabled?: boolean
+	title: string
+	triggerClassName?: string
+}
+
+export const ChatModelSelector = ({ disabled = false, title, triggerClassName = "" }: ChatModelSelectorProps) => {
+	const { t } = useAppTranslation()
+	const { apiConfiguration, organizationAllowList, currentApiConfigName } = useExtensionState()
+	const { id: selectedModelId } = useSelectedModel(apiConfiguration)
+	const { provider, models, modelIdKey, defaultModelId, isLoading, valueTransform, displayTransform } =
+		useChatModelSelector()
+
+	const [open, setOpen] = useState(false)
+	const [searchValue, setSearchValue] = useState("")
+	const portalContainer = useRooPortal("roo-portal")
+
+	// Filter deprecated models but always keep the currently selected one visible.
+	const modelIds = useMemo(
+		() =>
+			Object.entries(filterModels(models, provider, organizationAllowList) ?? {})
+				.filter(([modelId, modelInfo]) => modelId === selectedModelId || !modelInfo.deprecated)
+				.map(([modelId]) => modelId)
+				.sort((a, b) => a.localeCompare(b)),
+		[models, provider, organizationAllowList, selectedModelId],
+	)
+
+	// Gate arbitrary model ids against the organization allow-list. The webview is not a security
+	// boundary, but this keeps the UI from offering a custom model the host would reject on save.
+	const isModelAllowed = useCallback(
+		(modelId: string): boolean => {
+			if (!organizationAllowList || organizationAllowList.allowAll) {
+				return true
+			}
+			if (!provider) {
+				return false
+			}
+			const providerConfig = organizationAllowList.providers[provider]
+			if (!providerConfig) {
+				return false
+			}
+			if (providerConfig.allowAll) {
+				return true
+			}
+			return providerConfig.models?.includes(modelId) ?? false
+		},
+		[organizationAllowList, provider],
+	)
+
+	// Only offer a custom (non-listed) model when the allow-list permits that exact model id.
+	const customModelAllowed = !!searchValue && isModelAllowed(searchValue)
+
+	// Resolve the display value (custom transform for compound config values like VSCode LM).
+	const displayValue = useMemo(() => {
+		if (displayTransform && modelIdKey) {
+			const storedValue = apiConfiguration?.[modelIdKey]
+			return storedValue ? displayTransform(storedValue) : undefined
+		}
+		// Only the saved model is reflected; fall back to undefined so the placeholder shows.
+		return selectedModelId || undefined
+	}, [displayTransform, modelIdKey, apiConfiguration, selectedModelId])
+
+	const filteredModelIds = useMemo(() => {
+		if (!searchValue) return modelIds
+		const q = searchValue.toLowerCase()
+		return modelIds.filter((id) => id.toLowerCase().includes(q))
+	}, [modelIds, searchValue])
+
+	const onSelect = useCallback(
+		(modelId: string) => {
+			// Defense in depth: never persist a model the allow-list forbids, even if a caller
+			// bypasses the rendered list (e.g. custom search); also require the lookup to be ready.
+			if (!modelId || !modelIdKey || !apiConfiguration || !isModelAllowed(modelId)) return
+
+			setOpen(false)
+			setSearchValue("")
+			// Transform the model id for storage if needed (e.g. VSCode LM selector object).
+			const valueToStore = valueTransform ? valueTransform(modelId) : modelId
+			// Persist to the current API configuration profile; the backend saves and activates
+			// it and broadcasts the updated apiConfiguration back to the webview.
+			vscode.postMessage({
+				type: "upsertApiConfiguration",
+				text: currentApiConfigName,
+				apiConfiguration: { ...apiConfiguration, [modelIdKey]: valueToStore },
+			})
+		},
+		[modelIdKey, apiConfiguration, valueTransform, currentApiConfigName, isModelAllowed],
+	)
+
+	const onClearSearch = useCallback(() => setSearchValue(""), [])
+
+	return (
+		<Popover open={open} onOpenChange={setOpen} data-testid="chat-model-selector-root">
+			<StandardTooltip content={title}>
+				<PopoverTrigger
+					disabled={disabled || !modelIdKey}
+					data-testid="chat-model-selector-trigger"
+					className={cn(
+						"min-w-0 inline-flex items-center relative whitespace-nowrap px-1.5 py-1 text-xs",
+						"bg-transparent border border-[rgba(255,255,255,0.08)] rounded-md text-vscode-foreground",
+						"transition-all duration-150 focus:outline-none focus-visible:ring-1 focus-visible:ring-vscode-focusBorder focus-visible:ring-inset",
+						disabled || !modelIdKey
+							? "opacity-50 cursor-not-allowed"
+							: "opacity-90 hover:opacity-100 hover:bg-[rgba(255,255,255,0.03)] hover:border-[rgba(255,255,255,0.15)] cursor-pointer",
+						triggerClassName,
+					)}>
+					<span className="truncate max-w-[140px]">
+						{isLoading ? "…" : displayValue || defaultModelId || t("chat:selectModel")}
+					</span>
+				</PopoverTrigger>
+			</StandardTooltip>
+			<PopoverContent
+				align="start"
+				sideOffset={4}
+				container={portalContainer}
+				className="p-0 overflow-hidden w-[300px]">
+				<div className="flex flex-col w-full">
+					<div className="relative p-2 border-b border-vscode-dropdown-border">
+						<input
+							aria-label={t("chat:searchModel")}
+							value={searchValue}
+							onChange={(e) => setSearchValue(e.target.value)}
+							placeholder={t("chat:searchModel")}
+							className="w-full h-8 px-2 py-1 text-xs bg-vscode-input-background text-vscode-input-foreground border border-vscode-input-border rounded focus:outline-0"
+							autoFocus
+						/>
+						{searchValue.length > 0 && (
+							<div className="absolute right-4 top-0 bottom-0 flex items-center justify-center">
+								<button
+									type="button"
+									aria-label="Clear search"
+									data-testid="chat-model-search-clear"
+									onClick={onClearSearch}
+									className="codicon codicon-close text-vscode-input-foreground opacity-50 hover:opacity-100 text-xs cursor-pointer bg-transparent border-none p-0 focus:outline-none focus-visible:ring-1 focus-visible:ring-vscode-focusBorder"
+								/>
+							</div>
+						)}
+					</div>
+
+					{modelIds.length === 0 && !isLoading && (
+						<div className="py-2 px-3 text-sm text-vscode-foreground/70">{t("chat:modelListEmpty")}</div>
+					)}
+
+					{modelIds.length > 0 && (
+						<div className="max-h-[300px] overflow-y-auto">
+							{filteredModelIds.map((modelId) => (
+								<button
+									key={modelId}
+									type="button"
+									onClick={() => onSelect(modelId)}
+									data-testid={`chat-model-option-${modelId}`}
+									className={cn(
+										"w-full text-left bg-transparent border-none px-3 py-1.5 text-sm cursor-pointer flex items-center gap-2",
+										"focus:outline-none focus-visible:ring-1 focus-visible:ring-vscode-focusBorder focus-visible:ring-inset",
+										"hover:bg-vscode-list-hoverBackground",
+										modelId === displayValue &&
+											"bg-vscode-list-activeSelectionBackground text-vscode-list-activeSelectionForeground",
+									)}>
+									<span className="flex-1 min-w-0 truncate" title={modelId}>
+										{modelId}
+									</span>
+									{modelId === displayValue && <span className="codicon codicon-check text-xs" />}
+								</button>
+							))}
+						</div>
+					)}
+
+					{searchValue && customModelAllowed && !modelIds.includes(searchValue) && (
+						<button
+							type="button"
+							data-testid="chat-model-use-custom"
+							onClick={() => onSelect(searchValue)}
+							className="w-full text-left bg-transparent border-none px-3 py-1.5 text-sm cursor-pointer hover:bg-vscode-list-hoverBackground border-t border-vscode-input-border focus:outline-none focus-visible:ring-1 focus-visible:ring-vscode-focusBorder focus-visible:ring-inset">
+							{t("chat:useCustomModel", { modelId: searchValue })}
+						</button>
+					)}
+				</div>
+			</PopoverContent>
+		</Popover>
+	)
+}
diff --git a/webview-ui/src/components/chat/ChatTextArea.tsx b/webview-ui/src/components/chat/ChatTextArea.tsx
index 2c539766fe..27150a9e92 100644
--- a/webview-ui/src/components/chat/ChatTextArea.tsx
+++ b/webview-ui/src/components/chat/ChatTextArea.tsx
@@ -27,6 +27,7 @@ import { StandardTooltip } from "@src/components/ui"
 import Thumbnails from "../common/Thumbnails"
 import { ModeSelector } from "./ModeSelector"
 import { ApiConfigSelector } from "./ApiConfigSelector"
+import { ChatModelSelector } from "./ChatModelSelector"
 import { AutoApproveDropdown } from "./AutoApproveDropdown"
 import { MAX_IMAGES_PER_MESSAGE } from "./constants"
 import ContextMenu from "./ContextMenu"
@@ -1319,6 +1320,11 @@ export const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
 							lockApiConfigAcrossModes={!!lockApiConfigAcrossModes}
 							onToggleLockApiConfig={handleToggleLockApiConfig}
 						/>
+						<ChatModelSelector
+							disabled={selectApiConfigDisabled}
+							title={t("chat:selectModel")}
+							triggerClassName="min-w-[28px] text-ellipsis overflow-hidden flex-shrink min-[310px]:min-w-fit min-[310px]:overflow-visible min-[310px]:flex-shrink-0"
+						/>
 						<AutoApproveDropdown triggerClassName="min-w-[28px] text-ellipsis overflow-hidden flex-shrink min-[310px]:overflow-visible min-[310px]:flex-shrink-0" />
 					</div>
 					<div className={cn("flex flex-shrink-0 items-center gap-0.5 h-5 leading-none pr-2")}>
diff --git a/webview-ui/src/components/chat/__tests__/ChatModelSelector.spec.tsx b/webview-ui/src/components/chat/__tests__/ChatModelSelector.spec.tsx
new file mode 100644
index 0000000000..4221cb3c04
--- /dev/null
+++ b/webview-ui/src/components/chat/__tests__/ChatModelSelector.spec.tsx
@@ -0,0 +1,500 @@
+import type { ReactNode } from "react"
+import { render, screen, fireEvent } from "@/utils/test-utils"
+import { providerIdentifiers } from "@roo-code/types"
+import { vscode } from "@/utils/vscode"
+
+import { ChatModelSelector } from "../ChatModelSelector"
+import { useChatModelSelector } from "../hooks/useChatModelSelector"
+
+// Mock the dependencies
+vi.mock("@/utils/vscode", () => ({
+	vscode: {
+		postMessage: vi.fn(),
+	},
+}))
+
+vi.mock("@/i18n/TranslationContext", () => ({
+	useAppTranslation: () => ({
+		t: (key: string) => key,
+	}),
+}))
+
+vi.mock("@/components/ui/hooks/useRooPortal", () => ({
+	useRooPortal: () => document.body,
+}))
+
+// Mock the ExtensionStateContext (configurable per test)
+const { mockUseExtensionState } = vi.hoisted(() => ({
+	mockUseExtensionState: vi.fn(),
+}))
+
+vi.mock("@/context/ExtensionStateContext", () => ({
+	useExtensionState: (...args: unknown[]) => mockUseExtensionState(...args),
+}))
+
+// Mock useSelectedModel
+vi.mock("@/components/ui/hooks/useSelectedModel", () => ({
+	useSelectedModel: () => ({ id: "claude-opus-4-20250514", info: undefined }),
+}))
+
+// Mock useChatModelSelector hook
+vi.mock("../hooks/useChatModelSelector", () => ({
+	useChatModelSelector: vi.fn(),
+}))
+
+// Mock Popover components to be testable
+vi.mock("@/components/ui", () => {
+	type PopoverProps = { children: ReactNode; open?: boolean; onOpenChange?: (open: boolean) => void }
+	type TriggerProps = {
+		children: ReactNode
+		disabled?: boolean
+		className?: string
+		onClick?: () => void
+	}
+	return {
+		Popover: ({ children, open }: PopoverProps) => (
+			<div data-testid="popover-root" data-open={open}>
+				{children}
+			</div>
+		),
+		PopoverTrigger: ({ children, disabled, className, onClick }: TriggerProps) => (
+			<button
+				data-testid="chat-model-selector-trigger"
+				disabled={disabled}
+				className={className}
+				onClick={onClick}>
+				{children}
+			</button>
+		),
+		PopoverContent: ({ children }: { children: ReactNode }) => <div data-testid="popover-content">{children}</div>,
+		StandardTooltip: ({ children }: { children: ReactNode }) => <>{children}</>,
+	}
+})
+
+const mockUseChatModelSelector = useChatModelSelector as ReturnType<typeof vi.fn>
+
+const anthropicModels = {
+	"claude-opus-4-20250514": {
+		maxTokens: 32000,
+		contextWindow: 200000,
+		supportsPromptCache: true,
+		supportsImages: true,
+	},
+	"claude-sonnet-4-20250514": {
+		maxTokens: 32000,
+		contextWindow: 200000,
+		supportsPromptCache: true,
+		supportsImages: true,
+	},
+}
+
+// Minimal ModelInfo factory for ad-hoc fixtures.
+const modelInfo = (overrides: Record<string, unknown> = {}) => ({
+	maxTokens: 32000,
+	contextWindow: 200000,
+	supportsPromptCache: true,
+	...overrides,
+})
+
+describe("ChatModelSelector", () => {
+	const defaultProps = {
+		title: "Select model",
+	}
+
+	/** Helper: render the selector and open the popover so options are visible. */
+	const renderOpen = (disabled = false) => {
+		render(<ChatModelSelector {...defaultProps} disabled={disabled} />)
+		fireEvent.click(screen.getByTestId("chat-model-selector-trigger"))
+	}
+
+	/** Helper: read the visible option ids in DOM order. */
+	const visibleOptionIds = () =>
+		screen
+			.getAllByTestId(/^chat-model-option-/)
+			.map((element) => element.getAttribute("data-testid")!.replace("chat-model-option-", ""))
+
+	beforeEach(() => {
+		vi.clearAllMocks()
+		mockUseExtensionState.mockReturnValue({
+			apiConfiguration: {
+				apiProvider: providerIdentifiers.anthropic,
+				apiModelId: "claude-opus-4-20250514",
+			},
+			organizationAllowList: { allowAll: true, providers: {} },
+			currentApiConfigName: "default",
+		})
+		mockUseChatModelSelector.mockReturnValue({
+			provider: providerIdentifiers.anthropic,
+			models: anthropicModels,
+			modelIdKey: "apiModelId",
+			defaultModelId: "claude-opus-4-20250514",
+			isLoading: false,
+		})
+	})
+
+	test("renders the trigger with the current model id", () => {
+		render(<ChatModelSelector {...defaultProps} />)
+
+		const trigger = screen.getByTestId("chat-model-selector-trigger")
+		expect(trigger).toBeInTheDocument()
+		expect(trigger).toHaveTextContent("claude-opus-4-20250514")
+	})
+
+	test("disables the trigger when disabled prop is true", () => {
+		render(<ChatModelSelector {...defaultProps} disabled={true} />)
+
+		const trigger = screen.getByTestId("chat-model-selector-trigger")
+		expect(trigger).toBeDisabled()
+	})
+
+	test("renders model list when opened", () => {
+		render(<ChatModelSelector {...defaultProps} />)
+
+		const trigger = screen.getByTestId("chat-model-selector-trigger")
+		fireEvent.click(trigger)
+
+		// The mocked Popover always renders content, so the models are visible.
+		// Use testids instead of text queries because the selected model id also
+		// appears in the trigger label.
+		expect(screen.getByTestId("chat-model-option-claude-opus-4-20250514")).toBeInTheDocument()
+		expect(screen.getByTestId("chat-model-option-claude-sonnet-4-20250514")).toBeInTheDocument()
+	})
+
+	test("selecting a model posts upsertApiConfiguration message", () => {
+		render(<ChatModelSelector {...defaultProps} />)
+
+		const trigger = screen.getByTestId("chat-model-selector-trigger")
+		fireEvent.click(trigger)
+
+		const option = screen.getByTestId("chat-model-option-claude-sonnet-4-20250514")
+		fireEvent.click(option)
+
+		expect(vscode.postMessage).toHaveBeenCalledWith({
+			type: "upsertApiConfiguration",
+			text: "default",
+			apiConfiguration: {
+				apiProvider: providerIdentifiers.anthropic,
+				apiModelId: "claude-sonnet-4-20250514",
+			},
+		})
+	})
+
+	test("supports custom model via search", () => {
+		render(<ChatModelSelector {...defaultProps} />)
+
+		const trigger = screen.getByTestId("chat-model-selector-trigger")
+		fireEvent.click(trigger)
+
+		// Type in the search box (present in the always-rendered PopoverContent)
+		const searchInput = screen.getByPlaceholderText("chat:searchModel")
+		fireEvent.change(searchInput, { target: { value: "claude-3-5-haiku" } })
+
+		const customOption = screen.getByTestId("chat-model-use-custom")
+		fireEvent.click(customOption)
+
+		expect(vscode.postMessage).toHaveBeenCalledWith({
+			type: "upsertApiConfiguration",
+			text: "default",
+			apiConfiguration: {
+				apiProvider: providerIdentifiers.anthropic,
+				apiModelId: "claude-3-5-haiku",
+			},
+		})
+	})
+
+	test("clears the search query via the clear button", () => {
+		render(<ChatModelSelector {...defaultProps} />)
+
+		const trigger = screen.getByTestId("chat-model-selector-trigger")
+		fireEvent.click(trigger)
+
+		const searchInput = screen.getByPlaceholderText("chat:searchModel") as HTMLInputElement
+		fireEvent.change(searchInput, { target: { value: "claude-3" } })
+		expect(searchInput.value).toBe("claude-3")
+
+		const clearButton = searchInput.parentElement?.querySelector(".codicon-close") as HTMLElement | null
+		expect(clearButton).toBeTruthy()
+		fireEvent.click(clearButton!)
+
+		expect((screen.getByPlaceholderText("chat:searchModel") as HTMLInputElement).value).toBe("")
+	})
+
+	test("filters model ids case-insensitively", () => {
+		mockUseChatModelSelector.mockReturnValue({
+			provider: providerIdentifiers.anthropic,
+			models: {
+				"Claude-Opus-4": modelInfo(),
+				"Claude-Sonnet-4": modelInfo(),
+			},
+			modelIdKey: "apiModelId",
+			defaultModelId: "Claude-Opus-4",
+			isLoading: false,
+		})
+
+		renderOpen()
+
+		// Uppercase query must match the lowercase portion of the model id.
+		fireEvent.change(screen.getByPlaceholderText("chat:searchModel"), { target: { value: "SONNET" } })
+
+		expect(screen.getByTestId("chat-model-option-Claude-Sonnet-4")).toBeInTheDocument()
+		expect(screen.queryByTestId("chat-model-option-Claude-Opus-4")).not.toBeInTheDocument()
+	})
+
+	test("renders the empty state when no models are available", () => {
+		mockUseChatModelSelector.mockReturnValue({
+			provider: providerIdentifiers.anthropic,
+			models: {},
+			modelIdKey: "apiModelId",
+			defaultModelId: "claude-opus-4-20250514",
+			isLoading: false,
+		})
+
+		renderOpen()
+
+		expect(screen.getByText("chat:modelListEmpty")).toBeInTheDocument()
+		expect(screen.queryByTestId(/^chat-model-option-/)).not.toBeInTheDocument()
+	})
+
+	test("shows a loading label and hides the empty state while loading", () => {
+		mockUseChatModelSelector.mockReturnValue({
+			provider: providerIdentifiers.anthropic,
+			models: null,
+			modelIdKey: "apiModelId",
+			defaultModelId: "claude-opus-4-20250514",
+			isLoading: true,
+		})
+
+		render(<ChatModelSelector {...defaultProps} />)
+
+		// The trigger collapses to an ellipsis while loading, regardless of the
+		// resolved display/default value.
+		expect(screen.getByTestId("chat-model-selector-trigger")).toHaveTextContent("…")
+		// The empty-state message must not appear while a load is in flight.
+		expect(screen.queryByText("chat:modelListEmpty")).not.toBeInTheDocument()
+	})
+
+	test("does not post a message when selecting with no apiConfiguration", () => {
+		// Keep modelIdKey defined so the guard under test is the `!apiConfiguration`
+		// early return, not the `!modelIdKey` guard.
+		mockUseExtensionState.mockReturnValue({
+			apiConfiguration: undefined,
+			organizationAllowList: { allowAll: true, providers: {} },
+			currentApiConfigName: "default",
+		})
+
+		renderOpen()
+
+		fireEvent.click(screen.getByTestId("chat-model-option-claude-opus-4-20250514"))
+
+		expect(vscode.postMessage).not.toHaveBeenCalled()
+	})
+
+	test("renders the display-transformed value for compound configs (e.g. VSCode LM)", () => {
+		mockUseExtensionState.mockReturnValue({
+			apiConfiguration: {
+				apiProvider: providerIdentifiers.vscodeLm,
+				vsCodeLmModelSelector: { vendor: "copilot", family: "gpt-4o" },
+			},
+			organizationAllowList: { allowAll: true, providers: {} },
+			currentApiConfigName: "default",
+		})
+		mockUseChatModelSelector.mockReturnValue({
+			provider: providerIdentifiers.vscodeLm,
+			models: { "copilot/gpt-4o": { maxTokens: 1, contextWindow: 1 } },
+			modelIdKey: "vsCodeLmModelSelector",
+			defaultModelId: undefined,
+			isLoading: false,
+			displayTransform: (value: unknown) => {
+				const selector = value as { vendor?: string; family?: string }
+				return selector.vendor && selector.family ? `${selector.vendor}/${selector.family}` : ""
+			},
+		})
+
+		render(<ChatModelSelector {...defaultProps} />)
+
+		// The trigger shows the display-transformed value instead of the raw model id.
+		const trigger = screen.getByTestId("chat-model-selector-trigger")
+		expect(trigger).toHaveTextContent("copilot/gpt-4o")
+	})
+
+	describe("organization allow-list", () => {
+		test("filters models down to the provider allow-list", () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: {
+					apiProvider: providerIdentifiers.anthropic,
+					apiModelId: "test-model-not-real",
+				},
+				organizationAllowList: {
+					allowAll: false,
+					providers: {
+						[providerIdentifiers.anthropic]: {
+							allowAll: false,
+							models: ["claude-sonnet-4-20250514"],
+						},
+					},
+				},
+				currentApiConfigName: "default",
+			})
+
+			renderOpen()
+
+			expect(screen.getByTestId("chat-model-option-claude-sonnet-4-20250514")).toBeInTheDocument()
+			expect(screen.queryByTestId("chat-model-option-claude-opus-4-20250514")).not.toBeInTheDocument()
+		})
+
+		test("shows the empty state when the provider is absent from the allow-list", () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: {
+					apiProvider: providerIdentifiers.anthropic,
+					apiModelId: "test-model-not-real",
+				},
+				organizationAllowList: { allowAll: false, providers: {} },
+				currentApiConfigName: "default",
+			})
+
+			renderOpen()
+
+			expect(screen.queryByTestId(/^chat-model-option-/)).not.toBeInTheDocument()
+			expect(screen.getByText("chat:modelListEmpty")).toBeInTheDocument()
+		})
+
+		test("hides the custom-model row when the allow-list forbids the typed id", () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: {
+					apiProvider: providerIdentifiers.anthropic,
+					apiModelId: "test-model-not-real",
+				},
+				organizationAllowList: {
+					allowAll: false,
+					providers: {
+						[providerIdentifiers.anthropic]: {
+							allowAll: false,
+							models: ["claude-opus-4-20250514"],
+						},
+					},
+				},
+				currentApiConfigName: "default",
+			})
+
+			renderOpen()
+
+			fireEvent.change(screen.getByPlaceholderText("chat:searchModel"), {
+				target: { value: "unauthorized-model" },
+			})
+
+			expect(screen.queryByTestId("chat-model-use-custom")).not.toBeInTheDocument()
+		})
+
+		test("offers and posts the custom-model row when the allow-list permits it", () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: {
+					apiProvider: providerIdentifiers.anthropic,
+					apiModelId: "test-model-not-real",
+				},
+				organizationAllowList: {
+					allowAll: false,
+					providers: {
+						[providerIdentifiers.anthropic]: {
+							allowAll: false,
+							models: ["claude-opus-4-20250514", "approved-custom"],
+						},
+					},
+				},
+				currentApiConfigName: "default",
+			})
+			mockUseChatModelSelector.mockReturnValue({
+				provider: providerIdentifiers.anthropic,
+				models: { "claude-opus-4-20250514": modelInfo() },
+				modelIdKey: "apiModelId",
+				defaultModelId: "claude-opus-4-20250514",
+				isLoading: false,
+			})
+
+			renderOpen()
+
+			fireEvent.change(screen.getByPlaceholderText("chat:searchModel"), {
+				target: { value: "approved-custom" },
+			})
+
+			fireEvent.click(screen.getByTestId("chat-model-use-custom"))
+
+			expect(vscode.postMessage).toHaveBeenCalledWith({
+				type: "upsertApiConfiguration",
+				text: "default",
+				apiConfiguration: {
+					apiProvider: providerIdentifiers.anthropic,
+					apiModelId: "approved-custom",
+				},
+			})
+		})
+	})
+
+	test("guards the visible list: sorts ids, drops unselected deprecated models and keeps the selected one", () => {
+		mockUseChatModelSelector.mockReturnValue({
+			provider: providerIdentifiers.anthropic,
+			// Intentionally unsorted, with one deprecated model that is also the
+			// selected one (must survive) and one deprecated model that is not.
+			models: {
+				"zeta-model": modelInfo(),
+				"claude-opus-4-20250514": modelInfo({ deprecated: true }),
+				"legacy-model": modelInfo({ deprecated: true }),
+				"alpha-model": modelInfo(),
+				"middle-model": modelInfo(),
+			},
+			modelIdKey: "apiModelId",
+			defaultModelId: "claude-opus-4-20250514",
+			isLoading: false,
+		})
+
+		renderOpen()
+
+		// Rendered ids are sorted alphabetically and exclude the unselected deprecated model.
+		expect(visibleOptionIds()).toEqual(["alpha-model", "claude-opus-4-20250514", "middle-model", "zeta-model"])
+		expect(screen.queryByTestId("chat-model-option-legacy-model")).not.toBeInTheDocument()
+		expect(screen.getByTestId("chat-model-option-claude-opus-4-20250514")).toBeInTheDocument()
+	})
+
+	test("disables the trigger when there is no modelIdKey", () => {
+		mockUseChatModelSelector.mockReturnValue({
+			provider: undefined,
+			models: null,
+			modelIdKey: undefined,
+			defaultModelId: "",
+			isLoading: false,
+		})
+
+		render(<ChatModelSelector {...defaultProps} />)
+
+		const trigger = screen.getByTestId("chat-model-selector-trigger")
+		expect(trigger).toBeDisabled()
+		expect(trigger).toHaveClass("cursor-not-allowed")
+	})
+
+	test("exposes model options as keyboard-activatable buttons", () => {
+		renderOpen()
+
+		const option = screen.getByTestId("chat-model-option-claude-sonnet-4-20250514")
+		// A native <button type="button"> is in the tab order (tabIndex 0) and is
+		// activated by Enter/Space, giving the option keyboard accessibility.
+		expect(option.tagName).toBe("BUTTON")
+		expect(option).toHaveAttribute("type", "button")
+		expect(option.tabIndex).toBe(0)
+		// Keyboard focus styling must be present so focus is visible.
+		expect(option).toHaveClass("focus-visible:ring-vscode-focusBorder")
+
+		// Simulate the activation a keyboard Enter/Space would trigger on a
+		// native button (jsdom does not synthesise the click itself).
+		fireEvent.click(option)
+
+		expect(vscode.postMessage).toHaveBeenCalledWith(expect.objectContaining({ type: "upsertApiConfiguration" }))
+	})
+
+	test("keeps the trigger keyboard focusable with a visible focus ring", () => {
+		render(<ChatModelSelector {...defaultProps} />)
+
+		const trigger = screen.getByTestId("chat-model-selector-trigger")
+		expect(trigger.tagName).toBe("BUTTON")
+		expect(trigger.tabIndex).toBe(0)
+		expect(trigger).toHaveClass("focus-visible:ring-vscode-focusBorder")
+	})
+})
diff --git a/webview-ui/src/components/chat/__tests__/ChatTextArea.visual.tsx b/webview-ui/src/components/chat/__tests__/ChatTextArea.visual.tsx
index 9c447fe011..6c955767f8 100644
--- a/webview-ui/src/components/chat/__tests__/ChatTextArea.visual.tsx
+++ b/webview-ui/src/components/chat/__tests__/ChatTextArea.visual.tsx
@@ -17,7 +17,7 @@ for (const theme of visualThemes) {
 		await page.evaluate(() => (document.activeElement as HTMLElement | null)?.blur())
 		for (
 			let index = 0;
-			index < 10 && !(await editor.evaluate((element) => element === document.activeElement));
+			index < 50 && !(await editor.evaluate((element) => element === document.activeElement));
 			index++
 		) {
 			await page.keyboard.press("Tab")
diff --git a/webview-ui/src/components/chat/__tests__/ChatView.spec.tsx b/webview-ui/src/components/chat/__tests__/ChatView.spec.tsx
index 8f7de5c459..a1e918b63c 100644
--- a/webview-ui/src/components/chat/__tests__/ChatView.spec.tsx
+++ b/webview-ui/src/components/chat/__tests__/ChatView.spec.tsx
@@ -463,6 +463,45 @@ describe("ChatView - Tool Batching Tests", () => {
 			expect(toolRow?.text).toContain('"path":"b.ts"')
 		})
 	})
+
+	it("shows a repeated assistant preamble once while batching readFile asks", async () => {
+		renderChatView()
+		const preamble = "I'll read the files now."
+
+		mockPostMessage({
+			clineMessages: [
+				{ type: "say", say: "task", ts: 1, text: "Read the relevant files." },
+				{ type: "say", say: "text", ts: 2, text: preamble },
+				{
+					type: "ask",
+					ask: "tool",
+					ts: 3,
+					text: JSON.stringify({ tool: "readFile", path: "a.ts" }),
+				},
+				{ type: "say", say: "text", ts: 4, text: preamble },
+				{
+					type: "ask",
+					ask: "tool",
+					ts: 5,
+					text: JSON.stringify({ tool: "readFile", path: "b.ts" }),
+				},
+			],
+		})
+
+		await waitFor(() => {
+			const textRows = mockVirtuosoState.lastData.filter(
+				(message) => message.type === "say" && message.say === "text" && message.text === preamble,
+			)
+			const toolRows = mockVirtuosoState.lastData.filter(
+				(message) => message.type === "ask" && message.ask === "tool",
+			)
+
+			expect(textRows).toHaveLength(1)
+			expect(toolRows).toHaveLength(1)
+			const toolPayload = JSON.parse(toolRows[0]?.text ?? "{}") as { batchFiles?: Array<{ path?: string }> }
+			expect(toolPayload.batchFiles?.map(({ path }) => path)).toEqual(["a.ts", "b.ts"])
+		})
+	})
 })
 
 describe("ChatView - Aggregated Costs Lifecycle", () => {
diff --git a/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-focus-dark.png b/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-focus-dark.png
index 4de566f736..9bab7a3a7e 100644
Binary files a/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-focus-dark.png and b/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-focus-dark.png differ
diff --git a/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-focus-high-contrast-light.png b/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-focus-high-contrast-light.png
index f5c759fad8..8e9c01c7fe 100644
Binary files a/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-focus-high-contrast-light.png and b/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-focus-high-contrast-light.png differ
diff --git a/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-focus-high-contrast.png b/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-focus-high-contrast.png
index 465ffc0263..8d232cb2ab 100644
Binary files a/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-focus-high-contrast.png and b/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-focus-high-contrast.png differ
diff --git a/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-focus-light.png b/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-focus-light.png
index 1f238a4619..b6976d6cff 100644
Binary files a/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-focus-light.png and b/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-focus-light.png differ
diff --git a/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-resting-dark.png b/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-resting-dark.png
index fad9aa30b9..6c90b6f610 100644
Binary files a/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-resting-dark.png and b/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-resting-dark.png differ
diff --git a/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-resting-high-contrast-light.png b/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-resting-high-contrast-light.png
index f5c759fad8..8e9c01c7fe 100644
Binary files a/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-resting-high-contrast-light.png and b/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-resting-high-contrast-light.png differ
diff --git a/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-resting-high-contrast.png b/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-resting-high-contrast.png
index 465ffc0263..8d232cb2ab 100644
Binary files a/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-resting-high-contrast.png and b/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-resting-high-contrast.png differ
diff --git a/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-resting-light.png b/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-resting-light.png
index 1f238a4619..b6976d6cff 100644
Binary files a/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-resting-light.png and b/webview-ui/src/components/chat/__tests__/__screenshots__/chat-composer-resting-light.png differ
diff --git a/webview-ui/src/components/chat/hooks/__tests__/useChatModelSelector.spec.tsx b/webview-ui/src/components/chat/hooks/__tests__/useChatModelSelector.spec.tsx
new file mode 100644
index 0000000000..fbea135487
--- /dev/null
+++ b/webview-ui/src/components/chat/hooks/__tests__/useChatModelSelector.spec.tsx
@@ -0,0 +1,865 @@
+import React from "react"
+import { act, renderHook, waitFor } from "@testing-library/react"
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query"
+
+import {
+	providerIdentifiers,
+	retiredProviderIdentifiers,
+	anthropicDefaultModelId,
+	bedrockDefaultModelId,
+	deepSeekDefaultModelId,
+	moonshotDefaultModelId,
+	geminiDefaultModelId,
+	mistralDefaultModelId,
+	openAiNativeDefaultModelId,
+	qwenCodeDefaultModelId,
+	vertexDefaultModelId,
+	xaiDefaultModelId,
+	sambaNovaDefaultModelId,
+	internationalZAiDefaultModelId,
+	internationalZAiModels,
+	mainlandZAiDefaultModelId,
+	mainlandZAiModels,
+	fireworksDefaultModelId,
+	friendliDefaultModelId,
+	minimaxDefaultModelId,
+	mimoDefaultModelId,
+	basetenDefaultModelId,
+	openRouterDefaultModelId,
+	requestyDefaultModelId,
+	unboundDefaultModelId,
+	litellmDefaultModelId,
+	vercelAiGatewayDefaultModelId,
+	zooGatewayDefaultModelId,
+	opencodeGoDefaultModelId,
+	kenariDefaultModelId,
+	nanoGptDefaultModelId,
+	kimiCodeDefaultModelId,
+	poeDefaultModelId,
+} from "@roo-code/types"
+
+import { useChatModelSelector } from "../useChatModelSelector"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { useRouterModels } from "@/components/ui/hooks/useRouterModels"
+import { vscode } from "@/utils/vscode"
+
+vi.mock("@/context/ExtensionStateContext", () => ({
+	useExtensionState: vi.fn(),
+}))
+
+vi.mock("@/components/ui/hooks/useRouterModels", () => ({
+	useRouterModels: vi.fn(),
+}))
+
+vi.mock("@/utils/vscode", () => ({
+	vscode: {
+		postMessage: vi.fn(),
+	},
+}))
+
+const mockUseExtensionState = useExtensionState as ReturnType<typeof vi.fn>
+const mockUseRouterModels = useRouterModels as ReturnType<typeof vi.fn>
+const mockPostMessage = vscode.postMessage as ReturnType<typeof vi.fn>
+
+const wrapper = ({ children }: { children: React.ReactNode }) => {
+	const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+	return <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+}
+
+const emitMessage = (message: unknown) => {
+	window.dispatchEvent(new MessageEvent("message", { data: message }))
+}
+
+describe("useChatModelSelector", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+		mockUseRouterModels.mockReturnValue({
+			data: undefined,
+			isLoading: false,
+			isError: false,
+		})
+		mockUseExtensionState.mockReturnValue({
+			apiConfiguration: { apiProvider: providerIdentifiers.anthropic, apiModelId: "claude-opus-4-20250514" },
+			routerModels: undefined,
+		})
+	})
+
+	describe("static providers", () => {
+		it("returns static models for anthropic with apiModelId key", () => {
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(result.current.provider).toBe(providerIdentifiers.anthropic)
+			expect(result.current.modelIdKey).toBe("apiModelId")
+			expect(result.current.models).not.toBeNull()
+			expect(Object.keys(result.current.models!)).toContain("claude-opus-4-20250514")
+			// Assert the exact default id, not just "some non-empty value", so a
+			// wrong/empty default is caught.
+			expect(result.current.defaultModelId).toBe(anthropicDefaultModelId)
+		})
+
+		it("does not request message-based models for static providers", () => {
+			renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(mockPostMessage).not.toHaveBeenCalled()
+		})
+	})
+
+	describe("zai (static provider, API line aware)", () => {
+		it("uses international defaults and international model keys by default", () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: { apiProvider: providerIdentifiers.zai },
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(result.current.provider).toBe(providerIdentifiers.zai)
+			expect(result.current.defaultModelId).toBe(internationalZAiDefaultModelId)
+			expect(Object.keys(result.current.models!)).toEqual(
+				expect.arrayContaining(Object.keys(internationalZAiModels)),
+			)
+			// International pricing proves the international registry was read
+			// (the mainland registry uses different prices for the same model id).
+			expect(result.current.models!["glm-4.5"]?.inputPrice).toBe(internationalZAiModels["glm-4.5"].inputPrice)
+			expect(result.current.models!["glm-4.5"]?.inputPrice).not.toBe(mainlandZAiModels["glm-4.5"].inputPrice)
+		})
+
+		it("uses mainland defaults and mainland model keys when zaiApiLine is china_coding", () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: { apiProvider: providerIdentifiers.zai, zaiApiLine: "china_coding" },
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(result.current.defaultModelId).toBe(mainlandZAiDefaultModelId)
+			expect(Object.keys(result.current.models!)).toEqual(expect.arrayContaining(Object.keys(mainlandZAiModels)))
+			// The China Coding plan additionally exposes coding-plan-only models.
+			expect(Object.keys(result.current.models!)).toEqual(expect.arrayContaining(["glm-5.3", "glm-5.3-flash"]))
+			expect(result.current.models!["glm-4.5"]?.inputPrice).toBe(mainlandZAiModels["glm-4.5"].inputPrice)
+			expect(result.current.models!["glm-4.5"]?.inputPrice).not.toBe(internationalZAiModels["glm-4.5"].inputPrice)
+		})
+	})
+
+	describe("zoo-gateway (dynamic router provider)", () => {
+		it("reads zoo-gateway models from the react-query routerModels", () => {
+			mockUseRouterModels.mockReturnValue({
+				data: {
+					[providerIdentifiers.zooGateway]: {
+						"anthropic/claude-sonnet-4": { maxTokens: 1, contextWindow: 1 },
+					},
+				},
+				isLoading: false,
+				isError: false,
+			})
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: {
+					apiProvider: providerIdentifiers.zooGateway,
+					zooGatewayModelId: "anthropic/claude-sonnet-4",
+				},
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(result.current.modelIdKey).toBe("zooGatewayModelId")
+			expect(result.current.defaultModelId).toBe(zooGatewayDefaultModelId)
+			expect(Object.keys(result.current.models!)).toEqual(["anthropic/claude-sonnet-4"])
+		})
+
+		it("reports loading while the router models request is in flight", () => {
+			mockUseRouterModels.mockReturnValue({ data: undefined, isLoading: true, isError: false })
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: {
+					apiProvider: providerIdentifiers.zooGateway,
+					zooGatewayModelId: "anthropic/claude-sonnet-4",
+				},
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(result.current.isLoading).toBe(true)
+		})
+	})
+
+	describe("opencode-go (dynamic router provider)", () => {
+		it("reads opencode-go models from the react-query routerModels", () => {
+			mockUseRouterModels.mockReturnValue({
+				data: { [providerIdentifiers.opencodeGo]: { "glm-5.2": { maxTokens: 1, contextWindow: 1 } } },
+				isLoading: false,
+				isError: false,
+			})
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: { apiProvider: providerIdentifiers.opencodeGo, opencodeGoModelId: "glm-5.2" },
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(result.current.modelIdKey).toBe("opencodeGoModelId")
+			expect(result.current.defaultModelId).toBe(opencodeGoDefaultModelId)
+			expect(Object.keys(result.current.models!)).toEqual(["glm-5.2"])
+		})
+	})
+
+	describe("kenari (dynamic router provider)", () => {
+		it("reads kenari models from the react-query routerModels", () => {
+			mockUseRouterModels.mockReturnValue({
+				data: { [providerIdentifiers.kenari]: { "glm-5-2": { maxTokens: 1, contextWindow: 1 } } },
+				isLoading: false,
+				isError: false,
+			})
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: { apiProvider: providerIdentifiers.kenari, kenariModelId: "glm-5-2" },
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(result.current.modelIdKey).toBe("kenariModelId")
+			expect(result.current.defaultModelId).toBe(kenariDefaultModelId)
+			expect(Object.keys(result.current.models!)).toEqual(["glm-5-2"])
+		})
+	})
+
+	describe("nanogpt (dynamic router provider)", () => {
+		it("reads nanogpt models from the react-query routerModels", () => {
+			mockUseRouterModels.mockReturnValue({
+				data: { [providerIdentifiers.nanogpt]: { "openai/gpt-5.6-sol": { maxTokens: 1, contextWindow: 1 } } },
+				isLoading: false,
+				isError: false,
+			})
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: { apiProvider: providerIdentifiers.nanogpt, nanoGptModelId: "openai/gpt-5.6-sol" },
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(result.current.modelIdKey).toBe("nanoGptModelId")
+			expect(result.current.defaultModelId).toBe(nanoGptDefaultModelId)
+			expect(Object.keys(result.current.models!)).toEqual(["openai/gpt-5.6-sol"])
+		})
+	})
+
+	describe("requesty (dynamic router provider)", () => {
+		it("reads requesty models from the react-query routerModels", () => {
+			mockUseRouterModels.mockReturnValue({
+				data: { [providerIdentifiers.requesty]: { "openai/gpt-5.1": { maxTokens: 1, contextWindow: 1 } } },
+				isLoading: false,
+				isError: false,
+			})
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: { apiProvider: providerIdentifiers.requesty, requestyModelId: "openai/gpt-5.1" },
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(result.current.modelIdKey).toBe("requestyModelId")
+			expect(result.current.defaultModelId).toBe(requestyDefaultModelId)
+			expect(Object.keys(result.current.models!)).toEqual(["openai/gpt-5.1"])
+		})
+	})
+
+	describe("unbound (dynamic router provider)", () => {
+		it("reads unbound models from the react-query routerModels", () => {
+			mockUseRouterModels.mockReturnValue({
+				data: { [providerIdentifiers.unbound]: { "openai/gpt-4o": { maxTokens: 1, contextWindow: 1 } } },
+				isLoading: false,
+				isError: false,
+			})
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: { apiProvider: providerIdentifiers.unbound, unboundModelId: "openai/gpt-4o" },
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(result.current.modelIdKey).toBe("unboundModelId")
+			expect(result.current.defaultModelId).toBe(unboundDefaultModelId)
+			expect(Object.keys(result.current.models!)).toEqual(["openai/gpt-4o"])
+		})
+	})
+
+	describe("vercel-ai-gateway (dynamic router provider)", () => {
+		it("reads vercel-ai-gateway models from the react-query routerModels", () => {
+			mockUseRouterModels.mockReturnValue({
+				data: {
+					[providerIdentifiers.vercelAiGateway]: { "openai/gpt-4o-mini": { maxTokens: 1, contextWindow: 1 } },
+				},
+				isLoading: false,
+				isError: false,
+			})
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: {
+					apiProvider: providerIdentifiers.vercelAiGateway,
+					vercelAiGatewayModelId: "openai/gpt-4o-mini",
+				},
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(result.current.modelIdKey).toBe("vercelAiGatewayModelId")
+			expect(result.current.defaultModelId).toBe(vercelAiGatewayDefaultModelId)
+			expect(Object.keys(result.current.models!)).toEqual(["openai/gpt-4o-mini"])
+		})
+	})
+
+	describe("kimi-code (dynamic router provider)", () => {
+		it("reads kimi-code models from the react-query routerModels using apiModelId", () => {
+			mockUseRouterModels.mockReturnValue({
+				data: { [providerIdentifiers.kimiCode]: { "kimi-k2": { maxTokens: 1, contextWindow: 1 } } },
+				isLoading: false,
+				isError: false,
+			})
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: { apiProvider: providerIdentifiers.kimiCode, apiModelId: "kimi-k2" },
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(result.current.modelIdKey).toBe("apiModelId")
+			expect(result.current.defaultModelId).toBe(kimiCodeDefaultModelId)
+			expect(Object.keys(result.current.models!)).toEqual(["kimi-k2"])
+		})
+	})
+
+	describe("openai (OpenAI compatible)", () => {
+		it("requests openAi models on mount when baseUrl and apiKey are set", () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: {
+					apiProvider: providerIdentifiers.openai,
+					openAiBaseUrl: "https://api.example.com/v1",
+					openAiApiKey: "test-key",
+					openAiHeaders: {},
+				},
+				routerModels: undefined,
+			})
+
+			renderHook(() => useChatModelSelector(), { wrapper })
+
+			// The request now carries an identity token so the matching response
+			// can be correlated and stale replies discarded.
+			expect(mockPostMessage).toHaveBeenCalledWith(
+				expect.objectContaining({
+					type: "requestOpenAiModels",
+					requestId: expect.any(String),
+					values: {
+						baseUrl: "https://api.example.com/v1",
+						apiKey: "test-key",
+						customHeaders: {},
+						openAiHeaders: {},
+					},
+				}),
+			)
+		})
+
+		it("uses models delivered through the openAiModels message", async () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: {
+					apiProvider: providerIdentifiers.openai,
+					openAiBaseUrl: "https://api.example.com/v1",
+					openAiApiKey: "test-key",
+					openAiHeaders: {},
+				},
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			act(() => {
+				emitMessage({ type: "openAiModels", openAiModels: ["gpt-4o", "gpt-4o-mini"] })
+			})
+
+			await waitFor(() => {
+				expect(result.current.models).not.toBeNull()
+			})
+
+			expect(Object.keys(result.current.models!)).toEqual(expect.arrayContaining(["gpt-4o", "gpt-4o-mini"]))
+			expect(result.current.modelIdKey).toBe("openAiModelId")
+		})
+
+		it("adopts a response whose requestId matches the issued request", async () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: {
+					apiProvider: providerIdentifiers.openai,
+					openAiBaseUrl: "https://api.example.com/v1",
+					openAiApiKey: "test-key",
+					openAiHeaders: {},
+				},
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			const requestId = mockPostMessage.mock.calls[0][0].requestId as string
+
+			act(() => {
+				emitMessage({ type: "openAiModels", openAiModels: ["fresh-model"], requestId })
+			})
+
+			await waitFor(() => {
+				expect(result.current.models).not.toBeNull()
+			})
+
+			expect(Object.keys(result.current.models!)).toEqual(["fresh-model"])
+		})
+
+		it("ignores a response whose requestId does not match the issued request", async () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: {
+					apiProvider: providerIdentifiers.openai,
+					openAiBaseUrl: "https://api.example.com/v1",
+					openAiApiKey: "test-key",
+					openAiHeaders: {},
+				},
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			act(() => {
+				// A stale reply from a superseded request must not be adopted.
+				emitMessage({ type: "openAiModels", openAiModels: ["stale-model"], requestId: "superseded-request" })
+			})
+
+			expect(result.current.models).toBeNull()
+		})
+
+		it("re-requests with a new identity when the API profile changes and ignores the old reply", async () => {
+			const openAiConfig = {
+				apiProvider: providerIdentifiers.openai,
+				openAiBaseUrl: "https://api.example.com/v1",
+				openAiApiKey: "test-key",
+				openAiHeaders: {},
+			}
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: openAiConfig,
+				currentApiConfigName: "profile-a",
+				routerModels: undefined,
+			})
+
+			const { result, rerender } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			const firstRequestId = mockPostMessage.mock.calls[0][0].requestId as string
+
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: openAiConfig,
+				currentApiConfigName: "profile-b",
+				routerModels: undefined,
+			})
+			rerender()
+
+			await waitFor(() => {
+				expect(mockPostMessage).toHaveBeenCalledTimes(2)
+			})
+			const secondRequestId = mockPostMessage.mock.calls[1][0].requestId as string
+			expect(secondRequestId).not.toBe(firstRequestId)
+
+			// The reply to the superseded profile's request arrives late and must
+			// be dropped instead of overwriting the new profile's (empty) list.
+			act(() => {
+				emitMessage({ type: "openAiModels", openAiModels: ["stale-model"], requestId: firstRequestId })
+			})
+			expect(result.current.models).toBeNull()
+		})
+
+		it("reports loading while the openAi request is in flight", () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: {
+					apiProvider: providerIdentifiers.openai,
+					openAiBaseUrl: "https://api.example.com/v1",
+					openAiApiKey: "test-key",
+					openAiHeaders: {},
+				},
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(result.current.isLoading).toBe(true)
+		})
+
+		it("does not request openAi models when the base URL is missing", () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: {
+					apiProvider: providerIdentifiers.openai,
+					openAiApiKey: "test-key",
+					openAiHeaders: {},
+				},
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(mockPostMessage).not.toHaveBeenCalled()
+			expect(result.current.isLoading).toBe(false)
+		})
+
+		it("does not request openAi models when the API key is missing", () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: {
+					apiProvider: providerIdentifiers.openai,
+					openAiBaseUrl: "https://api.example.com/v1",
+					openAiHeaders: {},
+				},
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(mockPostMessage).not.toHaveBeenCalled()
+			expect(result.current.isLoading).toBe(false)
+		})
+	})
+
+	describe("router providers", () => {
+		it("reads openrouter models from the react-query routerModels", () => {
+			mockUseRouterModels.mockReturnValue({
+				data: { [providerIdentifiers.openrouter]: { "openai/gpt-4o": { maxTokens: 1, contextWindow: 1 } } },
+				isLoading: false,
+				isError: false,
+			})
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: { apiProvider: providerIdentifiers.openrouter, openRouterModelId: "openai/gpt-4o" },
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(result.current.modelIdKey).toBe("openRouterModelId")
+			expect(Object.keys(result.current.models!)).toEqual(["openai/gpt-4o"])
+		})
+
+		it("reads poe models from the backend-broadcast state routerModels", () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: { apiProvider: providerIdentifiers.poe, poeApiKey: "test" },
+				routerModels: { [providerIdentifiers.poe]: { "claude-sonnet": { maxTokens: 1, contextWindow: 1 } } },
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(result.current.modelIdKey).toBe("apiModelId")
+			expect(Object.keys(result.current.models!)).toEqual(["claude-sonnet"])
+		})
+
+		it("reads litellm models from the backend-broadcast state routerModels", () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: {
+					apiProvider: providerIdentifiers.litellm,
+					litellmApiKey: "test",
+					litellmBaseUrl: "http://x",
+				},
+				routerModels: { [providerIdentifiers.litellm]: { "gpt-4o": { maxTokens: 1, contextWindow: 1 } } },
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(result.current.modelIdKey).toBe("litellmModelId")
+			expect(Object.keys(result.current.models!)).toEqual(["gpt-4o"])
+		})
+	})
+
+	describe("ollama / lmstudio / vscode-lm", () => {
+		it("requests ollama models on mount", () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: { apiProvider: providerIdentifiers.ollama, ollamaModelId: "llama3" },
+				routerModels: undefined,
+			})
+
+			renderHook(() => useChatModelSelector(), { wrapper })
+
+			// The request now carries an identity token so a late reply can be
+			// correlated with the request that issued it.
+			expect(mockPostMessage).toHaveBeenCalledWith(
+				expect.objectContaining({ type: "requestOllamaModels", requestId: expect.any(String) }),
+			)
+		})
+
+		it("uses models delivered through the ollamaModels message", async () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: { apiProvider: providerIdentifiers.ollama, ollamaModelId: "llama3" },
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			act(() => {
+				emitMessage({ type: "ollamaModels", ollamaModels: { llama3: { maxTokens: 1, contextWindow: 1 } } })
+			})
+
+			await waitFor(() => {
+				expect(result.current.models).not.toBeNull()
+			})
+			expect(result.current.modelIdKey).toBe("ollamaModelId")
+			expect(Object.keys(result.current.models!)).toEqual(["llama3"])
+		})
+
+		it("requests lmstudio models on mount", () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: { apiProvider: providerIdentifiers.lmstudio, lmStudioModelId: "local-model" },
+				routerModels: undefined,
+			})
+
+			renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(mockPostMessage).toHaveBeenCalledWith(
+				expect.objectContaining({ type: "requestLmStudioModels", requestId: expect.any(String) }),
+			)
+		})
+
+		it("uses models delivered through the lmStudioModels message", async () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: { apiProvider: providerIdentifiers.lmstudio, lmStudioModelId: "local-model" },
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			act(() => {
+				emitMessage({
+					type: "lmStudioModels",
+					lmStudioModels: { "local-model": { maxTokens: 1, contextWindow: 1 } },
+				})
+			})
+
+			await waitFor(() => {
+				expect(result.current.models).not.toBeNull()
+			})
+			expect(result.current.modelIdKey).toBe("lmStudioModelId")
+			expect(Object.keys(result.current.models!)).toEqual(["local-model"])
+		})
+
+		it("requests vsCodeLm models on mount and builds model records", async () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: { apiProvider: providerIdentifiers.vscodeLm },
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(mockPostMessage).toHaveBeenCalledWith(
+				expect.objectContaining({ type: "requestVsCodeLmModels", requestId: expect.any(String) }),
+			)
+
+			act(() => {
+				emitMessage({
+					type: "vsCodeLmModels",
+					vsCodeLmModels: [{ vendor: "copilot", family: "gpt-4o" }],
+				})
+			})
+
+			await waitFor(() => {
+				expect(result.current.models).not.toBeNull()
+			})
+			expect(Object.keys(result.current.models!)).toEqual(["copilot/gpt-4o"])
+			expect(result.current.modelIdKey).toBe("vsCodeLmModelSelector")
+		})
+
+		it("transforms vsCodeLm model ids to vendor/family and formats display values", async () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: {
+					apiProvider: providerIdentifiers.vscodeLm,
+					vsCodeLmModelSelector: { vendor: "copilot", family: "gpt-4o" },
+				},
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			act(() => {
+				emitMessage({
+					type: "vsCodeLmModels",
+					vsCodeLmModels: [{ vendor: "copilot", family: "gpt-4o" }],
+				})
+			})
+
+			await waitFor(() => {
+				expect(result.current.models).not.toBeNull()
+			})
+
+			// valueTransform: "copilot/gpt-4o" -> { vendor: "copilot", family: "gpt-4o" }
+			expect(result.current.valueTransform!("copilot/gpt-4o")).toEqual({ vendor: "copilot", family: "gpt-4o" })
+			// displayTransform: { vendor, family } -> "copilot/gpt-4o"
+			expect(result.current.displayTransform!({ vendor: "copilot", family: "gpt-4o" })).toBe("copilot/gpt-4o")
+			// displayTransform returns "" for missing values
+			expect(result.current.displayTransform!(undefined)).toBe("")
+			expect(result.current.displayTransform!({ vendor: "copilot" })).toBe("")
+		})
+	})
+
+	describe("message-based request identity and cleanup", () => {
+		it("tags the ollama request with an identity and adopts only the matching response", async () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: { apiProvider: providerIdentifiers.ollama, ollamaModelId: "llama3" },
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			const requestId = mockPostMessage.mock.calls[0][0].requestId as string
+			expect(requestId).toEqual(expect.any(String))
+			expect(mockPostMessage).toHaveBeenCalledWith({ type: "requestOllamaModels", requestId })
+
+			act(() => {
+				emitMessage({
+					type: "ollamaModels",
+					ollamaModels: { llama3: { maxTokens: 1, contextWindow: 1 } },
+					requestId,
+				})
+			})
+
+			await waitFor(() => {
+				expect(result.current.models).not.toBeNull()
+			})
+			expect(Object.keys(result.current.models!)).toEqual(["llama3"])
+		})
+
+		it("ignores an ollama response carrying a superseded request id", () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: { apiProvider: providerIdentifiers.ollama, ollamaModelId: "llama3" },
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			act(() => {
+				emitMessage({
+					type: "ollamaModels",
+					ollamaModels: { stale: { maxTokens: 1, contextWindow: 1 } },
+					requestId: "superseded-request",
+				})
+			})
+
+			expect(result.current.models).toBeNull()
+		})
+
+		it("ignores a late lmStudio response after the hook unmounts (cleanup invalidates the request)", () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: { apiProvider: providerIdentifiers.lmstudio, lmStudioModelId: "local-model" },
+				routerModels: undefined,
+			})
+
+			const { result, unmount } = renderHook(() => useChatModelSelector(), { wrapper })
+			const requestId = mockPostMessage.mock.calls[0][0].requestId as string
+
+			unmount()
+
+			// The cleanup dropped the in-flight identity, so the reply can no
+			// longer be adopted by the unmounted hook.
+			act(() => {
+				emitMessage({
+					type: "lmStudioModels",
+					lmStudioModels: { "late-model": { maxTokens: 1, contextWindow: 1 } },
+					requestId,
+				})
+			})
+
+			expect(result.current.models).toBeNull()
+		})
+
+		it("tags the vsCodeLm request with an identity and adopts only the matching response", async () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: { apiProvider: providerIdentifiers.vscodeLm },
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			const requestId = mockPostMessage.mock.calls[0][0].requestId as string
+			expect(mockPostMessage).toHaveBeenCalledWith({ type: "requestVsCodeLmModels", requestId })
+
+			act(() => {
+				emitMessage({
+					type: "vsCodeLmModels",
+					vsCodeLmModels: [{ vendor: "copilot", family: "gpt-4o" }],
+					requestId,
+				})
+			})
+
+			await waitFor(() => {
+				expect(result.current.models).not.toBeNull()
+			})
+			expect(Object.keys(result.current.models!)).toEqual(["copilot/gpt-4o"])
+		})
+	})
+
+	describe("default model ids", () => {
+		// Asserting the exact default id for every mapped provider kills mutants
+		// that drop or change an entry in STATIC_DEFAULT_MODEL_IDS /
+		// ROUTER_DEFAULT_MODEL_IDS (a weak toBeTruthy() only proves non-empty).
+		const staticProviderDefaults: Array<[string, string]> = [
+			[providerIdentifiers.anthropic, anthropicDefaultModelId],
+			[providerIdentifiers.bedrock, bedrockDefaultModelId],
+			[providerIdentifiers.deepseek, deepSeekDefaultModelId],
+			[providerIdentifiers.moonshot, moonshotDefaultModelId],
+			[providerIdentifiers.gemini, geminiDefaultModelId],
+			[providerIdentifiers.mistral, mistralDefaultModelId],
+			[providerIdentifiers.openaiNative, openAiNativeDefaultModelId],
+			[providerIdentifiers.qwenCode, qwenCodeDefaultModelId],
+			[providerIdentifiers.vertex, vertexDefaultModelId],
+			[providerIdentifiers.xai, xaiDefaultModelId],
+			[providerIdentifiers.sambanova, sambaNovaDefaultModelId],
+			[providerIdentifiers.fireworks, fireworksDefaultModelId],
+			[providerIdentifiers.friendli, friendliDefaultModelId],
+			[providerIdentifiers.minimax, minimaxDefaultModelId],
+			[providerIdentifiers.mimo, mimoDefaultModelId],
+			[providerIdentifiers.baseten, basetenDefaultModelId],
+		]
+
+		it.each(staticProviderDefaults)("resolves the exact default id for %s", (provider, expected) => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: { apiProvider: provider },
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(result.current.defaultModelId).toBe(expected)
+		})
+
+		const routerProviderDefaults: Array<[string, string]> = [
+			[providerIdentifiers.openrouter, openRouterDefaultModelId],
+			[providerIdentifiers.requesty, requestyDefaultModelId],
+			[providerIdentifiers.unbound, unboundDefaultModelId],
+			[providerIdentifiers.litellm, litellmDefaultModelId],
+			[providerIdentifiers.vercelAiGateway, vercelAiGatewayDefaultModelId],
+			[providerIdentifiers.zooGateway, zooGatewayDefaultModelId],
+			[providerIdentifiers.opencodeGo, opencodeGoDefaultModelId],
+			[providerIdentifiers.kenari, kenariDefaultModelId],
+			[providerIdentifiers.nanogpt, nanoGptDefaultModelId],
+			[providerIdentifiers.kimiCode, kimiCodeDefaultModelId],
+			[providerIdentifiers.poe, poeDefaultModelId],
+		]
+
+		it.each(routerProviderDefaults)("resolves the exact router default id for %s", (provider, expected) => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: { apiProvider: provider },
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(result.current.defaultModelId).toBe(expected)
+		})
+	})
+
+	describe("retired providers", () => {
+		it("returns empty data for retired providers", () => {
+			mockUseExtensionState.mockReturnValue({
+				apiConfiguration: { apiProvider: retiredProviderIdentifiers.groq as unknown as "openrouter" },
+				routerModels: undefined,
+			})
+
+			const { result } = renderHook(() => useChatModelSelector(), { wrapper })
+
+			expect(result.current.provider).toBeUndefined()
+			expect(result.current.models).toBeNull()
+			expect(result.current.modelIdKey).toBeUndefined()
+		})
+	})
+})
diff --git a/webview-ui/src/components/chat/hooks/useChatModelSelector.ts b/webview-ui/src/components/chat/hooks/useChatModelSelector.ts
new file mode 100644
index 0000000000..dda916d6b5
--- /dev/null
+++ b/webview-ui/src/components/chat/hooks/useChatModelSelector.ts
@@ -0,0 +1,414 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react"
+import { useEvent } from "react-use"
+
+import {
+	type ProviderName,
+	type ProviderSettings,
+	type ModelInfo,
+	type ModelRecord,
+	type ExtensionMessage,
+	type LanguageModelChatSelector,
+	providerIdentifiers,
+	openAiModelInfoSaneDefaults,
+	anthropicDefaultModelId,
+	bedrockDefaultModelId,
+	deepSeekDefaultModelId,
+	moonshotDefaultModelId,
+	geminiDefaultModelId,
+	mistralDefaultModelId,
+	openAiNativeDefaultModelId,
+	qwenCodeDefaultModelId,
+	vertexDefaultModelId,
+	xaiDefaultModelId,
+	sambaNovaDefaultModelId,
+	internationalZAiDefaultModelId,
+	mainlandZAiDefaultModelId,
+	fireworksDefaultModelId,
+	friendliDefaultModelId,
+	minimaxDefaultModelId,
+	mimoDefaultModelId,
+	basetenDefaultModelId,
+	openRouterDefaultModelId,
+	requestyDefaultModelId,
+	unboundDefaultModelId,
+	litellmDefaultModelId,
+	vercelAiGatewayDefaultModelId,
+	zooGatewayDefaultModelId,
+	opencodeGoDefaultModelId,
+	kenariDefaultModelId,
+	nanoGptDefaultModelId,
+	kimiCodeDefaultModelId,
+	poeDefaultModelId,
+	isRetiredProvider,
+} from "@roo-code/types"
+
+import { useRouterModels } from "@/components/ui/hooks/useRouterModels"
+import { getStaticModelsForProvider } from "@/components/settings/utils/providerModelConfig"
+import { MODELS_BY_PROVIDER } from "@/components/settings/constants"
+import { useExtensionState } from "@/context/ExtensionStateContext"
+import { vscode } from "@/utils/vscode"
+
+type ModelIdKey = keyof Pick<
+	ProviderSettings,
+	| "openRouterModelId"
+	| "requestyModelId"
+	| "unboundModelId"
+	| "openAiModelId"
+	| "litellmModelId"
+	| "vercelAiGatewayModelId"
+	| "zooGatewayModelId"
+	| "opencodeGoModelId"
+	| "kenariModelId"
+	| "nanoGptModelId"
+	| "apiModelId"
+	| "ollamaModelId"
+	| "lmStudioModelId"
+	| "vsCodeLmModelSelector"
+>
+
+const STATIC_DEFAULT_MODEL_IDS: Partial<Record<ProviderName, string>> = {
+	[providerIdentifiers.anthropic]: anthropicDefaultModelId,
+	[providerIdentifiers.bedrock]: bedrockDefaultModelId,
+	[providerIdentifiers.deepseek]: deepSeekDefaultModelId,
+	[providerIdentifiers.moonshot]: moonshotDefaultModelId,
+	[providerIdentifiers.gemini]: geminiDefaultModelId,
+	[providerIdentifiers.mistral]: mistralDefaultModelId,
+	[providerIdentifiers.openaiNative]: openAiNativeDefaultModelId,
+	[providerIdentifiers.qwenCode]: qwenCodeDefaultModelId,
+	[providerIdentifiers.vertex]: vertexDefaultModelId,
+	[providerIdentifiers.xai]: xaiDefaultModelId,
+	[providerIdentifiers.sambanova]: sambaNovaDefaultModelId,
+	[providerIdentifiers.zai]: internationalZAiDefaultModelId,
+	[providerIdentifiers.fireworks]: fireworksDefaultModelId,
+	[providerIdentifiers.friendli]: friendliDefaultModelId,
+	[providerIdentifiers.minimax]: minimaxDefaultModelId,
+	[providerIdentifiers.mimo]: mimoDefaultModelId,
+	[providerIdentifiers.baseten]: basetenDefaultModelId,
+}
+
+const ROUTER_DEFAULT_MODEL_IDS: Partial<Record<ProviderName, string>> = {
+	[providerIdentifiers.openrouter]: openRouterDefaultModelId,
+	[providerIdentifiers.requesty]: requestyDefaultModelId,
+	[providerIdentifiers.unbound]: unboundDefaultModelId,
+	[providerIdentifiers.litellm]: litellmDefaultModelId,
+	[providerIdentifiers.vercelAiGateway]: vercelAiGatewayDefaultModelId,
+	[providerIdentifiers.zooGateway]: zooGatewayDefaultModelId,
+	[providerIdentifiers.opencodeGo]: opencodeGoDefaultModelId,
+	[providerIdentifiers.kenari]: kenariDefaultModelId,
+	[providerIdentifiers.nanogpt]: nanoGptDefaultModelId,
+	[providerIdentifiers.kimiCode]: kimiCodeDefaultModelId,
+	[providerIdentifiers.poe]: poeDefaultModelId,
+}
+
+// Providers whose model list is delivered through a dedicated message event
+// (mirrors the settings page provider components).
+const MESSAGE_BASED_PROVIDERS: ProviderName[] = [
+	providerIdentifiers.openai,
+	providerIdentifiers.ollama,
+	providerIdentifiers.lmstudio,
+	providerIdentifiers.vscodeLm,
+]
+
+/**
+ * Message channel for a message-based model list request. Each channel carries
+ * its own in-flight request identity so a reply can only be adopted by the
+ * request that most recently asked for it.
+ */
+type ModelRequestChannel = "openai" | "ollama" | "lmstudio" | "vscodeLm"
+
+export interface ChatModelSelectorData {
+	/** The provider key used to determine model source (undefined for retired providers). */
+	provider: ProviderName | undefined
+	/** Record of available models for the current provider (null until loaded or when N/A). */
+	models: Record<string, ModelInfo> | null
+	/** The configuration field key that stores the selected model for this provider. */
+	modelIdKey: ModelIdKey | undefined
+	/** The default model id for this provider. */
+	defaultModelId: string
+	/** Whether the model list is still loading. */
+	isLoading: boolean
+	/** Transform a selected model id into the stored configuration value (e.g. VSCode LM selector object). */
+	valueTransform?: (modelId: string) => unknown
+	/** Transform the stored configuration value back to a display string (e.g. VSCode LM selector). */
+	displayTransform?: (value: unknown) => string
+}
+
+/**
+ * Resolves the model list, storage key and defaults for the currently active
+ * provider so the chat input bar can render a compact model picker.
+ *
+ * The data sources mirror the settings page (`ApiOptions` and the provider
+ * components) so the chat selector shows the exact same models:
+ * - Router providers (openrouter, requesty, unbound, vercel-ai-gateway,
+ *   zoo-gateway, opencode-go, kenari, nanogpt, kimi-code):
+ *   react-query `useRouterModels` request.
+ * - litellm / poe: backend-broadcast `routerModels` from extension state.
+ * - openai (OpenAI compatible), ollama, lmstudio, vscode-lm: request on mount
+ *   and listen for the corresponding `*Models` message event.
+ * - Static providers: `getStaticModelsForProvider`.
+ */
+export const useChatModelSelector = (): ChatModelSelectorData => {
+	const { apiConfiguration, routerModels: stateRouterModels, currentApiConfigName } = useExtensionState()
+
+	const provider = (apiConfiguration?.apiProvider || providerIdentifiers.openrouter) as ProviderName
+	const activeProvider = isRetiredProvider(provider) ? undefined : provider
+
+	// Router providers are fetched through react-query (mirrors ApiOptions).
+	const routerModels = useRouterModels({
+		provider: activeProvider,
+		enabled: !!activeProvider && ROUTER_DEFAULT_MODEL_IDS[activeProvider] !== undefined,
+	})
+
+	// Message-based providers: request the models on mount and keep the
+	// latest list delivered by the backend.
+	const [openAiModels, setOpenAiModels] = useState<string[]>([])
+	const [ollamaModels, setOllamaModels] = useState<ModelRecord>({})
+	const [lmStudioModels, setLmStudioModels] = useState<ModelRecord>({})
+	const [vsCodeLmModels, setVsCodeLmModels] = useState<LanguageModelChatSelector[]>([])
+
+	// Identity of the in-flight model request per channel. A reply is adopted only by the request
+	// most recently issued for its channel, so a late reply from a previous provider/profile cannot
+	// overwrite the active list. `null` means no request is in flight (nothing may be adopted).
+	const modelRequestIdsRef = useRef<Record<ModelRequestChannel, string | null>>({
+		openai: null,
+		ollama: null,
+		lmstudio: null,
+		vscodeLm: null,
+	})
+
+	// Drop any previously fetched message-based model list when the provider or API profile
+	// changes; the lists are provider/profile scoped and a stale entry would leak across a switch.
+	useEffect(() => {
+		setOpenAiModels([])
+		setOllamaModels({})
+		setLmStudioModels({})
+		setVsCodeLmModels([])
+		modelRequestIdsRef.current = { openai: null, ollama: null, lmstudio: null, vscodeLm: null }
+	}, [activeProvider, currentApiConfigName])
+
+	const onMessage = useCallback((event: MessageEvent) => {
+		const message: ExtensionMessage = event.data
+
+		// Only accept a response belonging to the request most recently issued for its channel.
+		// Replies without an identity come from other callers (e.g. the settings page) and are
+		// accepted; a superseded request id, or one arriving after a provider/profile switch
+		// invalidated the channel, is dropped.
+		const isCurrentRequest = (channel: ModelRequestChannel) =>
+			!message.requestId || message.requestId === modelRequestIdsRef.current[channel]
+
+		switch (message.type) {
+			case "openAiModels":
+				if (isCurrentRequest("openai")) setOpenAiModels(message.openAiModels ?? [])
+				break
+			case "ollamaModels":
+				if (isCurrentRequest("ollama")) setOllamaModels(message.ollamaModels ?? {})
+				break
+			case "lmStudioModels":
+				if (isCurrentRequest("lmstudio")) setLmStudioModels(message.lmStudioModels ?? {})
+				break
+			case "vsCodeLmModels":
+				if (isCurrentRequest("vscodeLm")) setVsCodeLmModels(message.vsCodeLmModels ?? [])
+				break
+		}
+	}, [])
+	useEvent("message", onMessage)
+
+	// Request models on mount when a message-based provider is active (mirrors the settings page).
+	useEffect(() => {
+		if (!activeProvider || !MESSAGE_BASED_PROVIDERS.includes(activeProvider)) {
+			return
+		}
+
+		// Tag each request with an identity token so the matching reply can be identified.
+		const requestId = `${Date.now()}-${Math.random().toString(36).slice(2)}`
+
+		switch (activeProvider) {
+			case providerIdentifiers.openai:
+				if (apiConfiguration?.openAiBaseUrl && apiConfiguration?.openAiApiKey) {
+					modelRequestIdsRef.current.openai = requestId
+					vscode.postMessage({
+						type: "requestOpenAiModels",
+						requestId,
+						values: {
+							baseUrl: apiConfiguration.openAiBaseUrl,
+							apiKey: apiConfiguration.openAiApiKey,
+							customHeaders: {},
+							openAiHeaders: apiConfiguration.openAiHeaders ?? {},
+						},
+					})
+				}
+				break
+			case providerIdentifiers.ollama:
+				modelRequestIdsRef.current.ollama = requestId
+				vscode.postMessage({ type: "requestOllamaModels", requestId })
+				break
+			case providerIdentifiers.lmstudio:
+				modelRequestIdsRef.current.lmstudio = requestId
+				vscode.postMessage({ type: "requestLmStudioModels", requestId })
+				break
+			case providerIdentifiers.vscodeLm:
+				modelRequestIdsRef.current.vscodeLm = requestId
+				vscode.postMessage({ type: "requestVsCodeLmModels", requestId })
+				break
+		}
+
+		// Cancel the in-flight request when the provider/profile changes again or the hook unmounts:
+		// dropping the identity makes any reply still in flight fail the `isCurrentRequest` check
+		// instead of overwriting the newly requested list.
+		return () => {
+			modelRequestIdsRef.current = { openai: null, ollama: null, lmstudio: null, vscodeLm: null }
+		}
+	}, [
+		activeProvider,
+		// Re-request after a provider/profile switch (the reset effect clears the previous list).
+		currentApiConfigName,
+		apiConfiguration?.openAiBaseUrl,
+		apiConfiguration?.openAiApiKey,
+		apiConfiguration?.openAiHeaders,
+	])
+
+	// Map provider -> config field key + model list + default id.
+	return useMemo<ChatModelSelectorData>(() => {
+		if (!activeProvider) {
+			return {
+				provider: undefined,
+				models: null,
+				modelIdKey: undefined,
+				defaultModelId: "",
+				isLoading: false,
+			}
+		}
+
+		const defaultModelId =
+			(activeProvider === providerIdentifiers.zai && apiConfiguration?.zaiApiLine === "china_coding"
+				? mainlandZAiDefaultModelId
+				: (ROUTER_DEFAULT_MODEL_IDS[activeProvider] ?? STATIC_DEFAULT_MODEL_IDS[activeProvider] ?? "")) ?? ""
+
+		let models: Record<string, ModelInfo> | null = null
+		let modelIdKey: ModelIdKey | undefined = undefined
+		let valueTransform: ((modelId: string) => unknown) | undefined
+		let displayTransform: ((value: unknown) => string) | undefined
+		let isLoading = false
+
+		switch (activeProvider) {
+			case providerIdentifiers.openrouter:
+				models = routerModels.data?.openrouter ?? null
+				modelIdKey = "openRouterModelId"
+				break
+			case providerIdentifiers.requesty:
+				models = routerModels.data?.requesty ?? null
+				modelIdKey = "requestyModelId"
+				break
+			case providerIdentifiers.unbound:
+				models = routerModels.data?.unbound ?? null
+				modelIdKey = "unboundModelId"
+				break
+			case providerIdentifiers.litellm:
+				// The settings page reads litellm from the backend broadcast cache (stateRouterModels).
+				models = stateRouterModels?.litellm ?? null
+				modelIdKey = "litellmModelId"
+				break
+			case providerIdentifiers.vercelAiGateway:
+				models = routerModels.data?.[providerIdentifiers.vercelAiGateway] ?? null
+				modelIdKey = "vercelAiGatewayModelId"
+				break
+			case providerIdentifiers.zooGateway:
+				models = routerModels.data?.[providerIdentifiers.zooGateway] ?? null
+				modelIdKey = "zooGatewayModelId"
+				break
+			case providerIdentifiers.opencodeGo:
+				models = routerModels.data?.[providerIdentifiers.opencodeGo] ?? null
+				modelIdKey = "opencodeGoModelId"
+				break
+			case providerIdentifiers.kenari:
+				models = routerModels.data?.[providerIdentifiers.kenari] ?? null
+				modelIdKey = "kenariModelId"
+				break
+			case providerIdentifiers.nanogpt:
+				models = routerModels.data?.[providerIdentifiers.nanogpt] ?? null
+				modelIdKey = "nanoGptModelId"
+				break
+			case providerIdentifiers.kimiCode:
+				// Kimi Code stores its model id in apiModelId (mirrors useSelectedModel).
+				models = routerModels.data?.[providerIdentifiers.kimiCode] ?? null
+				modelIdKey = "apiModelId"
+				break
+			case providerIdentifiers.poe:
+				// Same as litellm: poe uses the backend broadcast cache.
+				models = stateRouterModels?.poe ?? null
+				modelIdKey = "apiModelId"
+				break
+			case providerIdentifiers.openai:
+				// OpenAI Compatible: fetched from the baseUrl via `requestOpenAiModels` → `openAiModels`.
+				models =
+					Object.keys(openAiModels).length > 0
+						? Object.fromEntries(openAiModels.map((item) => [item, openAiModelInfoSaneDefaults]))
+						: null
+				modelIdKey = "openAiModelId"
+				break
+			case providerIdentifiers.ollama:
+				models = Object.keys(ollamaModels).length > 0 ? ollamaModels : null
+				modelIdKey = "ollamaModelId"
+				break
+			case providerIdentifiers.lmstudio:
+				models = Object.keys(lmStudioModels).length > 0 ? lmStudioModels : null
+				modelIdKey = "lmStudioModelId"
+				break
+			case providerIdentifiers.vscodeLm:
+				models = Object.fromEntries(
+					vsCodeLmModels.map((model) => [
+						`${model.vendor}/${model.family}`,
+						{
+							maxTokens: 0,
+							contextWindow: 0,
+							supportsPromptCache: false,
+							description: `${model.vendor} - ${model.family}`,
+						},
+					]),
+				)
+				modelIdKey = "vsCodeLmModelSelector"
+				valueTransform = (modelId) => {
+					const [vendor, family] = modelId.split("/")
+					return { vendor, family }
+				}
+				displayTransform = (value) => {
+					const selector = value as { vendor?: string; family?: string } | undefined
+					return selector?.vendor && selector?.family ? `${selector.vendor}/${selector.family}` : ""
+				}
+				break
+			default:
+				// Static providers (anthropic, bedrock, gemini, …); pass the configuration so Z.ai
+				// resolves models for the same API line (China vs international) as `defaultModelId`.
+				models = MODELS_BY_PROVIDER[activeProvider]
+					? getStaticModelsForProvider(activeProvider, undefined, apiConfiguration)
+					: null
+				modelIdKey = "apiModelId"
+		}
+
+		isLoading =
+			(ROUTER_DEFAULT_MODEL_IDS[activeProvider] !== undefined && routerModels.isLoading) ||
+			(activeProvider === providerIdentifiers.openai &&
+				!!apiConfiguration?.openAiBaseUrl &&
+				!!apiConfiguration?.openAiApiKey &&
+				openAiModels.length === 0)
+
+		return {
+			provider: activeProvider,
+			models,
+			modelIdKey,
+			defaultModelId,
+			isLoading,
+			valueTransform,
+			displayTransform,
+		}
+	}, [
+		activeProvider,
+		apiConfiguration,
+		routerModels,
+		stateRouterModels,
+		openAiModels,
+		ollamaModels,
+		lmStudioModels,
+		vsCodeLmModels,
+	])
+}
diff --git a/webview-ui/src/components/common/MarkdownBlock.tsx b/webview-ui/src/components/common/MarkdownBlock.tsx
index 02f696553f..0310881623 100644
--- a/webview-ui/src/components/common/MarkdownBlock.tsx
+++ b/webview-ui/src/components/common/MarkdownBlock.tsx
@@ -299,10 +299,10 @@ const MarkdownBlock = memo(({ markdown }: MarkdownBlockProps) => {
 
 					// Extract line number if present
 					const match = filePath.match(/(.*):(\d+)(-\d+)?$/)
-					let values = undefined
+					let values: { fromMarkdown: true; line?: number } = { fromMarkdown: true }
 					if (match) {
 						filePath = match[1]
-						values = { line: parseInt(match[2]) }
+						values = { fromMarkdown: true, line: parseInt(match[2]) }
 					}
 
 					// Add ./ prefix if needed
diff --git a/webview-ui/src/components/common/__tests__/MarkdownBlock.spec.tsx b/webview-ui/src/components/common/__tests__/MarkdownBlock.spec.tsx
index 2c56fc418a..c60dd93f38 100644
--- a/webview-ui/src/components/common/__tests__/MarkdownBlock.spec.tsx
+++ b/webview-ui/src/components/common/__tests__/MarkdownBlock.spec.tsx
@@ -1,3 +1,5 @@
+import userEvent from "@testing-library/user-event"
+import { vscode } from "@src/utils/vscode"
 import { render, screen } from "@/utils/test-utils"
 
 import MarkdownBlock from "../MarkdownBlock"
@@ -15,6 +17,25 @@ vi.mock("@src/context/ExtensionStateContext", () => ({
 }))
 
 describe("MarkdownBlock", () => {
+	it.each([
+		["src/index.ts", "./src/index.ts", undefined],
+		["src/index.ts:12", "./src/index.ts", 12],
+		["../../.env", "./../../.env", undefined],
+		["../../.env:3", "./../../.env", 3],
+		["/workspace/index.ts", "/workspace/index.ts", undefined],
+	])("marks file link %s as Markdown-sourced", async (href, text, line) => {
+		vi.mocked(vscode.postMessage).mockClear()
+		const user = userEvent.setup()
+		render(<MarkdownBlock markdown={`[Open file](${href})`} />)
+		await user.click(await screen.findByRole("link", { name: "Open file" }))
+		expect(vscode.postMessage).toHaveBeenCalledTimes(1)
+		expect(vscode.postMessage).toHaveBeenCalledWith({
+			type: "openFile",
+			text,
+			values: { fromMarkdown: true, ...(line === undefined ? {} : { line }) },
+		})
+	})
+
 	it("should correctly handle URLs with trailing punctuation", async () => {
 		const markdown = "Check out this link: https://example.com."
 		const { container } = render(<MarkdownBlock markdown={markdown} />)
diff --git a/webview-ui/src/i18n/locales/ca/chat.json b/webview-ui/src/i18n/locales/ca/chat.json
index 687d9962a3..96c4ec1991 100644
--- a/webview-ui/src/i18n/locales/ca/chat.json
+++ b/webview-ui/src/i18n/locales/ca/chat.json
@@ -495,5 +495,9 @@
 		"title": "Proveïdor ja no compatible",
 		"message": "Aquest proveïdor ja no està disponible. Selecciona un proveïdor compatible per continuar.",
 		"openSettings": "Obrir configuració"
-	}
+	},
+	"searchModel": "Cerca models...",
+	"modelListEmpty": "Aquest proveïdor no té models disponibles",
+	"useCustomModel": "Utilitza el model personalitzat: {{modelId}}",
+	"selectModel": "Selecciona un model"
 }
diff --git a/webview-ui/src/i18n/locales/de/chat.json b/webview-ui/src/i18n/locales/de/chat.json
index e862fa9564..355b431505 100644
--- a/webview-ui/src/i18n/locales/de/chat.json
+++ b/webview-ui/src/i18n/locales/de/chat.json
@@ -495,5 +495,9 @@
 		"title": "Anbieter wird nicht mehr unterstützt",
 		"message": "Dieser Anbieter ist nicht mehr verfügbar. Wähle einen unterstützten Anbieter aus, um fortzufahren.",
 		"openSettings": "Einstellungen öffnen"
-	}
+	},
+	"searchModel": "Modelle durchsuchen...",
+	"modelListEmpty": "Für diesen Anbieter sind keine Modelle verfügbar",
+	"useCustomModel": "Benutzerdefiniertes Modell verwenden: {{modelId}}",
+	"selectModel": "Modell auswählen"
 }
diff --git a/webview-ui/src/i18n/locales/en/chat.json b/webview-ui/src/i18n/locales/en/chat.json
index cc02656a30..2541fb98d4 100644
--- a/webview-ui/src/i18n/locales/en/chat.json
+++ b/webview-ui/src/i18n/locales/en/chat.json
@@ -483,5 +483,9 @@
 		"title": "Provider no longer supported",
 		"message": "This provider is no longer available. Select a supported provider to continue.",
 		"openSettings": "Open Settings"
-	}
+	},
+	"searchModel": "Search models...",
+	"modelListEmpty": "No models available for this provider",
+	"useCustomModel": "Use custom model: {{modelId}}",
+	"selectModel": "Select a model"
 }
diff --git a/webview-ui/src/i18n/locales/es/chat.json b/webview-ui/src/i18n/locales/es/chat.json
index 937cb0cf56..829fe13719 100644
--- a/webview-ui/src/i18n/locales/es/chat.json
+++ b/webview-ui/src/i18n/locales/es/chat.json
@@ -495,5 +495,9 @@
 		"title": "Proveedor ya no compatible",
 		"message": "Este proveedor ya no está disponible. Selecciona un proveedor compatible para continuar.",
 		"openSettings": "Abrir configuración"
-	}
+	},
+	"searchModel": "Buscar modelos...",
+	"modelListEmpty": "No hay modelos disponibles para este proveedor",
+	"useCustomModel": "Usar modelo personalizado: {{modelId}}",
+	"selectModel": "Seleccionar un modelo"
 }
diff --git a/webview-ui/src/i18n/locales/fr/chat.json b/webview-ui/src/i18n/locales/fr/chat.json
index 4656d618a7..0ddc8f58f2 100644
--- a/webview-ui/src/i18n/locales/fr/chat.json
+++ b/webview-ui/src/i18n/locales/fr/chat.json
@@ -495,5 +495,9 @@
 		"title": "Fournisseur plus pris en charge",
 		"message": "Ce fournisseur n'est plus disponible. Choisis un fournisseur pris en charge pour continuer.",
 		"openSettings": "Ouvrir les paramètres"
-	}
+	},
+	"searchModel": "Rechercher des modèles...",
+	"modelListEmpty": "Aucun modèle disponible pour ce fournisseur",
+	"useCustomModel": "Utiliser un modèle personnalisé : {{modelId}}",
+	"selectModel": "Sélectionner un modèle"
 }
diff --git a/webview-ui/src/i18n/locales/hi/chat.json b/webview-ui/src/i18n/locales/hi/chat.json
index c36bca4e0f..83d2c91e80 100644
--- a/webview-ui/src/i18n/locales/hi/chat.json
+++ b/webview-ui/src/i18n/locales/hi/chat.json
@@ -495,5 +495,9 @@
 		"title": "प्रदाता अब समर्थित नहीं है",
 		"message": "यह प्रदाता अब उपलब्ध नहीं है। जारी रखने के लिए कोई समर्थित प्रदाता चुनें।",
 		"openSettings": "सेटिंग्स खोलें"
-	}
+	},
+	"searchModel": "मॉडल खोजें...",
+	"modelListEmpty": "इस प्रदाता के लिए कोई मॉडल उपलब्ध नहीं है",
+	"useCustomModel": "कस्टम मॉडल का उपयोग करें: {{modelId}}",
+	"selectModel": "एक मॉडल चुनें"
 }
diff --git a/webview-ui/src/i18n/locales/id/chat.json b/webview-ui/src/i18n/locales/id/chat.json
index d8a642b8ee..02dd298593 100644
--- a/webview-ui/src/i18n/locales/id/chat.json
+++ b/webview-ui/src/i18n/locales/id/chat.json
@@ -501,5 +501,9 @@
 		"title": "Penyedia tidak lagi didukung",
 		"message": "Penyedia ini sudah tidak tersedia. Pilih penyedia yang didukung untuk melanjutkan.",
 		"openSettings": "Buka Pengaturan"
-	}
+	},
+	"searchModel": "Cari model...",
+	"modelListEmpty": "Tidak ada model yang tersedia untuk penyedia ini",
+	"useCustomModel": "Gunakan model kustom: {{modelId}}",
+	"selectModel": "Pilih model"
 }
diff --git a/webview-ui/src/i18n/locales/it/chat.json b/webview-ui/src/i18n/locales/it/chat.json
index 6ce80b2316..a67441bc04 100644
--- a/webview-ui/src/i18n/locales/it/chat.json
+++ b/webview-ui/src/i18n/locales/it/chat.json
@@ -495,5 +495,9 @@
 		"title": "Provider non più supportato",
 		"message": "Questo provider non è più disponibile. Seleziona un provider supportato per continuare.",
 		"openSettings": "Apri impostazioni"
-	}
+	},
+	"searchModel": "Cerca modelli...",
+	"modelListEmpty": "Nessun modello disponibile per questo provider",
+	"useCustomModel": "Usa modello personalizzato: {{modelId}}",
+	"selectModel": "Seleziona un modello"
 }
diff --git a/webview-ui/src/i18n/locales/ja/chat.json b/webview-ui/src/i18n/locales/ja/chat.json
index f9e535ee89..4d78acfd6f 100644
--- a/webview-ui/src/i18n/locales/ja/chat.json
+++ b/webview-ui/src/i18n/locales/ja/chat.json
@@ -495,5 +495,9 @@
 		"title": "プロバイダーのサポート終了",
 		"message": "このプロバイダーは現在利用できません。続行するには、サポートされているプロバイダーを選択してください。",
 		"openSettings": "設定を開く"
-	}
+	},
+	"searchModel": "モデルを検索...",
+	"modelListEmpty": "このプロバイダーで利用可能なモデルはありません",
+	"useCustomModel": "カスタムモデルを使用: {{modelId}}",
+	"selectModel": "モデルを選択"
 }
diff --git a/webview-ui/src/i18n/locales/ko/chat.json b/webview-ui/src/i18n/locales/ko/chat.json
index a633602e26..83cf5f9d84 100644
--- a/webview-ui/src/i18n/locales/ko/chat.json
+++ b/webview-ui/src/i18n/locales/ko/chat.json
@@ -495,5 +495,9 @@
 		"title": "공급자 지원 종료",
 		"message": "이 공급자는 더 이상 사용할 수 없습니다. 계속하려면 지원되는 공급자를 선택하세요.",
 		"openSettings": "설정 열기"
-	}
+	},
+	"searchModel": "모델 검색...",
+	"modelListEmpty": "이 공급자에 사용 가능한 모델이 없습니다",
+	"useCustomModel": "사용자 지정 모델 사용: {{modelId}}",
+	"selectModel": "모델 선택"
 }
diff --git a/webview-ui/src/i18n/locales/nl/chat.json b/webview-ui/src/i18n/locales/nl/chat.json
index 67407b6b7b..19a94b5ebf 100644
--- a/webview-ui/src/i18n/locales/nl/chat.json
+++ b/webview-ui/src/i18n/locales/nl/chat.json
@@ -495,5 +495,9 @@
 		"title": "Provider wordt niet meer ondersteund",
 		"message": "Deze provider is niet meer beschikbaar. Selecteer een ondersteunde provider om door te gaan.",
 		"openSettings": "Instellingen openen"
-	}
+	},
+	"searchModel": "Modellen zoeken...",
+	"modelListEmpty": "Geen modellen beschikbaar voor deze provider",
+	"useCustomModel": "Aangepast model gebruiken: {{modelId}}",
+	"selectModel": "Selecteer een model"
 }
diff --git a/webview-ui/src/i18n/locales/pl/chat.json b/webview-ui/src/i18n/locales/pl/chat.json
index f7f88dc87a..94158d6e04 100644
--- a/webview-ui/src/i18n/locales/pl/chat.json
+++ b/webview-ui/src/i18n/locales/pl/chat.json
@@ -495,5 +495,9 @@
 		"title": "Dostawca nie jest już obsługiwany",
 		"message": "Ten dostawca nie jest już dostępny. Wybierz obsługiwanego dostawcę, aby kontynuować.",
 		"openSettings": "Otwórz ustawienia"
-	}
+	},
+	"searchModel": "Szukaj modeli...",
+	"modelListEmpty": "Brak dostępnych modeli dla tego dostawcy",
+	"useCustomModel": "Użyj niestandardowego modelu: {{modelId}}",
+	"selectModel": "Wybierz model"
 }
diff --git a/webview-ui/src/i18n/locales/pt-BR/chat.json b/webview-ui/src/i18n/locales/pt-BR/chat.json
index 1adf5870a8..3d33c6af8c 100644
--- a/webview-ui/src/i18n/locales/pt-BR/chat.json
+++ b/webview-ui/src/i18n/locales/pt-BR/chat.json
@@ -495,5 +495,9 @@
 		"title": "Provedor não é mais suportado",
 		"message": "Este provedor não está mais disponível. Selecione um provedor compatível para continuar.",
 		"openSettings": "Abrir configurações"
-	}
+	},
+	"searchModel": "Pesquisar modelos...",
+	"modelListEmpty": "Nenhum modelo disponível para este provedor",
+	"useCustomModel": "Usar modelo personalizado: {{modelId}}",
+	"selectModel": "Selecione um modelo"
 }
diff --git a/webview-ui/src/i18n/locales/ru/chat.json b/webview-ui/src/i18n/locales/ru/chat.json
index f42363c5f4..015d316f8c 100644
--- a/webview-ui/src/i18n/locales/ru/chat.json
+++ b/webview-ui/src/i18n/locales/ru/chat.json
@@ -496,5 +496,9 @@
 		"title": "Провайдер больше не поддерживается",
 		"message": "Этот провайдер больше недоступен. Выберите поддерживаемого провайдера, чтобы продолжить.",
 		"openSettings": "Открыть настройки"
-	}
+	},
+	"searchModel": "Поиск моделей...",
+	"modelListEmpty": "Нет доступных моделей для этого провайдера",
+	"useCustomModel": "Использовать пользовательскую модель: {{modelId}}",
+	"selectModel": "Выберите модель"
 }
diff --git a/webview-ui/src/i18n/locales/tr/chat.json b/webview-ui/src/i18n/locales/tr/chat.json
index 4d8ba6fead..52b9a7190d 100644
--- a/webview-ui/src/i18n/locales/tr/chat.json
+++ b/webview-ui/src/i18n/locales/tr/chat.json
@@ -496,5 +496,9 @@
 		"title": "Sağlayıcı artık desteklenmiyor",
 		"message": "Bu sağlayıcı artık kullanılamıyor. Devam etmek için desteklenen bir sağlayıcı seçin.",
 		"openSettings": "Ayarları aç"
-	}
+	},
+	"searchModel": "Modelleri ara...",
+	"modelListEmpty": "Bu sağlayıcı için kullanılabilir model yok",
+	"useCustomModel": "Özel model kullan: {{modelId}}",
+	"selectModel": "Bir model seçin"
 }
diff --git a/webview-ui/src/i18n/locales/vi/chat.json b/webview-ui/src/i18n/locales/vi/chat.json
index d48351deac..21fc1af167 100644
--- a/webview-ui/src/i18n/locales/vi/chat.json
+++ b/webview-ui/src/i18n/locales/vi/chat.json
@@ -496,5 +496,9 @@
 		"title": "Nhà cung cấp không còn được hỗ trợ",
 		"message": "Nhà cung cấp này không còn khả dụng. Hãy chọn một nhà cung cấp được hỗ trợ để tiếp tục.",
 		"openSettings": "Mở cài đặt"
-	}
+	},
+	"searchModel": "Tìm kiếm mô hình...",
+	"modelListEmpty": "Không có mô hình nào khả dụng cho nhà cung cấp này",
+	"useCustomModel": "Sử dụng mô hình tùy chỉnh: {{modelId}}",
+	"selectModel": "Chọn một mô hình"
 }
diff --git a/webview-ui/src/i18n/locales/zh-CN/chat.json b/webview-ui/src/i18n/locales/zh-CN/chat.json
index 00b0e3a85b..6d4d5030e0 100644
--- a/webview-ui/src/i18n/locales/zh-CN/chat.json
+++ b/webview-ui/src/i18n/locales/zh-CN/chat.json
@@ -496,5 +496,9 @@
 		"title": "供应商不再受支持",
 		"message": "此提供商已不可用。请选择受支持的提供商以继续。",
 		"openSettings": "打开设置"
-	}
+	},
+	"searchModel": "搜索模型...",
+	"modelListEmpty": "此提供商没有可用的模型",
+	"useCustomModel": "使用自定义模型：{{modelId}}",
+	"selectModel": "选择模型"
 }
diff --git a/webview-ui/src/i18n/locales/zh-TW/chat.json b/webview-ui/src/i18n/locales/zh-TW/chat.json
index d04b1fb08b..ec2b569638 100644
--- a/webview-ui/src/i18n/locales/zh-TW/chat.json
+++ b/webview-ui/src/i18n/locales/zh-TW/chat.json
@@ -486,5 +486,9 @@
 		"title": "供應商不再受支援",
 		"message": "此供應商已不可用。請選擇受支援的供應商以繼續。",
 		"openSettings": "開啟設定"
-	}
+	},
+	"searchModel": "搜尋模型...",
+	"modelListEmpty": "此提供者沒有可用的模型",
+	"useCustomModel": "使用自訂模型：{{modelId}}",
+	"selectModel": "選擇模型"
 }
diff --git a/webview-ui/src/utils/__tests__/batchNearby.spec.ts b/webview-ui/src/utils/__tests__/batchNearby.spec.ts
index c6fa640aea..5ac35de93d 100644
--- a/webview-ui/src/utils/__tests__/batchNearby.spec.ts
+++ b/webview-ui/src/utils/__tests__/batchNearby.spec.ts
@@ -94,6 +94,76 @@ describe("batchNearby", () => {
 		expect(result[0].text).toBe("BATCH:match-1,match-2")
 	})
 
+	test("repeated assistant preambles between matching tools are consumed by a successful batch", () => {
+		const preamble = "I'll read the files now."
+		const messages = [
+			msg(preamble, "say", "text"),
+			msg("match-1", "ask"),
+			msg("", "say", "api_req_started"),
+			msg(preamble, "say", "text"),
+			msg("match-2", "ask"),
+			msg(preamble, "say", "text"),
+			msg("match-3", "ask"),
+		]
+		const result = batchNearby(messages, {
+			isTarget: isMatch,
+			isIgnorableBetweenTargets,
+			isBoundary,
+			synthesize: synthesizeBatch,
+		})
+
+		expect(result).toHaveLength(2)
+		expect(result[0].text).toBe(preamble)
+		expect(result[1].text).toBe("BATCH:match-1,match-2,match-3")
+	})
+
+	test("distinct assistant text between matching tools remains a boundary", () => {
+		const messages = [
+			msg("I'll read the files now.", "say", "text"),
+			msg("match-1", "ask"),
+			msg("I found something important.", "say", "text"),
+			msg("match-2", "ask"),
+		]
+		const result = batchNearby(messages, {
+			isTarget: isMatch,
+			isIgnorableBetweenTargets,
+			isBoundary,
+			synthesize: synthesizeBatch,
+		})
+
+		expect(result).toEqual(messages)
+	})
+
+	test("restores a repeated preamble when no later target is found", () => {
+		const preamble = "I'll read the files now."
+		const messages = [
+			msg(preamble, "say", "text"),
+			msg("match-1", "ask"),
+			msg(preamble, "say", "text"),
+			msg("different tool", "ask"),
+		]
+		const result = batchNearby(messages, {
+			isTarget: isMatch,
+			isIgnorableBetweenTargets,
+			isBoundary,
+			synthesize: synthesizeBatch,
+		})
+
+		expect(result).toEqual(messages)
+	})
+
+	test("an item matching target and boundary stops the current batch", () => {
+		const messages = [msg("match-1", "ask"), msg("match-boundary", "ask"), msg("match-2", "ask")]
+		const result = batchNearby(messages, {
+			isTarget: isMatch,
+			isIgnorableBetweenTargets: () => false,
+			isBoundary: (item) => item.text === "match-boundary",
+			synthesize: synthesizeBatch,
+		})
+
+		expect(result).toEqual(messages)
+	})
+
 	test("boundary message stops batching", () => {
 		const messages = [msg("match-1", "ask"), msg("visible text", "say", "text"), msg("match-2", "ask")]
 		const result = batchNearby(messages, {
diff --git a/webview-ui/src/utils/batchNearby.ts b/webview-ui/src/utils/batchNearby.ts
index 201eef5078..ab49be2b22 100644
--- a/webview-ui/src/utils/batchNearby.ts
+++ b/webview-ui/src/utils/batchNearby.ts
@@ -12,7 +12,7 @@ export interface BatchNearbyOptions<T> {
 	/** Returns true if this item is the target type to batch (e.g., readFile ask) */
 	isTarget: (item: T) => boolean
 	/** Returns true if this item can be skipped over when looking for more targets */
-	isIgnorableBetweenTargets: (item: T) => boolean
+	isIgnorableBetweenTargets: (item: T, batchContext?: T) => boolean
 	/** Returns true if this item is a semantic boundary that stops merging */
 	isBoundary: (item: T) => boolean
 	/** Synthesize a batch of items into a single item */
@@ -43,15 +43,22 @@ export function batchNearby<T>(items: T[], options: BatchNearbyOptions<T>): T[]
 			const batch: T[] = [items[i]]
 			let j = i + 1
 			const pendingIgnorable: T[] = []
+			let batchContext: T | undefined
+
+			for (let contextIndex = i - 1; contextIndex >= 0; contextIndex--) {
+				if (!isIgnorableBetweenTargets(items[contextIndex])) {
+					batchContext = items[contextIndex]
+					break
+				}
+			}
 
 			while (j < items.length) {
-				if (isBoundary(items[j])) {
+				if (isBoundary(items[j]) && !isIgnorableBetweenTargets(items[j], batchContext)) {
 					break // boundary stops the batch
-				}
-				if (isTarget(items[j])) {
+				} else if (isTarget(items[j])) {
 					batch.push(items[j])
 					j++
-				} else if (isIgnorableBetweenTargets(items[j])) {
+				} else if (isIgnorableBetweenTargets(items[j], batchContext)) {
 					pendingIgnorable.push(items[j]) // track but don't commit yet
 					j++
 				} else {
diff --git a/webview-ui/src/utils/chatBatchingPredicates.ts b/webview-ui/src/utils/chatBatchingPredicates.ts
index 9fe65a98fa..b011605642 100644
--- a/webview-ui/src/utils/chatBatchingPredicates.ts
+++ b/webview-ui/src/utils/chatBatchingPredicates.ts
@@ -8,9 +8,18 @@ interface BatchableMessage {
  * Messages that can be safely skipped over when batching tool asks.
  * These are low-information or invisible messages that don't affect semantics.
  */
-export const isIgnorableBetweenTargets = (msg: BatchableMessage): boolean => {
+export const isIgnorableBetweenTargets = (msg: BatchableMessage, batchContext?: BatchableMessage): boolean => {
 	if (msg.type !== "say") return false
-	return msg.say === "api_req_started" || (msg.say === "text" && !msg.text?.trim()) || msg.say === "reasoning"
+	return (
+		msg.say === "api_req_started" ||
+		(msg.say === "text" &&
+			(!msg.text?.trim() ||
+				(batchContext?.type === "say" &&
+					batchContext.say === "text" &&
+					!!batchContext.text?.trim() &&
+					msg.text === batchContext.text))) ||
+		msg.say === "reasoning"
+	)
 }
 
 /**
diff --git a/webview-ui/vite.config.ts b/webview-ui/vite.config.ts
index f5743ee10e..3809d91d20 100644
--- a/webview-ui/vite.config.ts
+++ b/webview-ui/vite.config.ts
@@ -121,8 +121,10 @@ export default defineConfig(({ mode }) => {
 			},
 		},
 		server: {
-			hmr: {
-				host: "localhost",
+			hmr: true,
+			host: "127.0.0.1",
+			port: 5173,
+			ws: {
 				protocol: "ws",
 			},
 			cors: {