@@ -247,6 +247,11 @@ jobs:
             - name: Verify coverage cache inputs
               if: matrix.collect-coverage
               run: pnpm --dir src run verify:coverage-cache-inputs
+            # Validate build/static cache inputs (issue #2290 contract) so a
+            # stale webview or extension bundle is never restored as a hit.
+            - name: Verify build cache inputs
+              if: matrix.collect-coverage
+              run: pnpm --dir src run verify:build-cache-inputs
             - name: Save Turbo cache
               if: steps.turbo-cache.outputs.cache-hit != 'true'
               uses: actions/cache/save@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
 
@@ -140,11 +140,13 @@ The `model` field can be added to either match when a test targets a specific mo
 Use `streamingProfile: { ttft: <ms> }` on a fixture, not a flat `latency: <ms>`, when a test needs
 to simulate a slow or hung provider (e.g. to cancel an in-flight request mid-stream). `ttft` delays
 only the first SSE chunk, so the pending window is exactly the configured value. Flat `latency`
-delays _every_ chunk, and aimock never observes client disconnects — after a test cancels the
-request, a flat-latency stream keeps flushing chunks server-side for `chunks × latency` before
-reaching the dead socket, which can interleave with the next test's request against the same mock
-server. See `SUBTASK_API_HANG_RESPONSE_LATENCY_MS` in `fixtures/subtasks.ts` for an example,
-including the bounded post-test drain the calling suite uses to wait out that window.
+delays _every_ chunk. Before aimock 1.47.0, the mock did not observe client disconnects — after a
+test cancelled the request, a flat-latency stream kept flushing chunks server-side for
+`chunks × latency` before reaching the dead socket, which could interleave with the next test's
+request against the same mock server. Version 1.47.0 stops the reply on disconnect, but the
+suite keeps its drain wait until an e2e run shows it is not needed. See
+`SUBTASK_API_HANG_RESPONSE_LATENCY_MS` in `fixtures/subtasks.ts` for an example, including the
+bounded post-test drain the calling suite uses to wait out that window.
 
 ## 404 errors in logs are expected
 
 
@@ -25,7 +25,7 @@
 		"@roo-code/config-eslint": "workspace:^",
 		"@roo-code/config-typescript": "workspace:^",
 		"@roo-code/types": "workspace:^",
-		"@copilotkit/aimock": "1.35.0",
+		"@copilotkit/aimock": "1.47.0",
 		"@types/mocha": "10.0.10",
 		"@types/node": "catalog:",
 		"@types/vscode": "1.100.0",
 
@@ -93,10 +93,11 @@ const waitForAimockRequestContaining = async (
 // suite becomes flaky again on slow CI runners, widen this value first.
 const SUBTASK_API_HANG_DRAIN_GRACE_MS = 500
 
-// aimock does not observe client disconnects: after the API-hang child request is cancelled,
-// the mock keeps the delayed stream pending server-side until the fixture's ttft has fully
-// elapsed, then flushes the remaining chunks to the dead socket. A streamed request opened by
-// the next test can interleave with that late flush, so wait out the remainder of the delayed
+// aimock 1.47.0 stops and journals a reply when the client disconnects. Before that, the mock
+// kept the delayed stream pending server-side until the fixture's ttft had fully elapsed, then
+// flushed the remaining chunks to the dead socket. A streamed request opened by the next test
+// could interleave with that late flush. This wait is a conservative guard kept until an e2e
+// run shows it is not needed: wait out the remainder of the delayed
 // window before the next test runs. The deadline is anchored to the journal timestamp of the
 // request this test created (never earlier traffic), and bounded by one latency window plus
 // grace, so it cannot hide a genuine hang.
 
@@ -63,13 +63,24 @@ export const apiProviderHygieneConfig = {
 	},
 }
 
+// Shared by every spec lane, not only src/api: an abort assertion must not pass on a raw SDK error.
+export const abortSubstringSelector = {
+	selector:
+		// Strings contain literal punctuation; only regex source can contain anchors, wildcards,
+		// optional suffix groups, or word boundaries around the generic abort wording.
+		"CallExpression[callee.property.name=/^toThrow(Error)?$/]:not([callee.object.property.name='not']):matches([arguments.0.value=/^(the )?(request )?(was )?abort(ed)?[.]*$/i], [arguments.0.regex.pattern=/^[$^]?(?:\\.\\*)?(the )?(request )?(was )?abort(ed)?(?:\\(\\?:(?:ed|ion|al)\\)\\??)?(?:\\\\b)?(?:\\.\\*)?[\\\\.$]*$/i])",
+	message:
+		"A bare 'abort' substring also matches a raw SDK error. Assert the AbortError name and the full provider message.",
+}
+
 // Spec files under src/api. A loop of expects in one test stops at the first failing case and hides the rest.
 export const apiProviderTestSelectors = [
 	{
 		selector: "ForOfStatement[right.type='ArrayExpression']:has(CallExpression[callee.name='expect'])",
 		message:
 			"Use it.each for repeated cases. A loop of expects in one test stops at the first failing case and does not name it.",
 	},
+	abortSubstringSelector,
 ]
 
 // A new @ts-ignore in a provider spec hides a private-member access. Use bracket notation or a typed double.
 
@@ -1,7 +1,8 @@
 import assert from "node:assert/strict"
 import { describe, it } from "node:test"
+import { fileURLToPath, URL } from "node:url"
 
-import { Linter } from "eslint"
+import { ESLint, Linter } from "eslint"
 import typescriptEslint from "typescript-eslint"
 
 import { apiProviderHygieneConfig, apiProviderTestSelectors, apiSpecTsIgnoreConfig } from "./api-provider-hygiene.js"
@@ -173,6 +174,37 @@ describe("api provider hygiene: spec loops", () => {
 			assert.deepEqual(lintSpec(code), [])
 		})
 	}
+
+	for (const code of [
+		'await expect(p).rejects.toThrow("aborted")',
+		"expect(() => f()).toThrow('abort')",
+		'await expect(p).rejects.toThrowError("aborted")',
+		"expect(() => f()).toThrow(/abort/i)",
+		"await expect(p).rejects.toThrowError(/aborted/i)",
+		'await expect(p).rejects.toThrow("was aborted")',
+		'await expect(p).rejects.toThrow("Request was aborted.")',
+		'await expect(p).rejects.toThrow("The request was aborted")',
+		"await expect(p).rejects.toThrow(/was aborted/)",
+	]) {
+		it(`flags a bare abort substring: ${code}`, () => {
+			assert.equal(lintSpec(code).length, 1)
+		})
+	}
+
+	for (const code of [
+		'await expect(p).rejects.toThrow("The Requesty request was aborted")',
+		'await expect(p).rejects.toMatchObject({ name: "AbortError" })',
+		'await expect(p).rejects.toThrow("API Error")',
+		'expect(() => f()).not.toThrow("aborted")',
+		'await expect(p).rejects.not.toThrow("aborted")',
+		"expect(() => f()).not.toThrowError(/abort/i)",
+		"await expect(p).rejects.not.toThrowError(/aborted/i)",
+		"await expect(p).rejects.toThrow(/^The Requesty request was aborted$/)",
+	]) {
+		it(`allows: ${code}`, () => {
+			assert.deepEqual(lintSpec(code), [])
+		})
+	}
 })
 
 describe("api provider hygiene: hand-built AbortError", () => {
@@ -245,3 +277,68 @@ describe("api provider hygiene: @ts-ignore in specs", () => {
 		assert.deepEqual(lintSpecFile("// @ts-ignore x\nhandler.client", "services/__tests__/example.spec.ts"), [])
 	})
 })
+
+// Resolve each lane through the extension's real config before exercising its syntax rules.
+// Isolating syntax rules avoids requiring fixture files in the TypeScript project.
+describe("abort assertions in the extension ESLint config", () => {
+	const srcRoot = fileURLToPath(new URL("../../src/", import.meta.url))
+	const eslint = new ESLint({ cwd: srcRoot })
+
+	for (const filename of [
+		"core/task/__tests__/example.spec.ts",
+		"core/config/__tests__/example.spec.ts",
+		// The workflow tests are exempt from the path-traversal selectors, not from the abort
+		// rule; listing one proves the lane that re-applies it actually resolves for them.
+		"services/__tests__/pr-review-state-workflow.test.ts",
+	]) {
+		it(`checks rejected and accepted assertions in ${filename}`, async () => {
+			const resolved = await eslint.calculateConfigForFile(filename)
+			const syntaxConfig = [
+				{
+					files: ["**/*.ts"],
+					languageOptions: { parser: typescriptEslint.parser },
+					rules: { "no-restricted-syntax": resolved.rules["no-restricted-syntax"] },
+				},
+			]
+			for (const [code, expectedCount] of [
+				['await expect(p).rejects.toThrow("aborted")', 1],
+				["await expect(p).rejects.toThrowError(/abort/i)", 1],
+				// An escaped dot in the source text is still a bare abort substring: the pattern
+				// keeps a backslash, so the matcher must allow it before the trailing dot or anchor.
+				["await expect(p).rejects.toThrow(/^aborted$/)", 1],
+				["await expect(p).rejects.toThrow(/.*aborted.*/i)", 1],
+				["await expect(p).rejects.toThrowError(/abort(?:ed)/i)", 1],
+				["await expect(p).rejects.toThrow(/aborted\\b/i)", 1],
+				['await expect(p).rejects.toThrow("abort$")', 0],
+				['await expect(p).rejects.toThrow("^abort")', 0],
+				["await expect(p).rejects.toThrow(/.*The Requesty request was aborted.*/i)", 0],
+				["await expect(p).rejects.toThrow(/The Requesty request was aborted\\b/i)", 0],
+				["await expect(p).rejects.toThrow(/^Request was aborted\\.$/)", 1],
+				["await expect(p).rejects.toThrowError(/request aborted\\.$/i)", 1],
+				["await expect(p).rejects.toThrow(/^request aborted\\$/)", 1],
+				// An inline non-capturing group is regex source, not part of the asserted
+				// message: an anchored match that stops short of it lets a bare abort through.
+				["await expect(p).rejects.toThrow(/abort(?:ed)?/i)", 1],
+				["await expect(p).rejects.toThrowError(/^request aborted(?:ed)?$/i)", 1],
+				["await expect(p).rejects.toThrow(/cancel(?:ed)?/i)", 0],
+				[
+					"await expect(p).rejects.toThrow(/^The Requesty request was aborted(?:ed)? because the peer closed the stream\\.$/)",
+					0,
+				],
+				['await expect(p).rejects.not.toThrow("aborted")', 0],
+				["await expect(p).rejects.toThrow(/^Request was aborted because the peer closed the stream\\.$/)", 0],
+				[
+					'await expect(p).rejects.toMatchObject({ name: "AbortError", message: "The Requesty request was aborted" })',
+					0,
+				],
+			]) {
+				const messages = linter.verify(code, syntaxConfig, { filename })
+				assert.equal(messages.length, expectedCount, code)
+				if (expectedCount) {
+					assert.equal(messages[0].ruleId, "no-restricted-syntax")
+					assert.match(messages[0].message, /bare 'abort' substring/)
+				}
+			}
+		})
+	}
+})
@@ -0,0 +1,19 @@
+import { experimentIds, experimentIdsSchema, experimentsSchema } from "../experiment.js"
+
+describe("dynamicThinkingEffort experiment", () => {
+	it("is part of the experiment id enum", () => {
+		expect(experimentIds).toContain("dynamicThinkingEffort")
+		expect(experimentIdsSchema.safeParse("dynamicThinkingEffort").success).toBe(true)
+	})
+
+	it("parses enabled and disabled states", () => {
+		expect(experimentsSchema.parse({ dynamicThinkingEffort: true })).toEqual({ dynamicThinkingEffort: true })
+		expect(experimentsSchema.parse({ dynamicThinkingEffort: false })).toEqual({ dynamicThinkingEffort: false })
+		expect(experimentsSchema.parse({})).toEqual({})
+	})
+
+	it("rejects non-boolean values", () => {
+		expect(experimentsSchema.safeParse({ dynamicThinkingEffort: "yes" }).success).toBe(false)
+		expect(experimentIdsSchema.safeParse("dynamic-thinking-effort").success).toBe(false)
+	})
+})
@@ -2,6 +2,71 @@ import { openAiCodexDefaultModelId, openAiCodexModels } from "../providers/opena
 import { openAiNativeDefaultModelId, openAiNativeModels } from "../providers/openai.js"
 
 describe("OpenAI native models", () => {
+	it("describes GPT-6.1 Terra pricing and optional native reasoning without changing defaults", () => {
+		expect(openAiNativeDefaultModelId).toBe("gpt-5.6-sol")
+		expect(openAiCodexDefaultModelId).toBe("gpt-5.6-sol")
+		const model = openAiNativeModels["gpt-6.1-terra"]
+		expect(model).toMatchObject({
+			maxTokens: 128_000,
+			contextWindow: 1_050_000,
+			includedTools: ["apply_patch"],
+			excludedTools: ["apply_diff", "write_to_file"],
+			supportsImages: true,
+			supportsPromptCache: true,
+			supportsReasoningEffort: ["none", "low", "medium", "high", "xhigh", "max"],
+			reasoningEffort: "medium",
+			supportsTemperature: false,
+			supportsVerbosity: true,
+			inputPrice: 1,
+			outputPrice: 5,
+			cacheWritesPrice: 1.25,
+			cacheWritesPrice12h: 2.5,
+			cacheReadsPrice: 0.05,
+			longContextPricing: {
+				thresholdTokens: 272_000,
+				inputPriceMultiplier: 2,
+				outputPriceMultiplier: 1.5,
+				cacheWritesPriceMultiplier: 2,
+				cacheReadsPriceMultiplier: 2,
+				appliesToServiceTiers: ["default", "flex", "priority"],
+			},
+		})
+		expect(model).not.toHaveProperty("requiredReasoningEffort", true)
+		expect(model.tiers).toEqual([
+			{
+				name: "flex",
+				contextWindow: 1_050_000,
+				inputPrice: 0.5,
+				outputPrice: 2.5,
+				cacheWritesPrice: 0.625,
+				cacheReadsPrice: 0.025,
+			},
+			{
+				name: "priority",
+				contextWindow: 1_050_000,
+				inputPrice: 2,
+				outputPrice: 10,
+				cacheWritesPrice: 2.5,
+				cacheReadsPrice: 0.1,
+			},
+		])
+		expect(openAiCodexModels["gpt-6.1-terra"]).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,
+			supportsVerbosity: true,
+			inputPrice: 0,
+			outputPrice: 0,
+		})
+	})
+
 	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")
 
@@ -114,6 +114,7 @@ describe("provider identifiers", () => {
 			providerIdentifiers.nanogpt,
 			providerIdentifiers.ioIntelligence,
 			providerIdentifiers.kimiCode,
+			providerIdentifiers.friendli,
 		])
 		expect(localProviders).toEqual([providerIdentifiers.ollama, providerIdentifiers.lmstudio])
 		expect(internalProviders).toEqual([providerIdentifiers.vscodeLm, providerIdentifiers.githubCopilot])
 
@@ -12,6 +12,7 @@ export const experimentIds = [
 	"runSlashCommand",
 	"customTools",
 	"parallelToolExecution",
+	"dynamicThinkingEffort",
 ] as const
 
 export const experimentIdsSchema = z.enum(experimentIds)
@@ -28,6 +29,7 @@ export const experimentsSchema = z.object({
 	runSlashCommand: z.boolean().optional(),
 	customTools: z.boolean().optional(),
 	parallelToolExecution: z.boolean().optional(),
+	dynamicThinkingEffort: z.boolean().optional(),
 })
 
 export type Experiments = z.infer<typeof experimentsSchema>