@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import { resolveHandoffStatus } from "./handoff-status.js";
+
+/**
+ * A handoff whose page was closed reported `solved: true` (#641) — three lines below a
+ * comment stating that a status poll must never claim a lost handoff is done. The early
+ * return sat ahead of all three per-reason branches, so one line answered for every reason.
+ * There is a case per reason here for that reason: a fix that restores the shortcut for any
+ * one of them has to fail something.
+ */
+describe("a handoff whose page is gone", () => {
+	it("leaves a CHALLENGE unsolved — the captcha is no less unsolved for the tab being shut", () => {
+		expect(resolveHandoffStatus({ reason: "challenge", pageClosed: true })).toEqual({ solved: false, challenge: null });
+	});
+
+	it("leaves a STUCK handoff unsolved even when the human said they were done", () => {
+		// Deliberate: `humanDone` says a step was performed, but the page it was performed
+		// in no longer exists, so the brain has nothing to resume onto — its next action
+		// would land on a fresh blank tab. Unsolved times out into "not resolved in time",
+		// which the cloud maps to `escalated` → "Needs you", where the owner can retry.
+		expect(resolveHandoffStatus({ reason: "stuck", pageClosed: true, humanDone: true })).toEqual({ solved: false, challenge: null });
+		expect(resolveHandoffStatus({ reason: "stuck", pageClosed: true })).toEqual({ solved: false, challenge: null });
+	});
+
+	it("still delivers a NEEDS_INPUT value, which never travelled through the page", () => {
+		// The one reason whose answer arrives out of band (browserSubmitInput). Answering it
+		// after the tab has gone is honest; dropping it would make the brain re-ask for a
+		// value the owner already typed. `value` must survive — the workflow saves it to the
+		// Profile only when it is actually present.
+		expect(resolveHandoffStatus({ reason: "needs_input", pageClosed: true, inputValue: "3 years" })).toEqual({
+			solved: true,
+			challenge: null,
+			value: "3 years",
+		});
+	});
+
+	it("holds a NEEDS_INPUT handoff that has no value yet", () => {
+		expect(resolveHandoffStatus({ reason: "needs_input", pageClosed: true })).toMatchObject({ solved: false, challenge: null });
+		expect(resolveHandoffStatus({ reason: "needs_input", pageClosed: false })).toMatchObject({ solved: false, challenge: null });
+	});
+
+	it("treats an unrecognised reason as a challenge — lost, not done", () => {
+		// `reason` is a string off the HTTP boundary, so an unknown one must land in the
+		// conservative branch rather than fall through to `solved: true`.
+		expect(resolveHandoffStatus({ reason: "something-new", pageClosed: true })).toEqual({ solved: false, challenge: null });
+	});
+});
+
+describe("a handoff whose page is alive", () => {
+	it("defers a challenge to the live DOM", () => {
+		// null = "ask the page". Only `browserHandoffStatus` can answer this one, by reading
+		// the captcha token out of the DOM.
+		expect(resolveHandoffStatus({ reason: "challenge", pageClosed: false })).toBeNull();
+		expect(resolveHandoffStatus({ pageClosed: false })).toBeNull();
+	});
+
+	it("resolves a stuck handoff on the human's explicit Resume, and only that", () => {
+		expect(resolveHandoffStatus({ reason: "stuck", pageClosed: false })).toEqual({ solved: false, challenge: null });
+		expect(resolveHandoffStatus({ reason: "stuck", pageClosed: false, humanDone: true })).toEqual({ solved: true, challenge: null });
+	});
+});
@@ -0,0 +1,72 @@
+/**
+ * What a handoff-status poll can answer WITHOUT looking at the live page (#641).
+ *
+ * A handoff is the runner asking a human for something the brain cannot do: solve a
+ * challenge, perform one widget step it failed at, or supply a value it must not invent.
+ * The remote Workflow polls `browserHandoffStatus` until it is told the human acted, and
+ * `solved: true` is a licence to resume the application — so the only safe answers are the
+ * ones the runner can actually stand behind.
+ *
+ * ── The rule
+ *
+ * A handoff whose PAGE IS GONE is LOST, not resolved. It is the same category as a handoff
+ * whose SESSION is gone (the runner restarted, the takeover expired), which the caller
+ * already answers `solved: false` under a comment stating the rule outright: *a status poll
+ * must never relaunch the browser or claim a lost handoff is done.* Three lines below that
+ * comment sat `if (page.isClosed()) return { solved: true }`, ahead of all three per-reason
+ * branches, so it overrode every one of them:
+ *
+ *   - `challenge` — the brain resumed with the CAPTCHA unsolved, and the claim was acted
+ *     on rather than re-checked: the workflow records `solvedChallengeUrl`, and the apply
+ *     loop then suppresses captcha re-detection on that page for the rest of the round. A
+ *     false "solved" muted the detector that would have caught it.
+ *   - `stuck` — resumed without the human doing the single step the handoff exists for;
+ *     `humanDone` was never consulted.
+ *   - `needs_input` — resumed with `value: undefined`, so the workflow skipped the save and
+ *     the brain re-asked on the next round for a value it had been given.
+ *
+ * There is nothing to resume ONTO in any of those cases: the page the human was working in
+ * no longer exists, and the brain's next action would land on a freshly created blank tab.
+ * Staying unsolved lets the wait time out into "not resolved in time", which the cloud maps
+ * to `escalated` → the board's "Needs you" column — visible, and retryable by the owner.
+ *
+ * ── The one exception, and why it is not one
+ *
+ * `needs_input` is answered BEFORE page liveness is considered, because its answer never
+ * involved the page: the value arrives out of band through `browserSubmitInput`, which
+ * writes it onto the session. A value the owner typed is a real answer whether or not the
+ * tab survived, and discarding it would re-ask for something already in hand.
+ */
+
+/** The facts a status poll has about a handoff, with no browser in them — so this is pure. */
+export interface HandoffFacts {
+	/** `challenge` (the default for an unrecognised reason), `stuck`, or `needs_input`. */
+	reason?: string;
+	/** Whether the page the human was handed is closed. */
+	pageClosed: boolean;
+	/** The value supplied through the ask-and-hold channel, if any. */
+	inputValue?: string;
+	/** Whether the human explicitly said they were finished. */
+	humanDone?: boolean;
+}
+
+export interface HandoffStatus {
+	solved: boolean;
+	challenge: string | null;
+	value?: string;
+}
+
+/**
+ * The answer to a handoff-status poll, or `null` when only the live DOM can give one — a
+ * `challenge` on a page that is still open, whose token clears in the page itself.
+ */
+export function resolveHandoffStatus(facts: HandoffFacts): HandoffStatus | null {
+	// Out of band, and therefore unaffected by a page that has gone.
+	if (facts.reason === "needs_input") return { solved: !!facts.inputValue, challenge: null, value: facts.inputValue };
+	// Lost, not done. See the note above — this line is the fix for #641.
+	if (facts.pageClosed) return { solved: false, challenge: null };
+	// A stuck handoff resumes only when the human explicitly clicks Resume — there's
+	// nothing to auto-detect.
+	if (facts.reason === "stuck") return { solved: !!facts.humanDone, challenge: null };
+	return null;
+}
@@ -0,0 +1,76 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { LocalRunner } from "./runner.js";
+
+/**
+ * The wiring half of #641, against a REAL Chrome and a REAL closed page.
+ *
+ * `handoff-status.test.ts` pins the decision; this pins that `browserHandoffStatus` asks it.
+ * The two are separate because a poll that reasons correctly in a pure function and still
+ * shortcuts in the method is the bug — the method's own `if (page.isClosed()) return { solved:
+ * true }` sat below a comment forbidding exactly that, and no test held the ground.
+ */
+describe("browserHandoffStatus when the page the human was handed is gone (#641)", () => {
+	let dir: string;
+	let runner: LocalRunner;
+
+	beforeEach(() => {
+		dir = mkdtempSync(join(tmpdir(), "pags-handoff-"));
+		runner = new LocalRunner({ host: "127.0.0.1", port: 0, dataDir: dir, headless: true });
+	});
+
+	afterEach(async () => {
+		await runner.close();
+		rmSync(dir, { recursive: true, force: true });
+	}, 30_000);
+
+	/**
+	 * Register a real takeover on a real page, then take the browser away underneath it.
+	 *
+	 * `close()` shuts the browser context, which closes every page in it, and deliberately
+	 * leaves `takeovers` alone — so this produces exactly the state the bug is about: a live
+	 * handoff session holding a dead page. That is the real shape of it too: the human closes
+	 * the tab, the site replaces it in a popup flow, or Chrome dies mid-handoff.
+	 */
+	async function handoffThenLoseTheBrowser(reason: string, label: string): Promise<string> {
+		const task = runner.createTask({ type: "job.apply_agent", input: {} });
+		const handoff = await runner.browserHandoff(task.id, label, reason);
+		expect(handoff.screenshotBase64).toMatch(/^data:image\/jpeg;base64,/);
+		expect(runner.listTakeovers()).toContain(task.id);
+		expect(runner.store.getTask(task.id)?.status).toBe("needs_human");
+		return task.id;
+	}
+
+	it("reports a CAPTCHA handoff unsolved — it is no less unsolved for the tab being shut", async () => {
+		const taskId = await handoffThenLoseTheBrowser("challenge", "recaptcha");
+		await runner.close();
+		// Was `{ solved: true }`, and the workflow acted on it: it recorded the page as a
+		// solved challenge, which mutes captcha re-detection there for the rest of the round.
+		expect(await runner.browserHandoffStatus(taskId)).toEqual({ solved: false, challenge: null });
+	}, 120_000);
+
+	it("reports a STUCK handoff unsolved, even after the human pressed Resume", async () => {
+		const taskId = await handoffThenLoseTheBrowser("stuck", "Save and Continue");
+		// The human says they did the step — `resumeTakeover` sets humanDone for a
+		// workflow-driven task without completing it.
+		expect(await runner.resumeTakeover(taskId)).toMatchObject({ resumed: true });
+		await runner.close();
+		// Still not resumable: the page that step happened in is gone, so the brain would be
+		// handed a fresh blank tab. Unsolved times out into "not resolved in time" →
+		// `escalated` → "Needs you", which the owner can see and retry.
+		expect(await runner.browserHandoffStatus(taskId)).toEqual({ solved: false, challenge: null });
+	}, 120_000);
+
+	it("still delivers a NEEDS_INPUT value supplied after the tab was gone", async () => {
+		const taskId = await handoffThenLoseTheBrowser("needs_input", "Years of Python experience");
+		await runner.close();
+		// Nothing has been supplied yet: unsolved, and — the part the old shortcut got wrong
+		// in the other direction — carrying no value for the workflow to save.
+		expect(await runner.browserHandoffStatus(taskId)).toMatchObject({ solved: false, value: undefined });
+		// The value channel never involved the page, so it still works.
+		expect(runner.browserSubmitInput(taskId, "3 years")).toEqual({ ok: true });
+		expect(await runner.browserHandoffStatus(taskId)).toEqual({ solved: true, challenge: null, value: "3 years" });
+	}, 120_000);
+});
@@ -10,6 +10,7 @@ import { isTerminalTaskStatus, settleTaskOutcome } from "./apply-outcome.js";
 import { McpRuntime } from "./mcp-runtime.js";
 import { commitLabelRe, ELEMENT_PROBE_FN, FOCUS_PROBE_FN, refuseClick, refuseKey, type CommitGuardSpec, type ElementFacts, type FocusFacts } from "./commit-guard.js";
 import { HumanHandoffError, RunnerInputError } from "./errors.js";
+import { resolveHandoffStatus } from "./handoff-status.js";
 import { RunnerStore } from "./store.js";
 import { CodingRuntime } from "./coding/runtime.js";
 import { WORKFLOW_DRIVEN_TASKS } from "./task-types.js";
@@ -1162,12 +1163,11 @@ export class LocalRunner {
 		// must never relaunch the browser or claim a lost handoff is done.
 		if (!session) return { solved: false, challenge: null };
 		const page = session.page;
-		if (page.isClosed()) return { solved: true, challenge: null };
-		// A needs_input handoff resumes once the user supplies the value.
-		if (session.reason === "needs_input") return { solved: !!session.inputValue, challenge: null, value: session.inputValue };
-		// A stuck handoff resumes only when the human explicitly clicks Resume —
-		// there's nothing to auto-detect.
-		if (session.reason === "stuck") return { solved: !!session.humanDone, challenge: null };
+		// Every answer that needs no live DOM — including a GONE page, which used to report
+		// solved:true and resume past an unsolved challenge (#641) — comes from
+		// handoff-status.ts; null means only an open challenge's own DOM can answer.
+		const offline = resolveHandoffStatus({ reason: session.reason, pageClosed: page.isClosed(), inputValue: session.inputValue, humanDone: session.humanDone });
+		if (offline) return offline;
 		// A challenge resumes when the token/widget clears OR the human clicks Done —
 		// custom captchas (e.g. PageUp's "not a robot") have no detectable token, so
 		// the human's explicit Done is the authority; never strand them.