fix: sync CI fixes from pr/b03-error-integration-v2

Author: Zoo (VP)

.gitignore

@@ -55,12 +55,3 @@ qdrant_storage/
 plans/
 
 roo-cli-*.tar.gz*
-
-# Local dev scripts (not for CI)
-/ci-fix-commit.ps1
-/commit-and-push.ps1
-/commit-message.txt
-/resolve_conflicts.py
-
-# AI session artifacts (timestamped session directories)
-/docs/*_session_*/

CHANGELOG.md

@@ -1,5 +1,39 @@
 # Zoo Code Changelog
 
+## [3.74.0]
+
+### Minor Changes
+
+- Add Fast priority mode for OpenAI Codex, persisting the selection and sending it with requests (PR #1063 by @WebMad)
+- Add higher reasoning-effort options for OpenAI-compatible models (#882 by @MINLEGO, PR #1051 by @ivanarifin)
+- Fetch router-provider model metadata before making context-management decisions (PR #1053 by @JamesRobert20)
+- Make Ollama model refreshes reliable, surface refresh errors, and use the base URL currently being edited (#877 by @navedmerchant, PR #878 by @navedmerchant)
+- Fix Amazon Bedrock DNS resolution when using a corporate proxy (#905 by @LouisClt, PR #906 by @LouisClt)
+- Add reasoning-parameter support to the Friendli provider (PR #886 by @Lee-Si-Yoon)
+- Keep Save-managed settings in the local editing buffer until the user explicitly saves (#862 by @JunyongParkDev, PR #872 by @JunyongParkDev)
+- Stop prompting about command output after short foreground commands have already completed (#1042 by @edelauna, PR #1043 by @app/zoomote)
+- Keep Architect mode plans workspace-relative so creating `./plans` does not fail on read-only filesystem roots (#965 by @juneleung, PR #968 by @app/zoomote)
+- Replace remaining user-facing Roo branding with Zoo branding (#551 by @proyectoauraorg, PR #971 by @rrewll)
+- Introduce a semaphore-based task scheduler for controlled task execution (#358 by @edelauna, PR #1031 by @edelauna)
+- Introduce `TaskRegistry` and migrate task-stack management to it (#367 by @edelauna, PR #1014 by @edelauna)
+- Complete the API provider migration to canonical provider identifiers (#955 by @WebMad, PR #1012 by @WebMad)
+- Use canonical provider identifiers for default model definitions (#954 by @WebMad, PR #991 by @WebMad)
+- Use canonical provider identifiers for API model caches (#957 by @WebMad, PR #1020 by @WebMad)
+- Use canonical provider identifiers in shared profile settings (#956 by @WebMad, PR #1019 by @WebMad)
+- Use canonical provider identifiers throughout extension-core flows (#958 by @WebMad, PR #1022 by @WebMad)
+- Use canonical provider identifiers throughout the webview (#959 by @WebMad, PR #1023 by @WebMad)
+- Finish the repository-wide canonical provider identifier audit (#960 by @WebMad, PR #1030 by @WebMad)
+- Centralize API service-tier types and helpers (PR #1040 by @WebMad)
+- Support the platform-package layout introduced by `@vscode/ripgrep` 1.18 and later (#1024 by @saravanaraj0078-lab, PR #1032 by @edelauna)
+- Update `shell-quote` to 1.9.0 to incorporate security fixes (PR #986 by @app/renovate)
+- Update the development and build toolchain to Node.js 22.23.1 LTS (PR #743 by @app/renovate)
+- Add a Playwright visual-regression harness for webview components (#515 by @edelauna, PR #526 by @edelauna)
+- Enforce the no-floating-promises lint ratchet in `core/webview` (#949 by @edelauna, PR #950 by @morgan-coded)
+- Harden the end-to-end workflow against transient VS Code binary download failures (#1044 by @edelauna, PR #1045 by @app/zoomote)
+- Isolate mocked subtask fixtures to prevent flaky parent-resume tests (#1001 by @app/zoomote, PR #1002 by @app/zoomote)
+- Prevent cancelled delayed mock streams from leaking between subtask end-to-end tests (PR #1074 by @app/zoomote)
+- Merge the v3.72.0 release preparation branch into `main` (PR #1013 by @navedmerchant)
+
 ## [3.72.0]
 
 ### Minor Changes

README.md

@@ -35,15 +35,28 @@
 You can find a quick guide for migrating from Roo Code to Zoo Code in the [Roo→Zoo migration guide](https://docs.zoocode.dev/roo-to-zoo-migration). We plan to try and help users as they transition over, we have our [Reddit](https://www.reddit.com/r/ZooCode) and [Discord](https://discord.gg/VxfP4Vx3gX)
 for this exact support, so if you are having problems or if you have question, jump on and ask.
 
-## What's New in v3.72.0
+## What's New in v3.74.0
 
-- **Moonshot and Kimi Code providers** — discover Moonshot models dynamically or sign in to Kimi Code through its OAuth device flow.
-- **Latest model support** — use Claude Opus 5 across providers, plus Kimi K3, Gemini 3.6 Flash, and MiniMax-M3.
-- **Improved subtask workflows** — abandon interrupted subtasks cleanly, with safer task-history invalidation and better resume coverage.
-- **Expanded codebase indexing** — index Dart and plain-text files.
-- **Provider reliability** — fixes for GPT-5.6 Luna with ChatGPT OAuth, LiteLLM reasoning content, and DeepSeek V4 image input.
-- **Smoother setup and settings** — improved Zoo Gateway sign-in and mode-switch behavior.
-- API, provider-type, dependency, localization, and CI improvements.
+**Zoo Gateway is live!**
+
+The gateway is a single endpoint for all providers, with one balance and per-request spending/usage breakdown.
+
+**Setup:**
+
+- Add credits: https://www.zoocode.dev/dashboard/credits
+- Sign in from the extension.
+- In the settings, select Zoo Gateway as the provider when creating profiles for different models
+
+Usage and charges can be viewed in the [dashboard](https://www.zoocode.dev/dashboard).
+
+Models: https://www.zoocode.dev/dashboard/models
+
+- **More OpenAI controls** — use Fast priority mode with OpenAI Codex and choose higher reasoning effort for OpenAI-compatible models.
+- **More reliable providers and models** — improved router metadata handling, Ollama model refresh, Bedrock proxy support, and Friendli reasoning controls.
+- **Smoother settings and developer workflows** — settings now preserve unsaved edits, short terminal commands complete cleanly, architect plans use workspace-relative paths, and remaining user-facing Roo branding is updated to Zoo.
+- **Stronger task foundations** — new task registry and semaphore-based scheduler primitives prepare Zoo Code for safer task coordination.
+- **Consistent provider architecture** — provider identifiers and service-tier primitives are now centralized across the API, core, shared types, and webview.
+- Security, dependency, lint, visual-regression, and end-to-end test improvements.
 
 <details>
   <summary>🌐 Available languages</summary>
@@ -66,6 +79,7 @@ for this exact support, so if you are having problems or if you have question, j
 - [Tiếng Việt](locales/vi/README.md)
 - [简体中文](locales/zh-CN/README.md)
 - [繁體中文](locales/zh-TW/README.md)
+
 </details>
 
 ---

apps/vscode-e2e/AGENTS.md

@@ -121,6 +121,17 @@ Example:
 
 The `model` field can be added to either match when a test targets a specific model.
 
+## Delaying a fixture response (simulating a slow or hung provider)
+
+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.
+
 ## 404 errors in logs are expected
 
 Background API calls from the extension (usage collection, initialization) hit aimock with no matching fixture and return 404. These do **not** affect test results — the tests still pass. You'll see `[OpenRouter] API error: { message: '404 No fixture matched' }` in the output; this is normal.

apps/vscode-e2e/src/fixtures/apply-diff.ts

@@ -31,7 +31,7 @@ export function addApplyDiffResultFixtures(mock: InstanceType<typeof LLMock>) {
 		},
 		{
 			toolCallId: "call_apply_diff_error_001",
-			expected: ["Category: DIFF_MATCH_FAILED", "Pattern: EI/DIFF_MATCH_FAILED/001"],
+			expected: ["No sufficiently similar match found at line: 1", "This content does not exist"],
 			result: "The apply_diff operation on `apply-diff-tool-fixture/error-handling.txt` was rejected - the search content did not match any content in the file, so it was not modified.",
 			id: "call_apply_diff_error_002",
 		},

apps/vscode-e2e/src/fixtures/subtasks.ts

@@ -33,6 +33,12 @@ export const SUBTASK_API_HANG_RESUME_MESSAGE = "Continue after provider hang."
 export const SUBTASK_API_HANG_CHILD_RESULT = "Hung child completed"
 export const SUBTASK_API_HANG_PARENT_RESULT = "API hang parent resumed"
 
+// How long the API-hang child's first mocked response stays pending before its first SSE
+// chunk. Shared with the subtask suite so its post-test drain waits exactly one window.
+// Correctness depends on no flat `latency` (fixture or LLMock default) being set on that
+// fixture — a flat latency would apply to every chunk after the first, not just the ttft.
+export const SUBTASK_API_HANG_RESPONSE_LATENCY_MS = 15_000
+
 // Abandon-subtask scenario (#559) — separate markers to avoid sequenceIndex collisions with the
 // interrupted-child-resumes tests above, which exhaust the sequence count for INTERRUPT markers.
 const SUBTASK_ABANDON_PARENT_MARKER = "SUBTASK_PARENT_ABANDON_SEVER"
@@ -261,8 +267,14 @@ export function addSubtaskFixtures(mock: InstanceType<typeof LLMock>) {
 			userMessage: apiHangChildMatch,
 			sequenceIndex: 0,
 		},
-		// Keep the first child response pending long enough for the e2e test to cancel an in-flight API request.
-		latency: 15_000,
+		// Keep the first child response pending long enough for the e2e test to cancel an in-flight
+		// API request. Delay only the first chunk (ttft) rather than using flat `latency`: aimock
+		// applies `latency` to EVERY chunk and never observes client disconnects, so after the test
+		// cancels, a flat-latency stream would stay pending server-side for chunks × latency before
+		// flushing to the dead socket. With ttft the pending window is exactly
+		// SUBTASK_API_HANG_RESPONSE_LATENCY_MS (see its doc comment for the no-flat-latency
+		// invariant this relies on), which is what the suite's post-test drain waits out.
+		streamingProfile: { ttft: SUBTASK_API_HANG_RESPONSE_LATENCY_MS },
 		response: {
 			toolCalls: [
 				{

apps/vscode-e2e/src/suite/subtasks.test.ts

@@ -16,6 +16,7 @@ import {
 	SUBTASK_API_HANG_PARENT_MARKER,
 	SUBTASK_API_HANG_PARENT_PROMPT,
 	SUBTASK_API_HANG_PARENT_RESULT,
+	SUBTASK_API_HANG_RESPONSE_LATENCY_MS,
 	SUBTASK_API_HANG_RESUME_MESSAGE,
 	SUBTASK_CHILD_FOLLOWUP_ANSWER,
 	SUBTASK_FAST_CHILD_RESULT,
@@ -33,6 +34,7 @@ import {
 type AimockMessageContent = string | Array<{ type?: string; text?: string }>
 
 type AimockJournalEntry = {
+	timestamp?: number
 	body?: {
 		messages?: Array<{
 			role?: string
@@ -49,24 +51,67 @@ const messageContentText = (content?: AimockMessageContent) => {
 	return content?.map((part) => part.text ?? "").join("") ?? ""
 }
 
-const waitForAimockRequestContaining = async (expectedText: string, excludeText?: string) => {
+const fetchAimockJournal = async () => {
 	const aimockUrl = process.env.AIMOCK_URL
 	assert.ok(aimockUrl, "AIMOCK_URL must be set for aimock journal assertions")
 
+	const response = await fetch(`${aimockUrl}/__aimock/journal`)
+	return (await response.json()) as AimockJournalEntry[]
+}
+
+const findAimockRequest = (entries: AimockJournalEntry[], expectedText: string, excludeText?: string) =>
+	entries.find((entry) => {
+		const messages = entry.body?.messages
+		if (!messages) return false
+		const entryText = messages.map((m) => messageContentText(m.content)).join("")
+		if (excludeText && entryText.includes(excludeText)) return false
+		return messages.some(
+			(message) => message.role === "user" && messageContentText(message.content).includes(expectedText),
+		)
+	})
+
+// Waits for a matching request to appear in the aimock journal and returns its journal
+// timestamp, so callers can anchor post-test drains to the exact request this test created.
+const waitForAimockRequestContaining = async (
+	expectedText: string,
+	excludeText?: string,
+): Promise<number | undefined> => {
+	let matchedAt: number | undefined
+
 	await waitFor(async () => {
-		const response = await fetch(`${aimockUrl}/__aimock/journal`)
-		const entries = (await response.json()) as AimockJournalEntry[]
-
-		return entries.some((entry) => {
-			const messages = entry.body?.messages
-			if (!messages) return false
-			const entryText = messages.map((m) => messageContentText(m.content)).join("")
-			if (excludeText && entryText.includes(excludeText)) return false
-			return messages.some(
-				(message) => message.role === "user" && messageContentText(message.content).includes(expectedText),
-			)
-		})
+		matchedAt = findAimockRequest(await fetchAimockJournal(), expectedText, excludeText)?.timestamp
+		return matchedAt !== undefined
 	})
+
+	return matchedAt
+}
+
+// Grace period after the delayed window for aimock to flush the stream's remaining chunks to
+// the dead socket. 500ms is an empirical margin for that flush plus socket teardown; if this
+// 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
+// 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.
+const waitForDelayedSubtaskStreamDrain = async (delayedRequestStartedAt: number | undefined) => {
+	if (delayedRequestStartedAt === undefined) {
+		// The delayed request never reached the mock (the test failed before cancelling
+		// an in-flight request), so there is no delayed stream to drain.
+		return
+	}
+
+	const drainDeadlineMs =
+		delayedRequestStartedAt + SUBTASK_API_HANG_RESPONSE_LATENCY_MS + SUBTASK_API_HANG_DRAIN_GRACE_MS
+	const remainingMs = drainDeadlineMs - Date.now()
+
+	if (remainingMs > 0) {
+		await sleep(remainingMs)
+	}
 }
 
 suite("Roo Code Subtasks", function () {
@@ -482,6 +527,7 @@ suite("Roo Code Subtasks", function () {
 		const api = globalThis.api
 		const asks: Record<string, ClineMessage[]> = {}
 		const says: Record<string, ClineMessage[]> = {}
+		let delayedChildRequestStartedAt: number | undefined
 
 		const messageHandler = ({ taskId, message }: { taskId: string; message: ClineMessage }) => {
 			if (message.type === "ask") {
@@ -519,7 +565,10 @@ suite("Roo Code Subtasks", function () {
 				return false
 			})
 
-			await waitForAimockRequestContaining(SUBTASK_API_HANG_CHILD_MARKER, SUBTASK_API_HANG_PARENT_MARKER)
+			delayedChildRequestStartedAt = await waitForAimockRequestContaining(
+				SUBTASK_API_HANG_CHILD_MARKER,
+				SUBTASK_API_HANG_PARENT_MARKER,
+			)
 
 			await api.cancelCurrentTask()
 
@@ -580,6 +629,9 @@ suite("Roo Code Subtasks", function () {
 				await api.clearCurrentTask()
 			}
 			await waitFor(() => api.getCurrentTaskStack().length === 0).catch(() => {})
+			// Drain the cancelled delayed stream before the next test can open another
+			// streamed request against the mock.
+			await waitForDelayedSubtaskStreamDrain(delayedChildRequestStartedAt)
 		}
 	})
 
@@ -692,9 +744,6 @@ suite("Roo Code Subtasks", function () {
 		}
 	})
 
-	// NOTE: This test exercises parent-child resume via mock fixtures with overlapping
-	// predicates. If it flakes on CI, the fixture chain may need tighter matching.
-	// See debug-systemic report 190600 for root-cause analysis.
 	// Issue #560: interrupted child resumes and reports back to parent.
 	// Before the fix, cancelTask() severed the parent link, so the resumed child
 	// fell through to "Start New Task" instead of delegating back to the parent.