diff --git a/apps/web/DESIGN.md b/apps/web/DESIGN.md
index 3bdf9d391..2e2a381b9 100644
--- a/apps/web/DESIGN.md
+++ b/apps/web/DESIGN.md
@@ -173,6 +173,7 @@ Rectangular controls use a restrained four-step radius scale: small for grips an
 - **Document:** The authored page is white, readable, and wider only where content requires it. Headings, lists, tables, code, and callouts retain document semantics inside the editor.
 - **Document images:** Click opens a full-screen preview with zoom and close controls. Hover or keyboard focus reveals metadata editing and corner resize handles. Resizing preserves the image ratio, shares the chosen width with collaborators, and remains bounded by the document or column on narrow screens.
 - **Decision decks:** Adjacent decisions stack as a deck. The top card is live; up to two cards behind it show their header edges and are inert. Previous and next controls, Left and Right arrows, and a count of the top card's place cycle the deck with a short shuffle; answered decisions settle to the back. Reduced motion reorders without animation. Deck order is each reader's own.
+  On desktop, Decisions shows open decisions as the same deck when two or more wait, with resolved decisions listed below; phones keep the single-pane list and save bar. A blank document whose Planner asks decisions opens Decisions once per visit, unless the reader is editing the document.
 - **Unfold:** One disclosure for accordions and card previews. A button with `aria-expanded` and `aria-controls` folds a mounted panel open through its grid row while the content fades and tips down from its top edge, with the shared ease-out: card previews take the linger duration, plain accordions the accordion duration. A second press reverses from the current frame. Closed content is inert and hidden once the fold ends. Reduced motion snaps the height and keeps a short crossfade. A card preview never replaces the card's own open action.
 
 ## Do's and Don'ts
diff --git a/apps/web/src/document-editing.ts b/apps/web/src/document-editing.ts
new file mode 100644
index 000000000..7342f7981
--- /dev/null
+++ b/apps/web/src/document-editing.ts
@@ -0,0 +1,28 @@
+import { useEffect, useState } from "react";
+
+/** Whether focus is in this room's document editor, so routing can leave the reader alone. */
+export function useDocumentEditing(room: string): boolean {
+	let [editing, setEditing] = useState(false);
+	useEffect(() => {
+		// An open child's editor sits inside the parent's workspace but is not this document.
+		let selector = `[data-workspace-room="${CSS.escape(room)}"] [data-document-view="plan"] `
+			+ `[contenteditable="true"]:not(.workspace-child-slot *)`;
+		let inEditor = (target: EventTarget | null) =>
+			target instanceof Element && !!target.closest(selector);
+		let focus = (event: FocusEvent) => setEditing(inEditor(event.target));
+		// During focusout activeElement is not yet the new target; relatedTarget is.
+		let blur = (event: FocusEvent) => {
+			// The window losing focus keeps the editor's focus for when it returns.
+			if (event.relatedTarget === null && !document.hasFocus()) return;
+			setEditing(inEditor(event.relatedTarget));
+		};
+		setEditing(inEditor(document.activeElement));
+		document.addEventListener("focusin", focus);
+		document.addEventListener("focusout", blur);
+		return () => {
+			document.removeEventListener("focusin", focus);
+			document.removeEventListener("focusout", blur);
+		};
+	}, [room]);
+	return editing;
+}
diff --git a/apps/web/src/room-workspace.tsx b/apps/web/src/room-workspace.tsx
index 443621ac7..5b90cd1f9 100644
--- a/apps/web/src/room-workspace.tsx
+++ b/apps/web/src/room-workspace.tsx
@@ -33,6 +33,7 @@ import { Chat } from "./chat/chat";
 import { ChildProvenance } from "./child-provenance";
 import { shouldShowResearchActionError, useResearchOfferLinks } from "./chat/research-offer";
 import type { ResearchDraftController } from "./chat/research-draft-controller";
+import { useDocumentEditing } from "./document-editing";
 import { advanceConversationAnnouncement } from "./conversation-plan/announcements";
 import type { ConversationAnnouncementSummary } from "./conversation-plan/announcements";
 import { evidenceRows, hasEvidence } from "./conversation-plan/evidence";
@@ -467,13 +468,13 @@ export function RoomWorkspace(
 	let [researchErrors, setResearchErrors] = useState<Record<string, string>>({});
 	let [researchExecution, setResearchExecution] = useState(false);
 	let researchDrafts = useMemo(() => new Map<string, ResearchDraftController>(), [room]);
-	let [reveal, setReveal] = useState<{ widget: string; token: number }>();
+	let [reveal, setReveal] = useState<{ widget: string; token: number; resume?: boolean }>();
 	let [planScrollTop, setPlanScrollTop] = useState(0);
 	let entries = useQuestionnaires(questions);
 	let cardMetadata = useSyncExternalStore(cardMeta.subscribe, cardMeta.snapshot, cardMeta.snapshot);
 	let unanswered = countUnanswered(entries, cardMetadata);
 	let hasPlanProse = useHasPlanContent(questions);
-	let hasPlanContent = documentHasPlanningContent(hasPlanProse, entries);
+	let hasPlanContent = documentHasPlanningContent(hasPlanProse);
 	let [decisionView, setDecisionView] = useState<DecisionViewState>(() => {
 		let stored = localStorage.getItem("chopin:view:document");
 		return {
@@ -481,9 +482,10 @@ export function RoomWorkspace(
 			preferred: initialDocumentView(profile, stored),
 		};
 	});
+	let typing = useDocumentEditing(room);
 	let view: WorkspaceDocumentView = showImplementation && profile.implementation
 		? "build"
-		: visibleDecisionView(decisionView, hasPlanContent, unanswered);
+		: visibleDecisionView(decisionView, hasPlanContent, unanswered, typing);
 	let attention = useDecisionAttention(unanswered);
 	let latestCanEdit = useRef(canEdit);
 	let latestCanManage = useRef(canManage);
@@ -543,10 +545,28 @@ export function RoomWorkspace(
 		}
 	}, [onDocumentChanged, room, userId]);
 
+	// Focus alone never routes: only new decisions or new prose re-evaluate the opening.
 	useEffect(() => {
-		setDecisionView(state => advanceDecisionView(state, hasPlanContent, unanswered));
+		let next = advanceDecisionView(decisionView, hasPlanContent, unanswered, typing);
+		if (next === decisionView) return;
+		setDecisionView(state => (state === decisionView ? next : state));
+		// oxlint-disable-next-line react-hooks/exhaustive-deps -- typing and decisionView are read, not triggers
 	}, [hasPlanContent, unanswered]);
 
+	// Announce the route only once it has applied: a tab choice in the same
+	// batch makes the routing updater above a no-op.
+	let routedPhase = useRef(decisionView.phase);
+	useEffect(() => {
+		let before = routedPhase.current;
+		routedPhase.current = decisionView.phase;
+		if (before !== "initial" || decisionView.phase !== "forced") return;
+		setAnnouncement(current => ({
+			text: `Showing Decisions: ${unanswered} to answer`,
+			sequence: current.sequence + 1,
+		}));
+		// oxlint-disable-next-line react-hooks/exhaustive-deps -- the count is read when routing applies
+	}, [decisionView.phase]);
+
 	useEffect(() => {
 		if (!taskLink || !hasPlanContent) return;
 		setTaskLink(false);
@@ -612,7 +632,7 @@ export function RoomWorkspace(
 		}
 		if (next === "decisions" && revealFirst) {
 			let first = firstOpenDecision(entries, cardMetadata);
-			setReveal({ widget: first?.id ?? "", token: Date.now() });
+			setReveal({ widget: first?.id ?? "", token: Date.now(), resume: true });
 		}
 	};
 
diff --git a/e2e/decision-deck-fixtures.ts b/e2e/decision-deck-fixtures.ts
index 078a183fd..d3b8474db 100644
--- a/e2e/decision-deck-fixtures.ts
+++ b/e2e/decision-deck-fixtures.ts
@@ -1,6 +1,8 @@
 import { storedQuestion } from "../apps/server/src/testing/plan";
+import { expect } from "./room";
 
 import type { SeedState } from "../apps/server/src/testing/plan";
+import type { Page } from "@playwright/test";
 
 /** The digest of a paragraph reading exactly `Anchored paragraph.` */
 export const ANCHORED_DIGEST =
@@ -86,3 +88,21 @@ ${choices.map(choice => `<Option id="${choice.id}" label="${choice.label}" />`).
 		ids,
 	};
 }
+
+/** The desktop Decisions deck slot holding a decision, on top or waiting behind. */
+export function deckSlot(page: Page, prompt: string) {
+	return page.locator('[data-document-view="decisions"] [data-deck-slot]').filter({
+		hasText: prompt,
+	});
+}
+
+/** Cycle the desktop Decisions deck until a decision is on top and answerable. */
+export async function bringForward(page: Page, prompt: string) {
+	let slot = deckSlot(page, prompt);
+	let next = page.locator('[data-document-view="decisions"] [data-deck]')
+		.getByRole("button", { name: "Next decision" });
+	await expect(async () => {
+		if (await slot.getAttribute("data-deck-top") === null) await next.click();
+		await expect(slot).toHaveAttribute("data-deck-top", "", { timeout: 1_000 });
+	}).toPass();
+}
diff --git a/e2e/decisions-phone.e2e.ts b/e2e/decisions-phone.e2e.ts
index ea4650184..672424d87 100644
--- a/e2e/decisions-phone.e2e.ts
+++ b/e2e/decisions-phone.e2e.ts
@@ -1,3 +1,4 @@
+import { deckSeed } from "./decision-deck-fixtures";
 import { expect, test } from "./room";
 
 import type { Page } from "@playwright/test";
@@ -220,3 +221,13 @@ test("desktop keeps the in-card Save and the inline card", async ({ join, seed }
 	await expect(card.getByRole("button", { name: "Discard", exact: true })).toBeVisible();
 	await expect(page.locator(".decision-save-bar")).toHaveCount(0);
 });
+
+test("phone: several open decisions stay a list with the save bar, not a deck", async ({ join, seed }) => {
+	let fixture = deckSeed({ before: "Decisions on a phone." }, 3);
+	await seed(fixture.source, fixture.state);
+	let page = await join("ana", PHONE);
+	await showDecisions(page);
+	let view = page.locator('[data-document-view="decisions"]:visible');
+	await expect(view.locator("article[data-plan-sidecar-questionnaire]")).toHaveCount(3);
+	await expect(view.locator("[data-deck]")).toHaveCount(0);
+});
diff --git a/e2e/harness-decisions-deck.e2e.ts b/e2e/harness-decisions-deck.e2e.ts
new file mode 100644
index 000000000..c0af20047
--- /dev/null
+++ b/e2e/harness-decisions-deck.e2e.ts
@@ -0,0 +1,127 @@
+/**
+ * Planner questions reaching the Decisions tab, through the real server, sockets
+ * and host tools, against the isolated `AGENT=on` fake-harness project.
+ */
+import { chatInput } from "./chat-input";
+import { content, expect, test } from "./room";
+
+import type { Page } from "@playwright/test";
+
+async function ask(page: Page) {
+	let input = chatInput(page);
+	await input.fill("@chopin ASK-DECISIONS");
+	await input.press("Enter");
+}
+
+function decisionsButton(page: Page) {
+	return page.getByRole("group", { name: "Document view" })
+		.getByRole("button", { name: /^Decisions/ });
+}
+
+function deck(page: Page) {
+	return page.locator('[data-document-view="decisions"] [data-deck]');
+}
+
+function top(page: Page) {
+	return deck(page).locator("[data-deck-top]");
+}
+
+/** Answering ends the Planner's open ask, so the next @chopin message starts a new turn. */
+async function answerAll(page: Page) {
+	for (let index = 0; index < 3; index++) {
+		await top(page).getByText("First option", { exact: true }).click();
+		await top(page).getByRole("button", { name: "Save", exact: true }).click();
+		if (index < 2) await expect(deck(page).getByText(`${index + 1} decided`)).toBeVisible();
+	}
+	await expect(deck(page)).toHaveCount(0);
+}
+
+function routed(page: Page) {
+	return page.getByRole("status").filter({ hasText: "Showing Decisions:" });
+}
+
+test("a blank document routes the Planner's questions to a Decisions deck", async ({ join }) => {
+	let page = await join("ana");
+	await chatInput(page).click();
+	await ask(page);
+
+	await expect(decisionsButton(page)).toHaveAttribute("aria-pressed", "true");
+	await expect(routed(page).filter({ hasText: "Showing Decisions: 3 to answer" }))
+		.toHaveCount(1);
+	await expect(chatInput(page)).toBeFocused();
+	await expect(deck(page)).toHaveAttribute("aria-label", "3 open decisions");
+	await expect(deck(page).getByText("1 of 3")).toBeVisible();
+
+	await answerAll(page);
+	await expect(page.getByRole("button", { name: "3 resolved" })).toBeVisible();
+	// No prose yet, so the forced view holds.
+	await expect(decisionsButton(page)).toHaveAttribute("aria-pressed", "true");
+});
+
+test("a reader editing the blank document is not moved", async ({ join }) => {
+	let ana = await join("ana");
+	let ben = await join("ben");
+	await content(ana).click();
+	await expect(content(ana)).toBeFocused();
+	await ask(ben);
+
+	await expect(decisionsButton(ben)).toHaveAttribute("aria-pressed", "true");
+	await expect(decisionsButton(ana)).toContainText("3");
+	await expect(decisionsButton(ana)).toHaveAttribute("aria-pressed", "false");
+	await expect(content(ana)).toBeFocused();
+	await expect(routed(ana)).toHaveCount(0);
+});
+
+test("an explicit tab pick keeps a blank document in Document when more decisions arrive", async ({ join }) => {
+	let page = await join("ana");
+	// The status region is one persistent element, so count announcements as they are inserted.
+	await page.evaluate(() => {
+		let seen = { count: 0 };
+		(window as unknown as { routings: typeof seen }).routings = seen;
+		new MutationObserver(records => {
+			for (let record of records) {
+				for (let node of record.addedNodes) {
+					if (node.textContent?.includes("Showing Decisions:")) seen.count++;
+				}
+			}
+		}).observe(document.body, { childList: true, subtree: true });
+	});
+	let routings = () =>
+		page.evaluate(() => (window as unknown as { routings: { count: number } }).routings.count);
+	await ask(page);
+	await expect(decisionsButton(page)).toHaveAttribute("aria-pressed", "true");
+	await expect.poll(routings).toBe(1);
+	await answerAll(page);
+	// The document stays blank: only the once-per-entry latch can stop a second route.
+	await page.getByRole("button", { name: "Document", exact: true }).click();
+	await expect(decisionsButton(page)).toHaveAttribute("aria-pressed", "false");
+	await chatInput(page).click();
+	await ask(page);
+	await expect(decisionsButton(page)).toContainText("3");
+	await expect(decisionsButton(page)).toHaveAttribute("aria-pressed", "false");
+	expect(await routings()).toBe(1);
+});
+
+test("arrow keys shuffle the Decisions deck; reduced motion reorders instantly", async ({ join }) => {
+	let page = await join("ana");
+	await page.emulateMedia({ reducedMotion: "reduce" });
+	await ask(page);
+	await deck(page).getByRole("button", { name: "Next decision" }).focus();
+	await page.keyboard.press("ArrowRight");
+	await expect(top(page).getByRole("heading", { name: "What belongs in the first cut?" }))
+		.toBeVisible();
+	expect(await deck(page).evaluate(element => element.getAnimations({ subtree: true }).length))
+		.toBe(0);
+	await expect(deck(page).getByRole("status")).toHaveText("Decision 2 of 3: Scope");
+});
+
+test("selecting Decisions resumes at the deck's current top card", async ({ join }) => {
+	let page = await join("ana");
+	await ask(page);
+	await deck(page).getByRole("button", { name: "Next decision" }).click();
+	await page.getByRole("button", { name: "Document", exact: true }).click();
+	await decisionsButton(page).click();
+	await expect(top(page)).toBeFocused();
+	await expect(top(page).getByRole("heading", { name: "What belongs in the first cut?" }))
+		.toBeVisible();
+});
diff --git a/e2e/harness/fake-harness.ts b/e2e/harness/fake-harness.ts
index e74fd52e1..5eaa81fed 100644
--- a/e2e/harness/fake-harness.ts
+++ b/e2e/harness/fake-harness.ts
@@ -23,6 +23,13 @@ const SLOW_PROMPT = "SLOW-LIVE";
 const COMMENT_THREAD = /using thread ([0-9A-HJKMNP-TV-Z]{26})/;
 /** A comment saying this is answered only in Chat, so the server's backstop posts it. */
 const BACKSTOP_PROMPT = "COMMENT-BACKSTOP";
+/** Makes the fake Planner ask three decisions, appended without linked prose. */
+const ASK_PROMPT = "ASK-DECISIONS";
+const ASKED = [
+	{ header: "Storage", question: "Where should room state live?" },
+	{ header: "Scope", question: "What belongs in the first cut?" },
+	{ header: "Rollout", question: "How should we deploy?" },
+];
 const STEP_MS = 2_500;
 
 function promptText(prompt: HarnessV1PromptTurnOptions["prompt"]): string {
@@ -171,6 +178,34 @@ export function createFakeHarness(
 								turn.abortSignal?.removeEventListener("abort", onAbort);
 							}
 						})();
+					} else if (prompt.includes(ASK_PROMPT)) {
+						void (async () => {
+							try {
+								if (!available.has("ask")) throw new Error("e2e-fake harness expected ask");
+								let plan = await callTool("read_plan");
+								let revision = (JSON.parse(String(plan.output)) as { revision: number }).revision;
+								// The turn stays open until people answer, as a real ask does.
+								await callTool("ask", crypto.randomUUID(), {
+									revision,
+									questions: ASKED.map(item => ({
+										...item,
+										multiple: false,
+										blocks: [],
+										options: [
+											{ label: "First option", description: "" },
+											{ label: "Second option", description: "" },
+										],
+									})),
+								});
+								finish();
+								settled.resolve();
+							} catch (err) {
+								turn.emit({ type: "error", error: err });
+								settled.reject(err);
+							} finally {
+								turn.abortSignal?.removeEventListener("abort", onAbort);
+							}
+						})();
 					} else if (prompt.includes(SLOW_PROMPT)) {
 						void (async () => {
 							try {
diff --git a/e2e/inline-decision-deck.e2e.ts b/e2e/inline-decision-deck.e2e.ts
index a17a68f36..5f764a4d6 100644
--- a/e2e/inline-decision-deck.e2e.ts
+++ b/e2e/inline-decision-deck.e2e.ts
@@ -7,6 +7,10 @@ function deck(page: Page) {
 	return page.locator('[data-document-view="plan"] [data-deck]');
 }
 
+function slotOf(page: Page, id: string) {
+	return page.locator(`[data-document-view="plan"] [data-deck-slot="${id}"]`);
+}
+
 function top(page: Page) {
 	return deck(page).locator("[data-deck-top]");
 }
@@ -35,7 +39,7 @@ type Frame = { at: number; y: number; layer: number; opacity: number };
 
 /** Sample a card's shuffle at fractions of its duration, then let it finish. */
 async function sampleShuffle(page: Page, id: string, fractions: number[]) {
-	let slot = page.locator(`[data-deck-slot="${id}"]`);
+	let slot = slotOf(page, id);
 	await expect.poll(() =>
 		slot.evaluate(element => element.getAnimations().some(item => item.id === "deck-shuffle"))
 	).toBe(true);
@@ -196,7 +200,7 @@ test("an answered decision settles to the back and focus follows the new top", a
 	await expect(top(page)).toBeFocused();
 	// The answered card went to the back, and the rest moved up one place each.
 	await expect.poll(() => order(page)).toEqual([fixture.ids[1], fixture.ids[2], fixture.ids[0]]);
-	await expect(page.locator(`[data-deck-slot="${fixture.ids[0]}"]`)).toHaveAttribute(
+	await expect(slotOf(page, fixture.ids[0]!)).toHaveAttribute(
 		"data-deck-settled",
 		"",
 	);
@@ -234,7 +238,7 @@ test("a collaborator's answer to my top card settles it and leaves my focus alon
 	await expect(top(ana).getByRole("heading", { name: fixture.prompts[1] })).toBeVisible();
 	await expect(deck(ana).getByText("1 of 3 · 1 decided")).toBeVisible();
 	await expect.poll(() => order(ana)).toEqual([fixture.ids[1], fixture.ids[2], fixture.ids[0]]);
-	await expect(ana.locator(`[data-deck-slot="${fixture.ids[0]}"]`)).toHaveAttribute(
+	await expect(slotOf(ana, fixture.ids[0]!)).toHaveAttribute(
 		"data-deck-settled",
 		"",
 	);
@@ -262,9 +266,11 @@ test("showing a back decision from Decisions brings it to the top and focuses it
 	await expect.poll(() => order(page)).toEqual(fixture.ids);
 
 	await page.getByRole("button", { name: /^Decisions/ }).click();
-	let card = page.locator(
-		'[data-document-view="decisions"] article[data-plan-sidecar-questionnaire]',
-	)
+	// The Decisions tab is a deck too; bring the anchored card to its top first.
+	let decisionsDeck = page.locator('[data-document-view="decisions"] [data-deck]');
+	await decisionsDeck.getByRole("button", { name: "Next decision" }).click();
+	await decisionsDeck.getByRole("button", { name: "Next decision" }).click();
+	let card = decisionsDeck.locator("[data-deck-top] article[data-plan-sidecar-questionnaire]")
 		.filter({ hasText: fixture.prompts[2]! });
 	await card.getByRole("button", { name: /show in document/i }).click();
 
diff --git a/e2e/playwright.config.ts b/e2e/playwright.config.ts
index a644137d2..53667ad09 100644
--- a/e2e/playwright.config.ts
+++ b/e2e/playwright.config.ts
@@ -170,6 +170,7 @@ export default defineConfig({
 				"**/sidecar.e2e.ts",
 				"**/harness.e2e.ts",
 				"**/harness-comments.e2e.ts",
+				"**/harness-decisions-deck.e2e.ts",
 				"**/auth-lifecycle.e2e.ts",
 			],
 			use: { ...devices["Desktop Chrome"], baseURL: `http://${HOST}:${PLAIN}` },
@@ -195,7 +196,11 @@ export default defineConfig({
 		},
 		{
 			name: "harness",
-			testMatch: ["**/harness.e2e.ts", "**/harness-comments.e2e.ts"],
+			testMatch: [
+				"**/harness.e2e.ts",
+				"**/harness-comments.e2e.ts",
+				"**/harness-decisions-deck.e2e.ts",
+			],
 			use: { ...devices["Desktop Chrome"], baseURL: `http://${HOST}:${HARNESS}` },
 		},
 		{
diff --git a/e2e/sidebar-decision-counts.e2e.ts b/e2e/sidebar-decision-counts.e2e.ts
index 1938a70a0..064b8abc1 100644
--- a/e2e/sidebar-decision-counts.e2e.ts
+++ b/e2e/sidebar-decision-counts.e2e.ts
@@ -801,7 +801,11 @@ test("deleting an archived child updates the project total for a viewer in its p
 		let viewer = await join(`parent-viewer-${room.slice(0, 8)}`);
 		await addProject(viewer, baseURL!, ARCHIVED_CHILD);
 		await viewer.goto(parentPath);
-		await expect(content(viewer)).toHaveAttribute("aria-readonly", "true");
+		// A blank parent with open decisions opens on Decisions, so only wait for the room.
+		await expect(viewer.getByRole("button", { name: /^Decisions/, pressed: true }).first())
+			.toBeVisible();
+		await expect(viewer.getByRole("textbox", { name: "editable markdown", includeHidden: true }))
+			.toHaveAttribute("aria-readonly", "true");
 		await expect(viewer).toHaveURL(new RegExp(`${parentPath}$`));
 		let baseline = await catalogueTotal(viewer, ARCHIVED_CHILD.name);
 		let projects = sidebar(viewer);
diff --git a/e2e/sidecar-card-states.e2e.ts b/e2e/sidecar-card-states.e2e.ts
index f10e63876..881e3f04c 100644
--- a/e2e/sidecar-card-states.e2e.ts
+++ b/e2e/sidecar-card-states.e2e.ts
@@ -1,6 +1,7 @@
 /** Browser coverage for decision card lifecycle states and metadata regrouping. */
 
 import { authenticate, content, expect, roomPath, test } from "./room";
+import { bringForward, deckSlot } from "./decision-deck-fixtures";
 import { expectNoHorizontalOverflow } from "./responsive";
 
 import type { Question } from "../packages/protocol/index";
@@ -86,6 +87,15 @@ test("discarding an open card moves it into a collapsed, persistent resolved his
 	await expect(card.getByText("Discard this decision?", { exact: true })).toBeVisible();
 	await card.getByRole("button", { name: "Discard", exact: true }).click();
 
+	// Discarded in this visit, it waits behind the open decision rather than leaving.
+	let slot = deckSlot(page, "Where should room state live?");
+	await expect(slot).toHaveAttribute("data-deck-settled", "");
+	await expect(slot).not.toHaveAttribute("data-deck-top");
+	await expect(slot).toContainText("Discarded by @ana");
+	await expect(page.getByRole("button", { name: /resolved$/ })).toHaveCount(0);
+
+	await page.reload();
+	await page.getByRole("button", { name: /^Decisions/ }).click();
 	await expect(
 		page.locator(`[data-document-view="decisions"] [data-plan-sidecar-questionnaire="${cardId}"]`),
 	)
@@ -116,22 +126,19 @@ test("discarding a decided card records the person who discarded it", async ({ j
 
 	await card(ana).getByText("In SQLite", { exact: true }).click();
 	await card(ana).getByRole("button", { name: "Save", exact: true }).click();
-	await expect(ben.getByRole("button", { name: "1 resolved" })).toBeVisible();
-	await ben.getByRole("button", { name: "1 resolved" }).click();
+	// Ben saw it open, so the decided card waits at the back of his deck.
+	await expect(deckSlot(ben, "Where should room state live?"))
+		.toHaveAttribute("data-deck-settled", "");
+	await bringForward(ben, "Where should room state live?");
 	await card(ben).getByRole("button", { name: "Discard", exact: true }).click();
 	await card(ben).getByRole("button", { name: "Discard decision" }).click();
 
-	await expect(ben.getByRole("button", { name: "1 resolved" }))
-		.toHaveAttribute("aria-expanded", "true");
 	let discardedCard = cardByPrompt(ben, "Where should room state live?");
 	await expect(discardedCard).toContainText("Discarded by @ben");
 	await expect(discardedCard).not.toContainText("Discarded by @ana");
 	await ben.reload();
 	await ben.getByRole("button", { name: /^Decisions/ }).click();
-	await expect(ben.getByRole("button", { name: "1 resolved" })).toHaveAttribute(
-		"aria-expanded",
-		"true",
-	);
+	await ben.getByRole("button", { name: "1 resolved" }).click();
 	await expect(cardByPrompt(ben, "Where should room state live?"))
 		.toContainText("Discarded by @ben");
 });
@@ -149,12 +156,15 @@ test("reopening a decision shares a fresh draft and a later Save survives reload
 
 	await card(ana).getByText("In SQLite", { exact: true }).click();
 	await card(ana).getByRole("button", { name: "Save", exact: true }).click();
-	await ana.getByRole("button", { name: "1 resolved" }).click();
+	await expect(deckSlot(ana, "Where should room state live?"))
+		.toHaveAttribute("data-deck-settled", "");
+	await bringForward(ana, "Where should room state live?");
 	let selected = card(ana).locator(".question-option[data-selected]");
 	await expect(selected).toHaveCount(1);
 	await expect(selected).toContainText("In SQLite");
 	await expect(card(ana).getByRole("radio")).toHaveCount(0);
 	await card(ana).getByRole("button", { name: "Reopen" }).click();
+	await bringForward(ben, "Where should room state live?");
 
 	for (let page of [ana, ben]) {
 		await expect(card(page).getByText("Previously: In SQLite · @ana")).toBeVisible();
@@ -163,13 +173,11 @@ test("reopening a decision shares a fresh draft and a later Save survives reload
 	await card(ben).getByText("On disk as MDX", { exact: true }).click();
 	await expect(card(ana).getByRole("radio", { name: "On disk as MDX" })).toBeChecked();
 	await card(ben).getByRole("button", { name: "Save", exact: true }).click();
-	await expect(ana.getByRole("button", { name: "1 resolved" })).toBeVisible();
+	await expect(deckSlot(ana, "Where should room state live?"))
+		.toHaveAttribute("data-deck-settled", "");
 	await ana.reload();
 	await ana.getByRole("button", { name: /^Decisions/ }).click();
-	await expect(ana.getByRole("button", { name: "1 resolved" })).toHaveAttribute(
-		"aria-expanded",
-		"true",
-	);
+	await ana.getByRole("button", { name: "1 resolved" }).click();
 	await expect(cardByPrompt(ana, "Where should room state live?"))
 		.toContainText("On disk as MDX");
 });
@@ -235,12 +243,12 @@ test("card metadata regroups Decisions before the document update arrives", asyn
 	await Promise.all([updateHeld, decided]);
 
 	await expect(ben.getByRole("button", { name: "Decisions, 1 unanswered" })).toBeVisible();
-	await expect(
-		questionnaire(ben).filter({
-			has: ben.getByRole("heading", { name: "Which of these belong in the first cut?" }),
-		}),
-	).toBeFocused();
-	await ben.getByRole("button", { name: "1 resolved" }).click();
+	// The deck moves the decided card behind and hands focus to the next open one.
+	await expect(deckSlot(ben, "Which of these belong in the first cut?")).toBeFocused();
+	// Its prompt arrives with the held document update, so find its slot by id.
+	await ben.getByRole("button", { name: "Next decision" }).click();
+	await expect(ben.locator(`[data-document-view="decisions"] [data-deck-slot="${questionId}"]`))
+		.toHaveAttribute("data-deck-top", "");
 	let decidedCard = ben.locator(
 		`[data-document-view="decisions"] article[data-plan-sidecar-questionnaire="${questionId}"]`,
 	);
diff --git a/e2e/sidecar.e2e.ts b/e2e/sidecar.e2e.ts
index 62c814172..ee839d2a0 100644
--- a/e2e/sidecar.e2e.ts
+++ b/e2e/sidecar.e2e.ts
@@ -13,6 +13,7 @@ import { chatInput, expectChatValue } from "./chat-input";
  */
 
 import { authenticate, content, edit, expect, ready, roomPath, test } from "./room";
+import { bringForward, deckSeed, deckSlot } from "./decision-deck-fixtures";
 import { storedQuestion } from "../apps/server/src/testing/plan";
 
 import type { Locator, Page } from "@playwright/test";
@@ -285,29 +286,44 @@ test(
 );
 
 test(
-	"an unseeded document keeps linked questions inline and reveals them in Decisions",
+	"an unseeded document opens its Planner questions in Decisions",
 	async ({ baseURL, page, room }) => {
 		await authenticate(page, "ana", baseURL!);
 		await page.goto(roomPath(room));
-		await ready(page);
 		let decisions = page.getByRole("button", { name: /^Decisions/ });
-		await expect(decisions).toHaveAttribute("aria-pressed", "false");
-		await expect(page.getByRole("button", { name: "Document", exact: true }))
-			.toHaveAttribute("aria-pressed", "true");
-		await expect(content(page).locator("article[data-plan-sidecar-questionnaire]"))
-			.toHaveCount(2);
-		await decisions.click();
 		await expect(decisions).toHaveAttribute("aria-pressed", "true");
-		let card = questionnaire(page);
-		await expect(card).toHaveCount(2);
-		await expect(card.getByRole("heading", { name: "Where should room state live?" }))
-			.toBeVisible();
-		await expect(card.getByRole("heading", { name: "Which of these belong in the first cut?" }))
-			.toBeVisible();
-		await expect(card.getByRole("tablist")).toHaveCount(0);
+		await expect(page.getByRole("status").filter({ hasText: "Showing Decisions: 2 to answer" }))
+			.toHaveCount(1);
+		await expect(page.locator('[data-document-view="decisions"] [data-deck]'))
+			.toHaveAttribute("aria-label", "2 open decisions");
+		await page.getByRole("button", { name: "Document", exact: true }).click();
+		await ready(page);
+		await expect(decisions).toHaveAttribute("aria-pressed", "false");
+		await expect(content(page).locator("[data-deck]")).toHaveCount(1);
 	},
 );
 
+test("the Decisions deck label counts only decisions still open", async ({ join, seed }) => {
+	let fixture = deckSeed({ before: "Decisions for the rollout." }, 3);
+	await seed(fixture.source, fixture.state);
+	let page = await join("ana");
+	await page.getByRole("button", { name: /^Decisions/ }).click();
+	let deck = page.locator('[data-document-view="decisions"] [data-deck]');
+	let top = deck.locator("[data-deck-top]");
+	let answerTop = async () => {
+		await top.getByRole("radio").first().check();
+		await top.getByRole("button", { name: "Save", exact: true }).click();
+	};
+	await expect(deck).toHaveAttribute("aria-label", "3 open decisions");
+
+	// An answered card waits at the back of the deck but is no longer open.
+	await answerTop();
+	await expect(deck).toHaveAttribute("aria-label", "2 open decisions");
+	await answerTop();
+	await expect(deck).toHaveAttribute("aria-label", "1 open decision");
+	await expect(deck.locator("[data-deck-slot]")).toHaveCount(3);
+});
+
 test("questions leave the chat pane free of a waiting row", async ({ join, seed }) => {
 	await seed(PROSE);
 	let page = await join("ana");
@@ -431,10 +447,12 @@ test("compact Chat returns to the document after a collaborator adds prose", asy
 		{ timeout: 20_000 },
 	);
 	let nav = ana.getByRole("navigation", { name: "Workspace view" });
+	// A blank document opens in Decisions; choosing Document keeps the reader there.
+	await expect(nav.getByRole("button", { name: "Decisions, 2 unanswered", exact: true }))
+		.toHaveAttribute("aria-current", "page");
+	await nav.getByRole("button", { name: "Document", exact: true }).click();
 	await expect(nav.getByRole("button", { name: "Document", exact: true }))
 		.toHaveAttribute("aria-current", "page");
-	await expect(nav.getByRole("button", { name: "Decisions, 2 unanswered", exact: true }))
-		.toBeVisible();
 	await nav.getByRole("button", { name: /Chat/ }).click();
 
 	let boContext = await browser.newContext({ baseURL, viewport: { width: 1280, height: 800 } });
@@ -497,7 +515,8 @@ for (
 		let decisions = page.getByRole("button", { name: /^Decisions/ });
 		let plan = page.getByRole("button", { name: "Document", exact: true });
 		let stack = page.locator("[data-plan-decisions-scroll]");
-		let first = questionnaire(page).first();
+		// Desktop opens open decisions as a deck; choosing the tab focuses its top.
+		let first = page.locator('[data-document-view="decisions"] [data-deck-top]');
 
 		await decisions.click();
 		if (example.compact) {
@@ -589,13 +608,45 @@ test("decision cards save independently with progressive custom answers", async
 
 	await storage.getByRole("radio", { name: /On disk as MDX/ }).check();
 	await saveStorage.click();
+	// The answered card waits behind the deck's next open decision.
 	await expect(scope).toBeVisible();
-	await expect(scope).toBeFocused();
+	await expect(deckSlot(page, "Which of these belong in the first cut?")).toBeFocused();
+	await expect(deckSlot(page, "Where should room state live?")).toContainText("Answered by @ana");
 	await expect(scope.getByRole("button", { name: "Save", exact: true })).toBeVisible();
 	await expect(scope).not.toContainText("Answered by");
 	await expect(scope.getByRole("checkbox", { name: "Anchors" })).not.toBeChecked();
+	await expect(page.getByRole("button", { name: /resolved$/ })).toHaveCount(0);
+
+	let addRow = scope.getByRole("button", { name: "Add an option" });
+	await addRow.focus();
+	await page.keyboard.press("Enter");
+	let field = scope.getByRole("textbox", { name: "New option" });
+	await expect(field).toBeFocused();
+	let saveScope = scope.getByRole("button", { name: "Save", exact: true });
+	await expect(saveScope).toBeDisabled();
+	await field.press("Escape");
+	await expect(field).toHaveCount(0);
+	await expect(addRow).toBeFocused();
+	await addRow.click();
+	field = scope.getByRole("textbox", { name: "New option" });
+	await field.fill("Only collaborative anchors");
+	await field.press("Enter");
+	// It joins everyone's list as the next lettered row and is not chosen for anyone.
+	let added = scope.getByRole("checkbox", { name: "Only collaborative anchors" });
+	await expect(added).toBeVisible();
+	await expect(added).not.toBeChecked();
+	await expect(scope.locator("label", { hasText: "Only collaborative anchors" })).toContainText(
+		"D",
+	);
+	await expect(addRow).toBeFocused();
+	await expect(saveScope).toBeDisabled();
+	await added.check();
+	await scope.getByRole("checkbox", { name: /^Anchors/ }).check();
+	await saveScope.click();
 
-	let history = page.getByRole("button", { name: "1 resolved" });
+	// With nothing left open, the deck gives way to resolved history.
+	let history = page.getByRole("button", { name: "2 resolved" });
+	await expect(history).toBeVisible();
 	let historyIcon = history.locator("[data-feedback-icon]");
 	await history.hover();
 	await page.evaluate(() => {
@@ -633,6 +684,11 @@ test("decision cards save independently with progressive custom answers", async
 	await expect(resolved).toContainText("On disk as MDX");
 	await expect(resolved).toContainText("Answered by @ana");
 	await expect(resolved.getByRole("button", { name: "Save", exact: true })).toHaveCount(0);
+	let resolvedScope = questionnaire(page).filter({
+		hasText: "Which of these belong in the first cut?",
+	});
+	await expect(resolvedScope).toContainText("Only collaborative anchors");
+	await expect(resolvedScope).toContainText("Answered by @ana");
 	let iconStarts = await page.evaluate(() => {
 		let record = Reflect.get(window, "__feedbackIconTransitions") as { starts: number };
 		return record.starts;
@@ -666,47 +722,13 @@ test("decision cards save independently with progressive custom answers", async
 	).toBe(iconStarts);
 	await expect(history).not.toHaveAttribute("aria-controls");
 	await expect(historyContent).toHaveCount(0);
-
-	let addRow = scope.getByRole("button", { name: "Add an option" });
-	await addRow.focus();
-	await page.keyboard.press("Enter");
-	let field = scope.getByRole("textbox", { name: "New option" });
-	await expect(field).toBeFocused();
-	let saveScope = scope.getByRole("button", { name: "Save", exact: true });
-	await expect(saveScope).toBeDisabled();
-	await field.press("Escape");
-	await expect(field).toHaveCount(0);
-	await expect(addRow).toBeFocused();
-	await addRow.click();
-	field = scope.getByRole("textbox", { name: "New option" });
-	await field.fill("Only collaborative anchors");
-	await field.press("Enter");
-	// It joins everyone's list as the next lettered row and is not chosen for anyone.
-	let added = scope.getByRole("checkbox", { name: "Only collaborative anchors" });
-	await expect(added).toBeVisible();
-	await expect(added).not.toBeChecked();
-	await expect(scope.locator("label", { hasText: "Only collaborative anchors" })).toContainText(
-		"D",
-	);
-	await expect(addRow).toBeFocused();
-	await expect(saveScope).toBeDisabled();
-	await added.check();
-	await scope.getByRole("checkbox", { name: /^Anchors/ }).check();
-	await saveScope.click();
-	let allResolved = page.getByRole("button", { name: "2 resolved" });
-	await expect(allResolved).toBeVisible();
-	await allResolved.click();
-	let resolvedScope = questionnaire(page).filter({
-		hasText: "Which of these belong in the first cut?",
-	});
-	await expect(resolvedScope).toContainText("Only collaborative anchors");
-	await expect(resolvedScope).toContainText("Answered by @ana");
 });
 
 test("Save and Next wait for a chosen answer", async ({ join, seed }) => {
 	await seed(PROSE);
 	let page = await join("ana");
 	await page.getByRole("button", { name: /^Decisions/ }).click();
+	await bringForward(page, "Which of these belong in the first cut?");
 	let card = questionnaire(page).filter({
 		has: page.getByRole("heading", { name: "Which of these belong in the first cut?" }),
 	});
@@ -741,6 +763,7 @@ test("a rejected save is announced as an alert with motion feedback", async ({ j
 	await seed(PROSE);
 	await join("ana");
 	await page.getByRole("button", { name: /^Decisions/ }).click();
+	await bringForward(page, "Which of these belong in the first cut?");
 	let card = questionnaire(page).filter({
 		has: page.getByRole("heading", { name: "Which of these belong in the first cut?" }),
 	});
@@ -883,10 +906,10 @@ test("an option one member adds is shared, durable, and choosable by another", a
 	await chosen.check();
 	await storage(bo).getByRole("button", { name: "Save", exact: true }).click();
 
+	// Each reader saw it open, so the answered card waits behind the open deck.
 	for (let page of [ana, bo]) {
-		await page.getByRole("button", { name: "1 resolved" }).click();
-		await expect(questionnaire(page).filter({ hasText: "Where should room state live?" }))
-			.toContainText("In PostgreSQL");
+		await expect(deckSlot(page, "Where should room state live?")).toContainText("Answered by @bo");
+		await expect(deckSlot(page, "Where should room state live?")).toContainText("In PostgreSQL");
 	}
 });
 
@@ -959,6 +982,7 @@ test("discarding asks first", async ({ join, seed }) => {
 	await seed(PROSE);
 	let page = await join("ana");
 	await page.getByRole("button", { name: /^Decisions/ }).click();
+	await bringForward(page, "Which of these belong in the first cut?");
 	let card = questionnaire(page).filter({
 		has: page.getByRole("heading", { name: "Which of these belong in the first cut?" }),
 	});
diff --git a/packages/editor/src/decision-state.test.ts b/packages/editor/src/decision-state.test.ts
index d7b5a7109..80fd54b44 100644
--- a/packages/editor/src/decision-state.test.ts
+++ b/packages/editor/src/decision-state.test.ts
@@ -3,6 +3,7 @@ import { describe, expect, it } from "bun:test";
 import {
 	advanceDecisionView,
 	countUnanswered,
+	decisionsDeck,
 	documentHasPlanningContent,
 	firstOpenDecision,
 	selectDecisionView,
@@ -116,36 +117,39 @@ describe("decision attention", () => {
 		);
 	});
 
-	it("keeps a chat-linked inline card in Document while Planner questions still open Decisions", () => {
+	it("routes a blank document to Decisions whether or not its cards have threads", () => {
 		let plannerQuestion = entry([undefined]);
 		let conversationQuestion = entry([undefined]);
 		conversationQuestion.value = { ...conversationQuestion.value, thread: "thread-1" };
 		let initial: DecisionViewState = { phase: "initial", preferred: "plan" };
-		let plannerHasContent = documentHasPlanningContent(false, [plannerQuestion]);
-		let conversationHasContent = documentHasPlanningContent(false, [conversationQuestion]);
-
-		expect(visibleDecisionView(
-			initial,
-			plannerHasContent,
-			countUnanswered([plannerQuestion]),
-		)).toBe("decisions");
-		expect(visibleDecisionView(
-			initial,
-			conversationHasContent,
-			countUnanswered([conversationQuestion]),
-		)).toBe("plan");
+		let unanswered = countUnanswered([plannerQuestion, conversationQuestion]);
 
-		let state = advanceDecisionView(
-			initial,
-			plannerHasContent,
-			countUnanswered([plannerQuestion]),
-		);
+		expect(documentHasPlanningContent(false)).toBe(false);
+		expect(visibleDecisionView(initial, false, unanswered)).toBe("decisions");
+		expect(advanceDecisionView(initial, false, unanswered).phase).toBe("forced");
+	});
+
+	it("does not route a reader who is editing the document", () => {
+		let initial: DecisionViewState = { phase: "initial", preferred: "plan" };
+		expect(visibleDecisionView(initial, false, 2, true)).toBe("plan");
+		expect(advanceDecisionView(initial, false, 2, true))
+			.toEqual({ phase: "complete", preferred: "plan" });
+	});
+
+	it("holds forced Decisions while prose arrives and decisions are still open", () => {
+		let state = advanceDecisionView({ phase: "initial", preferred: "plan" }, false, 3);
+		state = advanceDecisionView(state, true, 2);
 		expect(state.phase).toBe("forced");
-		state = advanceDecisionView(
-			state,
-			conversationHasContent,
-			countUnanswered([plannerQuestion, conversationQuestion]),
-		);
+		expect(visibleDecisionView(state, true, 2)).toBe("decisions");
+		state = advanceDecisionView(state, true, 0);
+		expect(state).toEqual({ phase: "complete", preferred: "plan" });
+		expect(visibleDecisionView(state, true, 0)).toBe("plan");
+	});
+
+	it("never routes twice in one entry", () => {
+		let state = advanceDecisionView({ phase: "initial", preferred: "plan" }, false, 1);
+		state = advanceDecisionView(state, true, 0);
+		state = advanceDecisionView(state, false, 3);
 		expect(state).toEqual({ phase: "complete", preferred: "plan" });
 	});
 
@@ -178,6 +182,22 @@ describe("decision attention", () => {
 		},
 	);
 
+	it("keeps a forced view when nothing is unanswered and no prose exists", () => {
+		let state = advanceDecisionView({ phase: "initial", preferred: "plan" }, false, 2);
+
+		state = advanceDecisionView(state, false, 0);
+
+		expect(state.phase).toBe("forced");
+		expect(visibleDecisionView(state, false, 0)).toBe("decisions");
+	});
+
+	it("ignores editing once the opening is forced", () => {
+		let state = advanceDecisionView({ phase: "initial", preferred: "plan" }, false, 2);
+
+		expect(advanceDecisionView(state, false, 2, true)).toBe(state);
+		expect(visibleDecisionView(state, false, 2, true)).toBe("decisions");
+	});
+
 	it("lets explicit Document navigation override a forced Decisions opening", () => {
 		let state = advanceDecisionView(
 			{ phase: "initial", preferred: "plan" },
@@ -245,3 +265,25 @@ describe("Decisions opening target", () => {
 		expect(firstOpenDecision([decided, discarded])).toBeUndefined();
 	});
 });
+
+describe("Decisions deck", () => {
+	it("stacks two or more open decisions", () => {
+		expect(decisionsDeck(["a", "b"], ["z"], new Set(["a", "b"])))
+			.toEqual({ deck: ["a", "b"], answered: [], history: ["z"] });
+	});
+
+	it("keeps decisions answered here at the back while one is still open", () => {
+		expect(decisionsDeck(["b"], ["a", "z"], new Set(["a", "b"])))
+			.toEqual({ deck: ["b", "a"], answered: ["a"], history: ["z"] });
+	});
+
+	it("dissolves once nothing is open", () => {
+		expect(decisionsDeck([], ["a", "b"], new Set(["a", "b"])))
+			.toEqual({ deck: [], answered: [], history: ["a", "b"] });
+	});
+
+	it("shows one reopened decision on its own", () => {
+		expect(decisionsDeck(["r"], ["z"], new Set(["r"])))
+			.toEqual({ deck: [], answered: [], history: ["z"] });
+	});
+});
diff --git a/packages/editor/src/decision-state.ts b/packages/editor/src/decision-state.ts
index fc58d9126..82293a505 100644
--- a/packages/editor/src/decision-state.ts
+++ b/packages/editor/src/decision-state.ts
@@ -37,26 +37,35 @@ export function firstOpenDecision(
 	});
 }
 
-/** A conversation-linked card is authored document content even before prose exists. */
-export function documentHasPlanningContent(
-	hasPlanProse: boolean,
-	entries: QuestionnaireEntry[],
-): boolean {
-	return hasPlanProse || entries.some(entry => !!entry.value.thread);
+/**
+ * Only prose makes a document more than its questions. A card, even one linked
+ * to a conversation, is a question waiting for an answer, and a blank page full
+ * of them belongs in Decisions.
+ */
+export function documentHasPlanningContent(hasPlanProse: boolean): boolean {
+	return hasPlanProse;
 }
 
-/** A forced opening yields to Plan only when prose first arrives. */
+/**
+ * The opening phase routes a blank document to Decisions once per entry.
+ *
+ * Editing declines routing for good: moving someone mid-thought costs more
+ * than one extra click. A forced view holds until prose exists and nothing is
+ * left to answer, so a Planner heading cannot pull the reader out mid-deck.
+ */
 export function advanceDecisionView(
 	state: DecisionViewState,
 	hasPlanContent: boolean,
 	unanswered: number,
+	editing = false,
 ): DecisionViewState {
 	if (state.phase === "complete") return state;
 	if (state.phase === "forced") {
-		return hasPlanContent ? { phase: "complete", preferred: "plan" } : state;
+		return hasPlanContent && unanswered === 0 ? { phase: "complete", preferred: "plan" } : state;
 	}
 	if (hasPlanContent) return { ...state, phase: "complete" };
-	return unanswered > 0 ? { ...state, phase: "forced" } : state;
+	if (unanswered === 0) return state;
+	return editing ? { ...state, phase: "complete" } : { ...state, phase: "forced" };
 }
 
 export function selectDecisionView(
@@ -70,8 +79,31 @@ export function visibleDecisionView(
 	state: DecisionViewState,
 	hasPlanContent: boolean,
 	unanswered: number,
+	editing = false,
 ): DecisionView {
-	if (state.phase === "forced") return hasPlanContent ? "plan" : "decisions";
-	if (state.phase === "initial" && !hasPlanContent && unanswered > 0) return "decisions";
+	if (state.phase === "forced") {
+		return hasPlanContent && unanswered === 0 ? "plan" : "decisions";
+	}
+	if (state.phase === "initial" && !hasPlanContent && unanswered > 0 && !editing) {
+		return "decisions";
+	}
 	return state.preferred;
 }
+
+/** Which Decisions cards form a deck, and which stay in resolved history below it. */
+export function decisionsDeck(
+	pending: readonly string[],
+	settled: readonly string[],
+	seen: ReadonlySet<string>,
+): { deck: string[]; answered: string[]; history: string[] } {
+	let answered = pending.length > 0 ? settled.filter(id => seen.has(id)) : [];
+	if (pending.length + answered.length < 2) {
+		return { deck: [], answered: [], history: [...settled] };
+	}
+	let kept = new Set(answered);
+	return {
+		deck: [...pending, ...answered],
+		answered,
+		history: settled.filter(id => !kept.has(id)),
+	};
+}
diff --git a/packages/editor/src/decisions.test.tsx b/packages/editor/src/decisions.test.tsx
index bae05d025..e66aee64d 100644
--- a/packages/editor/src/decisions.test.tsx
+++ b/packages/editor/src/decisions.test.tsx
@@ -83,7 +83,7 @@ test("an expired card is listed with the resolved cards and says nobody answered
 		},
 	};
 	let history = markup("true", [expired, RESOLVED]);
-	expect(history).toMatch(/<span class="tabular-nums">2<\/span><span>resolved<\/span>/);
+	expect(history).toContain('<span class="tabular-nums">2 resolved</span>');
 	expect(history).toContain('data-plan-sidecar-questionnaire="expired"');
 	expect(history).toContain("Ship the migration?");
 	expect(history).toContain(
@@ -108,3 +108,26 @@ test("a failed document open offers a retry instead of indefinite loading", () =
 	expect(failed).toContain("Try again");
 	expect(failed).not.toContain("Loading decisions…");
 });
+
+function openEntry(id: string, header: string): QuestionnaireEntry {
+	return {
+		id,
+		value: {
+			id,
+			questions: [{ id: `${id}-q`, header, prompt: `${header}?`, multiple: false, options: [] }],
+		},
+	};
+}
+
+test("two open decisions render as a desktop deck above resolved history", () => {
+	let html = markup(undefined, [openEntry("a", "Storage"), openEntry("b", "Scope"), RESOLVED]);
+	expect(html).toContain('aria-roledescription="carousel"');
+	expect(html).toContain('aria-label="2 open decisions"');
+	expect(html).toContain("1 of 2");
+	expect(html.indexOf("data-deck=")).toBeLessThan(html.indexOf("resolved</span>"));
+	expect(html).not.toContain("decision-save-bar");
+});
+
+test("one open decision renders without a deck", () => {
+	expect(markup(undefined, [openEntry("a", "Storage")])).not.toContain("data-deck");
+});
diff --git a/packages/editor/src/decisions.tsx b/packages/editor/src/decisions.tsx
index cf2db2ab5..04dfce862 100644
--- a/packages/editor/src/decisions.tsx
+++ b/packages/editor/src/decisions.tsx
@@ -11,6 +11,8 @@ import { cardStatus } from "@chopin/dialect";
 import { CheckIcon, ChevronIcon, DecisionIcon } from "@chopin/icons";
 import { EmptyState } from "@chopin/visuals";
 
+import { decisionsDeck } from "./decision-state";
+import { Deck, revealDeckItem } from "./deck";
 import { MotionDisclosure, MotionDisclosureIcon } from "./disclosure-motion";
 import { usePhone } from "./pointer";
 import { useQuestionnaires } from "./questionnaires";
@@ -49,8 +51,10 @@ export type DecisionsProps = {
 	 *
 	 * Carries a token as well as an id so asking for the same one twice still
 	 * scrolls — naming it again means "show me", not "it is already open".
+	 * `resume` means the tab itself was chosen: a deck keeps its current top
+	 * rather than bringing the named card forward.
 	 */
-	reveal?: { widget: string; token: number };
+	reveal?: { widget: string; token: number; resume?: boolean };
 };
 
 let EMPTY_CARDS: ReadonlyMap<string, Question.CardMeta> = new Map();
@@ -260,9 +264,12 @@ export function Decisions(
 			`[data-plan-sidecar-questionnaire="${id}"]`,
 		);
 		if (target) {
-			target.scrollIntoView({ block: "center" });
-			target.tabIndex = -1;
-			target.focus({ preventScroll: true });
+			let inDeck = target.closest<HTMLElement>("[data-deck]");
+			if (inDeck && !reveal.resume) revealDeckItem(target);
+			let focusTarget = inDeck?.querySelector<HTMLElement>("[data-deck-top]") ?? target;
+			focusTarget.scrollIntoView({ block: "center" });
+			focusTarget.tabIndex = -1;
+			focusTarget.focus({ preventScroll: true });
 		} else heading.current?.focus();
 	}, [entries, metadata, reveal]);
 
@@ -273,11 +280,15 @@ export function Decisions(
 		if (!previous || previous.isConnected || document.activeElement !== document.body) return;
 		focusedQuestionnaire.current = undefined;
 		let next = entries.find(entry => waiting(entry, metadata));
-		let target = next
+		let card = next
 			? content.current?.querySelector<HTMLElement>(
 				`[data-plan-sidecar-questionnaire="${CSS.escape(next.id)}"]`,
 			)
 			: undefined;
+		// A card behind a deck's top is inert, so the deck's top takes focus instead.
+		let target = card?.closest<HTMLElement>("[data-deck]")?.querySelector<HTMLElement>(
+			"[data-deck-top]",
+		) ?? card;
 		if (target) {
 			target.tabIndex = -1;
 			target.focus({ preventScroll: true });
@@ -332,7 +343,7 @@ export function Decisions(
 			following.current = undefined;
 		};
 	}, []);
-	let leaveSaveBar = useCallback(() => {
+	let focusRemaining = useCallback(() => {
 		let next = content.current?.querySelector<HTMLElement>(
 			"[data-plan-sidecar-questionnaire]",
 		);
@@ -351,9 +362,29 @@ export function Decisions(
 	let pending = entries.filter(entry => open.has(entry.id) || closing.has(entry.id));
 	let settled = entries.filter(entry => !open.has(entry.id) && !closing.has(entry.id));
 
+	// Cards open at some point in this mount, so one answered here waits in the deck.
+	let [seen, setSeen] = useState<ReadonlySet<string>>(() => new Set());
+	let openKey = [...open].join("\n");
+	useEffect(() => {
+		if ([...open].every(id => seen.has(id))) return;
+		setSeen(previous => new Set([...previous, ...open]));
+		// `openKey` stands for `open`, which is rebuilt every render.
+	}, [openKey]);
+	// Phones keep the one-pane list and its save bar.
+	let arranged = phone
+		? { deck: [], answered: [], history: settled.map(entry => entry.id) }
+		: decisionsDeck(
+			pending.map(entry => entry.id),
+			settled.map(entry => entry.id),
+			new Set([...seen, ...open]),
+		);
+	let byId = new Map(entries.map(entry => [entry.id, entry]));
+	let answeredHere = new Set(arranged.answered);
+	let listed = settled.filter(entry => !answeredHere.has(entry.id));
+
 	let outstanding = pending.length;
-	// A folding card already counts as resolved, so this agrees with the tab's badge.
-	let resolved = settled.length + closing.size;
+	// Settled cards not waiting in the deck; a folding card already counts as resolved.
+	let resolved = listed.length + closing.size;
 	let empty = outstanding === 0 && resolved === 0 && !hasAdditional;
 
 	let question = (entry: QuestionnaireEntry) => (
@@ -438,6 +469,24 @@ export function Decisions(
 							/>
 						</>
 					)
+					: arranged.deck.length > 0
+					? (
+						<Deck
+							label={`${pending.length} open ${pending.length === 1 ? "decision" : "decisions"}`}
+							onLeave={() => focusRemaining()}
+							items={arranged.deck.flatMap(id => {
+								let entry = byId.get(id);
+								return entry
+									? [{
+										id,
+										settled: answeredHere.has(id),
+										label: entry.value.questions[0]?.header ?? "Decision",
+										card: question(entry),
+									}]
+									: [];
+							})}
+						/>
+					)
 					: (
 						<div className="flex flex-col gap-3">
 							{pending.map(entry => {
@@ -472,8 +521,7 @@ export function Decisions(
 								open={history}
 								opened={<ChevronIcon className="rotate-90" size={14} />}
 							/>
-							<span className="tabular-nums">{resolved}</span>
-							<span>resolved</span>
+							<span className="tabular-nums">{`${resolved} resolved`}</span>
 						</button>
 						<MotionDisclosure
 							className="plan-decision-history-motion"
@@ -484,7 +532,7 @@ export function Decisions(
 							surface="decision-history"
 						>
 							<div className="mt-2 flex flex-col gap-3">
-								{settled.map(question)}
+								{listed.map(question)}
 							</div>
 						</MotionDisclosure>
 					</div>
@@ -493,7 +541,7 @@ export function Decisions(
 			{phone && (
 				<SaveBar
 					onFailed={showCard}
-					onFocusLeave={leaveSaveBar}
+					onFocusLeave={focusRemaining}
 					onIncomplete={showCard}
 					store={pendingAnswers}
 				/>
diff --git a/packages/editor/src/index.ts b/packages/editor/src/index.ts
index 90a459739..d255c7b48 100644
--- a/packages/editor/src/index.ts
+++ b/packages/editor/src/index.ts
@@ -14,6 +14,7 @@ export type { Cursor } from "./cursor";
 export {
 	advanceDecisionView,
 	countUnanswered,
+	decisionsDeck,
 	documentHasPlanningContent,
 	firstOpenDecision,
 	selectDecisionView,