Fix wait baseline navigation and mixed batch stop logic

Author: cursoragent

packages/agent/src/translator/browser-wait.ts

@@ -109,7 +109,9 @@ export async function waitForBrowserExpectation(runtime: BrowserWaitRuntime, opt
 	}
 	const initial = evaluateBrowserExpectation(options.expect, baseline, baseline, runtime.resolveRef);
 	if (!baseline.complete) return terminal("unverifiable", "unverifiable", initial, initial, started, now(), "incomplete_observation");
-	if (runtime.liveNavigationEpoch(targetId) !== baseline.navigationEpoch || [...baseline.generations].some(([key, generation]) => runtime.liveGeneration(key) !== generation)) return terminal("interrupted", "unverifiable", initial, initial, started, now(), "navigation");
+	const baselineNavigated = runtime.liveNavigationEpoch(targetId) !== baseline.navigationEpoch || [...baseline.generations].some(([key, generation]) => runtime.liveGeneration(key) !== generation);
+	const allowLocationRecovery = !!options.baseline && isLocationExpectation(options.expect);
+	if (baselineNavigated && !allowLocationRecovery) return terminal("interrupted", "unverifiable", initial, initial, started, now(), "navigation");
 	if (expired()) return timedOut(started, now());
 	if (initial.reason === "stale_ref") return terminal("interrupted", "unverifiable", initial, initial, started, now(), initial.reason);
 	if (initial.truth === true && !options.baseline) return terminal("satisfied", "preexisting", initial, initial, started, now());

packages/agent/src/translator/translator.ts

@@ -136,7 +136,10 @@ export class InternalComputerTranslator {
 				await flush();
 				const reads = await this.browser().execute(action);
 				result.readResults.push(...reads);
-				if (action.type === "browser_act" && reads.some((read) => read.type === "browser_act" && read.result.stop_reason)) break;
+				if (
+					(action.type === "browser_act" && reads.some((read) => read.type === "browser_act" && read.result.stop_reason)) ||
+					(action.type === "browser_wait_for" && reads.some((read) => read.type === "browser_wait_for" && (read.result.status === "interrupted" || read.result.status === "timed_out" || read.result.status === "unverifiable")))
+				) break;
 				continue;
 			}
 			switch (action.type) {

packages/agent/test/browser-wait.test.ts

@@ -131,6 +131,23 @@ describe("waitForBrowserExpectation", () => {
 		expect(result).toMatchObject({ status: "satisfied", evidence: "newly_verified" });
 	});
 
+	it("allows location expectations to verify when a pre-action baseline is already stale", async () => {
+		let time = 0;
+		const baseline = observation([], true, { url: "https://a.test/start", generations: new Map([["page", 0]]) });
+		const result = await waitForBrowserExpectation({
+			selectTarget: async () => "page",
+			observeTarget: async () => observation([], true, { url: "https://a.test/done", navigationEpoch: 1, generations: new Map([["page", 1]]) }),
+			dialogCount: () => 0,
+			targetExists: async () => true,
+			liveGeneration: () => 1,
+			liveNavigationEpoch: () => 1,
+			resolveRef: missingRef,
+			now: () => time,
+			delay: async (ms) => { time += ms; },
+		}, { expect: { type: "url", changed: true }, baseline, targetId: "page", timeoutMs: 20, pollMs: 10 });
+		expect(result).toMatchObject({ status: "satisfied", evidence: "newly_verified" });
+	});
+
 	it("reports navigation instead of timeout when a location change lands at the deadline", async () => {
 		let time = 0, reads = 0;
 		const result = await waitForBrowserExpectation({

packages/agent/test/translator-browser.test.ts

@@ -300,6 +300,30 @@ describe("browser_act orchestration", () => {
 		await translator.executeBatch([{ type: "browser_act", steps: [{ type: "wait" }] }, { type: "browser_text" }]);
 		expect(executed).toEqual(["browser_act"]);
 	});
+
+	it.each(["interrupted", "timed_out", "unverifiable"] as const)("stops a mixed batch after a browser_wait_for %s result", async (status) => {
+		const { client } = createClient();
+		const executed: string[] = [];
+		const result: BrowserWaitForResult = {
+			status,
+			evidence: status === "timed_out" ? "failed" : "unverifiable",
+			initial: { truth: false, details: ["before"] },
+			final: { truth: false, details: ["after"] },
+			elapsed_ms: 1,
+			...(status === "interrupted" ? { reason: "navigation" } : {}),
+			details: [],
+		};
+		const executor = { execute: async (action: CuaBrowserAction) => {
+			executed.push(action.type);
+			return action.type === "browser_wait_for" ? [{ type: "browser_wait_for", result } as BatchReadResult] : [];
+		} } as unknown as BrowserExecutor;
+		const translator = new InternalComputerTranslator({ browser, client, createBrowserExecutor: () => executor });
+		await translator.executeBatch([
+			{ type: "browser_wait_for", expect: { type: "text", text: "Ready" } },
+			{ type: "browser_text" },
+		]);
+		expect(executed).toEqual(["browser_wait_for"]);
+	});
 });
 
 describe("InternalComputerTranslator computer additions", () => {