@@ -130,8 +130,15 @@ export interface ApiHandler {
 	 * Ensures model metadata has been fetched from the remote API so that getModel()
 	 * returns accurate info (context window, pricing, etc.) instead of hardcoded defaults.
 	 * Only router providers that discover models over the network implement this.
+	 *
+	 * `signal` bounds the caller's wait: when it aborts (e.g. the caller's bounded
+	 * metadata wait expired or the owning task was cancelled), the returned promise
+	 * settles with a rejection so no handler-side waiter outlives its caller.
+	 * Fetchers that observe the signal may also stop their network request; the
+	 * shared, de-duplicated catalog fetch may still complete and populate the model
+	 * cache, which is by design for concurrent waiters.
 	 */
-	ensureModelFetched?(): Promise<void>
+	ensureModelFetched?(signal?: AbortSignal): Promise<void>
 
 	/**
 	 * Optional context window for context-management / auto-condense when it must differ from
 
@@ -724,6 +724,72 @@ describe("ZooGatewayHandler", () => {
 			expect(refreshModels).not.toHaveBeenCalled()
 		})
 
+		it("settles the waiter with a rejection when the signal aborts mid-fetch", async () => {
+			// A caller that gives up must not leave a handler-side waiter pending
+			// on the (shared) catalog fetch: with an observing signal, the
+			// ensureModelFetched promise rejects at abort time, while the
+			// underlying fetch continues untouched for any other waiter.
+			const { getModels } = await import("../fetchers/modelCache")
+			vitest.mocked(getModels).mockImplementationOnce(() => new Promise(() => {}))
+
+			const handler = new ZooGatewayHandler(mockOptions)
+			const controller = new AbortController()
+
+			const wait = handler.ensureModelFetched(controller.signal)
+			// Let the waiter attach its abort listener before cancelling.
+			await Promise.resolve()
+			controller.abort()
+
+			await expect(wait).rejects.toThrow()
+		})
+
+		it("settles the waiter when the fetch wins against a live signal and detaches the listener", async () => {
+			// Fetch-wins branch: resolve() must settle the await (a dropped
+			// resolve or a detached .then handler hangs this test), the abort
+			// listener must be registered with the real { once: true } options
+			// object, and the detach must target the *same* event name/handler
+			// pair that was registered — a mutated event name detaches nothing.
+			const handler = new ZooGatewayHandler(mockOptions)
+			const controller = new AbortController()
+			const addEventListenerSpy = vitest.spyOn(controller.signal, "addEventListener")
+			const removeEventListenerSpy = vitest.spyOn(controller.signal, "removeEventListener")
+
+			await handler.ensureModelFetched(controller.signal)
+
+			expect(addEventListenerSpy).toHaveBeenCalledWith("abort", expect.any(Function), { once: true })
+			const registered = addEventListenerSpy.mock.calls.find(([event]) => event === "abort")
+			expect(registered).toBeDefined()
+			expect(removeEventListenerSpy).toHaveBeenCalledWith("abort", registered?.[1])
+		})
+
+		it("rejects a signal-observing waiter with the fetch error and detaches the listener", async () => {
+			// Rejection-branch twin of the fetch-wins test: reject(error) must
+			// propagate the catalog failure to the waiter (a dropped reject hangs
+			// this test) and the listener must be detached under the right event
+			// name. The no-signal reject path cannot attach a listener, so this is the only
+			// coverage of the reject-side detach.
+			const { getModels } = await import("../fetchers/modelCache")
+			vitest.mocked(getModels).mockRejectedValueOnce(new Error("network down"))
+
+			const handler = new ZooGatewayHandler(mockOptions)
+			const controller = new AbortController()
+			const addEventListenerSpy = vitest.spyOn(controller.signal, "addEventListener")
+			const removeEventListenerSpy = vitest.spyOn(controller.signal, "removeEventListener")
+
+			await expect(handler.ensureModelFetched(controller.signal)).rejects.toThrow("network down")
+			const registered = addEventListenerSpy.mock.calls.find(([event]) => event === "abort")
+			expect(registered).toBeDefined()
+			expect(removeEventListenerSpy).toHaveBeenCalledWith("abort", registered?.[1])
+		})
+
+		it("never starts a wait when the signal is already aborted", async () => {
+			const handler = new ZooGatewayHandler(mockOptions)
+			const controller = new AbortController()
+			controller.abort()
+
+			await expect(handler.ensureModelFetched(controller.signal)).rejects.toThrow()
+		})
+
 		it("skips the fetch when models are already populated", async () => {
 			const handler = new ZooGatewayHandler(mockOptions)
 			const { getModels, refreshModels } = await import("../fetchers/modelCache")
 
@@ -108,8 +108,35 @@ export abstract class RouterProvider extends BaseProvider {
 		return this.modelFetchPromise
 	}
 
-	async ensureModelFetched(): Promise<void> {
-		await this.fetchModel()
+	async ensureModelFetched(signal?: AbortSignal): Promise<void> {
+		// A caller that already gave up must not start (or keep) a wait on the
+		// shared catalog fetch.
+		if (signal?.aborted) {
+			throw signal.reason
+		}
+
+		const fetch = this.fetchModel()
+		if (!signal) {
+			await fetch
+			return
+		}
+
+		// Detach this waiter as soon as the signal aborts; the shared in-flight
+		// fetch continues for any other waiter and still populates the cache.
+		await new Promise<void>((resolve, reject) => {
+			const onAbort = () => reject(signal.reason)
+			signal.addEventListener("abort", onAbort, { once: true })
+			fetch.then(
+				() => {
+					signal.removeEventListener("abort", onAbort)
+					resolve()
+				},
+				(error: unknown) => {
+					signal.removeEventListener("abort", onAbort)
+					reject(error)
+				},
+			)
+		})
 	}
 
 	override getModel(): { id: string; info: ModelInfo } {
 
@@ -165,6 +165,21 @@ describe("getCapabilitiesSection", () => {
 		expect(result).not.toContain("only files matching")
 	})
 
+	it("keeps the capability clause and restriction for a model-included standalone edit tool", () => {
+		// The restricted edit group's default edit tools are disabled, but the
+		// model catalog re-adds the standalone `edit` tool: it is still an edit
+		// capability, so the clause and the file restriction both render.
+		const result = getCapabilitiesSection(
+			policyFor([["edit", { fileRegex: "\\.md$", description: "Markdown files only" }]], {
+				disabledTools: ["write_to_file", "apply_diff"],
+				modelInfo: { contextWindow: 128_000, supportsPromptCache: true, includedTools: ["edit"] },
+			}),
+		)
+
+		expect(result).toContain("write and edit files")
+		expect(result).toContain("(in this mode only files matching '\\.md$' can be edited — Markdown files only)")
+	})
+
 	it("lists files guidance only when list_files is available", () => {
 		const withListFiles = getCapabilitiesSection(policyFor(["read"]))
 		expect(withListFiles).toContain("you can use the list_files tool")
 
@@ -142,6 +142,17 @@ import { type TaskExecutionContext } from "./providerHandoff"
 
 const MAX_EXPONENTIAL_BACKOFF_SECONDS = 600 // 10 minutes
 const DEFAULT_USAGE_COLLECTION_TIMEOUT_MS = 5000 // 5 seconds
+// Upper bound on awaiting lazily loaded model metadata. Some model-catalog
+// fetchers (e.g. OpenRouter's bare axios GET) have no request timeout, so a
+// hung endpoint must not stall streaming, condense, or context-window
+// handling. On expiry the caller aborts its per-call AbortSignal (detaching
+// the provider-side waiter) and falls back to the handler's existing
+// getModel().info metadata — the same degradation a rejected fetch produces.
+// Kept in sync with PREVIEW_MODEL_FETCH_TIMEOUT_MS in the preview path
+// (src/core/webview/generateSystemPrompt.ts). Deliberately duplicated, not
+// shared: importing from the webview layer would close a
+// Task -> generateSystemPrompt -> ClineProvider -> Task circular import.
+export const MODEL_FETCH_TIMEOUT_MS = 5_000
 const QUEUED_FEEDBACK_SAVE_RETRY_DELAYS_MS = [250, 1_000, 4_000] as const
 
 type QueuedAskResolution = { response: ClineAskResponse; requiresDurableAck: boolean }
@@ -313,6 +324,13 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 	private readonly globalStoragePath: string
 	abort: boolean = false
 	currentRequestAbortController?: AbortController
+	/**
+	 * Controller for the waiter on an in-flight `ensureModelFetched()` call (see
+	 * safeEnsureModelFetched). Aborting it detaches this task from the provider-side
+	 * metadata fetch; it is aborted when the bounded wait expires and when the task's
+	 * current request is cancelled (cancel/dispose path in cancelCurrentRequest).
+	 */
+	metadataFetchAbortController?: AbortController
 	skipPrevResponseIdOnce: boolean = false
 
 	// TaskStatus
@@ -1858,8 +1876,8 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		const state = await this.providerRef.deref()?.getState()
 		const requestModelInfo = await this.safeEnsureModelFetched()
 
-		// A cancellation landing during the metadata wait must stop manual
-		// condensation before any prompt build or summarization request.
+		// A cancellation landing during the bounded metadata wait must stop
+		// manual condensation before any prompt build or summarization request.
 		if (this.abort || this.abandoned) {
 			return
 		}
@@ -1920,6 +1938,12 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 
 		const filesReadByRoo = await this.getFilesReadByRooSafely("condenseContext")
 
+		// A cancellation landing while the summarization inputs are gathered must
+		// stop manual condensation before any summarization request is issued.
+		if (this.abort || this.abandoned) {
+			return
+		}
+
 		const {
 			messages,
 			summary,
@@ -1941,6 +1965,11 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 			cwd: this.cwd,
 			rooIgnoreController: this.rooIgnoreController,
 		})
+		// A cancellation landing during the summarization request must stop
+		// manual condensation before it replaces and persists the history.
+		if (this.abort || this.abandoned) {
+			return
+		}
 		if (error) {
 			await this.say(
 				"condense_context_error",
@@ -2629,6 +2658,12 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 			this.currentRequestAbortController.abort()
 			this.currentRequestAbortController = undefined
 		}
+		// A metadata-fetch waiter still in flight is as stale as an abandoned
+		// stream: detach it from the provider-side fetch on cancel/dispose.
+		if (this.metadataFetchAbortController) {
+			this.metadataFetchAbortController.abort()
+			this.metadataFetchAbortController = undefined
+		}
 	}
 
 	/**
@@ -4283,28 +4318,63 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 	/**
 	 * Ensures router-provider model metadata is loaded before getModel() is used for
 	 * context management or streaming. Failures fall back to hardcoded defaults rather
-	 * than aborting the task.
+	 * than aborting the task; the wait is bounded by MODEL_FETCH_TIMEOUT_MS (see the
+	 * constant for the degradation semantics). On expiry or cancellation the per-call
+	 * AbortSignal detaches this task's waiter from the provider-side fetch instead of
+	 * leaving a handler-side promise waiting on it indefinitely.
 	 *
 	 * The return value is the settled post-wait read of getModel().info: request
 	 * entry points (attemptApiRequest, condenseContext) await this once before
 	 * prompt generation and share the returned snapshot between getSystemPrompt
-	 * and every tool-array build of the same request, so a fetch that resolves
-	 * mid-request cannot move model-specific tool policy between prompt time and
-	 * request time. Callers that do not thread a snapshot keep awaiting this
-	 * immediately before their own getModel() read; that per-site guard remains the
-	 * standalone/fallback read path, and repeat awaits stay cheap once a fetch has
-	 * succeeded because the provider caches successes. RouterProvider already
-	 * negative-caches catalog misses with a TTL (`missingModelRefreshAt`).
+	 * and every tool-array build of the same request, so a fetch that resolves after
+	 * the bounded wait was abandoned cannot move model-specific tool policy between
+	 * prompt time and request time. Callers that do not thread a snapshot keep
+	 * awaiting this immediately before their own getModel() read; that per-site guard
+	 * remains the standalone/fallback read path, and repeat awaits stay cheap once a
+	 * fetch has succeeded because the provider caches successes. RouterProvider
+	 * already negative-caches catalog misses with a TTL (`missingModelRefreshAt`).
 	 */
 	private async safeEnsureModelFetched(): Promise<ModelInfo> {
+		// Per-call controller: its signal makes ensureModelFetched() settle on
+		// abort, so neither this race nor the provider-side waiter outlives the
+		// bounded wait. cancel/dispose aborts it early via cancelCurrentRequest.
+		const controller = new AbortController()
+		this.metadataFetchAbortController = controller
+		// Promise.race attaches handlers to both inputs, so the fetch rejecting
+		// after the abort is already considered handled — no extra .catch needed.
+		let timeoutId: ReturnType<typeof setTimeout> | undefined
+		let timedOut = false
 		try {
-			await this.api.ensureModelFetched?.()
+			await Promise.race([
+				this.api.ensureModelFetched?.(controller.signal),
+				new Promise<void>((resolve) => {
+					timeoutId = setTimeout(() => {
+						timedOut = true
+						resolve()
+					}, MODEL_FETCH_TIMEOUT_MS)
+				}),
+			])
+			if (timedOut) {
+				console.warn(
+					`[Task#${this.taskId}] Timed out after ${MODEL_FETCH_TIMEOUT_MS}ms fetching model metadata; using fallback model info.`,
+				)
+			}
 		} catch (error) {
 			console.error(
 				`[Task#${this.taskId}] Failed to fetch model metadata:`,
 				error instanceof Error ? error.message : error,
 			)
+		} finally {
+			if (timeoutId) {
+				clearTimeout(timeoutId)
+			}
+			if (this.metadataFetchAbortController === controller) {
+				this.metadataFetchAbortController = undefined
+			}
+			// Unconditional: settles any waiter still attached to this call.
+			controller.abort()
 		}
+		// The post-wait read is the settled snapshot callers must share per request.
 		return this.api.getModel().info
 	}
 
@@ -4518,9 +4588,9 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		// Thread the request state snapshot into prompt generation so the prompt
 		// and the runtime tools (built below from the same `state`) stay aligned
 		// even if settings change while this method waits on MCP or rate limits.
-		// Capture one model-info snapshot per request, shared by the prompt and
-		// every tool array built below; prefer the caller's snapshot when one was
-		// threaded.
+		// Capture one bounded-wait model-info snapshot per request, shared by the
+		// prompt and every tool array built below; prefer the caller's snapshot
+		// when one was threaded.
 		const requestModelInfo = options.requestModelInfo ?? (await this.safeEnsureModelFetched())
 		// Retry recursions must reuse this snapshot instead of re-deriving it: a
 		// metadata fetch landing between attempts would otherwise move
@@ -4530,8 +4600,8 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		const retryOptions = options.requestModelInfo === undefined ? { ...options, requestModelInfo } : options
 		const systemPrompt = await this.getSystemPrompt(state, requestModelInfo)
 
-		// A cancellation landing during the rate-limit countdown, the metadata wait,
-		// or the MCP wait inside getSystemPrompt must stop this request before any
+		// A cancellation landing during the rate-limit countdown, the bounded metadata
+		// wait, or the MCP wait inside getSystemPrompt must stop this request before any
 		// tool array, AbortController, or createMessage call is issued for it.
 		if (this.abort || this.abandoned) {
 			throw new Error(