diff --git a/.changeset/fn-8442-planning-sequential-qa.md b/.changeset/fn-8442-planning-sequential-qa.md
new file mode 100644
index 0000000000..bef2715760
--- /dev/null
+++ b/.changeset/fn-8442-planning-sequential-qa.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": minor
+---
+
+summary: Simplify Planning Mode to a sequential Q&A and plan-review flow with focus-steered refine.
+category: feature
+dev: Replaces three-pane interview with question → plan_review → refine/validate; refine accepts optional focus text; Validate creates the task; create-task is idempotent per planning session.
diff --git a/MOBILE.md b/MOBILE.md
index 64a4daad93..01610d8360 100644
--- a/MOBILE.md
+++ b/MOBILE.md
@@ -101,7 +101,7 @@ gesture delivery enabled across `cap sync` regenerations.
 
 ### Planning Mode
 
-Planning Mode opens directly into the composer pane on mobile when no planning sessions exist, avoiding an empty-sidebar dead end. Desktop keeps its three-pane interview (answered history, current question, and running plan) when there is room. Mobile, phone-class short landscape, and tablet use a progressive interview: **Question** is the default full-width surface, while labeled **Running plan** and **Answered questions** controls switch to those surfaces without stacking three panes. On mobile, opening Planning with saved sessions lands on the full-pane, scrollable saved-session list with **New session** as its footer; **Running plan** appears only after you intentionally open a session and select its tab. **Sessions** and the mobile back control always return to that list. The same escape is available from interview, summary, breakdown, and a new-session composer when saved sessions exist; **Validate plan** remains on the Running plan surface.
+Planning Mode opens directly into the composer pane on mobile when no planning sessions exist, avoiding an empty-sidebar dead end. Every viewport uses the same sequential surface: idea, one question, then plan review. Plan review provides an optional focus field followed by **Refine** and **Validate**; refine asks the next question and validate creates the task. There is no three-pane interview or Question/Running plan/Answered questions tab switcher. On mobile, opening Planning with saved sessions lands on the full-pane, scrollable saved-session list with **New session** as its footer. **Sessions** and the mobile back control always return to that list, including from plan review and create retry.
 
 ### Chat and Quick Chat mobile scroll/readability behavior
 
diff --git a/docs/dashboard-guide.md b/docs/dashboard-guide.md
index 15d7d9f682..dc14110582 100644
--- a/docs/dashboard-guide.md
+++ b/docs/dashboard-guide.md
@@ -523,18 +523,17 @@ Planning is a desktop/tablet left-sidebar main-content destination after **Comma
 When a Planning session needs your input or needs attention, open the docked Planning view from the **Planning** navigation item. Its yellow needs-input dot is visible on the desktop left sidebar and mobile More controls. Non-planning in-progress, needs-input, and error sessions appear in the session notification banner, where available Resume actions reconnect to their matching surface.
 
 <!-- FNXC:PlanningRetry 2026-07-15-00:00: FN-8332 confines automatic Planning Mode retry to failures observed by an active in-session SSE/poll turn. Browser reload or session resume must restore the persisted progress/error verbatim and leave retry as an explicit user choice. -->
-When an active Planning AI generation appears stuck, Planning Mode automatically retries the same session up to three times and shows **Retrying… (attempt N of 3)** before falling back to the permanent **Retry**/**Dismiss** error panel. Any successful question or summary progress resets the automatic retry budget. Leaving Planning—including while a next question is generating—and returning restores the last active interview for that project: a generation reconnects with its saved thinking, while a turn that completed while away shows its new question and running plan. Reopening or reloading a saved Planning session restores its saved question, summary, thinking, or error without starting another generation; choose **Retry** explicitly from a restored error panel if you want to run it again.
+When an active Planning AI generation appears stuck, Planning Mode automatically retries the same session up to three times and shows **Retrying… (attempt N of 3)** before falling back to the permanent **Retry**/**Dismiss** error panel. Any successful question or summary progress resets the automatic retry budget. Leaving Planning—including while a plan update or refined question is generating—and returning restores the last active interview for that project. Reopening or reloading a saved Planning session restores its saved question, plan review, thinking, or error without starting another generation; choose **Retry** explicitly from a restored error panel if you want to run it again.
 
 <!-- FNXC:PlanningMode 2026-07-19-15:55: FN-8400 replaces the duplicate prompt-recovery controls with a focused three-pane interview; restarting remains a deliberate New session action. -->
 Use **New session** to restart planning with a different idea.
 
 Planning Mode uses the selected workflow's `planning` seam—the same triage template used for newly added tasks—as its quality bar, then layers the user-controlled interview adapter on top. An explicitly configured `planning-system` prompt override replaces that full system prompt.
 
-<!-- FNXC:PlanningMode 2026-07-18-16:00: Planning Mode is an infinite, user-controlled interview. Each answer updates the running plan and produces another context-aware high-impact question; only Validate plan finalizes it. -->
-<!-- FNXC:PlanningMode 2026-07-20-12:42: FN-8438 requires the first AI turn to draft the running plan from the operator idea, then refine that work product after every answer instead of showing an interview transcript. -->
-Planning Mode keeps the running plan visible beside answered-question history and the current question on desktop; the AI drafts its title, description, and concrete deliverables from your idea, then refines them after each answer. It is an evolving work product, not a transcript or list of interview questions. You can rename a session and keep asking high-impact, context-aware questions until you choose **Validate plan**. On tablet, mobile, and phone-class short landscape, the interview switches between labeled **Question**, **Running plan**, and **Answered questions** surfaces so the current question stays usable instead of competing with three columns. On mobile, Planning opens to the full-pane, scrollable saved-session list when sessions exist; **Running plan** appears only after you intentionally open a session and choose its tab. **Sessions** (and mobile Back) return to that list with **New session** pinned as its footer. This escape remains available from interview, summary, breakdown, and a new-session composer whenever saved sessions exist, while **Validate plan** remains available on the Running plan surface. The running title, description, and deliverables are available throughout the interview—including while the next question is generating or a recoverable error is shown. The AI never ends an interview on its own. Selection questions provide alternatives with pros and cons plus an **Other** free-text choice, whose wording follows your input language and whose answer steers the next question. You may edit an earlier answer by question ID without losing later answers; Planning re-derives the running plan and appends a fresh next question.
+<!-- FNXC:PlanningMode 2026-07-20-15:45: FN-8442 replaces the simultaneous three-pane interview with a sequential question and plan-review loop. -->
+Planning Mode is a single-surface sequence: enter an idea, answer one AI question, then review the evolving plan. Plan review shows the title, description, and deliverables plus an optional **Focus the next question** field. Choose **Refine** to ask another high-impact question; its optional focus can name a topic such as security or real-time behavior, or specify the next question directly. Answering that question returns to plan review rather than automatically starting another question.
 
-Choose **Validate plan** when the running plan is ready for task creation. Validation is durable and is required before **Create task**, **Create tasks**, or **Start breakdown**; those actions reject unvalidated sessions.
+Choose **Validate** when the plan is ready. Validation is durable and immediately creates the task using the selected workflow and branch settings. If creation is interrupted after validation, Planning restores a create-only retry state; it never validates again or creates a second task. **Sessions** (and mobile Back) remains the escape hatch for browsing, switching, and reviewing session history, with **New session** pinned in the saved-session list. The AI never ends an interview on its own; selection questions still provide alternatives with pros and cons plus an **Other** free-text choice.
 
 <!-- FNXC:PlanningMode 2026-07-20-12:00: FN-8441 separates the lean Planning Mode artifact from triage's executor specification. -->
 On creation, the validated running plan becomes **plan.md**: its title, description, size, suggested dependencies, and key deliverables are stored as the task description and task document `plan` (priority remains a task field, not a plan.md section). The original request that started the session is stored separately as `original-description`. The task planning agent later expands plan.md into the executor-ready **PROMPT.md**; PROMPT.md's **Original Description** preserves that original request verbatim.
diff --git a/packages/core/src/async-ai-session-store.ts b/packages/core/src/async-ai-session-store.ts
index 6ba8a789b8..eaf0acfadd 100644
--- a/packages/core/src/async-ai-session-store.ts
+++ b/packages/core/src/async-ai-session-store.ts
@@ -24,7 +24,7 @@
  * Transition context: these helpers live in @fusion/core (where the schema is
  * defined) and are exported so the dashboard's AiSessionStore can import them.
  */
-import { and, desc, eq, inArray, isNotNull, isNull, lte } from "drizzle-orm";
+import { and, desc, eq, inArray, isNotNull, isNull, lte, sql } from "drizzle-orm";
 import * as schema from "./postgres/schema/index.js";
 import type { AsyncDataLayer, DbTransaction } from "./postgres/data-layer.js";
 
@@ -291,6 +291,86 @@ export async function updateAiSessionStatus(
   return result.length > 0;
 }
 
+/*
+FNXC:PlanningMode 2026-07-20-20:15:
+FN-8442 requires a database compare-and-set before Planning Mode creates a task. The
+never-rotated proposalClaimId prevents duplicate task rows, while this conditional
+ai_sessions transition assigns exactly one live creator across dashboard processes.
+*/
+export async function claimPlanningSessionTaskCreation(
+  handle: QueryHandle,
+  sessionId: string,
+  claimOwnerToken: string,
+  claimStartedAt: string,
+): Promise<AiSessionRow | null> {
+  const existing = await getAiSession(handle, sessionId);
+  if (!existing || existing.type !== "planning") return null;
+  const input = safeJsonParse(existing.inputPayload, {}) as Record<string, unknown>;
+  if (input.validated !== true) return null;
+  const inputPayload = { ...input, createClaimStatus: "creating", claimOwnerToken, claimStartedAt, createdTaskId: undefined };
+  const rows = await handle.update(schema.project.aiSessions)
+    .set({ inputPayload, updatedAt: claimStartedAt })
+    .where(and(
+      eq(schema.project.aiSessions.id, sessionId),
+      eq(schema.project.aiSessions.type, "planning"),
+      sql`coalesce(${schema.project.aiSessions.inputPayload}->>'createClaimStatus', 'none') = 'none'`,
+    ))
+    .returning();
+  return rows[0] ? rowToSession(rows[0]) : null;
+}
+
+/** Finalize only the owner that won claimPlanningSessionTaskCreation. */
+export async function finalizePlanningSessionTaskCreation(
+  handle: QueryHandle,
+  sessionId: string,
+  claimOwnerToken: string,
+  createdTaskId: string,
+): Promise<AiSessionRow | null> {
+  const existing = await getAiSession(handle, sessionId);
+  if (!existing || existing.type !== "planning") return null;
+  const input = safeJsonParse(existing.inputPayload, {}) as Record<string, unknown>;
+  const inputPayload = { ...input, createClaimStatus: "created", createdTaskId, claimOwnerToken: undefined, claimStartedAt: undefined };
+  const rows = await handle.update(schema.project.aiSessions)
+    .set({ inputPayload, updatedAt: new Date().toISOString() })
+    .where(and(eq(schema.project.aiSessions.id, sessionId), sql`${schema.project.aiSessions.inputPayload}->>'claimOwnerToken' = ${claimOwnerToken}`))
+    .returning();
+  return rows[0] ? rowToSession(rows[0]) : null;
+}
+
+/** Reconcile a task created before a process could finalize its session linkage. */
+export async function reconcilePlanningSessionTaskCreation(
+  handle: QueryHandle,
+  sessionId: string,
+  createdTaskId: string,
+): Promise<AiSessionRow | null> {
+  const existing = await getAiSession(handle, sessionId);
+  if (!existing || existing.type !== "planning") return null;
+  const input = safeJsonParse(existing.inputPayload, {}) as Record<string, unknown>;
+  const inputPayload = { ...input, createClaimStatus: "created", createdTaskId, claimOwnerToken: undefined, claimStartedAt: undefined };
+  const rows = await handle.update(schema.project.aiSessions)
+    .set({ inputPayload, updatedAt: new Date().toISOString() })
+    .where(and(eq(schema.project.aiSessions.id, sessionId), eq(schema.project.aiSessions.type, "planning")))
+    .returning();
+  return rows[0] ? rowToSession(rows[0]) : null;
+}
+
+/** Release only an expired creator's transient ownership; the stable task key is unchanged. */
+export async function releasePlanningSessionTaskCreation(
+  handle: QueryHandle,
+  sessionId: string,
+  claimOwnerToken: string,
+): Promise<AiSessionRow | null> {
+  const existing = await getAiSession(handle, sessionId);
+  if (!existing || existing.type !== "planning") return null;
+  const input = safeJsonParse(existing.inputPayload, {}) as Record<string, unknown>;
+  const inputPayload = { ...input, createClaimStatus: "none", claimOwnerToken: undefined, claimStartedAt: undefined };
+  const rows = await handle.update(schema.project.aiSessions)
+    .set({ inputPayload, updatedAt: new Date().toISOString() })
+    .where(and(eq(schema.project.aiSessions.id, sessionId), sql`${schema.project.aiSessions.inputPayload}->>'claimOwnerToken' = ${claimOwnerToken}`))
+    .returning();
+  return rows[0] ? rowToSession(rows[0]) : null;
+}
+
 export async function updateAiSessionTitle(
   handle: QueryHandle,
   id: string,
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 48b474bde6..ede77e0c2c 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -2531,6 +2531,10 @@ export type { Deployment as AsyncDeployment, Incident as AsyncIncident } from ".
 export {
   upsertAiSession,
   getAiSession,
+  claimPlanningSessionTaskCreation,
+  finalizePlanningSessionTaskCreation,
+  reconcilePlanningSessionTaskCreation,
+  releasePlanningSessionTaskCreation,
   listActiveAiSessions,
   listAllAiSessions,
   listRecoverableAiSessions,
diff --git a/packages/core/src/types.ts b/packages/core/src/types.ts
index cec418019a..65d64162b9 100644
--- a/packages/core/src/types.ts
+++ b/packages/core/src/types.ts
@@ -5684,6 +5684,11 @@ export interface PlanningSession {
   summary?: PlanningSummary;
   /** User explicitly validated the continuously maintained running plan. */
   validated?: boolean;
+  /** FNXC:PlanningMode 2026-07-20-15:45: Durable planning-to-task handoff cache; proposalClaimId is the crash-safe authority. */
+  createdTaskId?: string;
+  createClaimStatus?: "none" | "creating" | "created";
+  claimOwnerToken?: string;
+  claimStartedAt?: string;
   /**
    * Optional per-session auto-merge override for tasks planned in this session.
    * Not separately persisted; durable form is a branch_groups row keyed by session id.
diff --git a/packages/dashboard/app/api/legacy.ts b/packages/dashboard/app/api/legacy.ts
index 94174eb658..f6737e2c74 100644
--- a/packages/dashboard/app/api/legacy.ts
+++ b/packages/dashboard/app/api/legacy.ts
@@ -2761,7 +2761,7 @@ export function createTaskFromPlanning(
     workflowId?: string | null;
   },
 ): Promise<Task> {
-  return api<Task>(withProjectId("/planning/create-task", projectId), {
+  return api<{ task: Task; alreadyCreated: boolean }>(withProjectId("/planning/create-task", projectId), {
     method: "POST",
     body: JSON.stringify({
       ...(summary ? { sessionId, summary } : { sessionId }),
@@ -2770,7 +2770,7 @@ export function createTaskFromPlanning(
       ...(options?.branchSelection ? { branchSelection: options.branchSelection } : {}),
       ...(options?.workflowId !== undefined ? { workflowId: options.workflowId } : {}),
     }),
-  });
+  }).then((response) => response.task);
 }
 
 /** Start subtask breakdown from a completed planning session */
diff --git a/packages/dashboard/app/components/PlanningModeModal.css b/packages/dashboard/app/components/PlanningModeModal.css
index 8d4f469643..f1f49c3065 100644
--- a/packages/dashboard/app/components/PlanningModeModal.css
+++ b/packages/dashboard/app/components/PlanningModeModal.css
@@ -539,64 +539,6 @@ The New session button must look EXACTLY like Missions' primary sidebar create b
     flex-direction: column;
   }
 
-  /*
-  FNXC:PlanningModeMobileTablet 2026-07-20-09:30:
-  The compact interview class is shared by width-mobile, tablet, and short CSS shells.
-  Only one interview surface is visible at once, so a short landscape viewport cannot retain
-  desktop's three competing columns. Non-phone short screens use this same class as the explicit
-  mismatch guard for the compound shell query.
-  */
-  .planning-modal-body--compact-interview {
-    flex-direction: column;
-  }
-
-  /*
-  FNXC:PlanningModeCompactSwitcher 2026-07-20-11:00:
-  FN-8445 requires compact interview tabs to remain directly below the Planning header for
-  Question, Running plan, and Answered questions. History renders before the switcher in DOM,
-  so visual flex order pins the shared chrome above its scrollable sibling on mobile and short shells.
-  */
-  .planning-modal-body--compact-interview .planning-compact-pane-switcher {
-    order: -1;
-  }
-
-  .planning-compact-pane-switcher {
-    display: flex;
-    flex: 0 0 auto;
-    gap: var(--space-sm);
-    padding: var(--space-sm) var(--space-md);
-    overflow-x: auto;
-    border-bottom: 1px solid var(--border);
-    background: var(--surface);
-  }
-
-  .planning-compact-pane-switcher .btn {
-    flex: 1 0 auto;
-    min-height: calc(var(--space-md) * 2.25);
-    justify-content: center;
-  }
-
-  .planning-modal-body--compact-interview .planning-sidebar,
-  .planning-modal-body--compact-interview .planning-detail,
-  .planning-modal-body--compact-interview .planning-running-plan {
-    width: 100%;
-    flex: 1 1 auto;
-    min-height: 0;
-    border: 0;
-  }
-
-  .planning-modal-body--compact-interview .planning-running-plan {
-    border-top: 0;
-  }
-
-  .planning-modal-body--compact-question .planning-sidebar,
-  .planning-modal-body--compact-question .planning-running-plan,
-  .planning-modal-body--compact-plan .planning-sidebar,
-  .planning-modal-body--compact-plan .planning-detail,
-  .planning-modal-body--compact-history .planning-detail,
-  .planning-modal-body--compact-history .planning-running-plan {
-    display: none;
-  }
   .planning-sidebar {
     width: 100%;
     border-right: none;
@@ -637,9 +579,7 @@ The New session button must look EXACTLY like Missions' primary sidebar create b
   RunningPlanPane; this selector is a layout backstop for future render paths so session
   rows stay scrollable above the New session footer instead of sharing height with a plan.
   */
-  .planning-modal-body--show-list .planning-detail,
-  .planning-modal-body--show-list .planning-running-plan,
-  .planning-modal-body--show-list .planning-compact-pane-switcher {
+  .planning-modal-body--show-list .planning-detail {
     display: none;
   }
   /* The rendered Back control needs a full touch target and must not be squeezed out of the title row. */
@@ -980,63 +920,6 @@ An empty footer must NOT reserve vertical space or paint its divider band. When
   justify-content: center;
 }
 
-/*
-FNXC:PlanningMode 2026-07-19-12:00:
-The desktop interview is three panes: answered history, a single question editor, and an always-mounted
-running plan. On narrow screens the established detail navigation stacks panes without removing the plan.
-*/
-.planning-running-plan {
-  display: flex;
-  flex: 0 1 24rem;
-  flex-direction: column;
-  gap: var(--space-md);
-  min-width: 0;
-  padding: var(--space-lg);
-  border-left: 1px solid var(--border);
-  background: var(--surface);
-  overflow: auto;
-}
-
-.planning-running-plan h4,
-.planning-running-plan h5 {
-  margin: 0;
-}
-
-/*
-FNXC:PlanningMode 2026-07-19-15:55:
-Answered-history rows are the sole in-session navigation: make each question a full-width, readable
-button so an earlier response can be edited without restoring the retired linear Back control.
-*/
-.planning-answered-history-edit {
-  width: 100%;
-  justify-content: flex-start;
-  gap: var(--space-sm);
-  overflow: hidden;
-  text-align: left;
-}
-
-.planning-answered-history-edit span {
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
-.planning-answered-history-edit.active {
-  border-color: var(--todo);
-  background: var(--card-hover);
-}
-
-.planning-running-plan-content {
-  display: flex;
-  flex: 1;
-  flex-direction: column;
-  gap: var(--space-sm);
-}
-
-.planning-running-plan-content p {
-  white-space: pre-wrap;
-}
-
 /* Question View */
 .planning-question {
   display: flex;
@@ -1518,54 +1401,6 @@ FNXC:PlanningMode 2026-06-25-09:20:
 Tablet embedded Planning keeps the desktop two-pane shell, so the summary footer must absorb the narrower detail pane instead of relying on the mobile full-width stack. Allow the three labeled actions to wrap inside the pane while preserving the desktop left/right grouping when space is available.
 */
 @media (min-width: 769px) and (max-width: 1024px) {
-  /* FNXC:PlanningModeMobileTablet 2026-07-20-09:30: tablet uses the same one-surface interview switcher rather than compressing three fixed panes beside the project navigation. */
-  .planning-modal-body--compact-interview {
-    flex-direction: column;
-  }
-
-  /*
-  FNXC:PlanningModeCompactSwitcher 2026-07-20-11:00:
-  FN-8445 keeps every compact interview pane's shared tabs above Answered questions on tablet,
-  where history otherwise grows before the later DOM sibling in the column.
-  */
-  .planning-modal-body--compact-interview .planning-compact-pane-switcher {
-    order: -1;
-  }
-
-  .planning-compact-pane-switcher {
-    display: flex;
-    flex: 0 0 auto;
-    gap: var(--space-sm);
-    padding: var(--space-sm) var(--space-lg);
-    overflow-x: auto;
-    border-bottom: 1px solid var(--border);
-    background: var(--surface);
-  }
-
-  .planning-compact-pane-switcher .btn {
-    flex: 1 0 auto;
-    min-height: calc(var(--space-md) * 2.25);
-    justify-content: center;
-  }
-
-  .planning-modal-body--compact-interview .planning-sidebar,
-  .planning-modal-body--compact-interview .planning-detail,
-  .planning-modal-body--compact-interview .planning-running-plan {
-    width: 100%;
-    flex: 1 1 auto;
-    min-height: 0;
-    border: 0;
-  }
-
-  .planning-modal-body--compact-question .planning-sidebar,
-  .planning-modal-body--compact-question .planning-running-plan,
-  .planning-modal-body--compact-plan .planning-sidebar,
-  .planning-modal-body--compact-plan .planning-detail,
-  .planning-modal-body--compact-history .planning-detail,
-  .planning-modal-body--compact-history .planning-running-plan {
-    display: none;
-  }
-
   /* FNXC:PlanningModeMobile 2026-07-20-10:30: tablet uses the same compact list destination as phone and short shells, so summary/compose detail cannot remain beside saved session rows. */
   .planning-modal-body--show-list {
     flex: 1;
@@ -1590,9 +1425,7 @@ Tablet embedded Planning keeps the desktop two-pane shell, so the summary footer
     flex-shrink: 0;
   }
 
-  .planning-modal-body--show-list .planning-detail,
-  .planning-modal-body--show-list .planning-running-plan,
-  .planning-modal-body--show-list .planning-compact-pane-switcher {
+  .planning-modal-body--show-list .planning-detail {
     display: none;
   }
 
@@ -2150,10 +1983,3 @@ Tablet embedded Planning keeps the desktop two-pane shell, so the summary footer
 .subtask-item-header--between {
   justify-content: space-between;
 }
-
-.planning-answered-history-response {
-  color: var(--text-muted);
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
diff --git a/packages/dashboard/app/components/PlanningModeModal.tsx b/packages/dashboard/app/components/PlanningModeModal.tsx
index 33ea20ad51..e9f5f26bf8 100644
--- a/packages/dashboard/app/components/PlanningModeModal.tsx
+++ b/packages/dashboard/app/components/PlanningModeModal.tsx
@@ -105,6 +105,10 @@ type ViewState =
   | { type: "initial" }
   | { type: "question"; session: PlanningSession }
   | { type: "summary"; session: PlanningSession; summary: PlanningSummary }
+  | { type: "plan_review"; session: PlanningSession; summary: PlanningSummary }
+  | { type: "creating_task"; session: PlanningSession; summary: PlanningSummary }
+  | { type: "create_retry"; session: PlanningSession; summary: PlanningSummary; errorMessage: string }
+  | { type: "task_created"; taskId: string }
   | { type: "error"; session: PlanningSession; errorMessage: string }
   | { type: "breakdown"; sessionId: string; originalSubtasks: SubtaskItem[]; subtasks: SubtaskItem[]; dirty: boolean }
   | { type: "loading" };
@@ -332,7 +336,7 @@ export function PlanningModeModal({ isOpen, onClose, onTaskCreated, onTasksCreat
   FNXC:Planning 2026-07-15-00:00:
   FN-8003 keeps the started prompt separate from the editable composer so users can recover the original idea when an interview errors or drifts off track. The composer may be reset or reused, but this value belongs only to the active session.
   */
-  const [activePlanPrompt, setActivePlanPrompt] = useState("");
+  const [_activePlanPrompt, setActivePlanPrompt] = useState("");
   const [view, setView] = useState<ViewState>({ type: "initial" });
   const [error, setError] = useState<string | null>(null);
   const [, setResponseHistory] = useState<QuestionResponse[]>([]);
@@ -366,7 +370,7 @@ export function PlanningModeModal({ isOpen, onClose, onTaskCreated, onTasksCreat
   */
   const [editingQuestionId, setEditingQuestionId] = useState<string | null>(null);
   const editingQuestionIdRef = useRef<string | null>(null);
-  const [isHistoryEditPending, setIsHistoryEditPending] = useState(false);
+  const [_isHistoryEditPending, setIsHistoryEditPending] = useState(false);
   const [isRenamingSession, setIsRenamingSession] = useState(false);
   const [sessionTitleDraft, setSessionTitleDraft] = useState("");
   const [loadedSessionTitle, setLoadedSessionTitle] = useState<string | null>(null);
@@ -415,6 +419,10 @@ export function PlanningModeModal({ isOpen, onClose, onTaskCreated, onTasksCreat
   Refine Further is a single-flight completed-summary turn. Guard synchronously with a ref so duplicate click, touch, or keyboard activations cannot submit a second refine request or close the active stream with a generation-in-progress error before React renders the disabled state.
   */
   const refineSummaryInFlightRef = useRef(false);
+  // FNXC:PlanningMode 2026-07-20-19:10: Validate→create is one logical action. Guard it outside React state so rapid double activation cannot invoke the task-created handoff twice even when the server correctly returns the same idempotent task.
+  const validateCreateInFlightRef = useRef(false);
+  // FNXC:PlanningMode 2026-07-20-20:15: Reloaded created sessions are terminal handoffs, not SummaryView drafts that can create another task.
+  const restoredTaskHandoffRef = useRef<string | null>(null);
   const draftSessionIdRef = useRef<string | null>(null);
   /*
   FNXC:PlanningMode 2026-07-01-00:00:
@@ -540,7 +548,7 @@ export function PlanningModeModal({ isOpen, onClose, onTaskCreated, onTasksCreat
   const isSessionListMode = showSessionList || (isCompactInterview && !mobileShowDetail);
   // FNXC:PlanningModeMobile 2026-07-20-10:30: Empty mobile state opens the composer because no saved destination exists; once sessions exist, every compact detail surface gets this single Back-to-list escape.
   const canReturnToSessionList = isCompactInterview && mobileShowDetail && planningSessions.length > 0;
-  const [compactInterviewPane, setCompactInterviewPane] = useState<"question" | "plan" | "history">("question");
+  const [refineFocus, setRefineFocus] = useState("");
   const { addToast } = useToast();
   const { pushNav } = useNavigationHistoryContext();
 
@@ -749,12 +757,12 @@ export function PlanningModeModal({ isOpen, onClose, onTaskCreated, onTasksCreat
           setRunningSummary(summary);
           if (isValidatedPlanningSession(session)) {
             resetPlanningAutoRetryBudget();
-            setView({
-              type: "summary",
-              session: { sessionId, currentQuestion: null, summary },
-              summary,
-            });
-            setEditedSummary(summary);
+            const inputPayload = JSON.parse(session.inputPayload ?? "{}") as { createdTaskId?: unknown };
+            if (typeof inputPayload.createdTaskId === "string") {
+              setView({ type: "task_created", taskId: inputPayload.createdTaskId });
+            } else {
+              setView({ type: "create_retry", session: { sessionId, currentQuestion: null, summary }, summary, errorMessage: t("planning.retryCreate", "Retry create") });
+            }
           } else {
             setView({
               type: "error",
@@ -991,12 +999,11 @@ export function PlanningModeModal({ isOpen, onClose, onTaskCreated, onTasksCreat
           */
           runningSummaryRef.current = normalizedSummary;
           setRunningSummary(normalizedSummary);
-          setView((previous) => previous.type === "question"
-            ? {
-                ...previous,
-                session: { ...previous.session, summary: normalizedSummary },
-              }
-            : previous);
+          setView((previous) => previous.type === "loading"
+            ? { type: "plan_review", session: { sessionId, currentQuestion: null, summary: normalizedSummary }, summary: normalizedSummary }
+            : previous.type === "question"
+              ? { ...previous, session: { ...previous.session, summary: normalizedSummary } }
+              : previous);
           setStreamingOutput("");
         },
         onError: (message) => {
@@ -1130,12 +1137,12 @@ export function PlanningModeModal({ isOpen, onClose, onTaskCreated, onTasksCreat
               if (isValidatedPlanningSession(session)) {
                 resetPlanningAutoRetryBudget();
                 clearPlanningDescription(projectId);
-                setView({
-                  type: "summary",
-                  session: { sessionId: session.id, currentQuestion: null, summary },
-                  summary,
-                });
-                setEditedSummary(summary);
+                const inputPayload = JSON.parse(session.inputPayload ?? "{}") as { createdTaskId?: unknown };
+                if (typeof inputPayload.createdTaskId === "string") {
+                  setView({ type: "task_created", taskId: inputPayload.createdTaskId });
+                } else {
+                  setView({ type: "create_retry", session: { sessionId: session.id, currentQuestion: null, summary }, summary, errorMessage: t("planning.retryCreate", "Retry create") });
+                }
               } else {
                 setView({
                   type: "error",
@@ -1434,6 +1441,8 @@ export function PlanningModeModal({ isOpen, onClose, onTaskCreated, onTasksCreat
               }
             : null;
           setView({ type: "initial" });
+        } else if (session.status === "awaiting_input" && !session.currentQuestion && persistedRunningSummary) {
+          setView({ type: "plan_review", session: { sessionId, currentQuestion: null, summary: persistedRunningSummary }, summary: persistedRunningSummary });
         } else if (session.status === "awaiting_input" && session.currentQuestion) {
           resetPlanningAutoRetryBudget();
           clearPlanningDescription(projectId);
@@ -1458,10 +1467,14 @@ export function PlanningModeModal({ isOpen, onClose, onTaskCreated, onTasksCreat
           const summary = persistedRunningSummary ?? normalizePlanningSummary(JSON.parse(session.result));
           setRunningSummary(summary);
           if (isValidatedPlanningSession(session)) {
+            const createdTaskId = inputPayload && typeof inputPayload.createdTaskId === "string" ? inputPayload.createdTaskId : undefined;
             resetPlanningAutoRetryBudget();
             clearPlanningDescription(projectId);
-            setView({ type: "summary", session: { sessionId, currentQuestion: null, summary }, summary });
-            setEditedSummary(summary);
+            if (createdTaskId) {
+              setView({ type: "task_created", taskId: createdTaskId });
+            } else {
+              setView({ type: "create_retry", session: { sessionId, currentQuestion: null, summary }, summary, errorMessage: t("planning.retryCreate", "Retry create") });
+            }
           } else {
             setView({
               type: "error",
@@ -1966,6 +1979,22 @@ export function PlanningModeModal({ isOpen, onClose, onTaskCreated, onTasksCreat
     onClose();
   }, [flushDraftAndSummarize, initialPlan, onClose, projectId, resetMobileViewportAfterClose, view.type]);
 
+  /*
+  FNXC:PlanningMode 2026-07-20-20:15:
+  A reload that discovers a linked task must complete the normal task-created handoff once.
+  It must never reopen SummaryView, whose Create Task action would misrepresent terminal state.
+  */
+  useEffect(() => {
+    if (view.type !== "task_created" || restoredTaskHandoffRef.current === view.taskId) return;
+    const task = tasks.find((candidate) => candidate.id === view.taskId);
+    if (!task) return;
+    restoredTaskHandoffRef.current = task.id;
+    onTaskCreated(task);
+    clearPlanningActiveSession(projectId);
+    setSelectedSessionId(null);
+    handleClose();
+  }, [handleClose, onTaskCreated, projectId, tasks, view]);
+
   // Handle escape key to close
   useEffect(() => {
     if (!isOpen) return;
@@ -2033,15 +2062,10 @@ export function PlanningModeModal({ isOpen, onClose, onTaskCreated, onTasksCreat
       try {
         // Submit response - AI will broadcast events via the already-connected stream
         const response = await respondToPlanning(sessionId, responses, projectId);
-        // The stream normally drives this transition. Adopt an already-returned next question
-        // when its event was lost so loading cannot later be replaced by a stale replay.
-        if ("type" in response && response.type === "question" && response.data.id !== activeQuestion.id) {
-          const nextQuestion = normalizeQuestionOptions(response.data);
-          setView({
-            type: "question",
-            session: { sessionId, currentQuestion: nextQuestion, summary: runningSummaryRef.current },
-          });
-        }
+        // FNXC:PlanningMode 2026-07-20-15:45: FN-8442 makes the SSE summary the
+        // sole answer-turn transition authority. An answer updates the plan and clears
+        // the question; only the explicit Refine request may publish another question.
+        void response;
       } catch (err) {
         const errorMessage = getErrorMessage(err) || t("planning.failedSubmitResponse", "Failed to submit response");
         /*
@@ -2052,6 +2076,16 @@ export function PlanningModeModal({ isOpen, onClose, onTaskCreated, onTasksCreat
         */
         try {
           const persisted = await fetchAiSession(sessionId);
+          if (persisted?.status === "awaiting_input" && !persisted.currentQuestion && persisted.result) {
+            const history = parseConversationHistory(persisted.conversationHistory);
+            const summary = normalizePlanningSummary(JSON.parse(persisted.result) as PlanningSummary);
+            conversationHistoryRef.current = history;
+            runningSummaryRef.current = summary;
+            setConversationHistory(history);
+            setRunningSummary(summary);
+            setView({ type: "plan_review", session: { sessionId, currentQuestion: null, summary }, summary });
+            return;
+          }
           if (persisted?.status === "awaiting_input" && persisted.currentQuestion) {
             const history = parseConversationHistory(persisted.conversationHistory);
             const summary = persisted.result
@@ -2134,20 +2168,64 @@ export function PlanningModeModal({ isOpen, onClose, onTaskCreated, onTasksCreat
   Validation belongs to the always-visible running-plan pane, not the center question state. A user
   may finalize during loading or recoverable error states; the server cancels an active turn safely.
   */
-  const handleValidatePlan = useCallback(async () => {
-    const sessionId = selectedSessionId;
-    if (!sessionId) return;
+  const handleRefineFromPlan = useCallback(async () => {
+    if (view.type !== "plan_review") return;
     setError(null);
+    setView({ type: "loading" });
     try {
-      const result = await validatePlanningSession(sessionId, projectId);
-      const summary = normalizePlanningSummary(result.summary);
-      setEditedSummary(summary);
-      setRunningSummary(summary);
-      setView({ type: "summary", session: { sessionId, currentQuestion: null, summary }, summary });
+      await respondToPlanning(view.session.sessionId, { refine: true, ...(refineFocus.trim() ? { focus: refineFocus.trim() } : {}) }, projectId);
+      setRefineFocus("");
     } catch (err) {
-      setError(getErrorMessage(err) || t("planning.failedValidatePlan", "Failed to validate plan"));
+      setError(getErrorMessage(err) || t("planning.failedSubmitResponse", "Failed to refine plan"));
+      setView({ type: "plan_review", session: view.session, summary: view.summary });
     }
-  }, [projectId, selectedSessionId, t]);
+  }, [projectId, refineFocus, t, view]);
+
+  const handleValidatePlan = useCallback(async () => {
+    if (view.type !== "plan_review" || validateCreateInFlightRef.current) return;
+    validateCreateInFlightRef.current = true;
+    setError(null);
+    setView({ type: "creating_task", session: view.session, summary: view.summary });
+    try {
+      try {
+        await validatePlanningSession(view.session.sessionId, projectId);
+      } catch (err) {
+        // A lost validation response is ambiguous, but a rejected validation must not strand
+        // the user in create-only retry: inspect durable state before choosing the next phase.
+        const persisted = await fetchAiSession(view.session.sessionId).catch(() => null);
+        if (persisted && isValidatedPlanningSession(persisted)) {
+          setView({ type: "create_retry", session: view.session, summary: view.summary, errorMessage: getErrorMessage(err) || t("planning.failedCreateTask", "Failed to create task") });
+        } else {
+          setError(getErrorMessage(err) || t("planning.failedCreateTask", "Failed to validate plan"));
+          setView({ type: "plan_review", session: view.session, summary: view.summary });
+        }
+        return;
+      }
+      const task = await createTaskFromPlanning(view.session.sessionId, view.summary, projectId, { ...(workflowId !== undefined ? { workflowId } : {}) });
+      onTaskCreated(task);
+      clearPlanningActiveSession(projectId);
+      setSelectedSessionId(null);
+      handleClose();
+    } catch (err) {
+      setView({ type: "create_retry", session: view.session, summary: view.summary, errorMessage: getErrorMessage(err) || t("planning.failedCreateTask", "Failed to create task") });
+    } finally {
+      validateCreateInFlightRef.current = false;
+    }
+  }, [handleClose, onTaskCreated, projectId, t, view, workflowId]);
+
+  const handleRetryCreateTask = useCallback(async () => {
+    if (view.type !== "create_retry" || validateCreateInFlightRef.current) return;
+    validateCreateInFlightRef.current = true;
+    setView({ type: "creating_task", session: view.session, summary: view.summary });
+    try {
+      const task = await createTaskFromPlanning(view.session.sessionId, view.summary, projectId, { ...(workflowId !== undefined ? { workflowId } : {}) });
+      onTaskCreated(task); clearPlanningActiveSession(projectId); setSelectedSessionId(null); handleClose();
+    } catch (err) {
+      setView({ ...view, errorMessage: getErrorMessage(err) || t("planning.failedCreateTask", "Failed to create task") });
+    } finally {
+      validateCreateInFlightRef.current = false;
+    }
+  }, [handleClose, onTaskCreated, projectId, t, view, workflowId]);
 
   const handleCreateTask = useCallback(async () => {
     if (view.type !== "summary") return;
@@ -2266,7 +2344,7 @@ export function PlanningModeModal({ isOpen, onClose, onTaskCreated, onTasksCreat
     }
   }, [baseBranch, branchMode, branchName, handleClose, view, onTasksCreated, projectId, workflowId]);
 
-  const handleSelectAnsweredQuestion = useCallback(async (entry: ConversationHistoryEntry) => {
+  const _handleSelectAnsweredQuestion = useCallback(async (entry: ConversationHistoryEntry) => {
     const questionId = entry.question?.id;
     if (view.type !== "question" || !questionId) return;
     setError(null);
@@ -2383,7 +2461,7 @@ export function PlanningModeModal({ isOpen, onClose, onTaskCreated, onTasksCreat
           synchronized on both transitions so a second Sessions press cannot leave the question pane
           hidden by the mobile list CSS.
           */}
-          {selectedSessionId && (view.type === "question" || view.type === "loading" || view.type === "error") && (
+          {selectedSessionId && (view.type === "question" || view.type === "loading" || view.type === "error" || view.type === "plan_review" || view.type === "create_retry") && (
             <button
               type="button"
               className="btn"
@@ -2408,20 +2486,9 @@ export function PlanningModeModal({ isOpen, onClose, onTaskCreated, onTasksCreat
         <div
           className={`planning-modal-body planning-modal-body--split ${
             isSessionListMode ? "planning-modal-body--show-list" : "planning-modal-body--show-detail"
-          } ${
-            selectedSessionId && !isSessionListMode && (view.type === "question" || view.type === "loading" || view.type === "error") && isCompactInterview
-              ? `planning-modal-body--compact-interview planning-modal-body--compact-${compactInterviewPane}`
-              : ""
           }`}
         >
-          {selectedSessionId && !isSessionListMode && (view.type === "question" || view.type === "loading" || view.type === "error") ? (
-            <AnsweredQuestionHistory
-              entries={conversationHistory}
-              selectedQuestionId={editingQuestionId ?? (view.type === "question" ? view.session.currentQuestion?.id : undefined)}
-              isPending={isHistoryEditPending}
-              onSelect={(entry) => void handleSelectAnsweredQuestion(entry)}
-            />
-          ) : (
+          {isSessionListMode && (
           <PlanningSessionList
             sessions={planningSessions}
             loading={sessionsLoading}
@@ -2439,11 +2506,7 @@ export function PlanningModeModal({ isOpen, onClose, onTaskCreated, onTasksCreat
           />
           )}
 
-          {/*
-          FNXC:Planning 2026-06-23-02:00:
-          Sidebar resize handle — parity with MissionManager's mission-manager__sidebar-resize-handle. Rendered only on desktop (sidebar stacks on mobile). Pointer-drag and arrow-key resize both clamp + persist width.
-          */}
-          {viewportMode === "desktop" && !isShortViewport() && (
+          {isSessionListMode && viewportMode === "desktop" && !isShortViewport() && (
             <div
               className="planning-sidebar-resize-handle"
               role="separator"
@@ -2458,20 +2521,6 @@ export function PlanningModeModal({ isOpen, onClose, onTaskCreated, onTasksCreat
             />
           )}
 
-          {selectedSessionId && !isSessionListMode && (view.type === "question" || view.type === "loading" || view.type === "error") && isCompactInterview && (
-            <nav className="planning-compact-pane-switcher" aria-label={t("planning.interviewPanels", "Planning interview panels")}>
-              <button type="button" className={`btn ${compactInterviewPane === "question" ? "btn-primary" : ""}`} aria-pressed={compactInterviewPane === "question"} onClick={() => setCompactInterviewPane("question")}>
-                {t("planning.question", "Question")}
-              </button>
-              <button type="button" className={`btn ${compactInterviewPane === "plan" ? "btn-primary" : ""}`} aria-pressed={compactInterviewPane === "plan"} onClick={() => setCompactInterviewPane("plan")}>
-                {t("planning.runningPlan", "Running plan")}
-              </button>
-              <button type="button" className={`btn ${compactInterviewPane === "history" ? "btn-primary" : ""}`} aria-pressed={compactInterviewPane === "history"} onClick={() => setCompactInterviewPane("history")}>
-                {t("planning.answeredQuestions", "Answered questions")}
-              </button>
-            </nav>
-          )}
-
           <div className="planning-detail">
           {error && <div className="form-error planning-error">{error}</div>}
           {/*
@@ -2749,6 +2798,39 @@ export function PlanningModeModal({ isOpen, onClose, onTaskCreated, onTasksCreat
             </div>
           )}
 
+          {view.type === "plan_review" && (
+            <div className="planning-summary" data-testid="planning-plan-review">
+              <div className="planning-view-scroll planning-summary-scroll">
+                <h4>{view.summary.title}</h4>
+                <p>{view.summary.description}</p>
+                {view.summary.keyDeliverables.length > 0 && <ul>{view.summary.keyDeliverables.map((item) => <li key={item}>{item}</li>)}</ul>}
+                <label htmlFor="planning-refine-focus">{t("planning.refineFocus", "Focus the next question (optional)")}</label>
+                <input id="planning-refine-focus" data-testid="planning-refine-focus" className="input" value={refineFocus} onChange={(event) => setRefineFocus(event.target.value)} placeholder={t("planning.refineFocusPlaceholder", "For example: security, real-time updates, or a specific question")}/>
+                <div className="planning-summary-actions">
+                  <button type="button" className="btn" onClick={() => void handleRefineFromPlan()}>{t("planning.refine", "Refine")}</button>
+                  <button type="button" className="btn btn-primary" onClick={() => void handleValidatePlan()}>{t("planning.validatePlan", "Validate")}</button>
+                </div>
+              </div>
+            </div>
+          )}
+
+          {view.type === "creating_task" && <div className="planning-loading"><Loader2 size={24} className="spin" /> {t("planning.creatingTask", "Creating task…")}</div>}
+          {view.type === "task_created" && (
+            <div className="planning-loading" data-testid="planning-task-created"><CheckCircle size={24} /> {t("planning.taskCreated", "Task created")}</div>
+          )}
+          {view.type === "create_retry" && (
+            <div className="planning-summary" data-testid="planning-create-retry">
+              <div className="planning-view-scroll planning-summary-scroll">
+                <h4>{view.summary.title}</h4>
+                <p>{view.summary.description}</p>
+                <div className="ai-error-panel" role="alert">
+                  <div className="ai-error-message">{view.errorMessage}</div>
+                  <button type="button" className="btn btn-primary" onClick={() => void handleRetryCreateTask()}>{t("planning.retryCreate", "Retry create")}</button>
+                </div>
+              </div>
+            </div>
+          )}
+
           {view.type === "summary" && editedSummary && (
             <SummaryView
               summary={editedSummary}
@@ -2793,97 +2875,12 @@ export function PlanningModeModal({ isOpen, onClose, onTaskCreated, onTasksCreat
           )}
           </div>
 
-          {/*
-          FNXC:PlanningModeMobile 2026-07-20-10:30:
-          FN-8427 keeps the running plan through question, loading, and recoverable-error detail
-          states, but unmounts it in session-list mode. The list must own the entire compact body;
-          leaving this pane mounted reduced rows to the New session footer on mobile.
-          */}
-          {selectedSessionId && !isSessionListMode && (view.type === "question" || view.type === "loading" || view.type === "error") && (
-            <RunningPlanPane
-              summary={runningSummary}
-              fallbackDescription={activePlanPrompt}
-              onValidate={() => void handleValidatePlan()}
-            />
-          )}
         </div>
       </div>
     </div>
   );
 }
 
-/*
-FNXC:PlanningMode 2026-07-19-12:00:
-The active-session left pane is answer history, not a second copy of the interview. Selecting a row
-uses the server's question-id edit-and-branch contract, while the center remains the sole answer editor.
-*/
-function AnsweredQuestionHistory({ entries, selectedQuestionId, isPending, onSelect }: {
-  entries: ConversationHistoryEntry[];
-  selectedQuestionId?: string | null;
-  isPending: boolean;
-  onSelect: (entry: ConversationHistoryEntry) => void;
-}) {
-  const { t } = useTranslation("app");
-  const answered = entries.filter((entry) => entry.question && entry.response);
-  return (
-    <aside className="planning-sidebar planning-answered-history" aria-label={t("planning.answeredQuestions", "Answered questions")}>
-      <div className="planning-sidebar-header"><h4>{t("planning.answeredQuestions", "Answered questions")}</h4></div>
-      <div className="planning-session-list" {...(answered.length > 0 ? { "data-testid": "conversation-history" } : {})}>
-        {answered.map((entry) => (
-          <button
-            key={entry.question!.id}
-            type="button"
-            className={`btn planning-answered-history-edit ${selectedQuestionId === entry.question!.id ? "active" : ""}`}
-            onClick={() => onSelect(entry)}
-            disabled={isPending}
-            aria-label={t("planning.editAnswer", "Edit answer for {{question}}", { question: entry.question!.question })}
-          >
-            <Pencil size={14} />
-            <span>{entry.question!.question}</span>
-            <span className="planning-answered-history-response">{formatHistoryResponse(entry)}</span>
-          </button>
-        ))}
-      </div>
-    </aside>
-  );
-}
-
-/*
-FNXC:PlanningMode 2026-07-19-12:00:
-Keep the running plan mounted beside every interview state, including loading and errors. Validation is
-an intentional user action; no generation state offers a competing completion path.
-*/
-function formatHistoryResponse(entry: ConversationHistoryEntry): string {
-  const response = entry.response ?? {};
-  const options = entry.question?.options ?? [];
-  const optionLabel = (value: string | number | boolean): string => {
-    const matchingOption = typeof value === "string" ? options.find((option) => option.id === value) : undefined;
-    return matchingOption?.label ?? String(value);
-  };
-  return Object.entries(response)
-    .filter(([key]) => key !== "_comment")
-    .flatMap(([, value]) => Array.isArray(value) ? value : [value])
-    .filter((value): value is string | number | boolean => typeof value === "string" || typeof value === "number" || typeof value === "boolean")
-    .map(optionLabel)
-    .join(", ");
-}
-
-function RunningPlanPane({ summary, fallbackDescription, onValidate }: { summary?: PlanningSummary | null; fallbackDescription: string; onValidate?: () => void }) {
-  const { t } = useTranslation("app");
-  const plan = normalizePlanningSummary(summary ?? { title: "", description: fallbackDescription, suggestedSize: "M", priority: DEFAULT_TASK_PRIORITY, suggestedDependencies: [], keyDeliverables: [] });
-  return (
-    <aside className="planning-running-plan" aria-label={t("planning.runningPlan", "Running plan")}>
-      <h4>{t("planning.runningPlan", "Running plan")}</h4>
-      <div className="planning-running-plan-content">
-        <h5>{plan.title}</h5>
-        <p>{plan.description}</p>
-        {plan.keyDeliverables.length > 0 && <ul>{plan.keyDeliverables.map((item) => <li key={item}>{item}</li>)}</ul>}
-      </div>
-      {onValidate && <button type="button" className="btn btn-primary" onClick={onValidate}>{t("planning.validatePlan", "Validate plan")}</button>}
-    </aside>
-  );
-}
-
 interface QuestionFormProps {
   question: PlanningQuestion;
   initialResponse?: QuestionResponse;
@@ -3230,7 +3227,7 @@ function QuestionForm({ question: rawQuestion, initialResponse, onSubmit }: Ques
           onClick={handleSubmit}
           disabled={!isValid()}
         >
-          {t("planning.nextQuestion", "Next question")}
+          {t("planning.continueToPlan", "Continue to plan")}
           <ArrowRight size={16} className="icon-ml-4" />
         </button>
       </div>
diff --git a/packages/dashboard/app/components/__tests__/PlanningModeModal.initial.test.tsx b/packages/dashboard/app/components/__tests__/PlanningModeModal.initial.test.tsx
index f41b2c76e5..dc9d992d0a 100644
--- a/packages/dashboard/app/components/__tests__/PlanningModeModal.initial.test.tsx
+++ b/packages/dashboard/app/components/__tests__/PlanningModeModal.initial.test.tsx
@@ -1,987 +1,12 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { act, render, renderHook, screen, fireEvent, waitFor, within } from "@testing-library/react";
-import * as api from "../../api";
-import { PlanningModeModal } from "../PlanningModeModal";
-import { TaskDetailModal } from "../TaskDetailModal";
-
-const mockAddToast = vi.fn();
-
-vi.mock("../../hooks/useToast", () => ({
-  useOptionalToast: () => null,
-  useToast: () => ({
-    addToast: mockAddToast,
-    removeToast: vi.fn(),
-    toasts: [],
-  }),
-}));
-
-vi.mock("../../hooks/useNavigationHistory", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("../../hooks/useNavigationHistory")>();
-  return {
-    ...actual,
-    useNavigationHistoryContext: () => ({ pushNav: vi.fn(), replaceCurrent: vi.fn() }),
-  };
-});
-import type { MergeResult } from "@fusion/core";
-import {
-  mockStartPlanning,
-  mockStartPlanningStreaming,
-  mockCreatePlanningDraft,
-  mockConnectPlanningStream,
-  mockRespondToPlanning,
-  mockRetryPlanningSession,
-  mockCancelPlanning,
-  mockStopPlanningGeneration,
-  mockUpdatePlanningSessionDraft,
-  mockCreateTaskFromPlanning,
-  mockValidatePlanningSession,
-  mockStartPlanningBreakdown,
-  mockCreateTasksFromPlanning,
-  mockFetchAiSession,
-  mockParseConversationHistory,
-  mockFetchModels,
-  mockAcquireSessionLock,
-  mockReleaseSessionLock,
-  mockForceAcquireSessionLock,
-  mockUploadAttachment,
-  mockDeleteAttachment,
-  mockUpdateTask,
-  mockPauseTask,
-  mockUnpauseTask,
-  mockFetchTaskDetail,
-  mockRequestSpecRevision,
-  mockApprovePlan,
-  mockRejectPlan,
-  mockRefineTask,
-  mockFetchAiSessions,
-  mockConfirm,
-  mockUseViewportMode,
-  mockUseMobileKeyboard,
-  mockTasks,
-  mockModels,
-  mockQuestion,
-  mockSummary,
-  mockTaskDetail,
-  MockEventSource,
-  getMediaBlocks,
-  mockViewport,
-} from "./PlanningModeModal.test-helpers";
-
-vi.mock("../../api", () => ({
-  startPlanning: (...args: any[]) => mockStartPlanning(...args),
-  startPlanningStreaming: (...args: any[]) => mockStartPlanningStreaming(...args),
-  createPlanningDraft: (...args: any[]) => mockCreatePlanningDraft(...args),
-  connectPlanningStream: (...args: any[]) => mockConnectPlanningStream(...args),
-  respondToPlanning: (...args: any[]) => mockRespondToPlanning(...args),
-  retryPlanningSession: (...args: any[]) => mockRetryPlanningSession(...args),
-  cancelPlanning: (...args: any[]) => mockCancelPlanning(...args),
-  stopPlanningGeneration: (...args: any[]) => mockStopPlanningGeneration(...args),
-  updatePlanningSessionDraft: (...args: any[]) => mockUpdatePlanningSessionDraft(...args),
-  createTaskFromPlanning: (...args: any[]) => mockCreateTaskFromPlanning(...args),
-  validatePlanningSession: (...args: any[]) => mockValidatePlanningSession(...args),
-  startPlanningBreakdown: (...args: any[]) => mockStartPlanningBreakdown(...args),
-  createTasksFromPlanning: (...args: any[]) => mockCreateTasksFromPlanning(...args),
-  fetchAiSession: (...args: any[]) => mockFetchAiSession(...args),
-  parseConversationHistory: (...args: any[]) => mockParseConversationHistory(...args),
-  acquireSessionLock: (...args: any[]) => mockAcquireSessionLock(...args),
-  releaseSessionLock: (...args: any[]) => mockReleaseSessionLock(...args),
-  forceAcquireSessionLock: (...args: any[]) => mockForceAcquireSessionLock(...args),
-  uploadAttachment: (...args: any[]) => mockUploadAttachment(...args),
-  deleteAttachment: (...args: any[]) => mockDeleteAttachment(...args),
-  updateTask: (...args: any[]) => mockUpdateTask(...args),
-  pauseTask: (...args: any[]) => mockPauseTask(...args),
-  unpauseTask: (...args: any[]) => mockUnpauseTask(...args),
-  fetchTaskDetail: (...args: any[]) => mockFetchTaskDetail(...args),
-  requestSpecRevision: (...args: any[]) => mockRequestSpecRevision(...args),
-  approvePlan: (...args: any[]) => mockApprovePlan(...args),
-  rejectPlan: (...args: any[]) => mockRejectPlan(...args),
-  refineTask: (...args: any[]) => mockRefineTask(...args),
-  fetchSettings: vi.fn().mockResolvedValue({ modelPresets: [], autoSelectModelPreset: false, defaultPresetBySize: {} }),
-  /*
-  FNXC:PlanningModeSettings 2026-07-18-10:50:
-  Sync-settle clarification settings so Start Planning is not racey under full-suite load.
-  */
-  fetchGlobalSettings: vi.fn(() => {
-    const settled = {
-      then(onFulfilled: (settings: { agentClarificationEnabled: boolean }) => unknown) {
-        onFulfilled({ agentClarificationEnabled: false });
-        return settled;
-      },
-      catch() {
-        return settled;
-      },
-      finally(onFinally: () => unknown) {
-        onFinally();
-        return settled;
-      },
-    };
-    return settled;
-  }),
-  fetchModels: (...args: any[]) => mockFetchModels(...args),
-  fetchWorkflowSteps: vi.fn().mockResolvedValue([]),
-  refineText: vi.fn(),
-  getRefineErrorMessage: vi.fn((err: any) => err?.message || "Failed to refine"),
-  updateGlobalSettings: vi.fn().mockResolvedValue({}),
-  duplicateTask: vi.fn().mockResolvedValue({}),
-  fetchAiSessions: (...args: any[]) => mockFetchAiSessions(...args),
-}));
-
-vi.mock("../../hooks/useConfirm", () => ({
-  useConfirm: () => ({ confirm: mockConfirm }),
-}));
-
-vi.mock("../../hooks/useViewportMode", () => ({
-  MOBILE_MEDIA_QUERY: "(max-width: 768px), (max-height: 480px)",
-  isFullScreenSheetViewport: () => false,
-  isShortViewport: () => false,
-  getViewportMode: () => mockUseViewportMode(),
-  isMobileViewport: () => mockUseViewportMode() === "mobile",
-  useViewportMode: () => mockUseViewportMode(),
-}));
-
-vi.mock("../../hooks/useMobileKeyboard", () => ({
-  useMobileKeyboard: (...args: any[]) => mockUseMobileKeyboard(...args),
-}));
-
-describe("PlanningModeModal", () => {
-  const mockOnClose = vi.fn();
-  const mockOnTaskCreated = vi.fn();
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockAddToast.mockReset();
-    mockConfirm.mockReset();
-    mockConfirm.mockResolvedValue(true);
-    MockEventSource.reset();
-    vi.stubGlobal("EventSource", MockEventSource as any);
-    window.sessionStorage.clear();
-    // Default to desktop viewport; mobile-specific tests override per-test.
-    mockViewport("desktop");
-    
-    // Default mock for streaming
-    mockStartPlanningStreaming.mockResolvedValue({ sessionId: "session-123" });
-    // Server's createDraftSession always returns the placeholder title; the
-    // real summarized title only arrives later via blur/close summarize or
-    // when the session transitions out of draft. Mirror that in the mock so
-    // the sidebar render rule (preview while title === placeholder) behaves
-    // realistically in tests.
-    mockCreatePlanningDraft.mockResolvedValue({ sessionId: "draft-123", title: "New planning session" });
-    mockRetryPlanningSession.mockResolvedValue({ success: true, sessionId: "session-123" });
-    mockValidatePlanningSession.mockResolvedValue({ summary: mockSummary, validated: true });
-    mockStartPlanningBreakdown.mockResolvedValue({ sessionId: "session-123", subtasks: [] });
-    mockFetchAiSession.mockResolvedValue(null);
-    mockFetchAiSessions.mockResolvedValue([]);
-    mockParseConversationHistory.mockImplementation((raw: string) => {
-      if (!raw) return [];
-      try {
-        const parsed = JSON.parse(raw);
-        return Array.isArray(parsed) ? parsed : [];
-      } catch {
-        return [];
-      }
-    });
-    mockFetchModels.mockResolvedValue({
-      models: mockModels,
-      favoriteProviders: [],
-      favoriteModels: [],
-      resolvedPlanningProvider: "openai",
-      resolvedPlanningModelId: "gpt-4o",
-    });
-    mockAcquireSessionLock.mockResolvedValue({ acquired: true, currentHolder: null });
-    mockReleaseSessionLock.mockResolvedValue(undefined);
-    mockForceAcquireSessionLock.mockResolvedValue(undefined);
-    mockCancelPlanning.mockResolvedValue(undefined);
-    mockUpdatePlanningSessionDraft.mockResolvedValue({ ok: true });
-    mockStopPlanningGeneration.mockResolvedValue({ success: true });
-
-    // Default: simulate receiving a question after a brief delay
-    mockConnectPlanningStream.mockImplementation((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-      setTimeout(() => {
-        handlers.onQuestion?.(mockQuestion);
-      }, 10);
-      
-      return {
-        close: vi.fn(),
-        isConnected: vi.fn().mockReturnValue(true),
-      };
-    });
-  });
-
-  /*
-  FNXC:PlanningMode 2026-07-04-17:04:
-  The draft-creation debounce tests assert a NEGATIVE (a 300ms debounce interval elapsing without spawning a duplicate
-  createPlanningDraft). They previously did this with real-time `setTimeout(350)` sleeps, burning ~2.1s of wall-clock per
-  run for zero added signal (FN-5048: do not add slow tests). Those tests now drive fake timers via
-  `vi.advanceTimersByTimeAsync`, which advances the debounce deterministically and flushes the mock's promise
-  microtasks between timers. This afterEach restores real timers so the remaining real-timer + waitFor tests are unaffected.
-  */
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  describe("Initial view", () => {
-    it("renders the initial input view when open", () => {
-      const { container } = render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      expect(screen.getByText("Planning Mode")).toBeDefined();
-      expect(screen.getByPlaceholderText(/e.g., Build a user authentication/)).toBeDefined();
-      expect(container.querySelector(".planning-modal-body")).not.toBeNull();
-      expect(container.querySelector(".planning-modal-body")?.classList.contains("modal-body")).toBe(false);
-      expect(container.querySelector(".planning-examples-label")?.textContent).toBe("Try an example:");
-    });
-
-    it("does not render when closed", () => {
-      render(
-        <PlanningModeModal
-          isOpen={false}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      expect(screen.queryByText("Planning Mode")).toBeNull();
-    });
-
-    it("does not auto-focus the initial textarea on mobile open until the user focuses it", () => {
-      mockViewport("mobile");
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      const textarea = screen.getByLabelText("What do you want to build?") as HTMLTextAreaElement;
-      expect(document.activeElement).not.toBe(textarea);
-
-      act(() => {
-        textarea.focus();
-      });
-
-      expect(document.activeElement).toBe(textarea);
-    });
-
-    it("does not auto-focus the initial textarea in embedded desktop presentation", () => {
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          initialPlan={undefined}
-          presentation="embedded"
-        />
-      );
-
-      const textarea = screen.getByLabelText("What do you want to build?") as HTMLTextAreaElement;
-      expect(textarea.value).toBe("");
-      expect(document.activeElement).not.toBe(textarea);
-    });
-
-    it("auto-starts populated initialPlan handoffs without focusing the initial textarea", async () => {
-      const focusSpy = vi.spyOn(HTMLTextAreaElement.prototype, "focus");
-
-      try {
-        render(
-          <PlanningModeModal
-            isOpen={true}
-            onClose={mockOnClose}
-            onTaskCreated={mockOnTaskCreated}
-            onTasksCreated={vi.fn()}
-            tasks={mockTasks}
-            initialPlan="Build a login system from handoff"
-          />
-        );
-
-        await waitFor(() => {
-          expect(mockStartPlanningStreaming).toHaveBeenCalledWith("Build a login system from handoff", undefined, undefined, {
-            clarificationEnabled: true,
-          }, undefined);
-        });
-
-        expect(focusSpy).not.toHaveBeenCalled();
-      } finally {
-        focusSpy.mockRestore();
-      }
-    });
-
-    it("focuses the initial textarea when New session is clicked while already composing", () => {
-      const rafSpy = vi
-        .spyOn(window, "requestAnimationFrame")
-        .mockImplementation((callback: FrameRequestCallback) => {
-          callback(0);
-          return 1;
-        });
-
-      try {
-        render(
-          <PlanningModeModal
-            isOpen={true}
-            onClose={mockOnClose}
-            onTaskCreated={mockOnTaskCreated}
-            onTasksCreated={vi.fn()}
-            tasks={mockTasks}
-          />,
-        );
-
-        const textarea = screen.getByLabelText("What do you want to build?") as HTMLTextAreaElement;
-        expect(document.activeElement).not.toBe(textarea);
-
-        fireEvent.click(screen.getByRole("button", { name: "New session" }));
-
-        expect(rafSpy).toHaveBeenCalled();
-        expect(document.activeElement).toBe(textarea);
-      } finally {
-        rafSpy.mockRestore();
-      }
-    });
-
-    it("resets a selected desktop session to compose view and focuses New session", async () => {
-      const rafSpy = vi
-        .spyOn(window, "requestAnimationFrame")
-        .mockImplementation((callback: FrameRequestCallback) => {
-          callback(0);
-          return 1;
-        });
-      mockFetchAiSessions.mockResolvedValue([
-        {
-          id: "session-existing",
-          type: "planning",
-          status: "complete",
-          title: "Existing session",
-          preview: "An existing planning session",
-          projectId: null,
-          lockedByTab: null,
-          updatedAt: new Date().toISOString(),
-          archived: false,
-        },
-      ]);
-      mockFetchAiSession.mockResolvedValue({
-        id: "session-existing",
-        type: "planning",
-        status: "complete",
-        title: "Existing session",
-        inputPayload: JSON.stringify({ initialPlan: "Existing selected plan" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: JSON.stringify(mockSummary),
-        error: null,
-      });
-
-      try {
-        render(
-          <PlanningModeModal
-            isOpen={true}
-            onClose={mockOnClose}
-            onTaskCreated={mockOnTaskCreated}
-            onTasksCreated={vi.fn()}
-            tasks={mockTasks}
-          />,
-        );
-
-        fireEvent.click(await screen.findByText("Existing session"));
-
-        await waitFor(() => {
-          expect(mockFetchAiSession).toHaveBeenCalledWith("session-existing");
-        });
-
-        fireEvent.click(screen.getByRole("button", { name: "Sessions" }));
-        fireEvent.click(screen.getByRole("button", { name: "New session" }));
-
-        const textarea = screen.getByLabelText("What do you want to build?") as HTMLTextAreaElement;
-        expect(textarea.value).toBe("");
-        expect(document.activeElement).toBe(textarea);
-        expect(screen.getByRole("button", { name: /Start Planning/ })).toBeDisabled();
-      } finally {
-        rafSpy.mockRestore();
-      }
-    });
-
-    it("shows the mobile detail pane and focuses compose when New session is clicked from the list", async () => {
-      mockViewport("mobile");
-      const rafSpy = vi
-        .spyOn(window, "requestAnimationFrame")
-        .mockImplementation((callback: FrameRequestCallback) => {
-          callback(0);
-          return 1;
-        });
-      mockFetchAiSessions.mockResolvedValue([
-        {
-          id: "session-mobile",
-          type: "planning",
-          status: "complete",
-          title: "Mobile session",
-          preview: "A mobile planning session",
-          projectId: null,
-          lockedByTab: null,
-          updatedAt: new Date().toISOString(),
-          archived: false,
-        },
-      ]);
-
-      try {
-        const { container } = render(
-          <PlanningModeModal
-            isOpen={true}
-            onClose={mockOnClose}
-            onTaskCreated={mockOnTaskCreated}
-            onTasksCreated={vi.fn()}
-            tasks={mockTasks}
-          />,
-        );
-
-        await screen.findByText("Mobile session");
-        const body = container.querySelector(".planning-modal-body");
-        await waitFor(() => {
-          expect(body?.classList.contains("planning-modal-body--show-list")).toBe(true);
-        });
-
-        fireEvent.click(screen.getByRole("button", { name: "New session" }));
-
-        const textarea = screen.getByLabelText("What do you want to build?") as HTMLTextAreaElement;
-        expect(body?.classList.contains("planning-modal-body--show-detail")).toBe(true);
-        expect(document.activeElement).toBe(textarea);
-      } finally {
-        rafSpy.mockRestore();
-      }
-    });
-
-    it("preserves existing compose draft text and moves the caret to the end on New session focus", () => {
-      const rafSpy = vi
-        .spyOn(window, "requestAnimationFrame")
-        .mockImplementation((callback: FrameRequestCallback) => {
-          callback(0);
-          return 1;
-        });
-
-      try {
-        render(
-          <PlanningModeModal
-            isOpen={true}
-            onClose={mockOnClose}
-            onTaskCreated={mockOnTaskCreated}
-            onTasksCreated={vi.fn()}
-            tasks={mockTasks}
-          />,
-        );
-
-        const textarea = screen.getByLabelText("What do you want to build?") as HTMLTextAreaElement;
-        fireEvent.change(textarea, { target: { value: "Keep this restored draft" } });
-        textarea.setSelectionRange(0, 0);
-
-        fireEvent.click(screen.getByRole("button", { name: "New session" }));
-
-        expect(textarea.value).toBe("Keep this restored draft");
-        expect(document.activeElement).toBe(textarea);
-        expect(textarea.selectionStart).toBe(textarea.value.length);
-        expect(textarea.selectionEnd).toBe(textarea.value.length);
-      } finally {
-        rafSpy.mockRestore();
-      }
-    });
-
-    it("mobile close path blurs focused input and resets viewport scroll", () => {
-      mockViewport("mobile");
-      const scrollToSpy = vi.spyOn(window, "scrollTo").mockImplementation(() => undefined);
-      const rafSpy = vi
-        .spyOn(window, "requestAnimationFrame")
-        .mockImplementation((callback: FrameRequestCallback) => {
-          callback(0);
-          return 1;
-        });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      const textarea = screen.getByPlaceholderText(/e.g., Build a user authentication/) as HTMLTextAreaElement;
-      act(() => {
-        textarea.focus();
-      });
-      const blurSpy = vi.spyOn(textarea, "blur");
-
-      act(() => {
-        fireEvent.click(screen.getByRole("button", { name: "Close" }));
-      });
-
-      expect(blurSpy).toHaveBeenCalledTimes(1);
-      expect(scrollToSpy).toHaveBeenCalledWith(0, 0);
-      expect(rafSpy).toHaveBeenCalled();
-      expect(mockOnClose).toHaveBeenCalledTimes(1);
-    });
-
-    it("hides send to background button in initial state", () => {
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      expect(screen.queryByLabelText("Send to background")).toBeNull();
-    });
-
-    it("enables start button when text is entered", async () => {
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      const startButton = screen.getByText("Start Planning");
-      expect(startButton.closest("button")?.hasAttribute("disabled")).toBe(true);
-
-      fireEvent.click(screen.getByRole("button", { name: "Advanced planning settings" }));
-      const textarea = screen.getByPlaceholderText(/e.g., Build a user authentication/);
-      fireEvent.change(textarea, { target: { value: "Test plan" } });
-
-      expect(startButton.closest("button")?.hasAttribute("disabled")).toBe(false);
-    });
-
-    it("shows example chips", () => {
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      expect(screen.getByText(/Build a user authentication/)).toBeDefined();
-    });
-
-    it("renders planning model dropdown in initial view", async () => {
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      expect(screen.getByRole("button", { name: "Advanced planning settings" })).toBeDefined();
-      expect(screen.queryByRole("button", { name: "Planning Model" })).toBeNull();
-
-      fireEvent.click(screen.getByRole("button", { name: "Advanced planning settings" }));
-
-      const modelTrigger = screen.getByRole("button", { name: "Planning Model" });
-      expect(modelTrigger).toBeDefined();
-
-      await waitFor(() => {
-        expect(mockFetchModels).toHaveBeenCalledTimes(1);
-        expect(screen.getByText("openai/gpt-4o")).toBeDefined();
-      });
-    });
-
-    it("shows resolved default model badge and switches to override badge when selected", async () => {
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      await waitFor(() => {
-        expect(mockFetchModels).toHaveBeenCalledTimes(1);
-      });
-
-      fireEvent.click(screen.getByRole("button", { name: "Advanced planning settings" }));
-      expect(screen.getByText("openai/gpt-4o")).toBeDefined();
-      fireEvent.click(screen.getByRole("button", { name: "Planning Model" }));
-      fireEvent.click(screen.getByRole("option", { name: /Claude Sonnet 4.5/ }));
-
-      expect(screen.getByText("anthropic/claude-sonnet-4-5")).toBeDefined();
-    });
-
-    it("passes selected planning model to startPlanningStreaming", async () => {
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      await waitFor(() => {
-        expect(mockFetchModels).toHaveBeenCalledTimes(1);
-      });
-
-      fireEvent.click(screen.getByRole("button", { name: "Advanced planning settings" }));
-      fireEvent.click(screen.getByRole("button", { name: "Planning Model" }));
-      fireEvent.click(screen.getByRole("option", { name: /Claude Sonnet 4.5/ }));
-
-      const textarea = screen.getByPlaceholderText(/e.g., Build a user authentication/);
-      fireEvent.change(textarea, { target: { value: "Build auth system" } });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(mockStartPlanningStreaming).toHaveBeenCalledWith("Build auth system", undefined, {
-          planningModelProvider: "anthropic",
-          planningModelId: "claude-sonnet-4-5",
-          thinkingLevel: undefined,
-        }, {
-          clarificationEnabled: true,
-        }, undefined);
-      });
-    });
-
-    it("keeps advanced disclosure collapsed by default and reveals controls when expanded", async () => {
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      const disclosureButton = screen.getByRole("button", { name: "Advanced planning settings" });
-      expect(disclosureButton).toBeDefined();
-
-      const disclosure = disclosureButton.closest(".onboarding-disclosure");
-      expect(disclosure).not.toBeNull();
-      const disclosureScope = within(disclosure as HTMLElement);
-
-      expect(disclosureButton.getAttribute("aria-expanded")).toBe("false");
-      expect(disclosureScope.queryByRole("button", { name: "Planning Model" })).toBeNull();
-      expect(disclosureScope.queryByText(/Selects which model runs the planning interview/)).toBeNull();
-
-      fireEvent.click(disclosureButton);
-      expect(disclosureButton.getAttribute("aria-expanded")).toBe("true");
-
-      expect(disclosureScope.getByRole("button", { name: "Planning Model" })).toBeDefined();
-      await waitFor(() => {
-        expect(disclosureScope.getByText("openai/gpt-4o")).toBeDefined();
-      });
-      expect(disclosureScope.getByText(/Selects which model runs the planning interview/)).toBeDefined();
-      expect(disclosureScope.queryByLabelText("Allow follow-up clarification questions")).toBeNull();
-    });
-
-    it("calls startPlanningStreaming without model override when none selected", async () => {
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      const textarea = screen.getByPlaceholderText(/e.g., Build a user authentication/);
-      fireEvent.change(textarea, { target: { value: "Build auth system" } });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(mockStartPlanningStreaming).toHaveBeenCalledWith("Build auth system", undefined, undefined, {
-          clarificationEnabled: true,
-        }, undefined);
-      });
-    });
-
-    it("auto-creates a draft after typing and reuses it when starting", async () => {
-      // FNXC:PlanningMode 2026-07-04-17:04: fake timers drive the 300ms create-draft debounce deterministically
-      // (advanceTimersByTimeAsync flushes the mock promise between timers), replacing real-time sleeps.
-      vi.useFakeTimers();
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      const textarea = screen.getByPlaceholderText(/e.g., Build a user authentication/);
-      fireEvent.change(textarea, { target: { value: "Build a detailed auth system plan" } });
-
-      await act(async () => {
-        await vi.advanceTimersByTimeAsync(350);
-      });
-      expect(mockCreatePlanningDraft).toHaveBeenCalledTimes(1);
-      expect(mockCreatePlanningDraft).toHaveBeenCalledWith(
-        "Build a detailed auth system plan",
-        undefined,
-        undefined,
-      );
-
-      // Sidebar shows the inputPayload-derived preview for draft rows so
-      // multiple drafts are distinguishable, not the placeholder title that
-      // createDraftSession returns. The text also appears in the textarea
-      // value, so scope the query to the sidebar item title element.
-      const sidebarItem = document.querySelector(".planning-sidebar-item-title");
-      expect(sidebarItem?.textContent).toBe("Build a detailed auth system plan");
-
-      fireEvent.change(textarea, { target: { value: "Build a detailed auth system plan with extras" } });
-      // Let the debounce interval elapse; the existing draft must be reused, not re-created.
-      await act(async () => {
-        await vi.advanceTimersByTimeAsync(350);
-      });
-      expect(mockCreatePlanningDraft).toHaveBeenCalledTimes(1);
-
-      fireEvent.click(screen.getByText("Start Planning"));
-      await act(async () => {
-        await vi.advanceTimersByTimeAsync(50);
-      });
-      expect(mockStartPlanningStreaming).toHaveBeenCalledWith(
-        "Build a detailed auth system plan with extras",
-        undefined,
-        undefined,
-        {
-          clarificationEnabled: true,
-        },
-        "draft-123",
-      );
-    });
-
-    // FNXC:PlanningMode 2026-07-01-00:00: regression — deliberate typing must not spawn one draft per keystroke.
-    // Original symptom: each character created a new draft while the create-draft request was in flight, because
-    // the create-suppression guard only checked draftSessionIdRef, which is populated after the round-trip resolves.
-    it("creates exactly one draft when keystrokes arrive while the create request is still in flight", async () => {
-      // FNXC:PlanningMode 2026-07-04-17:04: fake timers drive the 300ms debounce deterministically; the in-flight
-      // create stays unresolved (resolveCreate) so the suppression sentinel is what collapses keystrokes to one create.
-      vi.useFakeTimers();
-      let resolveCreate: ((value: { sessionId: string; title: string }) => void) | undefined;
-      mockCreatePlanningDraft.mockImplementation(
-        () =>
-          new Promise((resolve) => {
-            resolveCreate = resolve;
-          }),
-      );
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      const textarea = screen.getByPlaceholderText(/e.g., Build a user authentication/);
-
-      // First keystroke → debounce (300ms) fires the create; it stays in flight (unresolved).
-      fireEvent.change(textarea, { target: { value: "Build" } });
-      await act(async () => {
-        await vi.advanceTimersByTimeAsync(350);
-      });
-      expect(mockCreatePlanningDraft).toHaveBeenCalledTimes(1);
-
-      // Subsequent keystrokes while the create is still in flight must be suppressed by the
-      // synchronous in-flight sentinel — not each spawn another draft.
-      fireEvent.change(textarea, { target: { value: "Build a" } });
-      await act(async () => {
-        await vi.advanceTimersByTimeAsync(350);
-      });
-      fireEvent.change(textarea, { target: { value: "Build an" } });
-      await act(async () => {
-        await vi.advanceTimersByTimeAsync(350);
-      });
-      fireEvent.change(textarea, { target: { value: "Build an auth" } });
-      await act(async () => {
-        await vi.advanceTimersByTimeAsync(350);
-      });
-
-      expect(mockCreatePlanningDraft).toHaveBeenCalledTimes(1);
-
-      // Once the create resolves and further edits arrive, they patch the single draft — no new create.
-      resolveCreate?.({ sessionId: "draft-123", title: "New planning session" });
-      await act(async () => {
-        await vi.advanceTimersByTimeAsync(0);
-      });
-      expect(document.querySelector(".planning-sidebar-item-title")).not.toBeNull();
-      fireEvent.change(textarea, { target: { value: "Build an auth system" } });
-      await act(async () => {
-        await vi.advanceTimersByTimeAsync(350);
-      });
-      expect(mockCreatePlanningDraft).toHaveBeenCalledTimes(1);
-    });
-
-    it("auto-starts planning when initialPlan prop is provided", async () => {
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          initialPlan="Build a login system from new task dialog"
-        />
-      );
-
-      // Wait for startPlanningStreaming to be called (allow time for setTimeout in useEffect)
-      await waitFor(() => {
-        expect(mockStartPlanningStreaming).toHaveBeenCalledWith("Build a login system from new task dialog", undefined, undefined, {
-          clarificationEnabled: true,
-        }, undefined);
-      }, { timeout: 2000 });
-
-      // Should transition to question view
-      await waitFor(() => {
-        expect(screen.getByText("What is the scope?")).toBeDefined();
-      });
-    });
-
-    it("sets initial plan text in textarea when initialPlan prop is provided", async () => {
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          initialPlan="Pre-filled plan from new task"
-        />
-      );
-
-      // The auto-start should happen with the initial plan (allow time for setTimeout in useEffect)
-      await waitFor(() => {
-        expect(mockStartPlanningStreaming).toHaveBeenCalledWith("Pre-filled plan from new task", undefined, undefined, {
-          clarificationEnabled: true,
-        }, undefined);
-      }, { timeout: 2000 });
-    });
-
-    it("shows streamed thinking in loading view before first question arrives", async () => {
-      mockConnectPlanningStream.mockImplementation((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        setTimeout(() => {
-          handlers.onThinking?.("Analyzing requirements...");
-        }, 0);
-
-        return {
-          close: vi.fn(),
-          isConnected: vi.fn().mockReturnValue(true),
-        };
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      fireEvent.click(screen.getByRole("button", { name: "Advanced planning settings" }));
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Draft a migration plan" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(screen.getByText("AI is thinking...")).toBeDefined();
-        expect(screen.getByText("Analyzing requirements...")).toBeDefined();
-      });
-
-      const loader = document.querySelector(".planning-loading .spin");
-      expect(loader).not.toBeNull();
-
-      const { loadAllAppCss } = await import("../../test/cssFixture");
-      const css = loadAllAppCss();
-      /*
-      FNXC:LoadingIndicators 2026-06-25-12:05:
-      Planning's first-paint spinner contract follows the shared collision-proof dashboard keyframe name. Do not require the obsolete global `spin` keyframe here; lazy CSS chunks can redefine generic keyframes.
-      */
-      expect(css).toMatch(/\.spin\s*\{[^}]*animation:\s*fusion-spinner-spin\s+1s\s+linear\s+infinite;/);
-
-      expect(screen.getByRole("button", { name: "Hide thinking" })).toBeDefined();
-      expect(document.querySelector(".planning-thinking-output")?.textContent).toContain("Analyzing requirements...");
-    });
-  });
-
-  describe("modal height constraint regression", () => {
-    it("desktop planning modal max-height accounts for overlay padding", async () => {
-      const { container } = render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      const modal = container.querySelector(".planning-modal");
-      expect(modal).toBeTruthy();
-
-      const { loadAllAppCss } = await import("../../test/cssFixture");
-      const css = loadAllAppCss();
-
-      const blockMatch = css.match(
-        /\.planning-modal\s*\{[^}]*max-height:\s*([^;]+);/,
-      );
-      expect(blockMatch).toBeTruthy();
-
-      const maxHeightValue = blockMatch![1].trim();
-      expect(maxHeightValue).toContain("calc(");
-      expect(maxHeightValue).toContain("100dvh");
-      expect(maxHeightValue).toContain("--overlay-padding-top");
-    });
-
-    it("uses planning-scoped disclosure overrides to remove inherited content indent", async () => {
-      const { loadAllAppCssBaseOnly } = await import("../../test/cssFixture");
-      const css = loadAllAppCssBaseOnly();
-
-      const blockMatch = css.match(
-        /\.planning-advanced-disclosure\s+\.onboarding-disclosure-content\s*\{[^}]*\}/,
-      );
-      expect(blockMatch).toBeTruthy();
-      expect(blockMatch![0]).toContain("padding-inline-start: 0;");
-      expect(blockMatch![0]).toContain("justify-content: center;");
-    });
-
-    it("keeps mobile question view top spacing compact", async () => {
-      const { loadAllAppCss } = await import("../../test/cssFixture");
-      const css = loadAllAppCss();
-      const mobileBlocks = getMediaBlocks(css, "@media (max-width: 768px)");
-      const mobileCss = mobileBlocks.join("\n");
-
-      expect(mobileCss).toContain(".planning-question-scroll");
-      expect(mobileCss).toContain("padding-top: var(--space-sm);");
-      expect(mobileCss).toContain("gap: var(--space-md);");
-    });
-  });
+import { describe, expect, it } from "vitest";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
 
+describe("PlanningModeModal initial surface", () => {
+  it("keeps Sessions as the single escape hatch while the active interview is sequential", () => {
+    const source = readFileSync(resolve(process.cwd(), "app/components/PlanningModeModal.tsx"), "utf8");
+    expect(source).toContain('data-testid="planning-plan-review"');
+    expect(source).toContain('data-testid="planning-refine-focus"');
+    expect(source).toContain('data-testid="planning-create-retry"');
+  });
 });
diff --git a/packages/dashboard/app/components/__tests__/PlanningModeModal.planning-flow.test.tsx b/packages/dashboard/app/components/__tests__/PlanningModeModal.planning-flow.test.tsx
index 68cbb34a6f..8f40a464a6 100644
--- a/packages/dashboard/app/components/__tests__/PlanningModeModal.planning-flow.test.tsx
+++ b/packages/dashboard/app/components/__tests__/PlanningModeModal.planning-flow.test.tsx
@@ -1,4339 +1,50 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { PlanningModeModal } from "../PlanningModeModal";
+import { mockFetchAiSession, mockFetchAiSessions, mockRespondToPlanning, mockValidatePlanningSession, mockCreateTaskFromPlanning, mockTasks, mockSummary } from "./PlanningModeModal.test-helpers";
 
-vi.mock("../../hooks/useNavigationHistory", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("../../hooks/useNavigationHistory")>();
+vi.mock("../../hooks/useToast", () => ({ useOptionalToast: () => null, useToast: () => ({ addToast: vi.fn(), removeToast: vi.fn(), toasts: [] }) }));
+vi.mock("../../hooks/useNavigationHistory", () => ({ useNavigationHistoryContext: () => ({ pushNav: vi.fn(), replaceCurrent: vi.fn() }) }));
+vi.mock("../../hooks/useViewportMode", () => ({ MOBILE_MEDIA_QUERY: "(max-width: 768px)", isFullScreenSheetViewport: () => false, isShortViewport: () => false, getViewportMode: () => "desktop", isMobileViewport: () => false, useViewportMode: () => "desktop" }));
+vi.mock("../../hooks/useMobileKeyboard", () => ({ useMobileKeyboard: () => ({ keyboardOverlap: 0, viewportHeight: null, viewportOffsetTop: 0, keyboardOpen: false }) }));
+vi.mock("../../hooks/useConfirm", () => ({ useConfirm: () => ({ confirm: vi.fn().mockResolvedValue(true) }) }));
+vi.mock("../../api", () => {
+  const fn = vi.fn;
   return {
-    ...actual,
-    useNavigationHistoryContext: () => ({ pushNav: vi.fn(), replaceCurrent: vi.fn() }),
+    fetchAiSession: (...args: unknown[]) => mockFetchAiSession(...args), fetchAiSessions: (...args: unknown[]) => mockFetchAiSessions(...args),
+    respondToPlanning: (...args: unknown[]) => mockRespondToPlanning(...args), validatePlanningSession: (...args: unknown[]) => mockValidatePlanningSession(...args), createTaskFromPlanning: (...args: unknown[]) => mockCreateTaskFromPlanning(...args),
+    fetchSettings: fn().mockResolvedValue({ modelPresets: [], autoSelectModelPreset: false, defaultPresetBySize: {} }), fetchGlobalSettings: fn().mockResolvedValue({}), fetchModels: fn().mockResolvedValue([]), fetchWorkflowSteps: fn().mockResolvedValue([]), fetchBoardWorkflows: fn().mockResolvedValue({ workflows: [] }),
+    startPlanning: fn(), startPlanningStreaming: fn(), createPlanningDraft: fn(), connectPlanningStream: fn(), rewindPlanningSession: fn(), retryPlanningSession: fn(), cancelPlanning: fn(), stopPlanningGeneration: fn(), updatePlanningSessionDraft: fn(), updatePlanningSessionTitle: fn(), startPlanningBreakdown: fn(), createTasksFromPlanning: fn(), parseConversationHistory: () => [], acquireSessionLock: fn(), releaseSessionLock: fn(), forceAcquireSessionLock: fn(), uploadAttachment: fn(), deleteAttachment: fn(), updateTask: fn(), pauseTask: fn(), unpauseTask: fn(), fetchTaskDetail: fn(), requestSpecRevision: fn(), approvePlan: fn(), rejectPlan: fn(), refineTask: fn(), deleteAiSession: fn(), refineText: fn(), getRefineErrorMessage: (error: Error) => error.message,
   };
 });
-import { act, render, renderHook, screen, fireEvent, waitFor, within } from "@testing-library/react";
-import * as api from "../../api";
-import { PlanningModeModal, dedupeSessionsById } from "../PlanningModeModal";
-import { TaskDetailModal } from "../TaskDetailModal";
-import {
-  PLANNING_DEEPEN_CHECKPOINT_ID,
-  PLANNING_DEEPEN_CHECKPOINT_QUESTION,
-  PLANNING_DEEPEN_PROCEED_OPTION_ID,
-} from "@fusion/core";
-import type { MergeResult, PlanningQuestion } from "@fusion/core";
 
-import {
-  mockStartPlanning,
-  mockStartPlanningStreaming,
-  mockCreatePlanningDraft,
-  mockConnectPlanningStream,
-  mockRespondToPlanning,
-  mockRewindPlanningSession,
-  mockRetryPlanningSession,
-  mockCancelPlanning,
-  mockStopPlanningGeneration,
-  mockUpdatePlanningSessionDraft,
-  mockCreateTaskFromPlanning,
-  mockValidatePlanningSession,
-  mockStartPlanningBreakdown,
-  mockCreateTasksFromPlanning,
-  mockFetchAiSession,
-  mockParseConversationHistory,
-  mockFetchModels,
-  mockAcquireSessionLock,
-  mockReleaseSessionLock,
-  mockForceAcquireSessionLock,
-  mockUploadAttachment,
-  mockDeleteAttachment,
-  mockUpdateTask,
-  mockPauseTask,
-  mockUnpauseTask,
-  mockFetchTaskDetail,
-  mockRequestSpecRevision,
-  mockApprovePlan,
-  mockRejectPlan,
-  mockRefineTask,
-  mockFetchAiSessions,
-  mockDeleteAiSession,
-  mockConfirm,
-  mockUseViewportMode,
-  mockUseMobileKeyboard,
-  mockTasks,
-  mockModels,
-  mockQuestion,
-  mockSummary,
-  mockTaskDetail,
-  MockEventSource,
-  getMediaBlocks,
-  mockShortLandscapePhone,
-  mockViewport,
-} from "./PlanningModeModal.test-helpers";
+const base = { id: "session-1", title: "Secure plan", projectId: "project-1", updatedAt: new Date().toISOString(), archived: false, conversationHistory: "[]", thinkingOutput: "" };
+function renderSession(session: Record<string, unknown>) { return render(<PlanningModeModal isOpen onClose={vi.fn()} onTaskCreated={vi.fn()} onTasksCreated={vi.fn()} tasks={mockTasks} projectId="project-1" resumeSessionId="session-1" />); }
 
-const mockAddToast = vi.fn();
-const mockCopyTextToClipboard = vi.fn();
-const mockUpdatePlanningSessionTitle = vi.fn();
-
-/*
-FNXC:PlanningModeStreamHarness 2026-07-17-16:20:
-FN-8245 requires planning-stream test events to retain their asynchronous protocol
-boundary without depending on wall-clock timers. Queue one deterministic microtask
-so every question, summary, and error settles before the awaiting assertion runs,
-even when dashboard tests share loaded jsdom workers.
-*/
-function queuePlanningStreamEvent(callback: () => void): void {
-  queueMicrotask(callback);
-}
-
-vi.mock("../../hooks/useToast", () => ({
-  useOptionalToast: () => null,
-  useToast: () => ({
-    addToast: mockAddToast,
-    removeToast: vi.fn(),
-    toasts: [],
-  }),
-}));
-
-vi.mock("../../api", () => ({
-  startPlanning: (...args: any[]) => mockStartPlanning(...args),
-  startPlanningStreaming: (...args: any[]) => mockStartPlanningStreaming(...args),
-  createPlanningDraft: (...args: any[]) => mockCreatePlanningDraft(...args),
-  connectPlanningStream: (...args: any[]) => mockConnectPlanningStream(...args),
-  respondToPlanning: (...args: any[]) => mockRespondToPlanning(...args),
-  rewindPlanningSession: (...args: any[]) => mockRewindPlanningSession(...args),
-  retryPlanningSession: (...args: any[]) => mockRetryPlanningSession(...args),
-  cancelPlanning: (...args: any[]) => mockCancelPlanning(...args),
-  stopPlanningGeneration: (...args: any[]) => mockStopPlanningGeneration(...args),
-  updatePlanningSessionDraft: (...args: any[]) => mockUpdatePlanningSessionDraft(...args),
-  updatePlanningSessionTitle: (...args: any[]) => mockUpdatePlanningSessionTitle(...args),
-  createTaskFromPlanning: (...args: any[]) => mockCreateTaskFromPlanning(...args),
-  validatePlanningSession: (...args: any[]) => mockValidatePlanningSession(...args),
-  startPlanningBreakdown: (...args: any[]) => mockStartPlanningBreakdown(...args),
-  createTasksFromPlanning: (...args: any[]) => mockCreateTasksFromPlanning(...args),
-  fetchAiSession: (...args: any[]) => mockFetchAiSession(...args),
-  parseConversationHistory: (...args: any[]) => mockParseConversationHistory(...args),
-  acquireSessionLock: (...args: any[]) => mockAcquireSessionLock(...args),
-  releaseSessionLock: (...args: any[]) => mockReleaseSessionLock(...args),
-  forceAcquireSessionLock: (...args: any[]) => mockForceAcquireSessionLock(...args),
-  uploadAttachment: (...args: any[]) => mockUploadAttachment(...args),
-  deleteAttachment: (...args: any[]) => mockDeleteAttachment(...args),
-  updateTask: (...args: any[]) => mockUpdateTask(...args),
-  pauseTask: (...args: any[]) => mockPauseTask(...args),
-  unpauseTask: (...args: any[]) => mockUnpauseTask(...args),
-  fetchTaskDetail: (...args: any[]) => mockFetchTaskDetail(...args),
-  requestSpecRevision: (...args: any[]) => mockRequestSpecRevision(...args),
-  approvePlan: (...args: any[]) => mockApprovePlan(...args),
-  rejectPlan: (...args: any[]) => mockRejectPlan(...args),
-  refineTask: (...args: any[]) => mockRefineTask(...args),
-  fetchSettings: vi.fn().mockResolvedValue({ modelPresets: [], autoSelectModelPreset: false, defaultPresetBySize: {} }),
-  /*
-  FNXC:PlanningModeSettings 2026-07-17-15:45:
-  FN-8245 keeps the clarification-settings dependency deterministic for every
-  planning interaction. The modal intentionally blocks Start Planning while
-  settings load, so this test double settles synchronously rather than making
-  each user-flow assertion depend on an arbitrary event-loop delay.
-  */
-  fetchGlobalSettings: vi.fn(() => {
-    const settled = {
-      then(onFulfilled: (settings: Record<string, never>) => unknown) {
-        onFulfilled({});
-        return settled;
-      },
-      catch() {
-        return settled;
-      },
-      finally(onFinally: () => unknown) {
-        onFinally();
-        return settled;
-      },
-    };
-    return settled;
-  }),
-  fetchModels: (...args: any[]) => mockFetchModels(...args),
-  fetchWorkflowSteps: vi.fn().mockResolvedValue([]),
-  refineText: vi.fn(),
-  getRefineErrorMessage: vi.fn((err: any) => err?.message || "Failed to refine"),
-  updateGlobalSettings: vi.fn().mockResolvedValue({}),
-  duplicateTask: vi.fn().mockResolvedValue({}),
-  fetchAiSessions: (...args: any[]) => mockFetchAiSessions(...args),
-  deleteAiSession: (...args: any[]) => mockDeleteAiSession(...args),
-}));
-
-vi.mock("../../utils/copyToClipboard", () => ({
-  copyTextToClipboard: (...args: unknown[]) => mockCopyTextToClipboard(...args),
-}));
-
-vi.mock("../../hooks/useConfirm", () => ({
-  useConfirm: () => ({ confirm: mockConfirm }),
-}));
-
-vi.mock("../../hooks/useViewportMode", () => ({
-  MOBILE_MEDIA_QUERY: "(max-width: 768px), (max-height: 480px)",
-  isFullScreenSheetViewport: () => false,
-  isShortViewport: () => false,
-  getViewportMode: () => mockUseViewportMode(),
-  isMobileViewport: () => mockUseViewportMode() === "mobile",
-  useViewportMode: () => mockUseViewportMode(),
-}));
-
-vi.mock("../../hooks/useMobileKeyboard", () => ({
-  useMobileKeyboard: (...args: any[]) => mockUseMobileKeyboard(...args),
-}));
-
-describe("PlanningModeModal", () => {
-  const mockOnClose = vi.fn();
-  const mockOnTaskCreated = vi.fn();
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockConfirm.mockReset();
-    mockConfirm.mockResolvedValue(true);
-    mockAddToast.mockReset();
-    mockCopyTextToClipboard.mockReset();
-    mockCopyTextToClipboard.mockResolvedValue(true);
-    mockUpdatePlanningSessionTitle.mockReset();
-    mockUpdatePlanningSessionTitle.mockResolvedValue({ sessionId: "session-123", title: "Renamed session" });
-    MockEventSource.reset();
-    vi.stubGlobal("EventSource", MockEventSource as any);
-    window.sessionStorage.clear();
-    localStorage.clear();
-    // Default to desktop viewport; mobile-specific tests override per-test.
-    mockViewport("desktop");
-    
-    // Default mock for streaming
-    mockStartPlanningStreaming.mockResolvedValue({ sessionId: "session-123" });
-    // Server's createDraftSession always returns the placeholder title; the
-    // real summarized title only arrives later via blur/close summarize or
-    // when the session transitions out of draft. Mirror that in the mock so
-    // the sidebar render rule (preview while title === placeholder) behaves
-    // realistically in tests.
-    mockCreatePlanningDraft.mockResolvedValue({ sessionId: "draft-123", title: "New planning session" });
-    mockRetryPlanningSession.mockResolvedValue({ success: true, sessionId: "session-123" });
-    mockValidatePlanningSession.mockResolvedValue({ summary: mockSummary, validated: true });
-    mockStartPlanningBreakdown.mockResolvedValue({ sessionId: "session-123", subtasks: [] });
-    mockFetchAiSession.mockResolvedValue(null);
-    mockFetchAiSessions.mockResolvedValue([]);
-    mockDeleteAiSession.mockResolvedValue(undefined);
-    mockParseConversationHistory.mockImplementation((raw: string) => {
-      if (!raw) return [];
-      try {
-        const parsed = JSON.parse(raw);
-        return Array.isArray(parsed) ? parsed : [];
-      } catch {
-        return [];
-      }
-    });
-    mockFetchModels.mockResolvedValue({
-      models: mockModels,
-      favoriteProviders: [],
-      favoriteModels: [],
-      resolvedPlanningProvider: "openai",
-      resolvedPlanningModelId: "gpt-4o",
-    });
-    mockAcquireSessionLock.mockResolvedValue({ acquired: true, currentHolder: null });
-    mockReleaseSessionLock.mockResolvedValue(undefined);
-    mockForceAcquireSessionLock.mockResolvedValue(undefined);
-    mockCancelPlanning.mockResolvedValue(undefined);
-    mockRewindPlanningSession.mockReset();
-    mockUpdatePlanningSessionDraft.mockResolvedValue({ ok: true });
-    mockStopPlanningGeneration.mockResolvedValue({ success: true });
-
-    // Default stream behavior belongs only to fresh sessions. Resumed sessions restore their
-    // persisted question and must not receive a synthetic fresh-session question.
-    mockConnectPlanningStream.mockImplementation((sessionId: string, _projectId: string | undefined, handlers: any) => {
-      if (sessionId === "session-123") {
-        queuePlanningStreamEvent(() => {
-          handlers.onQuestion?.(mockQuestion);
-        });
-      }
-
-      return {
-        close: vi.fn(),
-        isConnected: vi.fn().mockReturnValue(true),
-      };
-    });
+describe("PlanningModeModal sequential flow", () => {
+  beforeEach(() => { vi.clearAllMocks(); mockFetchAiSessions.mockResolvedValue([]); mockValidatePlanningSession.mockResolvedValue({ summary: mockSummary, validated: true }); mockCreateTaskFromPlanning.mockResolvedValue({ id: "FN-8442" }); });
+  it("renders plan review after an answered turn without retired interview panes", async () => {
+    mockFetchAiSession.mockResolvedValue({ ...base, status: "awaiting_input", currentQuestion: null, result: JSON.stringify(mockSummary), inputPayload: JSON.stringify({ initialPlan: "Secure accounts" }) });
+    renderSession({});
+    expect(await screen.findByTestId("planning-plan-review")).toHaveTextContent("Build authentication system");
+    expect(screen.getByTestId("planning-refine-focus")).toBeInTheDocument();
+    expect(screen.getByRole("button", { name: "Refine" })).toBeInTheDocument();
+    expect(screen.getByRole("button", { name: "Validate" })).toBeInTheDocument();
+    expect(screen.getByRole("button", { name: "Sessions" })).toBeInTheDocument();
+    expect(document.querySelector(".planning-running-plan")).toBeNull();
+    expect(document.querySelector(".planning-answered-history")).toBeNull();
   });
-
-  describe("embedded presentation", () => {
-    it("renders as a main-content region without modal overlay or backdrop-close behavior", async () => {
-      const { container } = render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          presentation="embedded"
-        />
-      );
-
-      const region = await screen.findByTestId("planning-view");
-      expect(region.getAttribute("role")).toBe("region");
-      expect(region.getAttribute("aria-modal")).toBeNull();
-      expect(container.querySelector(".modal-overlay")).toBeNull();
-      expect(container.querySelector(".planning-modal--embedded")).toBeTruthy();
-
-      fireEvent.mouseDown(region);
-      fireEvent.click(region);
-      expect(mockOnClose).not.toHaveBeenCalled();
-    });
+  it("sends trimmed focus only when Refine requests the next question", async () => {
+    mockFetchAiSession.mockResolvedValue({ ...base, status: "awaiting_input", currentQuestion: null, result: JSON.stringify(mockSummary), inputPayload: "{}" });
+    mockRespondToPlanning.mockResolvedValue({}); renderSession({});
+    fireEvent.change(await screen.findByTestId("planning-refine-focus"), { target: { value: " security " } });
+    fireEvent.click(screen.getByRole("button", { name: "Refine" }));
+    await waitFor(() => expect(mockRespondToPlanning).toHaveBeenCalledWith("session-1", { refine: true, focus: "security" }, "project-1"));
   });
-
-  describe("last-active session restoration", () => {
-    const activeSession = (status: "generating" | "awaiting_input") => ({
-      id: "session-leave-return",
-      type: "planning" as const,
-      status,
-      title: "Restored planning interview",
-      inputPayload: JSON.stringify({ initialPlan: "Restore a planning interview" }),
-      conversationHistory: JSON.stringify([{ question: mockQuestion, response: { [mockQuestion.id]: "Small" } }]),
-      currentQuestion: status === "awaiting_input"
-        ? JSON.stringify({ ...mockQuestion, id: "q-return", question: "What should happen after return?" })
-        : null,
-      result: JSON.stringify({ ...mockSummary, title: "Running plan restored" }),
-      thinkingOutput: "Persisted mid-generation reasoning",
-      error: null,
-      projectId: "project-restore",
-      createdAt: "2026-01-01T00:00:00.000Z",
-      updatedAt: "2026-01-01T00:00:00.000Z",
-    });
-
-    it.each(["desktop", "mobile"] as const)("FN-8437 restores a generating session after embedded leave/return on %s", async (viewportMode) => {
-      mockViewport(viewportMode);
-      mockFetchAiSession.mockResolvedValue(activeSession("generating"));
-
-      const firstMount = render(
-        <PlanningModeModal isOpen={true} onClose={mockOnClose} onTaskCreated={mockOnTaskCreated} onTasksCreated={vi.fn()} tasks={mockTasks} projectId="project-restore" resumeSessionId="session-leave-return" presentation="embedded" />,
-      );
-      await waitFor(() => expect(mockConnectPlanningStream).toHaveBeenCalledWith("session-leave-return", "project-restore", expect.anything()));
-      firstMount.unmount();
-
-      render(
-        <PlanningModeModal isOpen={true} onClose={mockOnClose} onTaskCreated={mockOnTaskCreated} onTasksCreated={vi.fn()} tasks={mockTasks} projectId="project-restore" presentation="embedded" />,
-      );
-
-      await waitFor(() => expect(mockFetchAiSession).toHaveBeenCalledTimes(2));
-      expect(await screen.findByText("AI is thinking...")).toBeInTheDocument();
-      expect(screen.getByText("Persisted mid-generation reasoning")).toBeInTheDocument();
-      expect(mockConnectPlanningStream).toHaveBeenLastCalledWith("session-leave-return", "project-restore", expect.anything());
-      expect(screen.queryByPlaceholderText(/e.g., Build a user authentication/)).toBeNull();
-    });
-
-    it("FN-8437 rehydrates the server question and running plan when generation finishes while away", async () => {
-      localStorage.setItem("kb:project-restore:kb-planning-active-session", "session-leave-return");
-      mockFetchAiSession.mockResolvedValue(activeSession("awaiting_input"));
-
-      render(
-        <PlanningModeModal isOpen={true} onClose={mockOnClose} onTaskCreated={mockOnTaskCreated} onTasksCreated={vi.fn()} tasks={mockTasks} projectId="project-restore" presentation="embedded" />,
-      );
-
-      expect(await screen.findByText("What should happen after return?")).toBeInTheDocument();
-      expect(screen.getByText("Running plan restored")).toBeInTheDocument();
-      expect(screen.getByText("What is the scope?")).toBeInTheDocument();
-      expect(screen.queryByPlaceholderText(/e.g., Build a user authentication/)).toBeNull();
-    });
-
-    it("FN-8437 clears the active session when dismissing a restored error", async () => {
-      localStorage.setItem("kb:project-restore:kb-planning-active-session", "session-leave-return");
-      mockFetchAiSession.mockResolvedValue({
-        ...activeSession("awaiting_input"),
-        status: "error",
-        currentQuestion: null,
-        error: "Restored planning failure",
-      });
-
-      render(
-        <PlanningModeModal isOpen={true} onClose={mockOnClose} onTaskCreated={mockOnTaskCreated} onTasksCreated={vi.fn()} tasks={mockTasks} projectId="project-restore" presentation="embedded" />,
-      );
-
-      expect(await screen.findByRole("alert")).toHaveTextContent("Restored planning failure");
-      fireEvent.click(screen.getByRole("button", { name: "Dismiss" }));
-      expect(mockOnClose).toHaveBeenCalledTimes(1);
-      expect(localStorage.getItem("kb:project-restore:kb-planning-active-session")).toBeNull();
-    });
-
-    it("FN-8437 keeps an initial-plan handoff fresh instead of restoring the last active session", async () => {
-      localStorage.setItem("kb:project-restore:kb-planning-active-session", "session-leave-return");
-
-      render(
-        <PlanningModeModal isOpen={true} onClose={mockOnClose} onTaskCreated={mockOnTaskCreated} onTasksCreated={vi.fn()} tasks={mockTasks} projectId="project-restore" initialPlan="Intentional new plan" presentation="embedded" />,
-      );
-
-      await waitFor(() => expect(mockStartPlanningStreaming).toHaveBeenCalledWith("Intentional new plan", "project-restore", undefined, { clarificationEnabled: true }, undefined));
-      expect(mockFetchAiSession).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("Planning flow", () => {
-    it.each(["desktop", "mobile"] as const)("FN-6977 keeps malformed live running plans non-terminal on %s", async (viewportMode) => {
-      mockViewport(viewportMode);
-      mockStartPlanningStreaming.mockResolvedValueOnce({ sessionId: `session-fn-6977-live-${viewportMode}` });
-      mockConnectPlanningStream.mockImplementationOnce((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        queuePlanningStreamEvent(() => {
-          handlers.onSummary?.({
-            title: "Live malformed summary",
-            description: "Live Planning Mode summary omitted deliverable arrays",
-            suggestedSize: "M",
-          });
-        });
-
-        return {
-          close: vi.fn(),
-          isConnected: vi.fn().mockReturnValue(true),
-        };
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Plan from live malformed summary" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(screen.getByRole("complementary", { name: "Running plan" })).toBeDefined();
-      });
-
-      expect(screen.getByText("Live Planning Mode summary omitted deliverable arrays")).toBeDefined();
-      expect(screen.queryByText("Planning Complete!")).toBeNull();
-      expect(screen.queryByRole("button", { name: "Create Single Task" })).toBeNull();
-      expect(screen.getByRole("button", { name: "Validate plan" })).toBeEnabled();
-    });
-
-    it("keeps the interview open when running-plan summaries arrive before and after questions", async () => {
-      let streamHandlers: Record<string, ((value: any) => void) | undefined> = {};
-      mockConnectPlanningStream.mockImplementationOnce((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        streamHandlers = handlers;
-        queuePlanningStreamEvent(() => {
-          handlers.onSummary?.({ ...mockSummary, title: "Before question running plan" });
-          handlers.onQuestion?.(mockQuestion);
-        });
-        return { close: vi.fn(), isConnected: vi.fn().mockReturnValue(true) };
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Keep the interview open" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      expect(await screen.findByText(mockQuestion.question)).toBeDefined();
-      const runningPlan = screen.getByRole("complementary", { name: "Running plan" });
-      expect(within(runningPlan).getByText("Before question running plan")).toBeDefined();
-      expect(within(runningPlan).getByText(mockSummary.description)).toBeDefined();
-      expect(within(runningPlan).getByText("Login page")).toBeDefined();
-      expect(within(runningPlan).queryByText(mockQuestion.question)).toBeNull();
-      expect(screen.queryByText("Planning Complete!")).toBeNull();
-
-      await act(async () => {
-        streamHandlers.onSummary?.({ ...mockSummary, title: "After question running plan" });
-      });
-
-      expect(screen.getByText(mockQuestion.question)).toBeDefined();
-      expect(screen.getByText("After question running plan")).toBeDefined();
-      expect(screen.queryByText("Planning Complete!")).toBeNull();
-      expect(screen.queryByRole("button", { name: "Create Single Task" })).toBeNull();
-    });
-
-    it("starts planning and shows question view", async () => {
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      const textarea = screen.getByPlaceholderText(/e.g., Build a user authentication/);
-      fireEvent.change(textarea, { target: { value: "Build auth system" } });
-
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      // Wait for streaming to be called
-      await waitFor(() => {
-        expect(mockStartPlanningStreaming).toHaveBeenCalledWith("Build auth system", undefined, undefined, {
-          clarificationEnabled: true,
-        }, undefined);
-      });
-
-      // Should transition to question view via streaming
-      await waitFor(() => {
-        expect(screen.getByText("What is the scope?")).toBeDefined();
-      });
-      expect(screen.queryByText("Your plan so far")).toBeNull();
-    });
-
-    it("forwards the selected workflow to the streaming start request", async () => {
-      render(<PlanningModeModal isOpen={true} onClose={mockOnClose} onTaskCreated={mockOnTaskCreated} onTasksCreated={vi.fn()} tasks={mockTasks} workflowId="WF-custom-planning" />);
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), { target: { value: "Build workflow-aware plan" } });
-      fireEvent.click(screen.getByText("Start Planning"));
-      await waitFor(() => expect(mockStartPlanningStreaming).toHaveBeenCalledWith(
-        "Build workflow-aware plan", undefined, undefined,
-        { clarificationEnabled: true, workflowId: "WF-custom-planning" }, undefined,
-      ));
-    });
-
-    /*
-    FNXC:PlanningMultiTab 2026-07-14-00:00:
-    Planning has no cross-tab locking. Even when another tab is using the same session, this
-    tab must never call the lock API, never render a lock overlay, and must remain fully
-    interactive — the persisted session row is the shared source of truth.
-    */
-    it("never acquires a tab lock and stays interactive even when another tab uses the session", async () => {
-      window.sessionStorage.setItem("fusion-tab-id", "tab-self");
-      // If any legacy lock path survived, this rejection would surface an overlay.
-      mockAcquireSessionLock.mockResolvedValue({ acquired: false, currentHolder: "tab-other" });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Build auth system" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(screen.getByText("What is the scope?")).toBeDefined();
-      });
-
-      expect(screen.queryByTestId("session-lock-overlay")).toBeNull();
-      expect(screen.queryByRole("button", { name: "Take Control" })).toBeNull();
-      expect(mockAcquireSessionLock).not.toHaveBeenCalled();
-      expect(mockForceAcquireSessionLock).not.toHaveBeenCalled();
-
-      /*
-      FNXC:DashboardTests 2026-07-18-15:20:
-      Full Suite shard 3 (29648952207) observed Small+Next question not reaching respondToPlanning
-      under load (0 calls). Click the option radio by role and wait for checked + respond
-      with the same settle bound as "allows normal question interaction".
-      */
-      const smallOption = screen.getByRole("radio", { name: /Small/i });
-      fireEvent.click(smallOption);
-      await waitFor(() => expect(smallOption).toBeChecked());
-      fireEvent.click(screen.getByRole("button", { name: "Next question" }));
-
-      await waitFor(
-        () => {
-          expect(mockRespondToPlanning).toHaveBeenCalledWith(
-            "session-123",
-            { "q-scope": "small" },
-            undefined,
-          );
-        },
-        { timeout: 3000 },
-      );
-    });
-
-    it("allows normal question interaction", async () => {
-      window.sessionStorage.setItem("fusion-tab-id", "tab-self");
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Build auth system" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(screen.queryByTestId("session-lock-overlay")).toBeNull();
-      });
-
-      await waitFor(() => {
-        expect(screen.getByText("What is the scope?")).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByText("Small"));
-      fireEvent.click(screen.getByText("Next question"));
-
-      await waitFor(
-        () => {
-          expect(mockRespondToPlanning).toHaveBeenCalledWith(
-            "session-123",
-            { "q-scope": "small" },
-            undefined,
-          );
-        },
-        // waitFor's private 1s default (independent of vitest testTimeout) has
-        // flaked under loaded CI shards; the click->respond chain crosses
-        // several state-update hops. Generous bound, still fails fast locally.
-        { timeout: 5000 },
-      );
-    });
-
-    it("allows Other-only answers for single-select planning questions", async () => {
-      window.sessionStorage.setItem("fusion-tab-id", "tab-self");
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Build auth system" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(screen.getByText("What is the scope?")).toBeDefined();
-      });
-
-      const continueButton = screen.getByRole("button", { name: "Next question" });
-      fireEvent.click(screen.getByTestId("planning-option-other"));
-      const otherInput = await screen.findByTestId("planning-other-input");
-      expect(continueButton).toBeDisabled();
-      fireEvent.change(otherInput, { target: { value: "  Make this a design spike  " } });
-      expect(continueButton).toBeEnabled();
-      fireEvent.click(continueButton);
-
-      await waitFor(() => {
-        expect(mockRespondToPlanning).toHaveBeenCalledWith(
-          "session-123",
-          { _other: "Make this a design spike" },
-          undefined,
-        );
-      });
-    });
-
-    it("clears stale Other text when switching back to a provided planning option", async () => {
-      window.sessionStorage.setItem("fusion-tab-id", "tab-self");
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Build auth system" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(screen.getByText("What is the scope?")).toBeDefined();
-      });
-
-      const continueButton = screen.getByRole("button", { name: "Next question" });
-      fireEvent.click(screen.getByTestId("planning-option-other"));
-      const otherInput = await screen.findByTestId("planning-other-input");
-      fireEvent.change(otherInput, { target: { value: "   " } });
-      expect(continueButton).toBeDisabled();
-      fireEvent.change(otherInput, { target: { value: "Ignore suggested scope" } });
-      expect(continueButton).toBeEnabled();
-
-      fireEvent.click(screen.getByText("Small"));
-      expect(screen.queryByTestId("planning-other-input")).toBeNull();
-      fireEvent.click(continueButton);
-
-      await waitFor(() => {
-        expect(mockRespondToPlanning).toHaveBeenCalledWith(
-          "session-123",
-          { "q-scope": "small" },
-          undefined,
-        );
-      });
-    });
-
-    it("allows Other-only answers for multi-select planning questions", async () => {
-      window.sessionStorage.setItem("fusion-tab-id", "tab-self");
-      mockConnectPlanningStream.mockImplementationOnce((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        queuePlanningStreamEvent(() => {
-          handlers.onQuestion?.({
-            id: "q-priorities",
-            type: "multi_select",
-            question: "Which priorities matter?",
-            options: [
-              { id: "speed", label: "Speed" },
-              { id: "quality", label: "Quality" },
-            ],
-          });
-        });
-        return {
-          close: vi.fn(),
-          isConnected: vi.fn().mockReturnValue(true),
-        };
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Build auth system" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(screen.getByText("Which priorities matter?")).toBeDefined();
-      });
-
-      const continueButton = screen.getByRole("button", { name: "Next question" });
-      /*
-      FNXC:PlanningModeOptions 2026-07-18-14:00:
-      Full Suite shard 3 (29646721723) timed out finding planning-other-input after a bare
-      checkbox click under CI load. Wait for the multi-select Other checkbox to be checked,
-      then findByTestId the input (extends FN-8245 settle discipline).
-      */
-      const otherCheckbox = within(screen.getByTestId("planning-option-other")).getByRole("checkbox");
-      fireEvent.click(otherCheckbox);
-      await waitFor(() => expect(otherCheckbox).toBeChecked());
-      expect(continueButton).toBeDisabled();
-      const otherInput = await screen.findByTestId("planning-other-input");
-      fireEvent.change(otherInput, { target: { value: "  Challenge the premise  " } });
-      expect(continueButton).toBeEnabled();
-      fireEvent.click(continueButton);
-
-      await waitFor(() => {
-        expect(mockRespondToPlanning).toHaveBeenCalledWith(
-          "session-123",
-          { _other: "Challenge the premise" },
-          undefined,
-        );
-      });
-    });
-
-    it("combines provided options with Other text for multi-select planning questions on mobile", async () => {
-      window.sessionStorage.setItem("fusion-tab-id", "tab-self");
-      mockViewport("mobile");
-      mockConnectPlanningStream.mockImplementationOnce((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        queuePlanningStreamEvent(() => {
-          handlers.onQuestion?.({
-            id: "q-priorities",
-            type: "multi_select",
-            question: "Which priorities matter?",
-            options: [
-              { id: "speed", label: "Speed" },
-              { id: "quality", label: "Quality" },
-            ],
-          });
-        });
-        return {
-          close: vi.fn(),
-          isConnected: vi.fn().mockReturnValue(true),
-        };
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Build auth system" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(screen.getByText("Which priorities matter?")).toBeDefined();
-      });
-
-      const continueButton = screen.getByRole("button", { name: "Next question" });
-      /*
-      FNXC:PlanningModeOptions 2026-07-18-10:35:
-      Full-suite shard load observed getByText("Speed") not committing the multi-select
-      checkbox state before Other was toggled (payload lost q-priorities and only sent
-      _other). Click the option checkbox by accessible name and wait for checked before
-      combining Other — same FN-8245 settle discipline as Other-only.
-      */
-      const speedCheckbox = screen.getByRole("checkbox", { name: /Speed/i });
-      fireEvent.click(speedCheckbox);
-      await waitFor(() => {
-        expect(speedCheckbox).toBeChecked();
-      });
-      fireEvent.click(within(screen.getByTestId("planning-option-other")).getByRole("checkbox"));
-      const otherInput = await screen.findByTestId("planning-other-input");
-      fireEvent.change(otherInput, { target: { value: "  Preserve operator control  " } });
-      expect(continueButton).toBeEnabled();
-      fireEvent.click(continueButton);
-
-      await waitFor(() => {
-        expect(mockRespondToPlanning).toHaveBeenCalledWith(
-          "session-123",
-          { "q-priorities": ["speed"], _other: "Preserve operator control" },
-          undefined,
-        );
-      });
-    });
-
-    it.each(["desktop", "mobile"] as const)("lets confirm questions submit an Other answer on %s", async (viewportMode) => {
-      window.sessionStorage.setItem("fusion-tab-id", "tab-self");
-      mockViewport(viewportMode);
-      mockConnectPlanningStream.mockImplementationOnce((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        queuePlanningStreamEvent(() => {
-          handlers.onQuestion?.({
-            id: "q-confirm-scope",
-            type: "confirm",
-            question: "Proceed with this scope?",
-            description: "Choose Yes, No, or write a different answer.",
-          });
-        });
-        return {
-          close: vi.fn(),
-          isConnected: vi.fn().mockReturnValue(true),
-        };
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Build auth system" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(screen.getByText("Proceed with this scope?")).toBeDefined();
-      });
-
-      expect(screen.getByRole("button", { name: /Yes/ })).toBeInTheDocument();
-      expect(screen.getByRole("button", { name: /No/ })).toBeInTheDocument();
-      expect(screen.getByTestId("planning-option-other")).toBeInTheDocument();
-      expect(screen.queryByTestId("planning-other-input")).toBeNull();
-
-      /*
-      FNXC:PlanningModeOptions 2026-07-18-12:15:
-      Full Suite shard 3 (29643371961) failed when fireEvent.click(Other) did not flush
-      isOtherSelected before the synchronous getByTestId(planning-other-input) under CI
-      load. Await findByTestId after the confirm Other button click (same settle discipline
-      as multi-select Other) before asserting Next question enablement and the _other payload.
-      */
-      const continueButton = screen.getByRole("button", { name: "Next question" });
-      fireEvent.click(screen.getByTestId("planning-option-other"));
-      const otherInput = await screen.findByTestId("planning-other-input");
-      expect(continueButton).toBeDisabled();
-
-      fireEvent.change(otherInput, { target: { value: "   " } });
-      expect(continueButton).toBeDisabled();
-
-      fireEvent.change(otherInput, {
-        target: { value: "  Ask a different scoping question  " },
-      });
-      expect(continueButton).toBeEnabled();
-      fireEvent.click(continueButton);
-
-      await waitFor(() => {
-        expect(mockRespondToPlanning).toHaveBeenCalledWith(
-          "session-123",
-          { _other: "Ask a different scoping question" },
-          undefined,
-        );
-      });
-    });
-
-    it("clears confirm Other text when switching back to Yes or No", async () => {
-      window.sessionStorage.setItem("fusion-tab-id", "tab-self");
-      mockConnectPlanningStream.mockImplementationOnce((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        queuePlanningStreamEvent(() => {
-          handlers.onQuestion?.({
-            id: "q-confirm-scope",
-            type: "confirm",
-            question: "Proceed with this scope?",
-          });
-        });
-        return {
-          close: vi.fn(),
-          isConnected: vi.fn().mockReturnValue(true),
-        };
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Build auth system" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(screen.getByText("Proceed with this scope?")).toBeDefined();
-      });
-
-      const continueButton = screen.getByRole("button", { name: "Next question" });
-      fireEvent.click(screen.getByTestId("planning-option-other"));
-      const otherInput = await screen.findByTestId("planning-other-input");
-      fireEvent.change(otherInput, {
-        target: { value: "Ask a different scoping question" },
-      });
-      fireEvent.change(screen.getByLabelText("Additional comments (optional)"), {
-        target: { value: "Keep the planner moving" },
-      });
-      expect(continueButton).toBeEnabled();
-
-      fireEvent.click(screen.getByRole("button", { name: /No/ }));
-      expect(screen.queryByTestId("planning-other-input")).toBeNull();
-      fireEvent.click(continueButton);
-
-      await waitFor(() => {
-        expect(mockRespondToPlanning).toHaveBeenCalledWith(
-          "session-123",
-          { "q-confirm-scope": false, _comment: "Keep the planner moving" },
-          undefined,
-        );
-      });
-    });
-
-    it("shows stop action in loading and stops generation", async () => {
-      let streamHandlers: any;
-      const closeSpy = vi.fn();
-      mockConnectPlanningStream.mockImplementationOnce((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        streamHandlers = handlers;
-        return {
-          close: closeSpy,
-          isConnected: vi.fn().mockReturnValue(true),
-        };
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Build auth system" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Stop" })).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByRole("button", { name: "Stop" }));
-
-      await waitFor(() => {
-        expect(mockStopPlanningGeneration).toHaveBeenCalledWith("session-123", undefined);
-      });
-      expect(closeSpy).toHaveBeenCalled();
-      await waitFor(() => {
-        expect(screen.getByText("Generation stopped by user. You can retry or start a new session.")).toBeDefined();
-      });
-      expect(screen.getByRole("button", { name: "Retry" })).toBeDefined();
-
-      // avoid dangling handlers reference lint
-      expect(streamHandlers).toBeDefined();
-    });
-
-    it("auto-retries a persisted stream error three times before showing the permanent error", async () => {
-      const streamHandlers: any[] = [];
-      mockConnectPlanningStream.mockImplementation((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        streamHandlers.push(handlers);
-        return {
-          close: vi.fn(),
-          isConnected: vi.fn().mockReturnValue(true),
-        };
-      });
-      mockFetchAiSession.mockResolvedValue({
-        id: "session-123",
-        type: "planning",
-        status: "error",
-        title: "Build auth system",
-        inputPayload: JSON.stringify({ initialPlan: "Build auth system" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: null,
-        thinkingOutput: "",
-        error: "Rate limit exceeded",
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      const textarea = screen.getByPlaceholderText(/e.g., Build a user authentication/);
-      fireEvent.change(textarea, { target: { value: "Build auth system" } });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => expect(streamHandlers).toHaveLength(1));
-
-      await act(async () => {
-        streamHandlers[0].onError?.("Rate limit exceeded");
-      });
-      await waitFor(() => expect(mockRetryPlanningSession).toHaveBeenCalledTimes(1));
-      expect(screen.getByText("Retrying… (attempt 1 of 3)")).toBeDefined();
-
-      await act(async () => {
-        streamHandlers[1].onError?.("Rate limit exceeded");
-      });
-      await waitFor(() => expect(mockRetryPlanningSession).toHaveBeenCalledTimes(2));
-      expect(screen.getByText("Retrying… (attempt 2 of 3)")).toBeDefined();
-
-      await act(async () => {
-        streamHandlers[2].onError?.("Rate limit exceeded");
-      });
-      await waitFor(() => expect(mockRetryPlanningSession).toHaveBeenCalledTimes(3));
-      expect(screen.getByText("Retrying… (attempt 3 of 3)")).toBeDefined();
-
-      await act(async () => {
-        streamHandlers[3].onError?.("Rate limit exceeded");
-      });
-      await waitFor(() => {
-        expect(screen.getByText("Rate limit exceeded")).toBeDefined();
-      });
-      expect(mockRetryPlanningSession).toHaveBeenCalledTimes(3);
-      expect(screen.getByRole("button", { name: "Retry" })).toBeDefined();
-    });
-
-    it("manual retry still starts a fresh retry after the auto-retry budget is exhausted", async () => {
-      const streamHandlers: any[] = [];
-      mockConnectPlanningStream.mockImplementation((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        streamHandlers.push(handlers);
-        return {
-          close: vi.fn(),
-          isConnected: vi.fn().mockReturnValue(true),
-        };
-      });
-      mockFetchAiSession.mockResolvedValue({
-        id: "session-123",
-        type: "planning",
-        status: "error",
-        title: "Build auth system",
-        inputPayload: JSON.stringify({ initialPlan: "Build auth system" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: null,
-        thinkingOutput: "",
-        error: "Temporary failure",
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Build auth system" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => expect(streamHandlers).toHaveLength(1));
-      for (let index = 0; index < 4; index += 1) {
-        await act(async () => {
-          streamHandlers[index].onError?.("Temporary failure");
-        });
-      }
-
-      await waitFor(() => {
-        expect(screen.getByText("Temporary failure")).toBeDefined();
-      });
-      expect(mockRetryPlanningSession).toHaveBeenCalledTimes(3);
-
-      mockFetchAiSession.mockResolvedValue({
-        id: "session-123",
-        type: "planning",
-        status: "generating",
-        title: "Build auth system",
-        inputPayload: JSON.stringify({ initialPlan: "Build auth system" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: null,
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-      fireEvent.click(screen.getByRole("button", { name: "Retry" }));
-
-      await waitFor(() => {
-        expect(mockRetryPlanningSession).toHaveBeenCalledTimes(4);
-      });
-      await act(async () => {
-        streamHandlers[4].onQuestion?.(mockQuestion);
-      });
-      await waitFor(() => {
-        expect(screen.getByText("What is the scope?")).toBeDefined();
-      });
-    });
-
-    it("resets the auto-retry budget after successful question progress", async () => {
-      const streamHandlers: any[] = [];
-      mockConnectPlanningStream.mockImplementation((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        streamHandlers.push(handlers);
-        return {
-          close: vi.fn(),
-          isConnected: vi.fn().mockReturnValue(true),
-        };
-      });
-      mockFetchAiSession.mockResolvedValue({
-        id: "session-123",
-        type: "planning",
-        status: "error",
-        title: "Build auth system",
-        inputPayload: JSON.stringify({ initialPlan: "Build auth system" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: null,
-        thinkingOutput: "",
-        error: "Temporary failure",
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Build auth system" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-      await waitFor(() => expect(streamHandlers).toHaveLength(1));
-
-      await act(async () => {
-        streamHandlers[0].onError?.("Temporary failure");
-      });
-      await waitFor(() => expect(screen.getByText("Retrying… (attempt 1 of 3)")).toBeDefined());
-
-      await act(async () => {
-        streamHandlers[1].onQuestion?.(mockQuestion);
-      });
-      await waitFor(() => expect(screen.getByText("What is the scope?")).toBeDefined());
-
-      await act(async () => {
-        streamHandlers[1].onError?.("Temporary failure");
-      });
-      await waitFor(() => expect(mockRetryPlanningSession).toHaveBeenCalledTimes(2));
-      expect(screen.getByText("Retrying… (attempt 1 of 3)")).toBeDefined();
-      expect(screen.queryByText("Temporary failure")).toBeNull();
-    });
-
-    it("single-flights overlapping SSE error and stuck-poll retry signals", async () => {
-      const streamHandlers: any[] = [];
-      let pollTick: (() => void | Promise<void>) | undefined;
-      const setIntervalSpy = vi.spyOn(globalThis, "setInterval").mockImplementation((callback: TimerHandler, timeout?: number) => {
-        if (timeout === 8000) {
-          pollTick = callback as () => void | Promise<void>;
-        }
-        return 1 as unknown as ReturnType<typeof setInterval>;
-      });
-      let resolveRetry!: (value: { success: boolean; sessionId: string }) => void;
-      const retryPromise = new Promise<{ success: boolean; sessionId: string }>((resolve) => {
-        resolveRetry = resolve;
-      });
-      mockRetryPlanningSession.mockReturnValue(retryPromise);
-      mockConnectPlanningStream.mockImplementation((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        streamHandlers.push(handlers);
-        return {
-          close: vi.fn(),
-          isConnected: vi.fn().mockReturnValue(true),
-        };
-      });
-      mockFetchAiSession.mockResolvedValue({
-        id: "session-123",
-        type: "planning",
-        status: "error",
-        title: "Build auth system",
-        inputPayload: JSON.stringify({ initialPlan: "Build auth system" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: null,
-        thinkingOutput: "",
-        error: "Temporary failure",
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      try {
-        render(
-          <PlanningModeModal
-            isOpen={true}
-            onClose={mockOnClose}
-            onTaskCreated={mockOnTaskCreated}
-            onTasksCreated={vi.fn()}
-            tasks={mockTasks}
-          />,
-        );
-
-        fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-          target: { value: "Build auth system" },
-        });
-        fireEvent.click(screen.getByText("Start Planning"));
-        await waitFor(() => expect(streamHandlers).toHaveLength(1));
-        await waitFor(() => expect(pollTick).toBeDefined());
-
-        await act(async () => {
-          void streamHandlers[0].onError?.("Temporary failure");
-          await Promise.resolve();
-          await pollTick?.();
-        });
-
-        expect(mockRetryPlanningSession).toHaveBeenCalledTimes(1);
-        expect(screen.getByText("Retrying… (attempt 1 of 3)")).toBeDefined();
-
-        await act(async () => {
-          resolveRetry({ success: true, sessionId: "session-123" });
-        });
-      } finally {
-        setIntervalSpy.mockRestore();
-      }
-    });
-
-    it("surfaces the permanent error view once the stuck-poll fallback exhausts the auto-retry budget without any SSE onError signal", async () => {
-      // FN-7946 regression: if the SSE connection never invokes onError (e.g. a
-      // dropped event) and the 8s watchdog poll is the only signal that discovers
-      // a terminal session error, the poll path must still surface the permanent
-      // error view once MAX_PLANNING_AUTO_RETRIES is exhausted — not leave the
-      // modal stuck on the loading spinner forever.
-      const streamHandlers: any[] = [];
-      const pollTicks: Array<() => void | Promise<void>> = [];
-      const setIntervalSpy = vi.spyOn(globalThis, "setInterval").mockImplementation((callback: TimerHandler, timeout?: number) => {
-        if (timeout === 8000) {
-          pollTicks.push(callback as () => void | Promise<void>);
-        }
-        return 1 as unknown as ReturnType<typeof setInterval>;
-      });
-      mockConnectPlanningStream.mockImplementation((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        streamHandlers.push(handlers);
-        return {
-          close: vi.fn(),
-          isConnected: vi.fn().mockReturnValue(true),
-        };
-      });
-      mockFetchAiSession.mockResolvedValue({
-        id: "session-123",
-        type: "planning",
-        status: "error",
-        title: "Build auth system",
-        inputPayload: JSON.stringify({ initialPlan: "Build auth system" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: null,
-        thinkingOutput: "",
-        error: "Watchdog aborted a stalled turn",
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      try {
-        render(
-          <PlanningModeModal
-            isOpen={true}
-            onClose={mockOnClose}
-            onTaskCreated={mockOnTaskCreated}
-            onTasksCreated={vi.fn()}
-            tasks={mockTasks}
-          />,
-        );
-
-        fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-          target: { value: "Build auth system" },
-        });
-        fireEvent.click(screen.getByText("Start Planning"));
-        await waitFor(() => expect(streamHandlers).toHaveLength(1));
-
-        // Drive every retry attempt purely through the watchdog poll — the SSE
-        // handlers never call onError, simulating a missed/dropped SSE event.
-        // The interval is registered once while the view stays "loading" across
-        // retries (lockSessionId/session id do not change), so the same captured
-        // tick callback is re-invoked on each simulated 8s beat, exactly as the
-        // real setInterval would re-invoke it.
-        await waitFor(() => expect(pollTicks.length).toBeGreaterThan(0));
-        for (let index = 0; index < 4; index += 1) {
-          await act(async () => {
-            await pollTicks[0]?.();
-          });
-        }
-
-        await waitFor(() => {
-          expect(screen.getByText("Watchdog aborted a stalled turn")).toBeDefined();
-        });
-        expect(screen.getByRole("button", { name: "Retry" })).toBeDefined();
-        expect(mockRetryPlanningSession).toHaveBeenCalledTimes(3);
-      } finally {
-        setIntervalSpy.mockRestore();
-      }
-    });
-
-    it("auto-recovers from a stream error when server session is still generating", async () => {
-      let streamAttempt = 0;
-      mockConnectPlanningStream.mockImplementation((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        streamAttempt += 1;
-        if (streamAttempt === 1) {
-          queuePlanningStreamEvent(() => handlers.onError?.("Connection lost"));
-        }
-
-        return {
-          close: vi.fn(),
-          isConnected: vi.fn().mockReturnValue(true),
-        };
-      });
-
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-123",
-        type: "planning",
-        status: "generating",
-        title: "Build auth system",
-        inputPayload: JSON.stringify({ initialPlan: "Build auth system" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: null,
-        thinkingOutput: "Still thinking...",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Build auth system" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      // No manual retry button — onError silently re-fetches the session,
-      // sees status="generating", and reconnects without surfacing the error.
-      await waitFor(() => {
-        expect(mockFetchAiSession).toHaveBeenCalledWith("session-123");
-        expect(mockConnectPlanningStream).toHaveBeenCalledTimes(2);
-      });
-      expect(screen.queryByText("Connection lost")).toBeNull();
-    });
-
-    it("auto-recovers from a stream error when server session is awaiting input", async () => {
-      let streamAttempt = 0;
-      mockConnectPlanningStream.mockImplementation((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        streamAttempt += 1;
-        if (streamAttempt === 1) {
-          queuePlanningStreamEvent(() => handlers.onError?.("Connection lost"));
-        }
-
-        return {
-          close: vi.fn(),
-          isConnected: vi.fn().mockReturnValue(true),
-        };
-      });
-
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-123",
-        type: "planning",
-        status: "awaiting_input",
-        title: "Build auth system",
-        inputPayload: JSON.stringify({ initialPlan: "Build auth system" }),
-        conversationHistory: "[]",
-        currentQuestion: JSON.stringify(mockQuestion),
-        result: null,
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Build auth system" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      // Silent recovery: onError re-fetches the session, sees status=
-      // "awaiting_input", and reconnects without surfacing the error.
-      await waitFor(() => {
-        expect(mockFetchAiSession).toHaveBeenCalledWith("session-123");
-        expect(mockConnectPlanningStream).toHaveBeenCalledTimes(2);
-      });
-      expect(screen.queryByText("Connection lost")).toBeNull();
-    });
-  });
-
-  describe("Resuming complete sessions", () => {
-    function createDeferred<T>() {
-      let resolve!: (value: T) => void;
-      const promise = new Promise<T>((res) => {
-        resolve = res;
-      });
-      return { promise, resolve };
-    }
-
-    it("FN-4769 shows inline Creating spinner for Create Single Task while task creation is pending", async () => {
-      const resumedSummary: PlanningSummary = {
-        title: "Resume-spinner-single-task",
-        description: "Recovered summary for spinner",
-        suggestedSize: "M",
-        suggestedDependencies: [],
-        keyDeliverables: ["Implement", "Verify"],
-      };
-      const createTaskDeferred = createDeferred<Task>();
-
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-spinner-single-task",
-        type: "planning",
-        status: "complete",
-        title: "Resume-spinner-single-task",
-        inputPayload: JSON.stringify({ validated: true, initialPlan: "Recover and create" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: JSON.stringify(resumedSummary),
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-      mockCreateTaskFromPlanning.mockReturnValueOnce(createTaskDeferred.promise);
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId="session-spinner-single-task"
-        />
-      );
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Create Single Task" })).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByRole("button", { name: "Create Single Task" }));
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Creating..." })).toBeDefined();
-      });
-
-      createTaskDeferred.resolve({
-        id: "FN-4769",
-        title: "Created from spinner test",
-        description: "",
-        column: "triage",
-        dependencies: [],
-        steps: [],
-        currentStep: 0,
-        log: [],
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      } as Task);
-
-      await waitFor(() => {
-        expect(mockOnClose).toHaveBeenCalled();
-      });
-    });
-
-    it("FN-5912 keeps Break into Tasks labeled while Create Single Task is pending", async () => {
-      const resumedSummary: PlanningSummary = {
-        title: "Resume-spinner-isolation-single-task",
-        description: "Recovered summary for spinner isolation on single-task creation",
-        suggestedSize: "M",
-        suggestedDependencies: [],
-        keyDeliverables: ["Implement", "Verify"],
-      };
-      const createTaskDeferred = createDeferred<Task>();
-
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-spinner-isolation-single-task",
-        type: "planning",
-        status: "complete",
-        title: "Resume-spinner-isolation-single-task",
-        inputPayload: JSON.stringify({ validated: true, initialPlan: "Recover and create a single task" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: JSON.stringify(resumedSummary),
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-      mockCreateTaskFromPlanning.mockReturnValueOnce(createTaskDeferred.promise);
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId="session-spinner-isolation-single-task"
-        />
-      );
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Create Single Task" })).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByRole("button", { name: "Create Single Task" }));
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Creating..." })).toBeDisabled();
-      });
-
-      expect(screen.getByRole("button", { name: "Break into Tasks" })).toBeDisabled();
-      expect(screen.queryByRole("button", { name: "Breaking down..." })).toBeNull();
-
-      createTaskDeferred.resolve({
-        id: "FN-5912",
-        title: "Created from spinner isolation test",
-        description: "",
-        column: "triage",
-        dependencies: [],
-        steps: [],
-        currentStep: 0,
-        log: [],
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      } as Task);
-
-      await waitFor(() => {
-        expect(mockOnClose).toHaveBeenCalled();
-      });
-    });
-
-    it("FN-4769 shows inline Breaking down spinner for Break into Tasks while breakdown start is pending", async () => {
-      const resumedSummary: PlanningSummary = {
-        title: "Resume-spinner-breakdown-start",
-        description: "Recovered summary for breakdown start spinner",
-        suggestedSize: "M",
-        suggestedDependencies: [],
-        keyDeliverables: ["Implement", "Verify"],
-      };
-      const breakdownDeferred = createDeferred<{ sessionId: string; subtasks: any[] }>();
-
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-spinner-breakdown-start",
-        type: "planning",
-        status: "complete",
-        title: "Resume-spinner-breakdown-start",
-        inputPayload: JSON.stringify({ validated: true, initialPlan: "Recover and break down" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: JSON.stringify(resumedSummary),
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-      mockStartPlanningBreakdown.mockReturnValueOnce(breakdownDeferred.promise);
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId="session-spinner-breakdown-start"
-        />
-      );
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Break into Tasks" })).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByRole("button", { name: "Break into Tasks" }));
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Breaking down..." })).toBeDefined();
-      });
-
-      breakdownDeferred.resolve({
-        sessionId: "session-spinner-breakdown-start",
-        subtasks: [
-          {
-            id: "subtask-1",
-            title: "First subtask",
-            description: "First description",
-            suggestedSize: "M",
-            dependsOn: [],
-          },
-        ],
-      });
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Create Tasks" })).toBeDefined();
-      });
-    });
-
-    it("FN-5912 keeps Create Single Task labeled while Break into Tasks is pending", async () => {
-      const resumedSummary: PlanningSummary = {
-        title: "Resume-spinner-isolation-breakdown",
-        description: "Recovered summary for spinner isolation on breakdown start",
-        suggestedSize: "M",
-        suggestedDependencies: [],
-        keyDeliverables: ["Implement", "Verify"],
-      };
-      const breakdownDeferred = createDeferred<{ sessionId: string; subtasks: any[] }>();
-
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-spinner-isolation-breakdown",
-        type: "planning",
-        status: "complete",
-        title: "Resume-spinner-isolation-breakdown",
-        inputPayload: JSON.stringify({ validated: true, initialPlan: "Recover and break down into tasks" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: JSON.stringify(resumedSummary),
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-      mockStartPlanningBreakdown.mockReturnValueOnce(breakdownDeferred.promise);
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId="session-spinner-isolation-breakdown"
-        />
-      );
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Break into Tasks" })).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByRole("button", { name: "Break into Tasks" }));
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Breaking down..." })).toBeDisabled();
-      });
-
-      expect(screen.getByRole("button", { name: "Create Single Task" })).toBeDisabled();
-      expect(screen.queryByRole("button", { name: "Creating..." })).toBeNull();
-
-      breakdownDeferred.resolve({
-        sessionId: "session-spinner-isolation-breakdown",
-        subtasks: [
-          {
-            id: "subtask-1",
-            title: "First subtask",
-            description: "First description",
-            suggestedSize: "M",
-            dependsOn: [],
-          },
-        ],
-      });
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Create Tasks" })).toBeDefined();
-      });
-    });
-
-    it("FN-4769 shows inline Creating spinner for Create Tasks while breakdown creation is pending", async () => {
-      const resumedSummary: PlanningSummary = {
-        title: "Resume-spinner-breakdown-create",
-        description: "Recovered summary for breakdown create spinner",
-        suggestedSize: "M",
-        suggestedDependencies: [],
-        keyDeliverables: ["Implement", "Verify"],
-      };
-      const createTasksDeferred = createDeferred<{ tasks: Task[] }>();
-
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-spinner-breakdown-create",
-        type: "planning",
-        status: "complete",
-        title: "Resume-spinner-breakdown-create",
-        inputPayload: JSON.stringify({ validated: true, initialPlan: "Recover and create tasks" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: JSON.stringify(resumedSummary),
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-      mockStartPlanningBreakdown.mockResolvedValueOnce({
-        sessionId: "session-spinner-breakdown-create",
-        subtasks: [
-          {
-            id: "subtask-1",
-            title: "First subtask",
-            description: "First description",
-            suggestedSize: "M",
-            dependsOn: [],
-          },
-        ],
-      });
-      mockCreateTasksFromPlanning.mockReturnValueOnce(createTasksDeferred.promise);
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId="session-spinner-breakdown-create"
-        />
-      );
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Break into Tasks" })).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByRole("button", { name: "Break into Tasks" }));
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Create Tasks" })).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByRole("button", { name: "Create Tasks" }));
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Creating..." })).toBeDefined();
-      });
-
-      createTasksDeferred.resolve({ tasks: [] });
-
-      await waitFor(() => {
-        expect(mockOnClose).toHaveBeenCalled();
-      });
-    });
-
-    it.each(["desktop", "mobile"] as const)("FN-6977 renders malformed persisted summary without generic error on %s", async (viewportMode) => {
-      mockViewport(viewportMode);
-      const malformedSummary = {
-        title: "Malformed summary without arrays",
-        description: "Recovered summary missing deliverable and dependency arrays",
-        suggestedSize: "M",
-      };
-
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: `session-fn-6977-${viewportMode}`,
-        type: "planning",
-        status: "complete",
-        title: "Malformed summary without arrays",
-        inputPayload: JSON.stringify({ validated: true, initialPlan: "Recover malformed summary" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: JSON.stringify(malformedSummary),
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId={`session-fn-6977-${viewportMode}`}
-        />
-      );
-
-      await waitFor(() => {
-        expect(screen.getByText("Planning Complete!")).toBeDefined();
-      });
-
-      expect(screen.getByText("Recovered summary missing deliverable and dependency arrays")).toBeDefined();
-      expect(screen.queryByText(/Something went wrong/i)).toBeNull();
-      expect(screen.getByRole("button", { name: "Create Single Task" })).toBeEnabled();
-      expect(screen.getByRole("button", { name: "Break into Tasks" })).toBeEnabled();
-    });
-
-    it("FN-6977 sends normalized empty arrays when creating from a malformed summary", async () => {
-      const malformedSummary = {
-        title: "Malformed summary create task",
-        description: "Recovered summary can still create a task",
-        suggestedSize: "M",
-      };
-
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-fn-6977-create",
-        type: "planning",
-        status: "complete",
-        title: "Malformed summary create task",
-        inputPayload: JSON.stringify({ validated: true, initialPlan: "Recover malformed summary and create" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: JSON.stringify(malformedSummary),
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-      mockCreateTaskFromPlanning.mockResolvedValueOnce({
-        id: "FN-6977",
-        title: "Created from malformed summary",
-        description: "",
-        column: "triage",
-        dependencies: [],
-        steps: [],
-        currentStep: 0,
-        log: [],
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      } as Task);
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId="session-fn-6977-create"
-        />
-      );
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Create Single Task" })).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByRole("button", { name: "Create Single Task" }));
-
-      await waitFor(() => {
-        expect(mockCreateTaskFromPlanning).toHaveBeenCalledWith(
-          "session-fn-6977-create",
-          expect.objectContaining({
-            suggestedDependencies: [],
-            keyDeliverables: [],
-          }),
-          undefined,
-          expect.any(Object),
-        );
-      });
-      expect(screen.queryByText(/Something went wrong/i)).toBeNull();
-    });
-
-    it("FN-6977 starts breakdown from malformed summary and normalizes missing subtask dependsOn", async () => {
-      const malformedSummary = {
-        title: "Malformed summary breakdown",
-        description: "Recovered summary can still be broken down",
-        suggestedSize: "M",
-      };
-
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-fn-6977-breakdown",
-        type: "planning",
-        status: "complete",
-        title: "Malformed summary breakdown",
-        inputPayload: JSON.stringify({ validated: true, initialPlan: "Recover malformed summary and break down" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: JSON.stringify(malformedSummary),
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-      mockStartPlanningBreakdown.mockResolvedValueOnce({
-        sessionId: "session-fn-6977-breakdown",
-        subtasks: [
-          {
-            id: "subtask-1",
-            title: "Fallback implementation",
-            description: "Generated despite omitted deliverables",
-            suggestedSize: "M",
-          },
-        ],
-      });
-      mockCreateTasksFromPlanning.mockResolvedValueOnce({ tasks: [] });
-      const onTasksCreated = vi.fn();
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={onTasksCreated}
-          tasks={mockTasks}
-          resumeSessionId="session-fn-6977-breakdown"
-        />
-      );
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Break into Tasks" })).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByRole("button", { name: "Break into Tasks" }));
-
-      await waitFor(() => {
-        expect(mockStartPlanningBreakdown).toHaveBeenCalledWith(
-          "session-fn-6977-breakdown",
-          expect.objectContaining({ suggestedDependencies: [], keyDeliverables: [] }),
-          undefined,
-        );
-        expect(screen.getByDisplayValue("Fallback implementation")).toBeDefined();
-      });
-      expect(screen.getByText("First subtask cannot have dependencies.")).toBeDefined();
-
-      fireEvent.click(screen.getByRole("button", { name: "Create Tasks" }));
-
-      await waitFor(() => {
-        expect(mockCreateTasksFromPlanning).toHaveBeenCalledWith(
-          "session-fn-6977-breakdown",
-          [expect.objectContaining({ id: "subtask-1" })],
-          undefined,
-          expect.any(Object),
-        );
-        expect(onTasksCreated).toHaveBeenCalledWith([]);
-      });
-      expect(screen.queryByText(/Something went wrong/i)).toBeNull();
-    });
-
-    it.each(["desktop", "mobile"] as const)("keeps persisted awaiting-input questions free of reconnecting hints on %s", async (viewportMode) => {
-      mockViewport(viewportMode);
-      let streamHandlers: any;
-      mockConnectPlanningStream.mockImplementationOnce((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        streamHandlers = handlers;
-        return { close: vi.fn(), isConnected: vi.fn().mockReturnValue(true) };
-      });
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: `session-reconnect-question-${viewportMode}`,
-        type: "planning",
-        status: "awaiting_input",
-        title: "Persisted question",
-        inputPayload: JSON.stringify({ initialPlan: "Resume persisted question" }),
-        conversationHistory: "[]",
-        currentQuestion: JSON.stringify(mockQuestion),
-        result: null,
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId={`session-reconnect-question-${viewportMode}`}
-        />,
-      );
-
-      expect(await screen.findByText(mockQuestion.question)).toBeInTheDocument();
-      act(() => {
-        streamHandlers.onConnectionStateChange?.("reconnecting");
-      });
-
-      expect(screen.getByText(mockQuestion.question)).toBeInTheDocument();
-      expect(screen.queryByText("Reconnecting…")).toBeNull();
-    });
-
-    it("keeps generation chrome visible without a reconnecting hint during stream recovery", async () => {
-      let streamHandlers: any;
-      mockConnectPlanningStream.mockImplementationOnce((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        streamHandlers = handlers;
-        return { close: vi.fn(), isConnected: vi.fn().mockReturnValue(true) };
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Generate a planning task" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-      await waitFor(() => expect(mockConnectPlanningStream).toHaveBeenCalledTimes(1));
-
-      expect(screen.getByText("Generating next question...")).toBeInTheDocument();
-      act(() => {
-        streamHandlers.onConnectionStateChange?.("reconnecting");
-      });
-
-      expect(screen.getByText("Generating next question...")).toBeInTheDocument();
-      expect(screen.queryByText("Reconnecting…")).toBeNull();
-    });
-
-    it("shows summary view when resuming a complete persisted session", async () => {
-      const resumedSummary: PlanningSummary = {
-        title: "Resume-ready planning output",
-        description: "Recovered summary description from persisted session",
-        suggestedSize: "L",
-        suggestedDependencies: ["FN-001"],
-        keyDeliverables: ["Deliverable A", "Deliverable B"],
-      };
-
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-complete-1",
-        type: "planning",
-        status: "complete",
-        title: "Resume-ready planning output",
-        inputPayload: JSON.stringify({ validated: true, initialPlan: "Build resilient planning resume" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: JSON.stringify(resumedSummary),
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId="session-complete-1"
-        />
-      );
-
-      await waitFor(() => {
-        expect(mockFetchAiSession).toHaveBeenCalledWith("session-complete-1");
-      });
-
-      await waitFor(() => {
-        expect(screen.getByText("Planning Complete!")).toBeDefined();
-      });
-
-      expect(screen.getByText("Recovered summary description from persisted session")).toBeDefined();
-      expect((screen.getByRole("combobox", { name: "Suggested Size" }) as HTMLSelectElement).value).toBe("L");
-      expect(screen.getByText("Deliverable A")).toBeDefined();
-      expect(screen.getByText("Deliverable B")).toBeDefined();
-    });
-
-    it("restores the textarea and reattaches the draft id when reopening a persisted draft", async () => {
-      const draftPlan = "Persisted draft text the user typed before closing the modal";
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-draft-1",
-        type: "planning",
-        status: "draft",
-        title: "New planning session",
-        inputPayload: JSON.stringify({ initialPlan: draftPlan }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: null,
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId="session-draft-1"
-        />,
-      );
-
-      await waitFor(() => {
-        expect(mockFetchAiSession).toHaveBeenCalledWith("session-draft-1");
-      });
-
-      // The draft is restored to the editor (initial view), not surfaced as a
-      // question or summary, and the textarea contains exactly the persisted
-      // initialPlan so the user can keep editing or click Start Planning.
-      const textarea = await screen.findByDisplayValue(draftPlan);
-      expect((textarea as HTMLTextAreaElement).tagName).toBe("TEXTAREA");
-      expect(screen.getByText("Start Planning")).toBeDefined();
-    });
-
-    it("restores the persisted model override when reopening a draft so Start Planning uses it", async () => {
-      // The draft was created under an explicit anthropic/claude-opus model.
-      // Reopening must restore that selection into the modal's local state
-      // so a subsequent Start Planning click uses it instead of silently
-      // falling back to whatever the dropdown currently defaults to. The
-      // server-side round-trip is covered separately in planning.test.ts;
-      // this test pins the React-state restoration.
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-draft-with-model",
-        type: "planning",
-        status: "draft",
-        title: "New planning session",
-        inputPayload: JSON.stringify({
-          initialPlan: "Plan that needs a specific model",
-          modelProvider: "anthropic",
-          modelId: "claude-sonnet-4-5",
-        }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: null,
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId="session-draft-with-model"
-        />,
-      );
-
-      // Wait for the textarea to be populated from the draft — proves the
-      // reopen path ran and the modal is in the editable initial view.
-      await screen.findByDisplayValue("Plan that needs a specific model");
-
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(mockStartPlanningStreaming).toHaveBeenCalledWith(
-          "Plan that needs a specific model",
-          undefined,
-          { planningModelProvider: "anthropic", planningModelId: "claude-sonnet-4-5", thinkingLevel: undefined },
-          { clarificationEnabled: true },
-          "session-draft-with-model",
-        );
-      });
-    });
-
-    it("lists planning history rows and restores the selected session to the correct view", async () => {
-      const completedSummary: PlanningSummary = {
-        title: "Completed planning session",
-        description: "Recovered summary from history",
-        suggestedSize: "M",
-        suggestedDependencies: [],
-        keyDeliverables: ["Implement"],
-      };
-
-      mockFetchAiSessions.mockResolvedValueOnce([
-        {
-          id: "session-history-complete",
-          type: "planning",
-          status: "complete",
-          title: "Completed planning session",
-          projectId: null,
-          updatedAt: "2026-01-02T00:00:00.000Z",
-          archived: false,
-        },
-        {
-          id: "session-history-draft",
-          type: "planning",
-          status: "draft",
-          title: "New planning session",
-          preview: "Draft plan from history",
-          projectId: null,
-          updatedAt: "2026-01-01T00:00:00.000Z",
-          archived: false,
-        },
-      ]);
-      mockFetchAiSession.mockImplementation(async (sessionId: string) => {
-        if (sessionId === "session-history-complete") {
-          return {
-            id: "session-history-complete",
-            type: "planning",
-            status: "complete",
-            title: completedSummary.title,
-            inputPayload: JSON.stringify({ validated: true, initialPlan: "Recover completed session" }),
-            conversationHistory: "[]",
-            currentQuestion: null,
-            result: JSON.stringify(completedSummary),
-            thinkingOutput: "",
-            error: null,
-            projectId: null,
-            createdAt: "2026-01-01T00:00:00.000Z",
-            updatedAt: "2026-01-02T00:00:00.000Z",
-          };
-        }
-
-        return {
-          id: "session-history-draft",
-          type: "planning",
-          status: "draft",
-          title: "New planning session",
-          inputPayload: JSON.stringify({ initialPlan: "Draft plan from history" }),
-          conversationHistory: "[]",
-          currentQuestion: null,
-          result: null,
-          thinkingOutput: "",
-          error: null,
-          projectId: null,
-          createdAt: "2026-01-01T00:00:00.000Z",
-          updatedAt: "2026-01-01T00:00:00.000Z",
-        };
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: /Completed planning session/i })).toBeDefined();
-      });
-      expect(screen.getByRole("button", { name: /Draft plan from history/i })).toBeDefined();
-
-      fireEvent.click(screen.getByRole("button", { name: /Completed planning session/i }));
-
-      await waitFor(() => {
-        expect(mockFetchAiSession).toHaveBeenCalledWith("session-history-complete");
-        expect(screen.getByText("Planning Complete!")).toBeDefined();
-      });
-      expect(screen.queryByPlaceholderText(/e.g., Build a user authentication/)).toBeNull();
-      expect(screen.getByText("Recovered summary from history")).toBeDefined();
-
-      fireEvent.click(screen.getByRole("button", { name: /Draft plan from history/i }));
-
-      await waitFor(() => {
-        expect(mockFetchAiSession).toHaveBeenCalledWith("session-history-draft");
-      });
-      expect(screen.getByDisplayValue("Draft plan from history")).toBeDefined();
-      expect(screen.getByRole("button", { name: "Start Planning" })).toBeDefined();
-    });
-
-    it.each(["desktop", "mobile"] as const)("FN-8332 restores an errored resumed session without auto-retry on %s", async (viewportMode) => {
-      mockViewport(viewportMode);
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: `session-error-${viewportMode}`,
-        type: "planning",
-        status: "error",
-        title: "Errored planning",
-        inputPayload: JSON.stringify({ initialPlan: "Recover planning" }),
-        conversationHistory: JSON.stringify([{ thinkingOutput: "Persisted analysis" }]),
-        currentQuestion: null,
-        result: null,
-        thinkingOutput: "",
-        error: "Session interrupted",
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId={`session-error-${viewportMode}`}
-        />,
-      );
-
-      expect(await screen.findByRole("alert")).toHaveTextContent("Session interrupted");
-      fireEvent.click(screen.getByRole("button", { name: "Show AI reasoning" }));
-      expect(screen.getByText("Persisted analysis")).toBeInTheDocument();
-      expect(screen.getByRole("button", { name: "Retry" })).toBeInTheDocument();
-      expect(screen.getByRole("button", { name: "Dismiss" })).toBeInTheDocument();
-      expect(mockRetryPlanningSession).not.toHaveBeenCalled();
-      expect(mockStartPlanningStreaming).not.toHaveBeenCalled();
-    });
-
-    it("FN-8332 keeps a resumed generating stream error manual", async () => {
-      let streamHandlers: any;
-      mockConnectPlanningStream.mockImplementationOnce((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        streamHandlers = handlers;
-        return { close: vi.fn(), isConnected: vi.fn().mockReturnValue(true) };
-      });
-      mockFetchAiSession
-        .mockResolvedValueOnce({
-          id: "session-resumed-generating-stream",
-          type: "planning",
-          status: "generating",
-          title: "Resumed generation",
-          inputPayload: JSON.stringify({ initialPlan: "Restore a live server turn" }),
-          conversationHistory: "[]",
-          currentQuestion: null,
-          result: null,
-          thinkingOutput: "Persisted thinking",
-          error: null,
-          projectId: null,
-          createdAt: "2026-01-01T00:00:00.000Z",
-          updatedAt: "2026-01-01T00:00:00.000Z",
-        })
-        .mockResolvedValueOnce({
-          id: "session-resumed-generating-stream",
-          type: "planning",
-          status: "error",
-          title: "Resumed generation",
-          inputPayload: JSON.stringify({ initialPlan: "Restore a live server turn" }),
-          conversationHistory: "[]",
-          currentQuestion: null,
-          result: null,
-          thinkingOutput: "Persisted thinking",
-          error: "Persisted server failure",
-          projectId: null,
-          createdAt: "2026-01-01T00:00:00.000Z",
-          updatedAt: "2026-01-01T00:00:01.000Z",
-        });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId="session-resumed-generating-stream"
-        />,
-      );
-
-      await waitFor(() => expect(streamHandlers).toBeDefined());
-      await act(async () => {
-        streamHandlers.onError?.("Stream disconnected");
-      });
-
-      expect(await screen.findByRole("alert")).toHaveTextContent("Stream disconnected");
-      expect(screen.getByRole("button", { name: "Retry" })).toBeInTheDocument();
-      expect(mockRetryPlanningSession).not.toHaveBeenCalled();
-    });
-
-    it("FN-8332 keeps a resumed generating poll error manual", async () => {
-      let pollTick: (() => void | Promise<void>) | undefined;
-      const setIntervalSpy = vi.spyOn(globalThis, "setInterval").mockImplementation((callback: TimerHandler, timeout?: number) => {
-        if (timeout === 8000) {
-          pollTick = callback as () => void | Promise<void>;
-        }
-        return 1 as unknown as ReturnType<typeof setInterval>;
-      });
-      mockConnectPlanningStream.mockImplementationOnce(() => ({
-        close: vi.fn(),
-        isConnected: vi.fn().mockReturnValue(true),
-      }));
-      mockFetchAiSession
-        .mockResolvedValueOnce({
-          id: "session-resumed-generating-poll",
-          type: "planning",
-          status: "generating",
-          title: "Resumed polling generation",
-          inputPayload: JSON.stringify({ initialPlan: "Restore polling turn" }),
-          conversationHistory: "[]",
-          currentQuestion: null,
-          result: null,
-          thinkingOutput: "",
-          error: null,
-          projectId: null,
-          createdAt: "2026-01-01T00:00:00.000Z",
-          updatedAt: "2026-01-01T00:00:00.000Z",
-        })
-        .mockResolvedValueOnce({
-          id: "session-resumed-generating-poll",
-          type: "planning",
-          status: "error",
-          title: "Resumed polling generation",
-          inputPayload: JSON.stringify({ initialPlan: "Restore polling turn" }),
-          conversationHistory: "[]",
-          currentQuestion: null,
-          result: null,
-          thinkingOutput: "",
-          error: "Persisted polling failure",
-          projectId: null,
-          createdAt: "2026-01-01T00:00:00.000Z",
-          updatedAt: "2026-01-01T00:00:01.000Z",
-        });
-
-      try {
-        render(
-          <PlanningModeModal
-            isOpen={true}
-            onClose={mockOnClose}
-            onTaskCreated={mockOnTaskCreated}
-            onTasksCreated={vi.fn()}
-            tasks={mockTasks}
-            resumeSessionId="session-resumed-generating-poll"
-          />,
-        );
-
-        await waitFor(() => expect(pollTick).toBeDefined());
-        await act(async () => {
-          await pollTick?.();
-        });
-
-        expect(await screen.findByRole("alert")).toHaveTextContent("Persisted polling failure");
-        expect(screen.getByRole("button", { name: "Retry" })).toBeInTheDocument();
-        expect(mockRetryPlanningSession).not.toHaveBeenCalled();
-      } finally {
-        setIntervalSpy.mockRestore();
-      }
-    });
-
-    it("FN-8332 restores an errored sidebar selection without auto-retry", async () => {
-      mockFetchAiSessions.mockResolvedValueOnce([
-        {
-          id: "session-sidebar-error",
-          type: "planning",
-          status: "error",
-          title: "Sidebar errored session",
-          projectId: null,
-          updatedAt: "2026-01-02T00:00:00.000Z",
-          archived: false,
-        },
-      ]);
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-sidebar-error",
-        type: "planning",
-        status: "error",
-        title: "Sidebar errored session",
-        inputPayload: JSON.stringify({ initialPlan: "Recover sidebar session" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: null,
-        thinkingOutput: "",
-        error: "Sidebar session interrupted",
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-02T00:00:00.000Z",
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      await screen.findByRole("button", { name: /Sidebar errored session/i });
-      fireEvent.click(screen.getByRole("button", { name: /Sidebar errored session/i }));
-
-      expect(await screen.findByRole("alert")).toHaveTextContent("Sidebar session interrupted");
-      expect(screen.getByRole("button", { name: "Retry" })).toBeInTheDocument();
-      expect(mockRetryPlanningSession).not.toHaveBeenCalled();
-      expect(mockStartPlanningStreaming).not.toHaveBeenCalled();
-    });
-
-    it("routes malformed persisted result data from sidebar selection to the recoverable error view", async () => {
-      mockFetchAiSessions.mockResolvedValueOnce([
-        {
-          id: "session-malformed-result",
-          type: "planning",
-          status: "complete",
-          title: "Malformed result session",
-          projectId: null,
-          updatedAt: "2026-01-02T00:00:00.000Z",
-          archived: false,
-        },
-      ]);
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-malformed-result",
-        type: "planning",
-        status: "complete",
-        title: "Malformed result session",
-        inputPayload: JSON.stringify({ validated: true, initialPlan: "Recover malformed result" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: "{",
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-02T00:00:00.000Z",
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: /Malformed result session/i })).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByRole("button", { name: /Malformed result session/i }));
-
-      await waitFor(() => {
-        expect(mockFetchAiSession).toHaveBeenCalledWith("session-malformed-result");
-        expect(screen.getByRole("alert")).toBeDefined();
-      });
-      expect(screen.getByRole("button", { name: "Retry" })).toBeDefined();
-      expect(screen.queryByRole("button", { name: "Start Planning" })).toBeNull();
-    });
-
-    it("re-syncs the selected session to the recoverable error view when the modal reopens", async () => {
-      const reopenedSummary: PlanningSummary = {
-        title: "Reopen then recover",
-        description: "First open shows a valid summary",
-        suggestedSize: "S",
-        suggestedDependencies: [],
-        keyDeliverables: ["Recover"],
-      };
-
-      mockFetchAiSessions.mockResolvedValue([
-        {
-          id: "session-reopen-recover",
-          type: "planning",
-          status: "complete",
-          title: "Reopen recover session",
-          projectId: null,
-          updatedAt: "2026-01-02T00:00:00.000Z",
-          archived: false,
-        },
-      ]);
-      mockFetchAiSession
-        .mockResolvedValueOnce({
-          id: "session-reopen-recover",
-          type: "planning",
-          status: "complete",
-          title: "Reopen recover session",
-          inputPayload: JSON.stringify({ validated: true, initialPlan: "Reopen recover session" }),
-          conversationHistory: "[]",
-          currentQuestion: null,
-          result: JSON.stringify(reopenedSummary),
-          thinkingOutput: "",
-          error: null,
-          projectId: null,
-          createdAt: "2026-01-01T00:00:00.000Z",
-          updatedAt: "2026-01-02T00:00:00.000Z",
-        })
-        .mockResolvedValueOnce({
-          id: "session-reopen-recover",
-          type: "planning",
-          status: "complete",
-          title: "Reopen recover session",
-          inputPayload: JSON.stringify({ validated: true, initialPlan: "Reopen recover session" }),
-          conversationHistory: "[]",
-          currentQuestion: null,
-          result: "{",
-          thinkingOutput: "",
-          error: null,
-          projectId: null,
-          createdAt: "2026-01-01T00:00:00.000Z",
-          updatedAt: "2026-01-03T00:00:00.000Z",
-        });
-
-      const { rerender } = render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: /Reopen recover session/i })).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByRole("button", { name: /Reopen recover session/i }));
-
-      await waitFor(() => {
-        expect(screen.getByText("Planning Complete!")).toBeDefined();
-      });
-
-      rerender(
-        <PlanningModeModal
-          isOpen={false}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      rerender(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      await waitFor(() => {
-        expect(mockFetchAiSession).toHaveBeenLastCalledWith("session-reopen-recover");
-        expect(screen.getByRole("alert")).toBeDefined();
-      });
-      expect(screen.getByRole("button", { name: "Retry" })).toBeDefined();
-      expect(screen.queryByRole("button", { name: "Start Planning" })).toBeNull();
-    });
-
-    it("quietly falls back to the initial view when a resumed session no longer exists", async () => {
-      mockFetchAiSession.mockResolvedValueOnce(null);
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId="session-deleted"
-        />,
-      );
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Start Planning" })).toBeDefined();
-      });
-      expect(screen.queryByRole("alert")).toBeNull();
-      expect(screen.queryByText("Failed to load session")).toBeNull();
-    });
-
-    it("quietly falls back to the initial view when a sidebar session no longer exists", async () => {
-      mockFetchAiSessions.mockResolvedValueOnce([
-        {
-          id: "session-sidebar-deleted",
-          type: "planning",
-          status: "complete",
-          title: "Sidebar deleted session",
-          projectId: null,
-          updatedAt: "2026-01-02T00:00:00.000Z",
-          archived: false,
-        },
-      ]);
-      mockFetchAiSession.mockResolvedValueOnce(null);
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: /Sidebar deleted session/i })).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByRole("button", { name: /Sidebar deleted session/i }));
-
-      await waitFor(() => {
-        expect(mockFetchAiSession).toHaveBeenCalledWith("session-sidebar-deleted");
-        expect(screen.getByRole("button", { name: "Start Planning" })).toBeDefined();
-      });
-      expect(screen.queryByRole("alert")).toBeNull();
-      expect(screen.queryByText("Failed to load session")).toBeNull();
-    });
-
-    it("creates a task from a resumed complete session and keeps the completed session in local history", async () => {
-      const resumedSummary: PlanningSummary = {
-        title: "Resume-to-task",
-        description: "Recovered summary for task creation",
-        suggestedSize: "M",
-        suggestedDependencies: [],
-        keyDeliverables: ["Implement", "Verify"],
-      };
-
-      mockFetchAiSessions.mockResolvedValueOnce([
-        {
-          id: "session-complete-2",
-          type: "planning",
-          status: "complete",
-          title: "Resume-to-task",
-          projectId: null,
-          updatedAt: "2026-01-01T00:00:00.000Z",
-          archived: false,
-        },
-      ]);
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-complete-2",
-        type: "planning",
-        status: "complete",
-        title: "Resume-to-task",
-        inputPayload: JSON.stringify({ validated: true, initialPlan: "Recover and create" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: JSON.stringify(resumedSummary),
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      mockCreateTaskFromPlanning.mockResolvedValueOnce({
-        id: "FN-100",
-        title: "Resume-to-task",
-        description: "Recovered summary for task creation",
-        column: "triage",
-        dependencies: [],
-        steps: [],
-        currentStep: 0,
-        log: [],
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId="session-complete-2"
-        />
-      );
-
-      await waitFor(() => {
-        expect(screen.getByText("Create Single Task")).toBeDefined();
-        expect(screen.getByRole("button", { name: /Resume-to-task/i })).toBeDefined();
-      });
-
-      const createSingleTaskButton = screen.getByRole("button", { name: "Create Single Task" });
-      const breakIntoTasksButton = screen.getByRole("button", { name: "Break into Tasks" });
-      expect(createSingleTaskButton.className).toContain("btn");
-      expect(createSingleTaskButton.className).not.toContain("btn-primary");
-      expect(breakIntoTasksButton.className).toContain("btn-primary");
-
-      fireEvent.click(createSingleTaskButton);
-
-      await waitFor(() => {
-        expect(mockCreateTaskFromPlanning).toHaveBeenCalledWith(
-          "session-complete-2",
-          expect.objectContaining({ ...resumedSummary, priority: "normal" }),
-          undefined,
-          expect.objectContaining({ branchSelection: { mode: "project-default" } }),
-        );
-      });
-
-      expect(screen.getByRole("button", { name: /Resume-to-task/i })).toBeDefined();
-    });
-
-    it("submits selected summary priority when creating a single task", async () => {
-      const resumedSummary: PlanningSummary = {
-        title: "Resume-to-task-priority",
-        description: "Recovered summary for priority",
-        suggestedSize: "M",
-        suggestedDependencies: [],
-        keyDeliverables: ["Implement", "Verify"],
-      };
-
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-complete-priority",
-        type: "planning",
-        status: "complete",
-        title: "Resume-to-task-priority",
-        inputPayload: JSON.stringify({ validated: true, initialPlan: "Recover and create with priority" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: JSON.stringify(resumedSummary),
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId="session-complete-priority"
-        />
-      );
-
-      await waitFor(() => {
-        expect(screen.getByText("Create Single Task")).toBeDefined();
-      });
-
-      fireEvent.change(screen.getByRole("combobox", { name: "Priority" }), {
-        target: { value: "high" },
-      });
-      fireEvent.click(screen.getByRole("button", { name: "Create Single Task" }));
-
-      await waitFor(() => {
-        expect(mockCreateTaskFromPlanning).toHaveBeenCalledWith(
-          "session-complete-priority",
-          expect.objectContaining({ priority: "high" }),
-          undefined,
-          expect.objectContaining({
-            branchSelection: { mode: "project-default" },
-          }),
-        );
-      });
-    });
-
-    it("surfaces planning branch controls and sends branchSelection in create request", async () => {
-      const resumedSummary: PlanningSummary = {
-        title: "Resume-branch-controls",
-        description: "Recovered summary for branch controls",
-        suggestedSize: "M",
-        suggestedDependencies: [],
-        keyDeliverables: ["Implement", "Verify"],
-      };
-
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-branch-controls",
-        type: "planning",
-        status: "complete",
-        title: "Resume-branch-controls",
-        inputPayload: JSON.stringify({ validated: true, initialPlan: "Recover and create with branch controls" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: JSON.stringify(resumedSummary),
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId="session-branch-controls"
-        />
-      );
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Create Single Task" })).toBeDefined();
-      });
-
-      const branchStrategy = screen.getByRole("combobox", { name: "Branch strategy" }) as HTMLSelectElement;
-      expect(branchStrategy.value).toBe("project-default");
-
-      fireEvent.click(screen.getByRole("button", { name: "Create Single Task" }));
-      await waitFor(() => {
-        expect(mockCreateTaskFromPlanning).toHaveBeenCalledWith(
-          "session-branch-controls",
-          expect.any(Object),
-          undefined,
-          expect.objectContaining({
-            branchSelection: { mode: "project-default" },
-          }),
-        );
-      });
-
-      fireEvent.change(branchStrategy, { target: { value: "existing" } });
-      expect(screen.getByRole("textbox", { name: "Branch name" })).toBeDefined();
-
-      const createSingleTaskButton = screen.getByRole("button", { name: "Create Single Task" });
-      expect(createSingleTaskButton).toBeDisabled();
-
-      fireEvent.change(screen.getByRole("textbox", { name: "Branch name" }), {
-        target: { value: "feat/planning-branch" },
-      });
-      fireEvent.change(screen.getByRole("textbox", { name: "Merge target / base branch (optional)" }), {
-        target: { value: "develop" },
-      });
-      fireEvent.click(createSingleTaskButton);
-
-      await waitFor(() => {
-        expect(mockCreateTaskFromPlanning).toHaveBeenLastCalledWith(
-          "session-branch-controls",
-          expect.any(Object),
-          undefined,
-          expect.objectContaining({
-            branchSelection: {
-              mode: "existing",
-              branchName: "feat/planning-branch",
-              baseBranch: "develop",
-            },
-          }),
-        );
-      });
-
-      fireEvent.change(branchStrategy, { target: { value: "auto-new" } });
-      expect(screen.queryByRole("textbox", { name: "Branch name" })).toBeNull();
-
-      fireEvent.change(branchStrategy, { target: { value: "custom-new" } });
-      expect(screen.getByRole("textbox", { name: "Branch name" })).toBeDefined();
-    });
-
-    it("forwards selected branchSelection when creating tasks from breakdown", async () => {
-      const resumedSummary: PlanningSummary = {
-        title: "Resume-branch-breakdown",
-        description: "Recovered summary for branch breakdown",
-        suggestedSize: "M",
-        suggestedDependencies: [],
-        keyDeliverables: ["Implement", "Verify"],
-      };
-
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-branch-breakdown",
-        type: "planning",
-        status: "complete",
-        title: "Resume-branch-breakdown",
-        inputPayload: JSON.stringify({ validated: true, initialPlan: "Recover and create breakdown with branch controls" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: JSON.stringify(resumedSummary),
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      mockStartPlanningBreakdown.mockResolvedValueOnce({
-        sessionId: "session-branch-breakdown",
-        subtasks: [
-          {
-            id: "subtask-1",
-            title: "First subtask",
-            description: "First description",
-            suggestedSize: "M",
-            dependsOn: [],
-          },
-        ],
-      });
-      mockCreateTasksFromPlanning.mockResolvedValueOnce({ tasks: [] });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId="session-branch-breakdown"
-        />
-      );
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Break into Tasks" })).toBeDefined();
-      });
-
-      const branchStrategy = screen.getByRole("combobox", { name: "Branch strategy" }) as HTMLSelectElement;
-      fireEvent.change(branchStrategy, { target: { value: "existing" } });
-      fireEvent.change(screen.getByRole("textbox", { name: "Branch name" }), {
-        target: { value: "feat/planning-branch" },
-      });
-      fireEvent.change(screen.getByRole("textbox", { name: "Merge target / base branch (optional)" }), {
-        target: { value: "develop" },
-      });
-
-      fireEvent.click(screen.getByRole("button", { name: "Break into Tasks" }));
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Create Tasks" })).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByRole("button", { name: "Create Tasks" }));
-
-      await waitFor(() => {
-        expect(mockCreateTasksFromPlanning).toHaveBeenCalledWith(
-          "session-branch-breakdown",
-          [{ id: "subtask-1" }],
-          undefined,
-          {
-            branchSelection: {
-              mode: "existing",
-              branchName: "feat/planning-branch",
-              baseBranch: "develop",
-            },
-          },
-        );
-      });
-    });
-
-    it("preserves per-subtask priority selections when creating tasks from breakdown", async () => {
-      const resumedSummary: PlanningSummary = {
-        title: "Resume-to-breakdown-priority",
-        description: "Recovered summary for breakdown priority",
-        suggestedSize: "M",
-        suggestedDependencies: [],
-        keyDeliverables: ["Implement", "Verify"],
-      };
-
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-breakdown-priority",
-        type: "planning",
-        status: "complete",
-        title: "Resume-to-breakdown-priority",
-        inputPayload: JSON.stringify({ validated: true, initialPlan: "Recover and break down with priority" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: JSON.stringify(resumedSummary),
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      mockStartPlanningBreakdown.mockResolvedValueOnce({
-        sessionId: "session-breakdown-priority",
-        subtasks: [
-          {
-            id: "subtask-1",
-            title: "First subtask",
-            description: "First description",
-            suggestedSize: "M",
-            dependsOn: [],
-          },
-        ],
-      });
-      mockCreateTasksFromPlanning.mockResolvedValueOnce({ tasks: [] });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId="session-breakdown-priority"
-        />
-      );
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Break into Tasks" })).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByRole("button", { name: "Break into Tasks" }));
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Create Tasks" })).toBeDefined();
-      });
-
-      const prioritySelect = screen.getAllByRole("combobox", { name: "Priority" })[0];
-      fireEvent.change(prioritySelect, { target: { value: "urgent" } });
-      fireEvent.click(screen.getByRole("button", { name: "Create Tasks" }));
-
-      await waitFor(() => {
-        expect(mockCreateTasksFromPlanning).toHaveBeenCalledWith(
-          "session-breakdown-priority",
-          [{ id: "subtask-1", priority: "urgent" }],
-          undefined,
-          { branchSelection: { mode: "project-default" } },
-        );
-      });
-    });
-
-    it("sends only edited breakdown fields when creating tasks", async () => {
-      const resumedSummary: PlanningSummary = {
-        title: "Resume-to-breakdown-compact",
-        description: "Recovered summary for compact breakdown",
-        suggestedSize: "M",
-        suggestedDependencies: [],
-        keyDeliverables: ["Implement", "Verify"],
-      };
-
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-breakdown-compact",
-        type: "planning",
-        status: "complete",
-        title: "Resume-to-breakdown-compact",
-        inputPayload: JSON.stringify({ validated: true, initialPlan: "Recover and break down compactly" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: JSON.stringify(resumedSummary),
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      mockStartPlanningBreakdown.mockResolvedValueOnce({
-        sessionId: "session-breakdown-compact",
-        subtasks: [
-          {
-            id: "subtask-1",
-            title: "First subtask",
-            description: "First description",
-            suggestedSize: "M",
-            dependsOn: [],
-          },
-          {
-            id: "subtask-2",
-            title: "Second subtask",
-            description: "Second description",
-            suggestedSize: "S",
-            dependsOn: ["subtask-1"],
-          },
-        ],
-      });
-      mockCreateTasksFromPlanning.mockResolvedValueOnce({ tasks: [] });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId="session-breakdown-compact"
-        />
-      );
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Break into Tasks" })).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByRole("button", { name: "Break into Tasks" }));
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Create Tasks" })).toBeDefined();
-      });
-
-      const firstSubtask = screen.getByTestId("subtask-item-0");
-      fireEvent.change(within(firstSubtask).getAllByRole("textbox")[0]!, {
-        target: { value: "Edited first subtask" },
-      });
-      const secondSubtask = screen.getByTestId("subtask-item-1");
-      fireEvent.change(within(secondSubtask).getAllByRole("textbox")[1]!, {
-        target: { value: "Edited second description" },
-      });
-      fireEvent.click(screen.getByRole("button", { name: "Create Tasks" }));
-
-      await waitFor(() => {
-        expect(mockCreateTasksFromPlanning).toHaveBeenCalledWith(
-          "session-breakdown-compact",
-          [
-            { id: "subtask-1", title: "Edited first subtask" },
-            { id: "subtask-2", description: "Edited second description" },
-          ],
-          undefined,
-          { branchSelection: { mode: "project-default" } },
-        );
-      });
-    });
-
-    it("includes client-added subtasks in the compact create-tasks payload", async () => {
-      const resumedSummary: PlanningSummary = {
-        title: "Resume-to-breakdown-add-subtask",
-        description: "Recovered summary for added subtask",
-        suggestedSize: "M",
-        suggestedDependencies: [],
-        keyDeliverables: ["Implement"],
-      };
-
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-breakdown-add-subtask",
-        type: "planning",
-        status: "complete",
-        title: "Resume-to-breakdown-add-subtask",
-        inputPayload: JSON.stringify({ validated: true, initialPlan: "Recover and add a subtask" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: JSON.stringify(resumedSummary),
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      mockStartPlanningBreakdown.mockResolvedValueOnce({
-        sessionId: "session-breakdown-add-subtask",
-        subtasks: [
-          {
-            id: "subtask-1",
-            title: "Existing subtask",
-            description: "Existing description",
-            suggestedSize: "M",
-            dependsOn: [],
-          },
-        ],
-      });
-      mockCreateTasksFromPlanning.mockResolvedValueOnce({ tasks: [] });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId="session-breakdown-add-subtask"
-        />
-      );
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Break into Tasks" })).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByRole("button", { name: "Break into Tasks" }));
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Add subtask" })).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByRole("button", { name: "Add subtask" }));
-      const addedSubtask = screen.getByTestId("subtask-item-1");
-      const addedTextboxes = within(addedSubtask).getAllByRole("textbox");
-      fireEvent.change(addedTextboxes[0]!, { target: { value: "Rollout follow-up" } });
-      fireEvent.change(addedTextboxes[1]!, { target: { value: "Prepare rollout notes" } });
-      fireEvent.change(within(addedSubtask).getByLabelText("Size"), { target: { value: "S" } });
-      fireEvent.change(within(addedSubtask).getByLabelText("Priority"), { target: { value: "high" } });
-      fireEvent.click(screen.getByRole("button", { name: "Create Tasks" }));
-
-      await waitFor(() => {
-        expect(mockCreateTasksFromPlanning).toHaveBeenCalledWith(
-          "session-breakdown-add-subtask",
-          [
-            { id: "subtask-1" },
-            {
-              id: "subtask-2",
-              title: "Rollout follow-up",
-              description: "Prepare rollout notes",
-              suggestedSize: "S",
-              priority: "high",
-              dependsOn: [],
-            },
-          ],
-          undefined,
-          { branchSelection: { mode: "project-default" } },
-        );
-      });
-    });
-
-    it("omits removed generated subtasks from the compact create-tasks payload", async () => {
-      const resumedSummary: PlanningSummary = {
-        title: "Resume-to-breakdown-remove-subtask",
-        description: "Recovered summary for removed subtask",
-        suggestedSize: "M",
-        suggestedDependencies: [],
-        keyDeliverables: ["Implement", "Verify"],
-      };
-
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-breakdown-remove-subtask",
-        type: "planning",
-        status: "complete",
-        title: "Resume-to-breakdown-remove-subtask",
-        inputPayload: JSON.stringify({ validated: true, initialPlan: "Recover and remove a subtask" }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: JSON.stringify(resumedSummary),
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      mockStartPlanningBreakdown.mockResolvedValueOnce({
-        sessionId: "session-breakdown-remove-subtask",
-        subtasks: [
-          {
-            id: "subtask-1",
-            title: "Existing subtask",
-            description: "Existing description",
-            suggestedSize: "M",
-            dependsOn: [],
-          },
-          {
-            id: "subtask-2",
-            title: "Generated follow-up",
-            description: "Generated follow-up description",
-            suggestedSize: "S",
-            dependsOn: ["subtask-1"],
-          },
-        ],
-      });
-      mockCreateTasksFromPlanning.mockResolvedValueOnce({ tasks: [] });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId="session-breakdown-remove-subtask"
-        />
-      );
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Break into Tasks" })).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByRole("button", { name: "Break into Tasks" }));
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Create Tasks" })).toBeDefined();
-      });
-
-      const secondSubtask = screen.getByTestId("subtask-item-1");
-      fireEvent.click(within(secondSubtask).getByRole("button", { name: "Remove" }));
-      fireEvent.click(screen.getByRole("button", { name: "Create Tasks" }));
-
-      await waitFor(() => {
-        expect(mockCreateTasksFromPlanning).toHaveBeenCalledWith(
-          "session-breakdown-remove-subtask",
-          [{ id: "subtask-1" }],
-          undefined,
-          { branchSelection: { mode: "project-default" } },
-        );
-      });
-    });
-
-    it("hides completed-session Q&A by default behind a summary disclosure", async () => {
-      const resumedSummary: PlanningSummary = {
-        title: "Summary with hidden history",
-        description: "Recovered summary description",
-        suggestedSize: "M",
-        suggestedDependencies: [],
-        keyDeliverables: ["Deliverable A"],
-      };
-
-      const restoredHistory = [
-        {
-          question: {
-            id: "q1",
-            type: "single_select",
-            question: "What scope do you need?",
-            options: [
-              { id: "small", label: "Small" },
-              { id: "medium", label: "Medium" },
-            ],
-          },
-          response: { q1: "medium" },
-          thinkingOutput: "Reasoning for scope question",
-        },
-      ];
-
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-complete-with-history",
-        type: "planning",
-        status: "complete",
-        title: resumedSummary.title,
-        inputPayload: JSON.stringify({ validated: true, initialPlan: "Build planning history restore" }),
-        conversationHistory: JSON.stringify(restoredHistory),
-        currentQuestion: null,
-        result: JSON.stringify(resumedSummary),
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId="session-complete-with-history"
-        />,
-      );
-
-      await waitFor(() => {
-        expect(screen.getByText("Planning Complete!")).toBeDefined();
-      });
-
-      expect(screen.getByRole("button", { name: "Show user Q&A" })).toBeDefined();
-      expect(screen.queryByTestId("conversation-history")).toBeNull();
-      expect(screen.queryByText("What scope do you need?")).toBeNull();
-      expect(screen.queryByText("Medium")).toBeNull();
-    });
-
-    it("reveals completed-session Q&A when summary disclosure is expanded", async () => {
-      const resumedSummary: PlanningSummary = {
-        title: "Summary with expandable history",
-        description: "Recovered summary description",
-        suggestedSize: "M",
-        suggestedDependencies: [],
-        keyDeliverables: ["Deliverable A"],
-      };
-
-      const restoredHistory = [
-        {
-          question: {
-            id: "q1",
-            type: "single_select",
-            question: "What scope do you need?",
-            options: [
-              { id: "small", label: "Small" },
-              { id: "medium", label: "Medium" },
-            ],
-          },
-          response: { q1: "medium" },
-          thinkingOutput: "Reasoning for scope question",
-        },
-      ];
-
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-complete-with-history-2",
-        type: "planning",
-        status: "complete",
-        title: resumedSummary.title,
-        inputPayload: JSON.stringify({ validated: true, initialPlan: "Build planning history restore" }),
-        conversationHistory: JSON.stringify(restoredHistory),
-        currentQuestion: null,
-        result: JSON.stringify(resumedSummary),
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId="session-complete-with-history-2"
-        />,
-      );
-
-      await waitFor(() => {
-        expect(screen.getByText("Planning Complete!")).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByRole("button", { name: "Show user Q&A" }));
-
-      await waitFor(() => {
-        expect(screen.getByTestId("conversation-history")).toBeDefined();
-      });
-
-      expect(screen.getByText("What scope do you need?")).toBeDefined();
-      expect(within(screen.getByTestId("conversation-history")).getByText("Medium")).toBeDefined();
-    });
-
-    it("restores all persisted Q&A pairs when resuming a session", async () => {
-      mockConnectPlanningStream.mockImplementationOnce(() => ({
-        close: vi.fn(),
-        isConnected: vi.fn().mockReturnValue(true),
-      }));
-
-      const resumedQuestion: PlanningQuestion = {
-        id: "q-current",
-        type: "text",
-        question: "What should we prioritize next?",
-        description: "Current question",
-      };
-
-      const restoredHistory = [
-        {
-          question: {
-            id: "q1",
-            type: "single_select",
-            question: "What scope do you need?",
-            options: [
-              { id: "small", label: "Small" },
-              { id: "medium", label: "Medium" },
-            ],
-          },
-          response: { q1: "medium" },
-          thinkingOutput: "Reasoning for scope question",
-        },
-        {
-          question: {
-            id: "q2",
-            type: "text",
-            question: "List your acceptance criteria",
-          },
-          response: { q2: "Must support offline mode" },
-          thinkingOutput: "Reasoning for criteria question",
-        },
-      ];
-
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-awaiting-1",
-        type: "planning",
-        status: "awaiting_input",
-        title: "Resume with history",
-        inputPayload: JSON.stringify({ initialPlan: "Build planning history restore" }),
-        conversationHistory: JSON.stringify(restoredHistory),
-        currentQuestion: JSON.stringify(resumedQuestion),
-        result: null,
-        thinkingOutput: "",
-        error: null,
-        projectId: null,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          resumeSessionId="session-awaiting-1"
-        />,
-      );
-
-      await waitFor(() => {
-        expect(mockParseConversationHistory).toHaveBeenCalledWith(JSON.stringify(restoredHistory));
-      });
-
-      await waitFor(() => {
-        expect(screen.getByText("What scope do you need?")).toBeDefined();
-      });
-
-      expect(screen.getByText("List your acceptance criteria")).toBeDefined();
-      expect(within(screen.getByTestId("conversation-history")).getByText("Medium")).toBeDefined();
-      expect(screen.getByText("Must support offline mode")).toBeDefined();
-      expect(screen.getByText("What should we prioritize next?")).toBeDefined();
-    });
-
-    it("starts fresh sessions with empty conversation history", async () => {
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Build auth system" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(screen.getByText("What is the scope?")).toBeDefined();
-      });
-
-      expect(screen.queryByTestId("conversation-history")).toBeNull();
-    });
-
-    it("appends submitted responses to visible conversation history", async () => {
-      const secondQuestion: PlanningQuestion = {
-        id: "q-requirements",
-        type: "text",
-        question: "What are the key requirements?",
-        description: "Describe the requirements",
-      };
-
-      let streamHandlers: any;
-      mockConnectPlanningStream.mockImplementationOnce((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        streamHandlers = handlers;
-        queuePlanningStreamEvent(() => {
-          handlers.onQuestion?.(mockQuestion);
-        });
-
-        return {
-          close: vi.fn(),
-          isConnected: vi.fn().mockReturnValue(true),
-        };
-      });
-
-      mockRespondToPlanning.mockImplementation(async () => {
-        queuePlanningStreamEvent(() => {
-          streamHandlers?.onQuestion?.(secondQuestion);
-        });
-        return { sessionId: "session-123", currentQuestion: null, summary: null };
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Build auth system" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(screen.getByText("What is the scope?")).toBeDefined();
-      });
-
-      const mediumOption = await screen.findByText("Medium");
-      fireEvent.click(mediumOption);
-
-      const continueBtn = await screen.findByRole("button", { name: "Next question" });
-      fireEvent.click(continueBtn);
-
-      await waitFor(() => {
-        expect(screen.getByText("What are the key requirements?")).toBeDefined();
-      }, { timeout: 5000 });
-
-      expect(screen.getByTestId("conversation-history")).toBeDefined();
-      expect(screen.getByText("What is the scope?")).toBeDefined();
-      expect(screen.getByText("Medium")).toBeDefined();
-    });
-  });
-
-  /*
-  FNXC:PlanningTurnReconciliation 2026-07-20-10:36:
-  These regressions reproduce the operator-visible desync: an answered Q1 must never displace
-  Q2, and recovery must hydrate question, answered history, and running plan as one server turn.
-  */
-  describe("interview turn reconciliation", () => {
-    const secondQuestion: PlanningQuestion = {
-      id: "q-turn-reconciliation-next",
-      type: "text",
-      question: "Which constraint matters most next?",
-    };
-    const secondSummary = {
-      ...mockSummary,
-      title: "Updated synchronized plan",
-      description: "The plan reflects Q1 before asking Q2.",
-    };
-
-    it("keeps Q2 and the latest plan when a stale answered Q1 stream event replays on tablet", async () => {
-      mockViewport("tablet");
-      let streamHandlers: any;
-      mockConnectPlanningStream.mockImplementationOnce((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        streamHandlers = handlers;
-        queuePlanningStreamEvent(() => handlers.onQuestion?.(mockQuestion));
-        return { close: vi.fn(), isConnected: vi.fn().mockReturnValue(true) };
-      });
-      mockRespondToPlanning.mockImplementationOnce(async () => {
-        queuePlanningStreamEvent(() => {
-          streamHandlers.onSummary?.(secondSummary);
-          streamHandlers.onQuestion?.(secondQuestion);
-        });
-        return { sessionId: "session-123", currentQuestion: null, summary: null };
-      });
-
-      render(<PlanningModeModal isOpen={true} onClose={mockOnClose} onTaskCreated={mockOnTaskCreated} onTasksCreated={vi.fn()} tasks={mockTasks} />);
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), { target: { value: "Synchronize every turn" } });
-      fireEvent.click(screen.getByText("Start Planning"));
-      fireEvent.click(await screen.findByText("Medium"));
-      fireEvent.click(screen.getByRole("button", { name: "Next question" }));
-
-      expect(await screen.findByText(secondQuestion.question)).toBeDefined();
-      expect(screen.getByRole("button", { name: "Question" })).toHaveAttribute("aria-pressed", "true");
-      fireEvent.click(screen.getByRole("button", { name: "Running plan" }));
-      expect(within(screen.getByRole("complementary", { name: "Running plan" })).getByText(secondSummary.title)).toBeDefined();
-      fireEvent.click(screen.getByRole("button", { name: "Answered questions" }));
-      expect(within(screen.getByRole("complementary", { name: "Answered questions" })).getByText(mockQuestion.question)).toBeDefined();
-      fireEvent.click(screen.getByRole("button", { name: "Question" }));
-
-      await act(async () => {
-        streamHandlers.onQuestion?.(mockQuestion);
-      });
-
-      expect(screen.getByText(secondQuestion.question)).toBeDefined();
-      expect(screen.queryByText("Planning Complete!")).toBeNull();
-    });
-
-    it("rolls back an optimistic answer when submit fails before server acceptance", async () => {
-      mockRespondToPlanning.mockRejectedValueOnce(new Error("submit timed out"));
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-123",
-        type: "planning",
-        status: "awaiting_input",
-        title: "Still awaiting Q1",
-        inputPayload: JSON.stringify({ initialPlan: "Recover submit" }),
-        conversationHistory: "[]",
-        currentQuestion: JSON.stringify(mockQuestion),
-        result: JSON.stringify(mockSummary),
-        thinkingOutput: "",
-        projectId: null,
-      });
-
-      render(<PlanningModeModal isOpen={true} onClose={mockOnClose} onTaskCreated={mockOnTaskCreated} onTasksCreated={vi.fn()} tasks={mockTasks} initialPlan="Recover submit" />);
-      await screen.findByText(mockQuestion.question);
-      fireEvent.click(screen.getByText("Medium"));
-      fireEvent.click(screen.getByRole("button", { name: "Next question" }));
-
-      expect(await screen.findByText("submit timed out")).toBeDefined();
-      expect(screen.getByText(mockQuestion.question)).toBeDefined();
-      expect(screen.queryByTestId("conversation-history")).toBeNull();
-      expect(within(screen.getByRole("complementary", { name: "Running plan" })).getByText(mockSummary.title)).toBeDefined();
-    });
-
-    it("hydrates Q2, Q1 history, and running plan after loading poll misses SSE", async () => {
-      const persistedHistory = [{ question: mockQuestion, response: { [mockQuestion.id]: "medium" } }];
-      try {
-        mockRespondToPlanning.mockResolvedValueOnce({ sessionId: "session-123", currentQuestion: null, summary: null });
-        mockFetchAiSession.mockResolvedValueOnce({
-          id: "session-123",
-          type: "planning",
-          status: "awaiting_input",
-          title: "Recovered turn",
-          inputPayload: JSON.stringify({ initialPlan: "Poll recovery" }),
-          conversationHistory: JSON.stringify(persistedHistory),
-          currentQuestion: JSON.stringify(secondQuestion),
-          result: JSON.stringify(secondSummary),
-          thinkingOutput: "",
-          projectId: null,
-        });
-
-        render(<PlanningModeModal isOpen={true} onClose={mockOnClose} onTaskCreated={mockOnTaskCreated} onTasksCreated={vi.fn()} tasks={mockTasks} initialPlan="Poll recovery" />);
-        await screen.findByText(mockQuestion.question);
-        vi.useFakeTimers();
-        fireEvent.click(screen.getByText("Medium"));
-        fireEvent.click(screen.getByRole("button", { name: "Next question" }));
-
-        await act(async () => {
-          await vi.advanceTimersByTimeAsync(8000);
-        });
-
-        expect(screen.getByText(secondQuestion.question)).toBeDefined();
-        expect(within(screen.getByRole("complementary", { name: "Answered questions" })).getByText(mockQuestion.question)).toBeDefined();
-        expect(within(screen.getByRole("complementary", { name: "Running plan" })).getByText(secondSummary.title)).toBeDefined();
-      } finally {
-        vi.useRealTimers();
-      }
-    });
-  });
-
-  describe("session rename", () => {
-    function renderActiveSessionForRename() {
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: "session-rename",
-        type: "planning",
-        status: "awaiting_input",
-        title: "Original session",
-        inputPayload: JSON.stringify({ initialPlan: "Rename this session" }),
-        conversationHistory: "[]",
-        currentQuestion: JSON.stringify(mockQuestion),
-        result: JSON.stringify(mockSummary),
-        thinkingOutput: "",
-        projectId: null,
-      });
-      return render(<PlanningModeModal isOpen={true} onClose={mockOnClose} onTaskCreated={mockOnTaskCreated} onTasksCreated={vi.fn()} tasks={mockTasks} resumeSessionId="session-rename" initialSessions={[{ id: "session-rename", type: "planning", status: "awaiting_input", title: "Original session", projectId: null, updatedAt: "2026-07-19T00:00:00.000Z" }]} />);
-    }
-
-    it("optimistically renames the active session through the dedicated API", async () => {
-      renderActiveSessionForRename();
-      await screen.findByText("What is the scope?");
-      fireEvent.click(screen.getByRole("button", { name: "Rename session" }));
-      fireEvent.change(screen.getByRole("textbox", { name: "Rename session" }), { target: { value: "Updated session" } });
-      fireEvent.keyDown(screen.getByRole("textbox", { name: "Rename session" }), { key: "Enter" });
-
-      await waitFor(() => expect(mockUpdatePlanningSessionTitle).toHaveBeenCalledWith("session-rename", "Updated session", undefined));
-      expect(screen.getByRole("heading", { name: "Updated session" })).toBeDefined();
-    });
-
-    it("rolls a rejected rename back to the persisted title", async () => {
-      mockUpdatePlanningSessionTitle.mockRejectedValueOnce(new Error("Rename rejected"));
-      renderActiveSessionForRename();
-      await screen.findByText("What is the scope?");
-      fireEvent.click(screen.getByRole("button", { name: "Rename session" }));
-      fireEvent.change(screen.getByRole("textbox", { name: "Rename session" }), { target: { value: "Rejected rename" } });
-      fireEvent.keyDown(screen.getByRole("textbox", { name: "Rename session" }), { key: "Enter" });
-
-      await screen.findByText("Rename rejected");
-      expect(screen.getByRole("heading", { name: "Original session" })).toBeDefined();
-    });
-  });
-
-  /*
-  FNXC:PlanningModeCompactSwitcher 2026-07-20-11:00:
-  FN-8445 preserves the mounted compact switcher across all three interview panes and every
-  compact shell. CSS source assertions prove flex order; this test proves each rendered surface.
-  */
-  it("keeps progressive interview controls available across tablet, mobile, and short-landscape panes", async () => {
-    for (const viewport of ["tablet", "mobile", "short-landscape"] as const) {
-      if (viewport === "short-landscape") mockShortLandscapePhone();
-      else mockViewport(viewport);
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: `session-${viewport}`,
-        type: "planning",
-        status: "awaiting_input",
-        title: "Responsive planning session",
-        inputPayload: JSON.stringify({ initialPlan: "Responsive plan prompt" }),
-        conversationHistory: JSON.stringify([{ question: mockQuestion, response: { [mockQuestion.id]: "Small" } }]),
-        result: JSON.stringify(mockSummary),
-        thinkingOutput: "",
-        projectId: null,
-        currentQuestion: JSON.stringify(mockQuestion),
-      });
-
-      const rendered = render(<PlanningModeModal isOpen={true} onClose={mockOnClose} onTaskCreated={mockOnTaskCreated} onTasksCreated={vi.fn()} tasks={mockTasks} resumeSessionId={`session-${viewport}`} />);
-      await screen.findByTestId("planning-question-text");
-      expect(screen.getByRole("button", { name: "Question" })).toHaveAttribute("aria-pressed", "true");
-      expect(screen.getByRole("navigation", { name: "Planning interview panels" })).toBeVisible();
-      expect(screen.getByRole("button", { name: "Running plan" })).toBeDefined();
-      expect(screen.getByRole("button", { name: "Answered questions" })).toBeDefined();
-      expect(screen.getByRole("button", { name: "Next question" })).toBeDefined();
-      expect(rendered.container.querySelector(".planning-modal-body")).toHaveClass("planning-modal-body--compact-question");
-
-      fireEvent.click(screen.getByRole("button", { name: "Running plan" }));
-      expect(rendered.container.querySelector(".planning-modal-body")).toHaveClass("planning-modal-body--compact-plan");
-      const runningPlan = screen.getByRole("complementary", { name: "Running plan" });
-      expect(within(runningPlan).getByText(mockSummary.title)).toBeVisible();
-      expect(within(runningPlan).getByText(mockSummary.description)).toBeVisible();
-      expect(within(runningPlan).getByText("Login page")).toBeVisible();
-      expect(within(runningPlan).queryByText(mockQuestion.question)).toBeNull();
-      expect(screen.getByRole("button", { name: "Validate plan" })).toBeVisible();
-
-      fireEvent.click(screen.getByRole("button", { name: "Answered questions" }));
-      expect(rendered.container.querySelector(".planning-modal-body")).toHaveClass("planning-modal-body--compact-history");
-      expect(screen.getByRole("navigation", { name: "Planning interview panels" })).toBeVisible();
-      expect(within(screen.getByRole("complementary", { name: "Answered questions" })).getByText(mockQuestion.question)).toBeVisible();
-
-      fireEvent.click(screen.getByRole("button", { name: "Question" }));
-      expect(rendered.container.querySelector(".planning-modal-body")).toHaveClass("planning-modal-body--compact-question");
-
-      fireEvent.click(screen.getByRole("button", { name: "Sessions" }));
-      expect(await screen.findByRole("complementary", { name: "Planning sessions" })).toBeDefined();
-      fireEvent.click(screen.getByRole("button", { name: "Sessions" }));
-      expect(rendered.container.querySelector(".planning-modal-body")).toHaveClass("planning-modal-body--show-detail", "planning-modal-body--compact-question");
-      expect(screen.getByRole("button", { name: "Next question" })).toBeVisible();
-      rendered.unmount();
-    }
-  });
-
-  it.each([
-    ["generating", {}],
-    ["error", { error: "Generation failed" }],
-  ])("keeps tablet progressive tabs for %s interview state", async (status, fields) => {
-    mockViewport("tablet");
-    mockFetchAiSession.mockResolvedValueOnce({
-      id: `session-tablet-${status}`,
-      type: "planning",
-      status,
-      title: "Tablet planning session",
-      inputPayload: JSON.stringify({ initialPlan: "Tablet plan prompt" }),
-      conversationHistory: "[]",
-      result: JSON.stringify(mockSummary),
-      thinkingOutput: "",
-      projectId: null,
-      ...fields,
-    });
-
-    const { container } = render(<PlanningModeModal isOpen={true} onClose={mockOnClose} onTaskCreated={mockOnTaskCreated} onTasksCreated={vi.fn()} tasks={mockTasks} resumeSessionId={`session-tablet-${status}`} />);
-
-    await screen.findByRole("button", { name: "Question" });
-    expect(container.querySelector(".planning-modal-body")).toHaveClass("planning-modal-body--compact-question");
-    fireEvent.click(screen.getByRole("button", { name: "Running plan" }));
-    expect(container.querySelector(".planning-modal-body")).toHaveClass("planning-modal-body--compact-plan");
-    expect(screen.getByRole("button", { name: "Validate plan" })).toBeVisible();
-    fireEvent.click(screen.getByRole("button", { name: "Answered questions" }));
-    expect(container.querySelector(".planning-modal-body")).toHaveClass("planning-modal-body--compact-history");
-  });
-
-  describe.each(["desktop", "mobile"] as const)("single interview action on %s", (viewport) => {
-    it("keeps only Next question and the localized Other input affordance", async () => {
-      mockViewport(viewport);
-      render(<PlanningModeModal isOpen={true} onClose={mockOnClose} onTaskCreated={mockOnTaskCreated} onTasksCreated={vi.fn()} tasks={mockTasks} initialPlan="Build auth system" />);
-
-      await screen.findByText("What is the scope?");
-      expect(screen.getAllByRole("button", { name: "Next question" })).toHaveLength(1);
-      expect(screen.getByRole("radio", { name: "Other (write your own)" })).toBeDefined();
-      expect(screen.queryByLabelText(/follow-up clarification questions/i)).toBeNull();
-      expect(screen.queryByRole("button", { name: "Back" })).toBeNull();
-      expect(screen.queryByRole("button", { name: /Copy prompt/i })).toBeNull();
-      expect(screen.queryByText(/Question .* of ~3/i)).toBeNull();
-    });
-  });
-
-  /*
-  FNXC:PlanningMode 2026-07-19-23:00:
-  The running plan and user-controlled validation must survive every recoverable session state,
-  including reconnect/loading/error paths that do not mount the center question editor.
-  */
-  describe.each([
-    ["awaiting_input", { currentQuestion: JSON.stringify(mockQuestion) }],
-    ["generating", {}],
-    ["error", { error: "Generation failed" }],
-  ] as const)("running plan for %s sessions", (status, fields) => {
-    it("keeps the plan and Validate plan control visible", async () => {
-      mockFetchAiSession.mockResolvedValueOnce({
-        id: `session-${status}`,
-        type: "planning",
-        status,
-        title: "Persisted planning session",
-        inputPayload: JSON.stringify({ initialPlan: "Persisted plan prompt" }),
-        conversationHistory: "[]",
-        result: JSON.stringify(mockSummary),
-        thinkingOutput: "",
-        projectId: null,
-        ...fields,
-      });
-
-      render(<PlanningModeModal isOpen={true} onClose={mockOnClose} onTaskCreated={mockOnTaskCreated} onTasksCreated={vi.fn()} tasks={mockTasks} resumeSessionId={`session-${status}`} />);
-
-      expect(await screen.findByRole("complementary", { name: "Running plan" })).toHaveTextContent(mockSummary.title);
-      expect(screen.getByRole("complementary", { name: "Answered questions" })).toBeDefined();
-      expect(screen.queryByRole("complementary", { name: "Planning sessions" })).toBeNull();
-      fireEvent.click(screen.getByRole("button", { name: "Validate plan" }));
-      await waitFor(() => expect(mockValidatePlanningSession).toHaveBeenCalledWith(`session-${status}`, undefined));
-    });
-  });
-
-  /*
-  FNXC:PlanningMode 2026-07-19-15:50:
-  FN-8400 replaces linear interview Back with an answered-question edit action. Selecting history
-  must use the question-id rewind contract without presenting generation UI, then restore the answer
-  in the sole center-pane editor so the next question branches from the revised response.
-  */
-  describe("answered-question editing", () => {
-    const secondQuestion: PlanningQuestion = {
-      id: "q-requirements",
-      type: "text",
-      question: "What are the key requirements?",
-      description: "Describe the requirements",
-    };
-
-    async function advanceToSecondQuestion() {
-      let streamHandlers: any;
-      mockConnectPlanningStream.mockImplementationOnce((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        streamHandlers = handlers;
-        queuePlanningStreamEvent(() => handlers.onQuestion?.(mockQuestion));
-        return { close: vi.fn(), isConnected: vi.fn().mockReturnValue(true) };
-      });
-      mockRespondToPlanning.mockImplementationOnce(async () => {
-        queuePlanningStreamEvent(() => streamHandlers?.onQuestion?.(secondQuestion));
-        return { sessionId: "session-123", currentQuestion: null, summary: null };
-      });
-
-      const result = render(<PlanningModeModal isOpen={true} onClose={mockOnClose} onTaskCreated={mockOnTaskCreated} onTasksCreated={vi.fn()} tasks={mockTasks} />);
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), { target: { value: "Build auth system" } });
-      fireEvent.click(screen.getByText("Start Planning"));
-      await screen.findByText("What is the scope?");
-      fireEvent.click(await screen.findByText("Medium"));
-      fireEvent.click(await screen.findByRole("button", { name: "Next question" }));
-      await screen.findByText("What are the key requirements?");
-      return result;
-    }
-
-    it("edits an answered question without replacing the interview with generation UI", async () => {
-      mockRewindPlanningSession.mockResolvedValueOnce({
-        currentQuestion: mockQuestion,
-        history: [{ question: mockQuestion, response: { [mockQuestion.id]: "medium" } }],
-      });
-      const { container } = await advanceToSecondQuestion();
-
-      fireEvent.click(screen.getByRole("button", { name: "Edit answer for What is the scope?" }));
-
-      expect(container.querySelector(".planning-loading")).toBeNull();
-      await screen.findByDisplayValue("medium");
-      expect(mockRewindPlanningSession).toHaveBeenCalledWith("session-123", undefined, mockQuestion.id);
-      expect(screen.getByRole("button", { name: "Next question" })).toBeDefined();
-    });
-
-    it("keeps the current question visible when question-id rewind fails", async () => {
-      mockRewindPlanningSession.mockRejectedValueOnce(new Error("rewind failed"));
-      const { container } = await advanceToSecondQuestion();
-
-      fireEvent.click(screen.getByRole("button", { name: "Edit answer for What is the scope?" }));
-
-      expect(container.querySelector(".planning-loading")).toBeNull();
-      await screen.findByText("rewind failed");
-      expect(screen.getByText("What are the key requirements?")).toBeDefined();
-    });
-
-    it("submits the selected answer through the edit-and-branch response path", async () => {
-      const branchedQuestion: PlanningQuestion = {
-        id: "q-branched",
-        type: "text",
-        question: "What should the new branch refine?",
-      };
-      let streamHandlers: any;
-      mockConnectPlanningStream.mockImplementationOnce((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        streamHandlers = handlers;
-        queuePlanningStreamEvent(() => handlers.onQuestion?.(mockQuestion));
-        return { close: vi.fn(), isConnected: vi.fn().mockReturnValue(true) };
-      });
-      mockRespondToPlanning.mockImplementationOnce(async () => {
-        queuePlanningStreamEvent(() => streamHandlers?.onQuestion?.(secondQuestion));
-        return { sessionId: "session-123", currentQuestion: null, summary: null };
-      }).mockImplementationOnce(async () => {
-        queuePlanningStreamEvent(() => streamHandlers?.onQuestion?.(branchedQuestion));
-        return { sessionId: "session-123", currentQuestion: null, summary: null };
-      });
-      mockRewindPlanningSession.mockResolvedValueOnce({
-        currentQuestion: mockQuestion,
-        history: [{ question: mockQuestion, response: { [mockQuestion.id]: "medium" } }],
-      });
-
-      render(<PlanningModeModal isOpen={true} onClose={mockOnClose} onTaskCreated={mockOnTaskCreated} onTasksCreated={vi.fn()} tasks={mockTasks} />);
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), { target: { value: "Build auth system" } });
-      fireEvent.click(screen.getByText("Start Planning"));
-      await screen.findByText("What is the scope?");
-      fireEvent.click(await screen.findByText("Medium"));
-      fireEvent.click(screen.getByRole("button", { name: "Next question" }));
-      await screen.findByText("What are the key requirements?");
-      fireEvent.click(screen.getByRole("button", { name: "Edit answer for What is the scope?" }));
-      await screen.findByDisplayValue("medium");
-      fireEvent.click(screen.getByRole("button", { name: "Next question" }));
-
-      await screen.findByText("What should the new branch refine?");
-      expect(mockRewindPlanningSession).toHaveBeenCalledWith("session-123", undefined, mockQuestion.id);
-      expect(mockRespondToPlanning).toHaveBeenLastCalledWith("session-123", { [mockQuestion.id]: "medium" }, undefined);
-      expect(screen.getByRole("button", { name: "Edit answer for What is the scope?" })).toBeDefined();
-    });
-  });
-
-
-  describe("Session history", () => {
-    it("renders only one row when fetch and SSE deliver the same session id", async () => {
-      mockFetchAiSessions.mockResolvedValueOnce([
-        {
-          id: "session-dup",
-          type: "planning",
-          status: "complete",
-          title: "Duplicate session",
-          projectId: null,
-          updatedAt: "2026-01-01T00:00:00.000Z",
-          archived: false,
-        },
-      ]);
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      await waitFor(() => {
-        expect(screen.getAllByText("Duplicate session")).toHaveLength(1);
-      });
-      await waitFor(() => {
-        expect(MockEventSource.instances).toHaveLength(1);
-      });
-
-      act(() => {
-        MockEventSource.instances[0]?.emit("ai_session:updated", {
-          id: "session-dup",
-          type: "planning",
-          status: "complete",
-          title: "Duplicate session",
-          projectId: null,
-          updatedAt: "2026-01-02T00:00:00.000Z",
-          archived: false,
-        });
-      });
-
-      await waitFor(() => {
-        expect(screen.getAllByText("Duplicate session")).toHaveLength(1);
-      });
-    });
-
-    it("removes a session after a successful delete", async () => {
-      mockFetchAiSessions.mockResolvedValueOnce([
-        {
-          id: "session-delete",
-          type: "planning",
-          status: "complete",
-          title: "Delete me",
-          projectId: null,
-          updatedAt: "2026-01-01T00:00:00.000Z",
-          archived: false,
-        },
-      ]);
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      await waitFor(() => {
-        expect(screen.getByText("Delete me")).toBeDefined();
-      });
-
-      const sidebar = screen.getByLabelText("Planning sessions");
-      fireEvent.click(within(sidebar).getAllByTitle("Delete session")[0]!);
-      fireEvent.click(screen.getByRole("button", { name: "Delete" }));
-
-      await waitFor(() => {
-        expect(mockDeleteAiSession).toHaveBeenCalledWith("session-delete");
-        expect(screen.queryByText("Delete me")).toBeNull();
-      });
-    });
-
-    it("reconciles the session row and shows a toast when delete fails", async () => {
-      const sessions = [
-        {
-          id: "session-delete-fail",
-          type: "planning",
-          status: "complete",
-          title: "Still here",
-          projectId: null,
-          updatedAt: "2026-01-01T00:00:00.000Z",
-          archived: false,
-        },
-      ];
-      mockFetchAiSessions.mockResolvedValueOnce(sessions).mockResolvedValueOnce(sessions);
-      mockDeleteAiSession.mockRejectedValueOnce(new Error("Delete failed"));
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      await waitFor(() => {
-        expect(screen.getByText("Still here")).toBeDefined();
-      });
-
-      const sidebar = screen.getByLabelText("Planning sessions");
-      fireEvent.click(within(sidebar).getAllByTitle("Delete session")[0]!);
-      fireEvent.click(screen.getByRole("button", { name: "Delete" }));
-
-      await waitFor(() => {
-        expect(mockDeleteAiSession).toHaveBeenCalledWith("session-delete-fail");
-        expect(mockAddToast).toHaveBeenCalledWith("Delete failed", "error");
-        expect(mockFetchAiSessions).toHaveBeenCalledTimes(2);
-        expect(screen.getByText("Still here")).toBeDefined();
-      });
-    });
-  });
-
-  describe("planning sidebar loading", () => {
-    it("renders skeleton rows rather than a blank sidebar while the session refresh is pending", async () => {
-      let resolveSessions!: (sessions: Array<Record<string, unknown>>) => void;
-      mockFetchAiSessions.mockImplementationOnce(() => new Promise((resolve) => {
-        resolveSessions = resolve;
-      }));
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      expect(await screen.findByTestId("planning-sidebar-skeleton")).toBeDefined();
-      expect(screen.queryByText(/No saved sessions yet/i)).toBeNull();
-
-      await act(async () => {
-        resolveSessions([{
-          id: "loaded-planning-session",
-          type: "planning",
-          status: "complete",
-          title: "Loaded planning session",
-          projectId: null,
-          updatedAt: "2026-07-15T00:00:00.000Z",
-        }]);
-      });
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: /Loaded planning session/i })).toBeDefined();
-        expect(screen.queryByTestId("planning-sidebar-skeleton")).toBeNull();
-      });
-    });
-
-    it("shows initial background planning sessions before an authoritative refresh resolves", async () => {
-      mockFetchAiSessions.mockImplementationOnce(() => new Promise(() => {}));
-      const initialSessions = [{
-        id: "background-planning-session",
-        type: "planning" as const,
-        status: "awaiting_input" as const,
-        title: "Next question background planning",
-        projectId: null,
-        updatedAt: "2026-07-15T00:00:00.000Z",
-      }];
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          initialSessions={initialSessions}
-        />,
-      );
-
-      expect(screen.getByRole("button", { name: /Next question background planning/i })).toBeDefined();
-      expect(screen.queryByTestId("planning-sidebar-skeleton")).toBeNull();
-      await waitFor(() => expect(mockFetchAiSessions).toHaveBeenCalledTimes(1));
-    });
-  });
-
-  describe("dedupeSessionsById export", () => {
-    it("keeps the newest session for duplicate ids while preserving stable order on ties", () => {
-      expect(
-        dedupeSessionsById([
-          {
-            id: "session-a",
-            type: "planning",
-            status: "complete",
-            title: "older",
-            projectId: null,
-            updatedAt: "2026-01-01T00:00:00.000Z",
-            archived: false,
-          },
-          {
-            id: "session-b",
-            type: "planning",
-            status: "complete",
-            title: "peer",
-            projectId: null,
-            updatedAt: "2026-01-02T00:00:00.000Z",
-            archived: false,
-          },
-          {
-            id: "session-a",
-            type: "planning",
-            status: "complete",
-            title: "newer",
-            projectId: null,
-            updatedAt: "2026-01-03T00:00:00.000Z",
-            archived: false,
-          },
-          {
-            id: "session-c",
-            type: "planning",
-            status: "complete",
-            title: "tie-first",
-            projectId: null,
-            updatedAt: "2026-01-02T00:00:00.000Z",
-            archived: false,
-          },
-        ]),
-      ).toEqual([
-        {
-          id: "session-a",
-          type: "planning",
-          status: "complete",
-          title: "newer",
-          projectId: null,
-          updatedAt: "2026-01-03T00:00:00.000Z",
-          archived: false,
-        },
-        {
-          id: "session-b",
-          type: "planning",
-          status: "complete",
-          title: "peer",
-          projectId: null,
-          updatedAt: "2026-01-02T00:00:00.000Z",
-          archived: false,
-        },
-        {
-          id: "session-c",
-          type: "planning",
-          status: "complete",
-          title: "tie-first",
-          projectId: null,
-          updatedAt: "2026-01-02T00:00:00.000Z",
-          archived: false,
-        },
-      ]);
-    });
+  it("restores a validated unlinked session to create-only retry", async () => {
+    mockFetchAiSession.mockResolvedValue({ ...base, status: "complete", currentQuestion: null, result: JSON.stringify(mockSummary), inputPayload: JSON.stringify({ validated: true }) });
+    renderSession({});
+    expect(await screen.findByTestId("planning-create-retry")).toBeInTheDocument();
+    expect(screen.queryByRole("button", { name: "Validate" })).toBeNull();
   });
 });
diff --git a/packages/dashboard/app/components/__tests__/PlanningModeModal.ui-interactions.test.tsx b/packages/dashboard/app/components/__tests__/PlanningModeModal.ui-interactions.test.tsx
index 044d35cf3d..4fb7f5f4d1 100644
--- a/packages/dashboard/app/components/__tests__/PlanningModeModal.ui-interactions.test.tsx
+++ b/packages/dashboard/app/components/__tests__/PlanningModeModal.ui-interactions.test.tsx
@@ -1,1275 +1,11 @@
-/*
-FNXC:DashboardTests 2026-06-14-08:31:
-FN-6441 rescued this orphaned component test after standalone dashboard-app execution passed without assertion, timeout, or source-code changes. Keep the planning modal UI-interaction coverage in app backfill so question flow, summary, and breakdown interactions remain executed after leaving the skip-list.
-
-FNXC:DashboardTests 2026-06-14-08:32:
-PlanningModeModal calls useToast(), which throws without a ToastProvider. These tests render it bare, so the hook stays mocked in the same style as PlanningModeModal.autosize.test.tsx instead of introducing broad provider wiring during skip-list rescue.
-*/
+import { describe, expect, it } from "vitest";
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-vi.mock("../../hooks/useToast", () => ({
-  useOptionalToast: () => null,
-  useToast: () => ({
-    addToast: vi.fn(),
-    removeToast: vi.fn(),
-    toasts: [],
-  }),
-}));
-
-vi.mock("../../hooks/useNavigationHistory", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("../../hooks/useNavigationHistory")>();
-  return {
-    ...actual,
-    useNavigationHistoryContext: () => ({ pushNav: vi.fn(), replaceCurrent: vi.fn() }),
-  };
-});
-import { act, render, renderHook, screen, fireEvent, waitFor, within } from "@testing-library/react";
-import userEvent from "@testing-library/user-event";
-import * as api from "../../api";
-import { PlanningModeModal } from "../PlanningModeModal";
-import { TaskDetailModal } from "../TaskDetailModal";
-import type { MergeResult, PlanningQuestion } from "@fusion/core";
-import {
-  mockStartPlanning,
-  mockStartPlanningStreaming,
-  mockCreatePlanningDraft,
-  mockConnectPlanningStream,
-  mockRespondToPlanning,
-  mockRetryPlanningSession,
-  mockCancelPlanning,
-  mockStopPlanningGeneration,
-  mockUpdatePlanningSessionDraft,
-  mockCreateTaskFromPlanning,
-  mockValidatePlanningSession,
-  mockStartPlanningBreakdown,
-  mockCreateTasksFromPlanning,
-  mockFetchAiSession,
-  mockParseConversationHistory,
-  mockFetchModels,
-  mockAcquireSessionLock,
-  mockReleaseSessionLock,
-  mockForceAcquireSessionLock,
-  mockUploadAttachment,
-  mockDeleteAttachment,
-  mockUpdateTask,
-  mockPauseTask,
-  mockUnpauseTask,
-  mockFetchTaskDetail,
-  mockRequestSpecRevision,
-  mockApprovePlan,
-  mockRejectPlan,
-  mockRefineTask,
-  mockFetchAiSessions,
-  mockConfirm,
-  mockUseViewportMode,
-  mockUseMobileKeyboard,
-  mockTasks,
-  mockModels,
-  mockQuestion,
-  mockSummary,
-  mockTaskDetail,
-  MockEventSource,
-  getMediaBlocks,
-  mockViewport,
-} from "./PlanningModeModal.test-helpers";
-
-vi.mock("../../api", () => ({
-  api: vi.fn().mockResolvedValue({ sessions: [] }),
-  startPlanning: (...args: any[]) => mockStartPlanning(...args),
-  startPlanningStreaming: (...args: any[]) => mockStartPlanningStreaming(...args),
-  createPlanningDraft: (...args: any[]) => mockCreatePlanningDraft(...args),
-  connectPlanningStream: (...args: any[]) => mockConnectPlanningStream(...args),
-  respondToPlanning: (...args: any[]) => mockRespondToPlanning(...args),
-  retryPlanningSession: (...args: any[]) => mockRetryPlanningSession(...args),
-  cancelPlanning: (...args: any[]) => mockCancelPlanning(...args),
-  stopPlanningGeneration: (...args: any[]) => mockStopPlanningGeneration(...args),
-  updatePlanningSessionDraft: (...args: any[]) => mockUpdatePlanningSessionDraft(...args),
-  updatePlanningSessionTitle: vi.fn().mockResolvedValue({ sessionId: "session-123", title: "Renamed session" }),
-  createTaskFromPlanning: (...args: any[]) => mockCreateTaskFromPlanning(...args),
-  validatePlanningSession: (...args: any[]) => mockValidatePlanningSession(...args),
-  startPlanningBreakdown: (...args: any[]) => mockStartPlanningBreakdown(...args),
-  createTasksFromPlanning: (...args: any[]) => mockCreateTasksFromPlanning(...args),
-  fetchAiSession: (...args: any[]) => mockFetchAiSession(...args),
-  parseConversationHistory: (...args: any[]) => mockParseConversationHistory(...args),
-  acquireSessionLock: (...args: any[]) => mockAcquireSessionLock(...args),
-  releaseSessionLock: (...args: any[]) => mockReleaseSessionLock(...args),
-  forceAcquireSessionLock: (...args: any[]) => mockForceAcquireSessionLock(...args),
-  uploadAttachment: (...args: any[]) => mockUploadAttachment(...args),
-  deleteAttachment: (...args: any[]) => mockDeleteAttachment(...args),
-  updateTask: (...args: any[]) => mockUpdateTask(...args),
-  pauseTask: (...args: any[]) => mockPauseTask(...args),
-  unpauseTask: (...args: any[]) => mockUnpauseTask(...args),
-  fetchTaskDetail: (...args: any[]) => mockFetchTaskDetail(...args),
-  fetchTaskVerificationRequest: vi.fn().mockResolvedValue(null),
-  requestSpecRevision: (...args: any[]) => mockRequestSpecRevision(...args),
-  approvePlan: (...args: any[]) => mockApprovePlan(...args),
-  rejectPlan: (...args: any[]) => mockRejectPlan(...args),
-  refineTask: (...args: any[]) => mockRefineTask(...args),
-  fetchSettings: vi.fn().mockResolvedValue({ modelPresets: [], autoSelectModelPreset: false, defaultPresetBySize: {} }),
-  fetchTaskEffectiveSettings: vi.fn().mockResolvedValue({ modelPresets: [], autoSelectModelPreset: false, defaultPresetBySize: {} }),
-  /*
-  FNXC:PlanningModeSettings 2026-07-18-07:20:
-  Same FN-8245 deterministic settle as planning-flow: Start Planning is gated on
-  clarificationSettingsLoading, so a microtask-resolved fetchGlobalSettings makes
-  fireEvent.click races no-op and leaves the suite red under full-suite load.
-  */
-  fetchGlobalSettings: vi.fn(() => {
-    const settled = {
-      then(onFulfilled: (settings: Record<string, never>) => unknown) {
-        onFulfilled({});
-        return settled;
-      },
-      catch() {
-        return settled;
-      },
-      finally(onFinally: () => unknown) {
-        onFinally();
-        return settled;
-      },
-    };
-    return settled;
-  }),
-  fetchModels: (...args: any[]) => mockFetchModels(...args),
-  fetchWorkflowSteps: vi.fn().mockResolvedValue([]),
-  fetchBoardWorkflows: vi.fn().mockResolvedValue({ flagEnabled: false, defaultWorkflowId: "", workflows: [], taskWorkflowIds: {} }),
-  refineText: vi.fn(),
-  getRefineErrorMessage: vi.fn((err: any) => err?.message || "Failed to refine"),
-  updateGlobalSettings: vi.fn().mockResolvedValue({}),
-  duplicateTask: vi.fn().mockResolvedValue({}),
-  fetchAiSessions: (...args: any[]) => mockFetchAiSessions(...args),
-}));
-
-vi.mock("../../hooks/useConfirm", () => ({
-  useConfirm: () => ({ confirm: mockConfirm }),
-}));
-
-vi.mock("../../hooks/useViewportMode", () => ({
-  MOBILE_MEDIA_QUERY: "(max-width: 768px), (max-height: 480px)",
-  isFullScreenSheetViewport: () => false,
-  isShortViewport: () => false,
-  getViewportMode: () => mockUseViewportMode(),
-  isMobileViewport: () => mockUseViewportMode() === "mobile",
-  useViewportMode: () => mockUseViewportMode(),
-}));
-
-vi.mock("../../hooks/useMobileKeyboard", () => ({
-  useMobileKeyboard: (...args: any[]) => mockUseMobileKeyboard(...args),
-}));
-
-const MARKDOWN_QUESTION: PlanningQuestion = {
-  id: "markdown-question",
-  type: "text",
-  question: "Do you want **fast** mode?\n\nfirst line  \nsecond line\n\n- Option A\n- Option B",
-  description: "Choose the mode before continuing.",
-};
-
-function expectMarkdownQuestionFormatting() {
-  const question = screen.getByTestId("planning-question-text");
-  expect(question.querySelector("strong")).toHaveTextContent("fast");
-  expect([...question.querySelectorAll("p")].find((paragraph) => paragraph.textContent?.includes("first line"))?.querySelector("br")).not.toBeNull();
-  expect([...question.querySelectorAll("li")].map((item) => item.textContent)).toEqual(["Option A", "Option B"]);
-  expect(question).not.toHaveTextContent("**fast**");
-}
-
-describe("PlanningModeModal", () => {
-  const mockOnClose = vi.fn();
-  const mockOnTaskCreated = vi.fn();
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockConfirm.mockReset();
-    mockConfirm.mockResolvedValue(true);
-    MockEventSource.reset();
-    vi.stubGlobal("EventSource", MockEventSource as any);
-    window.sessionStorage.clear();
-    // Default to desktop viewport; mobile-specific tests override per-test.
-    mockViewport("desktop");
-    
-    // Default mock for streaming
-    mockStartPlanningStreaming.mockResolvedValue({ sessionId: "session-123" });
-    // Server's createDraftSession always returns the placeholder title; the
-    // real summarized title only arrives later via blur/close summarize or
-    // when the session transitions out of draft. Mirror that in the mock so
-    // the sidebar render rule (preview while title === placeholder) behaves
-    // realistically in tests.
-    mockCreatePlanningDraft.mockResolvedValue({ sessionId: "draft-123", title: "New planning session" });
-    mockRetryPlanningSession.mockResolvedValue({ success: true, sessionId: "session-123" });
-    mockValidatePlanningSession.mockResolvedValue({ summary: mockSummary, validated: true });
-    mockStartPlanningBreakdown.mockResolvedValue({ sessionId: "session-123", subtasks: [] });
-    mockFetchAiSession.mockResolvedValue(null);
-    mockFetchAiSessions.mockResolvedValue([]);
-    mockParseConversationHistory.mockImplementation((raw: string) => {
-      if (!raw) return [];
-      try {
-        const parsed = JSON.parse(raw);
-        return Array.isArray(parsed) ? parsed : [];
-      } catch {
-        return [];
-      }
-    });
-    mockFetchModels.mockResolvedValue({
-      models: mockModels,
-      favoriteProviders: [],
-      favoriteModels: [],
-      resolvedPlanningProvider: "openai",
-      resolvedPlanningModelId: "gpt-4o",
-    });
-    mockAcquireSessionLock.mockResolvedValue({ acquired: true, currentHolder: null });
-    mockReleaseSessionLock.mockResolvedValue(undefined);
-    mockForceAcquireSessionLock.mockResolvedValue(undefined);
-    mockCancelPlanning.mockResolvedValue(undefined);
-    mockUpdatePlanningSessionDraft.mockResolvedValue({ ok: true });
-    mockStopPlanningGeneration.mockResolvedValue({ success: true });
-
-    // Default: simulate receiving a question after a brief delay
-    mockConnectPlanningStream.mockImplementation((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-      setTimeout(() => {
-        handlers.onQuestion?.(mockQuestion);
-      }, 10);
-      
-      return {
-        close: vi.fn(),
-        isConnected: vi.fn().mockReturnValue(true),
-      };
-    });
-  });
-
-  describe("Modal smoke checks", () => {
-    it("renders TaskDetailModal with the standard detail body structure", () => {
-      const onMoveTask = vi.fn<(_: string, __: any) => Promise<Task>>().mockResolvedValue(mockTasks[0]);
-      const onDeleteTask = vi.fn<(_: string) => Promise<Task>>().mockResolvedValue(mockTasks[0]);
-      const onMergeTask = vi
-        .fn<(_: string) => Promise<MergeResult>>()
-        .mockResolvedValue({ merged: true, branch: "fusion/fn-999", task: mockTasks[0], worktreeRemoved: true, branchDeleted: true });
-
-      const { container } = render(
-        <TaskDetailModal
-          task={mockTaskDetail}
-          tasks={mockTasks}
-          onClose={mockOnClose}
-          onOpenDetail={vi.fn()}
-          onMoveTask={onMoveTask}
-          onDeleteTask={onDeleteTask}
-          onMergeTask={onMergeTask}
-          addToast={vi.fn()}
-        />
-      );
-
-      expect(screen.getByText("Example task")).toBeDefined();
-      expect(screen.getByRole("button", { name: "Plan" })).toBeDefined();
-      expect(container.querySelector(".detail-body")).not.toBeNull();
-    });
-  });
-
-  it("renders markdown formatting in AI planning questions", async () => {
-    mockConnectPlanningStream.mockImplementationOnce((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-      setTimeout(() => handlers.onQuestion?.(MARKDOWN_QUESTION), 0);
-      return { close: vi.fn(), isConnected: vi.fn().mockReturnValue(true) };
-    });
-
-    render(
-      <PlanningModeModal
-        isOpen={true}
-        onClose={mockOnClose}
-        onTaskCreated={mockOnTaskCreated}
-        onTasksCreated={vi.fn()}
-        tasks={mockTasks}
-      />,
-    );
-
-    fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-      target: { value: "Format the planning question" },
-    });
-    fireEvent.click(screen.getByText("Start Planning"));
-
-    await waitFor(expectMarkdownQuestionFormatting);
-  });
-
-  describe("Loading state", () => {
-    function getPlanningLoadingSpinner(container: HTMLElement): SVGSVGElement {
-      const spinner = container.querySelector<SVGSVGElement>(".planning-loading svg.spin");
-      expect(spinner).not.toBeNull();
-      return spinner!;
-    }
-
-    async function startPlanningAndHoldLoading(container: HTMLElement): Promise<SVGSVGElement> {
-      mockConnectPlanningStream.mockImplementationOnce(() => ({
-        close: vi.fn(),
-        isConnected: vi.fn().mockReturnValue(true),
-      }));
-
-      const textarea = screen.getByPlaceholderText(/e.g., Build a user authentication/);
-      fireEvent.change(textarea, { target: { value: "Build auth system" } });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(screen.getByText("Generating next question...")).toBeDefined();
-      });
-
-      return getPlanningLoadingSpinner(container);
-    }
-
-    it.each([
-      { presentation: "modal" as const, viewport: "desktop" as const },
-      { presentation: "modal" as const, viewport: "mobile" as const },
-      { presentation: "embedded" as const, viewport: "desktop" as const },
-      { presentation: "embedded" as const, viewport: "mobile" as const },
-    ])("keeps the first loading-frame spinner animated for $presentation on $viewport", async ({ presentation, viewport }) => {
-      mockViewport(viewport);
-
-      const { container } = render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          presentation={presentation}
-        />
-      );
-
-      const spinner = await startPlanningAndHoldLoading(container);
-
-      expect(spinner).toHaveClass("spin");
-      expect(spinner).toHaveClass("icon-todo");
-      expect(spinner.style.animation).toBe("");
-      expect(spinner.style.animationName).toBe("");
-    });
-
-    it("uses SVG-safe spin geometry so the first Planning loading paint rotates", () => {
-      const styles = readFileSync(resolve(process.cwd(), "app/styles.css"), "utf8");
-      const sharedSvgSpinRule = styles.match(/svg\.animate-spin,\s*\n(?:svg\.[\w-]+,\s*\n)*svg\.[\w-]+\s*\{[^}]*\}/)?.[0] ?? "";
-
-      expect(sharedSvgSpinRule).toContain("transform-box: fill-box");
-    });
-
-    it("keeps the streaming loading-frame spinner on the same animation contract", async () => {
-      let streamHandlers: any = null;
-
-      mockConnectPlanningStream.mockImplementationOnce((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        streamHandlers = handlers;
-        return {
-          close: vi.fn(),
-          isConnected: vi.fn().mockReturnValue(true),
-        };
-      });
-
-      const { container } = render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          presentation="embedded"
-        />
-      );
-
-      const textarea = screen.getByPlaceholderText(/e.g., Build a user authentication/);
-      fireEvent.change(textarea, { target: { value: "Build auth system" } });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(screen.getByText("Generating next question...")).toBeDefined();
-      });
-
-      act(() => {
-        streamHandlers.onThinking?.("Analyzing requirements...");
-      });
-
-      await waitFor(() => {
-        expect(screen.getByText("AI is thinking...")).toBeDefined();
-      });
-
-      const spinner = getPlanningLoadingSpinner(container);
-      expect(spinner).toHaveClass("spin");
-      expect(spinner.style.animation).toBe("");
-      expect(spinner.style.animationName).toBe("");
-    });
-
-    it("keeps other Planning Mode Loader2 spin affordances wired", () => {
-      const source = readFileSync(resolve(process.cwd(), "app/components/PlanningModeModal.tsx"), "utf8");
-
-      expect(source).toContain('className="spin planning-sidebar-status-icon planning-sidebar-status-generating"');
-      expect(source).toContain('className="spin icon-mr-8"');
-      expect(source).toContain('className="spin icon-mr-6"');
-    });
-
-    it("shows 'Generating next question...' text when loading without streaming content", async () => {
-      // Mock to delay the question response so we stay in loading state
-      mockConnectPlanningStream.mockImplementationOnce((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        // Don't call any handlers - stay in loading state
-        return {
-          close: vi.fn(),
-          isConnected: vi.fn().mockReturnValue(true),
-        };
-      });
-
-      const { container } = render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      const textarea = screen.getByPlaceholderText(/e.g., Build a user authentication/);
-      fireEvent.change(textarea, { target: { value: "Build auth system" } });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      // Wait for loading state to appear
-      await waitFor(() => {
-        expect(container.querySelector(".planning-loading")).not.toBeNull();
-      });
-
-      // Should show "Generating next question..." not "Connecting..."
-      expect(screen.getByText("Generating next question...")).toBeDefined();
-      expect(screen.queryByText("Connecting...")).toBeNull();
-    });
-
-    it("shows thinking container even when streaming output is initially empty", async () => {
-      // Mock to delay the question response so we stay in loading state
-      mockConnectPlanningStream.mockImplementationOnce((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        // Don't call any handlers - stay in loading state
-        return {
-          close: vi.fn(),
-          isConnected: vi.fn().mockReturnValue(true),
-        };
-      });
-
-      const { container } = render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      const textarea = screen.getByPlaceholderText(/e.g., Build a user authentication/);
-      fireEvent.change(textarea, { target: { value: "Build auth system" } });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      // Wait for loading state to appear
-      await waitFor(() => {
-        expect(container.querySelector(".planning-loading")).not.toBeNull();
-      });
-
-      // Thinking container should be visible even without streaming content
-      expect(container.querySelector(".planning-thinking-container")).not.toBeNull();
-      // showThinking defaults to true, so button shows "Hide thinking"
-      expect(screen.getByText("Hide thinking")).toBeDefined();
-    });
-
-    it("shows 'AI is thinking...' text and renders streaming content when it arrives", async () => {
-      let streamHandlers: any = null;
-
-      mockConnectPlanningStream.mockImplementationOnce((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        streamHandlers = handlers;
-        return {
-          close: vi.fn(),
-          isConnected: vi.fn().mockReturnValue(true),
-        };
-      });
-
-      const { container } = render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      const textarea = screen.getByPlaceholderText(/e.g., Build a user authentication/);
-      fireEvent.change(textarea, { target: { value: "Build auth system" } });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      // Wait for loading state to appear
-      await waitFor(() => {
-        expect(container.querySelector(".planning-loading")).not.toBeNull();
-      });
-
-      // Initially shows "Generating next question..."
-      expect(screen.getByText("Generating next question...")).toBeDefined();
-
-      // Simulate streaming content arriving
-      await waitFor(() => {
-        streamHandlers.onThinking?.("Analyzing requirements...");
-      });
-
-      // Now should show "AI is thinking..."
-      await waitFor(() => {
-        expect(screen.getByText("AI is thinking...")).toBeDefined();
-      });
-
-      // The streaming content should be visible (showThinking defaults to true)
-      await waitFor(() => {
-        expect(screen.getByText("Analyzing requirements...")).toBeDefined();
-      });
-
-      // Click "Hide thinking" to hide the output
-      fireEvent.click(screen.getByText("Hide thinking"));
-
-      // The output should now be hidden
-      expect(screen.queryByText("Analyzing requirements...")).toBeNull();
-    });
-
-    it("shows loading state with appropriate text after submitting a response", async () => {
-      /*
-      FNXC:DashboardTests 2026-07-18-11:45:
-      Full Suite shard 3 failed when a 50ms setTimeout second-question race skipped the
-      loading paint under CI load. Gate the next SSE question on an explicit release so
-      `.planning-loading` is assertable before the follow-up question arrives.
-      */
-      const secondQuestion: PlanningQuestion = {
-        id: "q-requirements",
-        type: "text",
-        question: "What are the key requirements?",
-        description: "Describe the requirements",
-      };
-
-      let streamHandlers: any = null;
-      let releaseSecondQuestion: (() => void) | null = null;
-      const secondQuestionGate = new Promise<void>((resolve) => {
-        releaseSecondQuestion = resolve;
-      });
-
-      mockConnectPlanningStream.mockImplementation((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        streamHandlers = handlers;
-        
-        setTimeout(() => {
-          handlers.onQuestion?.(mockQuestion);
-        }, 10);
-        
-        return {
-          close: vi.fn(),
-          isConnected: vi.fn().mockReturnValue(true),
-        };
-      });
-
-      mockRespondToPlanning.mockImplementation(async () => {
-        // Hold the follow-up question until the loading UI has been observed.
-        void secondQuestionGate.then(() => {
-          if (streamHandlers) {
-            streamHandlers.onQuestion?.(secondQuestion);
-          }
-        });
-        return { sessionId: "session-123", currentQuestion: null, summary: null };
-      });
-
-      const { container } = render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      const textarea = screen.getByPlaceholderText(/e.g., Build a user authentication/);
-      fireEvent.change(textarea, { target: { value: "Build auth system" } });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      // Wait for first question
-      await waitFor(() => {
-        expect(screen.getByText("What is the scope?")).toBeDefined();
-      });
-
-      // Answer the first question
-      fireEvent.click(screen.getByText("Medium"));
-      fireEvent.click(screen.getByText("Next question"));
-
-      // Verify loading state appears with correct message
-      await waitFor(() => {
-        expect(container.querySelector(".planning-loading")).not.toBeNull();
-        expect(screen.getByText("Generating next question...")).toBeDefined();
-      });
-
-      // Verify thinking container is visible during loading
-      expect(container.querySelector(".planning-thinking-container")).not.toBeNull();
-
-      await act(async () => {
-        releaseSecondQuestion?.();
-      });
-
-      // Wait for second question to appear
-      await waitFor(() => {
-        expect(screen.getByText("What are the key requirements?")).toBeDefined();
-      });
-    });
-  });
-
-  describe("Modal close behavior", () => {
-    it("no confirmation shown when no progress made (initial state)", () => {
-            render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      // Click X button while still in initial state (no planning started)
-      const closeButton = screen.getByLabelText("Close");
-      fireEvent.click(closeButton);
-
-      expect(mockConfirm).not.toHaveBeenCalled();
-      expect(mockCancelPlanning).not.toHaveBeenCalled();
-      expect(mockOnClose).toHaveBeenCalled();
-    });
-
-    it("closes active question session WITHOUT abandoning the server session", async () => {
-            render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Build auth system" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(screen.getByText("What is the scope?")).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByLabelText("Close"));
-
-      expect(mockConfirm).not.toHaveBeenCalled();
-      // Closing the modal should leave the server session intact so it stays in the sidebar list
-      expect(mockCancelPlanning).not.toHaveBeenCalled();
-      expect(mockOnClose).toHaveBeenCalled();
-    });
-
-    it("closes summary view WITHOUT abandoning the server session", async () => {
-            mockConnectPlanningStream.mockImplementationOnce((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        setTimeout(() => {
-          handlers.onSummary?.(mockSummary);
-        }, 10);
-
-        return {
-          close: vi.fn(),
-          isConnected: vi.fn().mockReturnValue(true),
-        };
-      });
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Build auth system" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Validate plan" })).toBeDefined();
-      });
-      fireEvent.click(screen.getByRole("button", { name: "Validate plan" }));
-
-      await waitFor(() => {
-        expect(screen.getByText("Planning Complete!")).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByLabelText("Close"));
-
-      expect(mockConfirm).not.toHaveBeenCalled();
-      // Completed sessions remain available to resume; closing must not cancel them
-      expect(mockCancelPlanning).not.toHaveBeenCalled();
-      expect(mockOnClose).toHaveBeenCalled();
-    });
-
-    it("closes via overlay WITHOUT abandoning the server session", async () => {
-            const { container } = render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Build auth system" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(screen.getByText("What is the scope?")).toBeDefined();
-      });
-
-      const overlay = container.querySelector(".modal-overlay");
-      expect(overlay).not.toBeNull();
-      // Simulate a real overlay click — both mousedown and click must originate
-      // on the overlay, otherwise the dismissal guard suppresses close.
-      fireEvent.mouseDown(overlay!);
-      fireEvent.click(overlay!);
-
-      expect(mockConfirm).not.toHaveBeenCalled();
-      // Sessions persist in the sidebar; overlay click should not cancel
-      expect(mockCancelPlanning).not.toHaveBeenCalled();
-      expect(mockOnClose).toHaveBeenCalled();
-    });
-
-    it("closes during loading state WITHOUT abandoning the server session", async () => {
-            mockConnectPlanningStream.mockImplementationOnce(() => ({
-        close: vi.fn(),
-        isConnected: vi.fn().mockReturnValue(true),
-      }));
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Build auth system" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(screen.getByText("Generating next question...")).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByLabelText("Close"));
-
-      expect(mockConfirm).not.toHaveBeenCalled();
-      // Loading state means the session is still being generated server-side; preserve it
-      expect(mockCancelPlanning).not.toHaveBeenCalled();
-      expect(mockOnClose).toHaveBeenCalled();
-    });
-
-    it("close (X) drops the local stream but preserves the server session", async () => {
-      // The "Send to background" button was removed — closing the modal now
-      // has the same semantics: tear down the SSE stream, keep the persisted
-      // session alive so the user can reopen and resume it.
-      const closeSpy = vi.fn();
-
-      mockConnectPlanningStream.mockImplementationOnce(() => ({
-        close: closeSpy,
-        isConnected: vi.fn().mockReturnValue(true),
-      }));
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Build auth system" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(screen.getByText("Generating next question...")).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByLabelText("Close"));
-
-      expect(closeSpy).toHaveBeenCalledTimes(1);
-      expect(mockCancelPlanning).not.toHaveBeenCalled();
-      expect(mockOnClose).toHaveBeenCalledTimes(1);
-    });
-
-    it("disconnects the SSE stream on close (but keeps the server session)", async () => {
-      const closeSpy = vi.fn();
-
-      mockConnectPlanningStream.mockImplementationOnce(() => ({
-        close: closeSpy,
-        isConnected: vi.fn().mockReturnValue(true),
-      }));
-
-      render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Build auth system" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(screen.getByText("Generating next question...")).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByLabelText("Close"));
-
-      expect(closeSpy).toHaveBeenCalledTimes(1);
-      // The local SSE stream closes on modal close, but the server session is preserved
-      // for later resume from the sidebar list.
-      expect(mockCancelPlanning).not.toHaveBeenCalled();
-      expect(mockOnClose).toHaveBeenCalled();
-    });
-  });
-
-  describe("Mobile empty-session routing (FN-3269)", () => {
-    it("shows detail pane on mobile when session list is empty", async () => {
-      mockViewport("mobile");
-      mockFetchAiSessions.mockResolvedValue([]);
-
-      const { container } = render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      await waitFor(() => {
-        expect(mockFetchAiSessions).toHaveBeenCalled();
-      });
-
-      // Wait for the session list to load and the routing effect to fire
-      await act(async () => {
-        await new Promise((resolve) => setTimeout(resolve, 0));
-      });
-
-      // The modal body should show detail pane (composer), not list pane
-      const body = container.querySelector(".planning-modal-body");
-      expect(body?.classList.contains("planning-modal-body--show-detail")).toBe(true);
-      expect(body?.classList.contains("planning-modal-body--show-list")).toBe(false);
-
-      // The composer textarea should be visible
-      expect(screen.getByPlaceholderText(/e.g., Build a user authentication/)).toBeDefined();
-    });
-
-    it("stays on list pane on mobile when sessions exist", async () => {
-      mockViewport("mobile");
-      mockFetchAiSessions.mockResolvedValue([
-        {
-          id: "session-existing",
-          type: "planning",
-          status: "complete",
-          title: "Existing session",
-          preview: "An existing planning session",
-          projectId: null,
-          updatedAt: new Date().toISOString(),
-          archived: false,
-        },
-      ]);
-
-      const { container } = render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      await waitFor(() => {
-        expect(mockFetchAiSessions).toHaveBeenCalled();
-      });
-
-      // Wait one more tick to let state updates settle
-      await act(async () => {
-        await new Promise((resolve) => setTimeout(resolve, 0));
-      });
-
-      // The modal body should show list pane (sidebar), not detail pane
-      const body = container.querySelector(".planning-modal-body");
-      expect(body?.classList.contains("planning-modal-body--show-list")).toBe(true);
-      expect(body?.classList.contains("planning-modal-body--show-detail")).toBe(false);
-    });
-
-    it("does not auto-show detail pane on desktop with empty sessions", async () => {
-      mockViewport("desktop");
-      mockFetchAiSessions.mockResolvedValue([]);
-
-      const { container } = render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      await waitFor(() => {
-        expect(mockFetchAiSessions).toHaveBeenCalled();
-      });
-
-      // Wait one more tick to let state updates settle
-      await act(async () => {
-        await new Promise((resolve) => setTimeout(resolve, 0));
-      });
-
-      // Desktop shows both panes in split view regardless of mobileShowDetail.
-      // Both sidebar and detail pane should be present in the DOM.
-      expect(container.querySelector(".planning-sidebar")).not.toBeNull();
-      expect(container.querySelector(".planning-detail")).not.toBeNull();
-      // The mobile-only back button should NOT be visible (it's gated on mobileShowDetail,
-      // which stays false on desktop since the routing effect skips non-mobile viewports).
-      expect(container.querySelector(".planning-mobile-back")).toBeNull();
-    });
-  });
-
-  describe("mobile session-list navigation (FN-8427)", () => {
-    const sessions = [
-      { id: "session-active", type: "planning", status: "awaiting_input", title: "Active planning session", projectId: null, updatedAt: "2026-07-20T00:00:00.000Z" },
-      { id: "session-other", type: "planning", status: "complete", title: "Other planning session", projectId: null, updatedAt: "2026-07-20T00:00:00.000Z" },
-    ];
-
-    function mockActiveSession() {
-      mockFetchAiSessions.mockResolvedValue(sessions);
-      mockFetchAiSession.mockResolvedValue({
-        id: "session-active",
-        type: "planning",
-        status: "awaiting_input",
-        title: "Active planning session",
-        inputPayload: JSON.stringify({ initialPlan: "Restore navigation" }),
-        conversationHistory: "[]",
-        currentQuestion: JSON.stringify(mockQuestion),
-        result: JSON.stringify(mockSummary),
-        thinkingOutput: "",
-        projectId: null,
-      });
-    }
-
-    /*
-    FNXC:PlanningModeMobileTablet 2026-07-20-11:00:
-    Opening Planning on a phone with saved sessions is list-first, not an implicit resume.
-    The plan is permitted only after an intentional session selection and is unmounted again on return.
-    */
-    it("keeps mobile main list-first until an operator opens a session", async () => {
-      mockViewport("mobile");
-      mockActiveSession();
-      const { container } = render(<PlanningModeModal isOpen={true} onClose={mockOnClose} onTaskCreated={mockOnTaskCreated} onTasksCreated={vi.fn()} tasks={mockTasks} initialSessions={sessions} />);
-
-      expect(container.querySelector(".planning-modal-body")).toHaveClass("planning-modal-body--show-list");
-      expect(screen.getByRole("button", { name: /Active planning session/ })).toBeVisible();
-      expect(screen.queryByRole("complementary", { name: "Running plan" })).toBeNull();
-
-      fireEvent.click(screen.getByRole("button", { name: /Active planning session/ }));
-      await screen.findByText("What is the scope?");
-      expect(container.querySelector(".planning-modal-body")).toHaveClass("planning-modal-body--show-detail");
-      fireEvent.click(screen.getByRole("button", { name: "Running plan" }));
-      expect(screen.getByRole("complementary", { name: "Running plan" })).toBeVisible();
-
-      fireEvent.click(screen.getByRole("button", { name: "Sessions" }));
-      expect(container.querySelector(".planning-modal-body")).toHaveClass("planning-modal-body--show-list");
-      expect(screen.queryByRole("complementary", { name: "Running plan" })).toBeNull();
-    });
-
-    it("returns an active mobile interview to usable session rows without a running plan", async () => {
-      mockViewport("mobile");
-      mockActiveSession();
-      const { container } = render(<PlanningModeModal isOpen={true} onClose={mockOnClose} onTaskCreated={mockOnTaskCreated} onTasksCreated={vi.fn()} tasks={mockTasks} resumeSessionId="session-active" initialSessions={sessions} />);
-
-      await screen.findByText("What is the scope?");
-      expect(screen.getByLabelText("Running plan")).toBeInTheDocument();
-      const back = await screen.findByLabelText("Back to sessions");
-      expect(back).toBeEnabled();
-      fireEvent.click(back);
-
-      expect(container.querySelector(".planning-modal-body")).toHaveClass("planning-modal-body--show-list");
-      expect(screen.getByRole("button", { name: /Other planning session/ })).toBeVisible();
-      expect(screen.queryByLabelText("Running plan")).toBeNull();
-      expect(screen.getByRole("button", { name: "New session" })).toBeVisible();
-    });
-
-    it("keeps desktop running-plan interview chrome without mobile back navigation", async () => {
-      mockViewport("desktop");
-      mockActiveSession();
-      const { container } = render(<PlanningModeModal isOpen={true} onClose={mockOnClose} onTaskCreated={mockOnTaskCreated} onTasksCreated={vi.fn()} tasks={mockTasks} resumeSessionId="session-active" initialSessions={sessions} />);
-
-      await screen.findByText("What is the scope?");
-      expect(screen.getByLabelText("Running plan")).toBeInTheDocument();
-      expect(container.querySelector(".planning-mobile-back")).toBeNull();
-    });
-
-    it("keeps a mobile list escape from summary and new-session compose when sessions exist", async () => {
-      mockViewport("mobile");
-      mockFetchAiSessions.mockResolvedValue(sessions);
-      mockFetchAiSession.mockResolvedValue({
-        id: "session-active",
-        type: "planning",
-        status: "complete",
-        title: "Active planning session",
-        inputPayload: JSON.stringify({ initialPlan: "Restore navigation", validated: true }),
-        conversationHistory: "[]",
-        currentQuestion: null,
-        result: JSON.stringify(mockSummary),
-        thinkingOutput: "",
-        projectId: null,
-      });
-      const { container } = render(<PlanningModeModal isOpen={true} onClose={mockOnClose} onTaskCreated={mockOnTaskCreated} onTasksCreated={vi.fn()} tasks={mockTasks} resumeSessionId="session-active" initialSessions={sessions} />);
-
-      await screen.findByText("Planning Complete!");
-      fireEvent.click(screen.getByLabelText("Back to sessions"));
-      expect(screen.getByRole("button", { name: /Other planning session/ })).toBeVisible();
-
-      fireEvent.click(screen.getByRole("button", { name: "New session" }));
-      expect(screen.getByPlaceholderText(/e.g., Build a user authentication/)).toBeVisible();
-      fireEvent.click(screen.getByLabelText("Back to sessions"));
-      expect(container.querySelector(".planning-modal-body")).toHaveClass("planning-modal-body--show-list");
-      expect(screen.getByRole("button", { name: /Other planning session/ })).toBeVisible();
-    });
-  });
-
-  /*
-  FNXC:Planning 2026-06-23-02:00:
-  The embedded Planning sidebar is resizable like Missions: a desktop-only drag handle (role=separator) drives an inline width on .planning-sidebar that persists to localStorage and is clamped to the PLANNING_SIDEBAR_MIN/MAX range. These tests assert the handle exists on desktop, persists a clamped width on arrow-key resize, restores from localStorage, and is absent on mobile (where the sidebar stacks full-width).
-  */
-  describe("Resizable sidebar (Missions parity)", () => {
-    const STORAGE_KEY = "fusion:planning-sidebar-width";
-
-    beforeEach(() => {
-      window.localStorage.removeItem(STORAGE_KEY);
-    });
-
-    function renderEmbedded() {
-      return render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-          presentation="embedded"
-        />,
-      );
-    }
-
-    it("renders a desktop resize handle and defaults the sidebar to 300px", () => {
-      mockViewport("desktop");
-      const { container } = renderEmbedded();
-
-      const handle = container.querySelector(".planning-sidebar-resize-handle");
-      expect(handle).not.toBeNull();
-      expect(handle?.getAttribute("role")).toBe("separator");
-      expect(handle?.getAttribute("aria-orientation")).toBe("vertical");
-
-      const sidebar = container.querySelector<HTMLElement>(".planning-sidebar");
-      expect(sidebar?.style.width).toBe("300px");
-    });
-
-    it("clamps and persists width on arrow-key resize", () => {
-      mockViewport("desktop");
-      const { container } = renderEmbedded();
-
-      const handle = container.querySelector<HTMLElement>(".planning-sidebar-resize-handle")!;
-      // Shift+ArrowRight steps +50 -> 350px, persisted.
-      fireEvent.keyDown(handle, { key: "ArrowRight", shiftKey: true });
-
-      const sidebar = container.querySelector<HTMLElement>(".planning-sidebar");
-      expect(sidebar?.style.width).toBe("350px");
-      expect(window.localStorage.getItem(STORAGE_KEY)).toBe("350");
-
-      // ArrowLeft below the minimum clamps to PLANNING_SIDEBAR_MIN_WIDTH (220).
-      for (let i = 0; i < 20; i += 1) {
-        fireEvent.keyDown(handle, { key: "ArrowLeft", shiftKey: true });
-      }
-      expect(sidebar?.style.width).toBe("220px");
-      expect(window.localStorage.getItem(STORAGE_KEY)).toBe("220");
-    });
-
-    it("restores a persisted clamped width from localStorage", () => {
-      window.localStorage.setItem(STORAGE_KEY, "9999");
-      mockViewport("desktop");
-      const { container } = renderEmbedded();
-
-      // Out-of-range stored value clamps to PLANNING_SIDEBAR_MAX_WIDTH (560).
-      const sidebar = container.querySelector<HTMLElement>(".planning-sidebar");
-      expect(sidebar?.style.width).toBe("560px");
-    });
-
-    it("omits the resize handle and inline width on mobile", () => {
-      mockViewport("mobile");
-      const { container } = renderEmbedded();
-
-      expect(container.querySelector(".planning-sidebar-resize-handle")).toBeNull();
-      const sidebar = container.querySelector<HTMLElement>(".planning-sidebar");
-      expect(sidebar?.style.width).toBe("");
-    });
-  });
-
-  describe("Summary markdown preview toggle", () => {
-    async function renderPlanningSummary(description: string) {
-      mockConnectPlanningStream.mockImplementationOnce((_sessionId: string, _projectId: string | undefined, handlers: any) => {
-        setTimeout(() => {
-          handlers.onSummary?.({
-            ...mockSummary,
-            description,
-          });
-        }, 10);
-
-        return {
-          close: vi.fn(),
-          isConnected: vi.fn().mockReturnValue(true),
-        };
-      });
-
-      const result = render(
-        <PlanningModeModal
-          isOpen={true}
-          onClose={mockOnClose}
-          onTaskCreated={mockOnTaskCreated}
-          onTasksCreated={vi.fn()}
-          tasks={mockTasks}
-        />,
-      );
-
-      fireEvent.change(screen.getByPlaceholderText(/e.g., Build a user authentication/), {
-        target: { value: "Build auth system" },
-      });
-      fireEvent.click(screen.getByText("Start Planning"));
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Validate plan" })).toBeDefined();
-      });
-      mockValidatePlanningSession.mockResolvedValueOnce({
-        summary: { ...mockSummary, description },
-        validated: true,
-      });
-      fireEvent.click(screen.getByRole("button", { name: "Validate plan" }));
-
-      await waitFor(() => {
-        expect(screen.getByText("Planning Complete!")).toBeDefined();
-      });
-
-      return result;
-    }
-
-    it("toggles description between plain textarea and formatted markdown preview", async () => {
-      const { container } = await renderPlanningSummary("## Heading\n\n- item\n\n**bold**");
-
-      expect(container.querySelector(".planning-description-preview")).not.toBeNull();
-      expect(container.querySelector(".planning-textarea")).toBeNull();
-      expect(screen.getByRole("heading", { level: 2, name: "Heading" })).toBeDefined();
-      expect(container.querySelector("strong")?.textContent).toBe("bold");
-
-      fireEvent.click(screen.getByTestId("planning-description-markdown-toggle"));
-
-      await waitFor(() => {
-        expect(container.querySelector(".planning-textarea")).not.toBeNull();
-        expect(container.querySelector(".planning-description-preview")).toBeNull();
-      });
-
-      fireEvent.click(screen.getByTestId("planning-description-markdown-toggle"));
-
-      await waitFor(() => {
-        expect(container.querySelector(".planning-description-preview")).not.toBeNull();
-        expect(screen.getByRole("heading", { level: 2, name: "Heading" })).toBeDefined();
-        expect(container.querySelector("strong")?.textContent).toBe("bold");
-      });
-    });
-
-    it.each([
-      { viewport: "mobile" as const, typedDescription: "Mobile summary accepts spaces" },
-      { viewport: "desktop" as const, typedDescription: "Desktop summary accepts spaces" },
-    ])("preserves typed spaces in the $viewport summary description textarea", async ({ viewport, typedDescription }) => {
-      mockViewport(viewport);
-      const user = userEvent.setup();
-      await renderPlanningSummary("Generated summary with existing words");
-      fireEvent.click(screen.getByTestId("planning-description-markdown-toggle"));
-
-      const textarea = screen.getByLabelText("Description") as HTMLTextAreaElement;
-      textarea.focus();
-      textarea.setSelectionRange(0, textarea.value.length);
-      await user.type(textarea, typedDescription);
-
-      expect(textarea.value).toContain(typedDescription);
-      expect(textarea.value).not.toContain(typedDescription.replaceAll(" ", ""));
-      expect(screen.getByRole("button", { name: /Create Single Task/i })).toBeDefined();
-      expect(screen.getByRole("button", { name: /Break into Tasks/i })).toBeDefined();
-    });
-
-    it("expands and collapses the mobile summary description without breaking the adjacent markdown toggle", async () => {
-      mockViewport("mobile");
-      const { container } = await renderPlanningSummary(
-        "## Heading\n\n" +
-          "This is a long planning description that should visibly change between collapsed and expanded summary states on mobile.\n\n" +
-          "- Keep markdown available\n" +
-          "- Keep expand available",
-      );
-
-      const markdownToggle = screen.getByTestId("planning-description-markdown-toggle");
-      const expandButton = screen.getByRole("button", { name: "Expand description" });
-      expect(markdownToggle.closest("label")).toBeNull();
-      expect(expandButton.closest("label")).toBeNull();
-
-      expect(container.querySelector(".planning-description-preview")).not.toBeNull();
-      expect(container.querySelector(".planning-textarea")).toBeNull();
-
-      fireEvent.click(markdownToggle);
-
-      const textarea = container.querySelector<HTMLTextAreaElement>(".planning-textarea");
-      expect(textarea).not.toBeNull();
-      expect(textarea?.classList.contains("expanded")).toBe(false);
-
-      fireEvent.click(expandButton);
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Collapse description" })).toBeDefined();
-        expect(container.querySelector(".planning-textarea")?.classList.contains("expanded")).toBe(true);
-      });
-
-      fireEvent.click(markdownToggle);
-
-      await waitFor(() => {
-        const preview = container.querySelector(".planning-description-preview");
-        expect(preview).not.toBeNull();
-        expect(preview?.classList.contains("expanded")).toBe(true);
-        expect(screen.getByRole("heading", { level: 2, name: "Heading" })).toBeDefined();
-      });
-
-      fireEvent.click(screen.getByRole("button", { name: "Collapse description" }));
-
-      await waitFor(() => {
-        expect(screen.getByRole("button", { name: "Expand description" })).toBeDefined();
-        expect(container.querySelector(".planning-description-preview")?.classList.contains("expanded")).toBe(false);
-      });
-
-      fireEvent.click(markdownToggle);
-
-      await waitFor(() => {
-        expect(container.querySelector(".planning-textarea")).not.toBeNull();
-        expect(container.querySelector(".planning-description-preview")).toBeNull();
-      });
-    });
-  });
 
+describe("PlanningModeModal sequential layout", () => {
+  it("removes retired three-pane and compact interview selectors across responsive surfaces", () => {
+    const css = readFileSync(resolve(process.cwd(), "app/components/PlanningModeModal.css"), "utf8");
+    expect(css).not.toMatch(/planning-compact-pane-switcher|planning-running-plan|planning-answered-history/);
+    expect(css).toContain("planning-summary-actions");
+  });
 });
diff --git a/packages/dashboard/src/__tests__/planning-e2e-plan-creation.test.ts b/packages/dashboard/src/__tests__/planning-e2e-plan-creation.test.ts
index 7e513d320c..a08904c22e 100644
--- a/packages/dashboard/src/__tests__/planning-e2e-plan-creation.test.ts
+++ b/packages/dashboard/src/__tests__/planning-e2e-plan-creation.test.ts
@@ -111,11 +111,11 @@ function installContextAwareAgent() {
 }
 
 function createStore() {
-  const createTask = vi.fn(async (input: { title: string; description: string }) => ({
-    id: "FN-E2E-001",
-    title: input.title,
-    description: input.description,
-  }));
+  let createdTask: { id: string; title: string; description: string } | undefined;
+  const createTask = vi.fn(async (input: { title: string; description: string }) => {
+    createdTask = { id: "FN-E2E-001", title: input.title, description: input.description };
+    return createdTask;
+  });
   return {
     getSettings: vi.fn().mockResolvedValue({
       autoMerge: false,
@@ -123,8 +123,11 @@ function createStore() {
       ntfyEnabled: false,
     }),
     getRootDir: vi.fn().mockReturnValue("/tmp/planning-e2e"),
-    listTasks: vi.fn().mockResolvedValue([]),
-    getTask: vi.fn(async () => { throw new Error("not found"); }),
+    listTasks: vi.fn(async () => createdTask ? [createdTask] : []),
+    getTask: vi.fn(async (id: string) => {
+      if (createdTask?.id === id) return createdTask;
+      throw new Error("not found");
+    }),
     createTask,
     updateTask: vi.fn().mockResolvedValue(undefined),
     logEntry: vi.fn().mockResolvedValue(undefined),
@@ -219,11 +222,15 @@ describe("Planning Mode plan creation E2E", () => {
     expect(validate).toMatchObject({ status: 200, body: { validated: true } });
 
     const created = await post(app, "/api/planning/create-task", { sessionId });
-    expect(created).toMatchObject({ status: 201, body: { id: "FN-E2E-001", title: "Plan: Build secure account recovery" } });
+    expect(created).toMatchObject({ status: 201, body: { task: { id: "FN-E2E-001", title: "Plan: Build secure account recovery" }, alreadyCreated: false } });
     expect(store.createTask).toHaveBeenCalledWith(expect.objectContaining({
       description: expect.stringContaining("## Key deliverables"),
     }));
-    expect(await getSession(sessionId)).toBeUndefined();
+    expect((await getSession(sessionId))?.createdTaskId).toBe("FN-E2E-001");
+
+    const retry = await post(app, "/api/planning/create-task", { sessionId });
+    expect(retry).toMatchObject({ status: 200, body: { task: { id: "FN-E2E-001" }, alreadyCreated: true } });
+    expect(store.createTask).toHaveBeenCalledTimes(1);
   });
 
   it("keeps AI-authored options and Other in the input language", async () => {
diff --git a/packages/dashboard/src/__tests__/planning-infinite-interview.test.ts b/packages/dashboard/src/__tests__/planning-infinite-interview.test.ts
index 83ec43204c..a778ee932d 100644
--- a/packages/dashboard/src/__tests__/planning-infinite-interview.test.ts
+++ b/packages/dashboard/src/__tests__/planning-infinite-interview.test.ts
@@ -27,6 +27,8 @@ import {
 } from "../planning.js";
 
 const MOCK_TASK_STORE = {
+  // FNXC:PlanningMode 2026-07-20-20:15: Agent-backed planning turns resolve the configured prompt lane before emitting the sequential question/plan transition.
+  getSettings: vi.fn(async () => ({})),
   listTasks: vi.fn(async () => []),
   getTask: vi.fn(async () => { throw new Error("not found"); }),
 } as unknown as TaskStore;
@@ -191,10 +193,11 @@ describe("reactive Planning Mode question contract", () => {
       [fallbackQuestion.id]: "other",
       _other: "Ask about audit-log security before anything else.",
     }, "/tmp/project", undefined, MOCK_TASK_STORE);
-    expect(next).toEqual(expect.objectContaining({ type: "question", data: expect.objectContaining({ id: "rollout" }) }));
+    // FNXC:PlanningMode 2026-07-20-20:15: Answers update the plan only; the next
+    // question is user-triggered by refine so a focus can steer it.
+    expect(next).toEqual(expect.objectContaining({ type: "complete" }));
+    expect((await getSession(sessionId))?.currentQuestion).toBeUndefined();
     expect(prompts.at(-1)).toContain("Ask about audit-log security before anything else.");
-    expect(prompts.at(-1)).toContain("exactly one new, high-impact question");
-    expect(prompts.at(-1)).toContain("only the user can validate it");
     expect(events.filter((type) => type === "summary")).toHaveLength(2);
 
     await validateSession(sessionId);
@@ -217,8 +220,8 @@ describe("reactive Planning Mode question contract", () => {
       scope: "other",
       _other: "Ask me questions about audit logging security instead.",
     }, "/tmp/project", undefined, MOCK_TASK_STORE);
-    expect(firstNext.type).toBe("question");
-    expect(firstNext.data.id).not.toBe("scope");
+    expect(firstNext.type).toBe("complete");
+    expect((await getSession(created.sessionId))?.currentQuestion).toBeUndefined();
     expect(prompts[1]).toContain("Ask me questions about audit logging security instead.");
 
     const afterCompletion = await getSession(created.sessionId);
@@ -228,11 +231,7 @@ describe("reactive Planning Mode question contract", () => {
       title: "Secure account recovery delivery",
       keyDeliverables: ["Implement recovery workflow", "Verify audit coverage"],
     });
-    expect(afterCompletion?.currentQuestion).toBeDefined();
-
-    const secondQuestion = afterCompletion!.currentQuestion!;
-    const secondNext = await submitResponse(created.sessionId, { [secondQuestion.id]: "option-1" }, "/tmp/project", undefined, MOCK_TASK_STORE);
-    expect(secondNext).toEqual(expect.objectContaining({ type: "question" }));
+    expect(afterCompletion?.currentQuestion).toBeUndefined();
     expect((await getSession(created.sessionId))?.summary).toBeDefined();
     expect((await getSession(created.sessionId))?.validated).toBe(false);
 
@@ -374,30 +373,19 @@ describe("reactive Planning Mode question contract", () => {
     expect(session?.validated).toBe(false);
   });
 
-  it("replays an edited historical answer while retaining later answers and appending a fresh question", async () => {
-    installScriptedAgent([
-      payload(FIRST_QUESTION),
-      payload(SECOND_QUESTION),
-      payload({ ...SECOND_QUESTION, id: "verification", question: "What verification is required?" }),
-      payload({ ...SECOND_QUESTION, id: "ignored-replay" }),
-      payload({ ...SECOND_QUESTION, id: "ignored-replay-after-edit" }),
-      payload({ ...SECOND_QUESTION, id: "fresh-after-edit", question: "What risk remains after the edit?" }),
-    ]);
+  it("replays an edited historical answer into plan review without automatically asking a question", async () => {
+    installScriptedAgent([payload(FIRST_QUESTION), completePayload(), completePayload(), completePayload(), completePayload()]);
     const created = await createSession("127.0.0.2", "Improve audit trails", MOCK_TASK_STORE, "/tmp/project");
     await submitResponse(created.sessionId, { scope: "secure" }, "/tmp/project", undefined, MOCK_TASK_STORE);
-    const second = (await getSession(created.sessionId))!.currentQuestion!;
-    await submitResponse(created.sessionId, { [second.id]: "gradual" }, "/tmp/project", undefined, MOCK_TASK_STORE);
 
     await rewindSession(created.sessionId, "scope", "/tmp/project", undefined, MOCK_TASK_STORE);
-    await submitResponse(created.sessionId, { scope: "fast" }, "/tmp/project", undefined, MOCK_TASK_STORE);
+    const revised = await submitResponse(created.sessionId, { scope: "fast" }, "/tmp/project", undefined, MOCK_TASK_STORE);
 
     const edited = await getSession(created.sessionId);
-    expect(edited?.history).toHaveLength(2);
+    expect(revised.type).toBe("complete");
+    expect(edited?.history).toHaveLength(1);
     expect(edited?.history[0]?.response).toEqual({ scope: "fast" });
-    expect(edited?.history[1]?.response).toEqual({ [second.id]: "gradual" });
-    expect(edited?.currentQuestion?.id).toBe("fresh-after-edit");
-    expect(edited?.summary?.description).toContain("Fast delivery");
-    expect(edited?.summary?.description.match(/Gradual rollout/g)).toHaveLength(1);
-    expect(edited?.summary?.keyDeliverables).not.toContain(edited?.currentQuestion?.question);
+    expect(edited?.currentQuestion).toBeUndefined();
+    expect(edited?.summary).toBeDefined();
   });
 });
diff --git a/packages/dashboard/src/__tests__/routes-planning.test.ts b/packages/dashboard/src/__tests__/routes-planning.test.ts
index 9711dfd93f..c4e0591ee6 100644
--- a/packages/dashboard/src/__tests__/routes-planning.test.ts
+++ b/packages/dashboard/src/__tests__/routes-planning.test.ts
@@ -1591,7 +1591,7 @@ describe("Planning Mode Routes", () => {
     });
 
     describe("POST /planning/respond", () => {
-      it("processes response and returns next question", async () => {
+      it("updates the plan after an answer", async () => {
         // First create a session
         const startRes = await REQUEST(
           buildApp(),
@@ -1613,65 +1613,18 @@ describe("Planning Mode Routes", () => {
         );
 
         expect(res.status).toBe(200);
-        expect(res.body.type).toBe("question");
+        expect(res.body.type).toBe("complete");
         expect(res.body.data).toBeDefined();
       });
 
-      it("returns checkpoint before summary, then completes only after explicit proceed", async () => {
-        // Create a session
-        const startRes = await REQUEST(
-          buildApp(),
-          "POST",
-          "/api/planning/start",
-          JSON.stringify({ initialPlan: "Build a user auth system" }),
-          { "Content-Type": "application/json" }
-        );
+      it("requires an explicit refine request before asking another question", async () => {
+        const startRes = await REQUEST(buildApp(), "POST", "/api/planning/start", JSON.stringify({ initialPlan: "Build a user auth system" }), { "Content-Type": "application/json" });
         const sessionId = startRes.body.sessionId;
+        const answer = await REQUEST(buildApp(), "POST", "/api/planning/respond", JSON.stringify({ sessionId, responses: { scope: "medium" } }), { "Content-Type": "application/json" });
+        expect(answer.body).toMatchObject({ type: "complete" });
 
-        // Submit 3 responses to complete the session
-        await REQUEST(
-          buildApp(),
-          "POST",
-          "/api/planning/respond",
-          JSON.stringify({ sessionId, responses: { scope: "medium" } }),
-          { "Content-Type": "application/json" }
-        );
-
-        await REQUEST(
-          buildApp(),
-          "POST",
-          "/api/planning/respond",
-          JSON.stringify({ sessionId, responses: { requirements: "Must have login" } }),
-          { "Content-Type": "application/json" }
-        );
-
-        const checkpointRes = await REQUEST(
-          buildApp(),
-          "POST",
-          "/api/planning/respond",
-          JSON.stringify({ sessionId, responses: { confirm: true } }),
-          { "Content-Type": "application/json" }
-        );
-
-        expect(checkpointRes.status).toBe(200);
-        expect(checkpointRes.body.type).toBe("question");
-        expect(checkpointRes.body.data.id).toEqual(expect.any(String));
-        expect(checkpointRes.body.data.question).toEqual(expect.any(String));
-
-        const finalRes = await REQUEST(
-          buildApp(),
-          "POST",
-          "/api/planning/respond",
-          JSON.stringify({
-            sessionId,
-            responses: { [PLANNING_DEEPEN_CHECKPOINT_ID]: [PLANNING_DEEPEN_PROCEED_OPTION_ID] },
-          }),
-          { "Content-Type": "application/json" }
-        );
-
-        expect(finalRes.status).toBe(200);
-        expect(finalRes.body).toMatchObject({ type: "question", data: { id: expect.any(String) } });
-        expect(planningModule.getSummary(sessionId)).toBeDefined();
+        const refine = await REQUEST(buildApp(), "POST", "/api/planning/respond", JSON.stringify({ sessionId, responses: { refine: true, focus: "security" } }), { "Content-Type": "application/json" });
+        expect(refine.body).toMatchObject({ type: "question", data: { id: expect.any(String) } });
       });
 
       it("FN-6977 normalizes omitted summary arrays from live AI completion", async () => {
@@ -1725,11 +1678,8 @@ describe("Planning Mode Routes", () => {
 
         expect(checkpointRes.status).toBe(200);
         expect(checkpointRes.body).toMatchObject({
-          type: "question",
-          data: {
-            id: expect.any(String),
-            question: expect.any(String),
-          },
+          type: "complete",
+          data: { title: "Malformed AI summary" },
         });
         expect(planningModule.getSummary(sessionId)).toMatchObject({
           suggestedDependencies: ["FN-100"],
@@ -1738,17 +1688,6 @@ describe("Planning Mode Routes", () => {
           ]),
         });
 
-        const finalRes = await REQUEST(
-          buildApp(),
-          "POST",
-          "/api/planning/respond",
-          JSON.stringify({
-            sessionId,
-            responses: { [PLANNING_DEEPEN_CHECKPOINT_ID]: [PLANNING_DEEPEN_PROCEED_OPTION_ID] },
-          }),
-          { "Content-Type": "application/json" },
-        );
-        expect(finalRes.body).toMatchObject({ type: "question", data: { id: expect.any(String) } });
         expect(planningModule.getSummary(sessionId)).toMatchObject({
           suggestedDependencies: ["FN-100"],
           keyDeliverables: expect.arrayContaining([
@@ -1817,7 +1756,7 @@ describe("Planning Mode Routes", () => {
           JSON.stringify({ sessionId, responses: { "q-one": "Make it responsive and tested" } }),
           { "Content-Type": "application/json" },
         );
-        expect(checkpointRes.body.data.question).toEqual(expect.any(String));
+        expect(checkpointRes.body.type).toBe("complete");
 
         const deepeningRes = await REQUEST(
           buildApp(),
@@ -1825,10 +1764,7 @@ describe("Planning Mode Routes", () => {
           "/api/planning/respond",
           JSON.stringify({
             sessionId,
-            responses: {
-              [PLANNING_DEEPEN_CHECKPOINT_ID]: ["theme-ux"],
-              _other: "Explore rollout risk",
-            },
+            responses: { refine: true, focus: "Explore rollout risk" },
           }),
           { "Content-Type": "application/json" },
         );
@@ -1845,22 +1781,7 @@ describe("Planning Mode Routes", () => {
           JSON.stringify({ sessionId, responses: { "q-deeper": "Keyboard and touch interactions" } }),
           { "Content-Type": "application/json" },
         );
-        expect(secondCheckpointRes.body).toMatchObject({
-          type: "question",
-          data: { id: expect.any(String), question: expect.any(String) },
-        });
-
-        const finalRes = await REQUEST(
-          buildApp(),
-          "POST",
-          "/api/planning/respond",
-          JSON.stringify({
-            sessionId,
-            responses: { [PLANNING_DEEPEN_CHECKPOINT_ID]: [PLANNING_DEEPEN_PROCEED_OPTION_ID] },
-          }),
-          { "Content-Type": "application/json" },
-        );
-        expect(finalRes.body).toMatchObject({ type: "question", data: { id: expect.any(String) } });
+        expect(secondCheckpointRes.body.type).toBe("complete");
       });
 
       it("prefers AI-authored deepeningThemes over generic themes on both completion paths", async () => {
@@ -1914,13 +1835,7 @@ describe("Planning Mode Routes", () => {
           JSON.stringify({ sessionId, responses: { "q-offline-context": "Conflicts and recovery" } }),
           { "Content-Type": "application/json" },
         );
-        expect(interviewRes.body.data.question).toEqual(expect.any(String));
-        expect(interviewRes.body.data.options?.[0]?.id).toEqual(expect.any(String));
-        expect(interviewRes.body.data.options?.map((option: { label: string }) => option.label)).toEqual([
-          "Option 1",
-          "Option 2",
-          "Other (write your own)",
-        ]);
+        expect(interviewRes.body.type).toBe("complete");
 
         const deepeningRes = await REQUEST(
           buildApp(),
@@ -1928,7 +1843,7 @@ describe("Planning Mode Routes", () => {
           "/api/planning/respond",
           JSON.stringify({
             sessionId,
-            responses: { [PLANNING_DEEPEN_CHECKPOINT_ID]: [PLANNING_DEEPEN_PROCEED_OPTION_ID] },
+            responses: { refine: true },
           }),
           { "Content-Type": "application/json" },
         );
@@ -3989,7 +3904,7 @@ describe("Saturated-slot regression: utility AI routes", () => {
       );
 
       expect(res.status).toBe(200);
-      expect(res.body.type).toBe("question");
+      expect(res.body.type).toBe("complete");
     });
 
     /*
@@ -4026,7 +3941,7 @@ describe("Saturated-slot regression: utility AI routes", () => {
       );
 
       expect(res.status).toBe(200);
-      expect(res.body.type).toBe("question");
+      expect(res.body.type).toBe("complete");
       expect(mockAiSessionStore.acquireLock).not.toHaveBeenCalled();
     });
   });
diff --git a/packages/dashboard/src/ai-session-store.ts b/packages/dashboard/src/ai-session-store.ts
index b914c8165c..f2bcf62169 100644
--- a/packages/dashboard/src/ai-session-store.ts
+++ b/packages/dashboard/src/ai-session-store.ts
@@ -15,6 +15,10 @@ import { THINKING_LEVELS, type AsyncDataLayer, type ThinkingLevel } from "@fusio
 import {
   upsertAiSession,
   getAiSession,
+  claimPlanningSessionTaskCreation,
+  finalizePlanningSessionTaskCreation,
+  reconcilePlanningSessionTaskCreation,
+  releasePlanningSessionTaskCreation,
   listActiveAiSessions,
   listAllAiSessions,
   listRecoverableAiSessions,
@@ -147,6 +151,35 @@ export class AiSessionStore extends EventEmitter<AiSessionStoreEvents> {
     return;
   }
 
+  /*
+  FNXC:PlanningMode 2026-07-20-20:15:
+  Planning creation claims must use one conditional database update, not a read then an
+  upsert, so competing dashboard processes cannot both become the creator.
+  */
+  async claimPlanningTaskCreation(sessionId: string, ownerToken: string, startedAt: string): Promise<AiSessionRow | null> {
+    const row = await claimPlanningSessionTaskCreation(this.dbAsync, sessionId, ownerToken, startedAt) as AiSessionRow | null;
+    if (row) this.emit("ai_session:updated", toSummary(row, row.updatedAt));
+    return row;
+  }
+
+  async finalizePlanningTaskCreation(sessionId: string, ownerToken: string, taskId: string): Promise<AiSessionRow | null> {
+    const row = await finalizePlanningSessionTaskCreation(this.dbAsync, sessionId, ownerToken, taskId) as AiSessionRow | null;
+    if (row) this.emit("ai_session:updated", toSummary(row, row.updatedAt));
+    return row;
+  }
+
+  async reconcilePlanningTaskCreation(sessionId: string, taskId: string): Promise<AiSessionRow | null> {
+    const row = await reconcilePlanningSessionTaskCreation(this.dbAsync, sessionId, taskId) as AiSessionRow | null;
+    if (row) this.emit("ai_session:updated", toSummary(row, row.updatedAt));
+    return row;
+  }
+
+  async releasePlanningTaskCreation(sessionId: string, ownerToken: string): Promise<AiSessionRow | null> {
+    const row = await releasePlanningSessionTaskCreation(this.dbAsync, sessionId, ownerToken) as AiSessionRow | null;
+    if (row) this.emit("ai_session:updated", toSummary(row, row.updatedAt));
+    return row;
+  }
+
   /**
    * Update only the thinkingOutput field, debounced to reduce write frequency.
    * Flushes immediately if `flush` is true (e.g. on status transition).
diff --git a/packages/dashboard/src/planning.ts b/packages/dashboard/src/planning.ts
index 1aa7427b65..dd4a79132e 100644
--- a/packages/dashboard/src/planning.ts
+++ b/packages/dashboard/src/planning.ts
@@ -240,11 +240,11 @@ export const PLANNING_SYSTEM_PROMPT = `## Planning Mode interaction adapter
 
 First analyze the codebase and active board with the available readonly tools, fn_task_list, and fn_task_show. Treat the workflow planning template above as the quality bar and PROMPT.md structure for the evolving plan, but do not write PROMPT.md or use write tools during this interview.
 
-Ask exactly one next, high-impact question on every turn. Use every prior answer as context, avoid repeated questions, and never decide that the interview is complete or emit a terminal/complete response. Only the user can validate the plan.
+Ask exactly one next, high-impact question only when the user explicitly requests a refine turn. After an answer, update the running plan and do not ask a question. Never decide that the interview is complete or emit a terminal/complete response. Only the user can validate the plan.
 
-Respond only with JSON: {"type":"question","data":{"id":"unique-id","type":"single_select|multi_select","question":"...","description":"...","options":[{"id":"option-a","label":"...","description":"...","pros":["..."],"cons":["..."]},{"id":"option-b","label":"...","description":"...","pros":["..."],"cons":["..."]},{"id":"other","label":"...","isOther":true}],"runningPlan":{"title":"...","description":"...","suggestedSize":"S|M|L","priority":"normal","suggestedDependencies":[],"keyDeliverables":["concrete work item"]}}}.
+For a refine turn respond only with JSON: {"type":"question","data":{"id":"unique-id","type":"single_select|multi_select","question":"...","description":"...","options":[{"id":"option-a","label":"...","description":"...","pros":["..."],"cons":["..."]},{"id":"option-b","label":"...","description":"...","pros":["..."],"cons":["..."]},{"id":"other","label":"...","isOther":true}],"runningPlan":{"title":"...","description":"...","suggestedSize":"S|M|L","priority":"normal","suggestedDependencies":[],"keyDeliverables":["concrete work item"]}}}. For an answer-update turn respond only with {"type":"complete","data":{"title":"...","description":"...","suggestedSize":"S|M|L","priority":"normal","suggestedDependencies":[],"keyDeliverables":["concrete work item"]}}.
 
-Every turn must include runningPlan: only title, description, suggestedSize, optional priority, suggestedDependencies, and concrete keyDeliverables informed by the idea and answers so far. Never use interview question text as a deliverable. Do not put PROMPT.md sections (Mission, Before → After, Steps, File Scope, Review Level, Completion Criteria, or Do NOT) in runningPlan or free text: triage writes PROMPT.md only after Validate. Validate serializes this lean plan as plan.md without priority; priority remains a task field. Every question must provide at least two alternatives, each with non-empty pros and cons, plus exactly one Other/write-your-own option. Write every label, option, and Other label in the language of the user's original input. Incorporate free-text Other answers verbatim as steering context for the following question.`;
+Every turn must include the running-plan fields: only title, description, suggestedSize, optional priority, suggestedDependencies, and concrete keyDeliverables informed by the idea and answers so far. Never use interview question text as a deliverable. Do not put PROMPT.md sections (Mission, Before → After, Steps, File Scope, Review Level, Completion Criteria, or Do NOT) in runningPlan or free text: triage writes PROMPT.md only after Validate. Validate serializes this lean plan as plan.md without priority; priority remains a task field. Every question must provide at least two alternatives, each with non-empty pros and cons, plus exactly one Other/write-your-own option. Write every label, option, and Other label in the language of the user's original input. Incorporate free-text Other answers verbatim as steering context for the following question.`;
 
 /*
 FNXC:PlanningMode 2026-07-20-14:30:
@@ -311,6 +311,10 @@ export interface DraftInputPayload {
   summarizedFor?: string;
   validated?: boolean;
   workflowId?: string;
+  createdTaskId?: string;
+  createClaimStatus?: "none" | "creating" | "created";
+  claimOwnerToken?: string;
+  claimStartedAt?: string;
 }
 
 /** Session TTL in milliseconds (7 days) */
@@ -389,6 +393,13 @@ interface Session {
   summary?: PlanningSummary;
   /** User-controlled finalization state. */
   validated: boolean;
+  /** Durable create-task linkage; proposalClaimId remains the crash-recovery authority. */
+  createdTaskId?: string;
+  createClaimStatus?: "none" | "creating" | "created";
+  claimOwnerToken?: string;
+  claimStartedAt?: string;
+  /** Whether the current generation must end at plan review rather than a question. */
+  generationPurpose?: "plan_update" | "question";
   /** Last terminal error for retry UX */
   error?: string;
   /** AI agent session for real-time interaction */
@@ -589,6 +600,10 @@ function persistSession(session: Session, status: "generating" | "awaiting_input
       ...(session.draftSummarizedFor ? { summarizedFor: session.draftSummarizedFor } : {}),
       ...(session.workflowId ? { workflowId: session.workflowId } : {}),
       validated: session.validated,
+      ...(session.createdTaskId ? { createdTaskId: session.createdTaskId } : {}),
+      ...(session.createClaimStatus ? { createClaimStatus: session.createClaimStatus } : {}),
+      ...(session.claimOwnerToken ? { claimOwnerToken: session.claimOwnerToken } : {}),
+      ...(session.claimStartedAt ? { claimStartedAt: session.claimStartedAt } : {}),
       ...(typeof session.clarificationEnabled === "boolean"
         ? { clarificationEnabled: session.clarificationEnabled }
         : {}),
@@ -735,6 +750,10 @@ function buildSessionFromRow(row: AiSessionRow): Session {
     lastNotifiedQuestionKey: currentQuestion ? `${row.id}:${currentQuestion.id}` : undefined,
     summary: persistedSummary ?? buildRunningSummary(payload.initialPlan ?? row.title, history),
     validated: payload.validated === true,
+    createdTaskId: typeof payload.createdTaskId === "string" ? payload.createdTaskId : undefined,
+    createClaimStatus: payload.createClaimStatus,
+    claimOwnerToken: typeof payload.claimOwnerToken === "string" ? payload.claimOwnerToken : undefined,
+    claimStartedAt: typeof payload.claimStartedAt === "string" ? payload.claimStartedAt : undefined,
     thinkingOutput: row.thinkingOutput,
     lastGeneratedThinking: row.thinkingOutput || "",
     error: row.error ?? undefined,
@@ -2418,18 +2437,25 @@ async function continueAgentConversation(session: Session, message: string): Pro
       return;
     }
 
-      // A generic engine completion is never terminal in Planning Mode. Its data remains
-      // eligible as a model-authored running plan while the fallback question keeps interviewing.
-      session.currentQuestion = coerceQuestionResponse(parsed, session);
       session.summary = mergeRunningSummary(session, parsed);
       session.error = undefined;
       session.lastGeneratedThinking = session.thinkingOutput;
       session.updatedAt = new Date();
-      // Persist after deriving the plan: reloads must see the running summary on every turn.
+      const planUpdate = session.generationPurpose === "plan_update";
+      session.generationPurpose = undefined;
+      /*
+      FNXC:PlanningMode 2026-07-20-15:45:
+      A model can accidentally return question-shaped JSON during an answer update. FN-8442
+      deliberately strips that question instead of exposing it: the next question is exclusively
+      triggered by the plan-review Refine action, optionally with operator focus text.
+      */
+      session.currentQuestion = planUpdate ? undefined : coerceQuestionResponse(parsed, session);
       persistSession(session, "awaiting_input");
-      void maybeNotifyPlanningAwaitingInput(session, session.currentQuestion, true);
       planningStreamManager.broadcast(session.id, { type: "summary", data: session.summary });
-      planningStreamManager.broadcast(session.id, { type: "question", data: session.currentQuestion });
+      if (session.currentQuestion) {
+        void maybeNotifyPlanningAwaitingInput(session, session.currentQuestion, true);
+        planningStreamManager.broadcast(session.id, { type: "question", data: session.currentQuestion });
+      }
     });
   } catch (err) {
     if (err instanceof Error && err.name === "AbortError") {
@@ -2693,12 +2719,13 @@ function isRefineRequest(responses: Record<string, unknown>): boolean {
   return responses.refine === true;
 }
 
-function formatRefineRequestForAgent(summary: PlanningSummary): string {
+function formatRefineRequestForAgent(summary: PlanningSummary, focus?: string): string {
   return [
     "The user clicked Refine Further on the planning summary.",
     "Continue the planning interview from the existing context.",
     "Ask exactly one focused, high-impact follow-up question with alternatives and pros/cons.",
     "Do not return a completion response: only the user can validate a plan.",
+    ...(focus ? ["The operator wants this next question to focus on:", focus] : []),
     "Current summary:",
     JSON.stringify(summary),
   ].join("\n\n");
@@ -2783,7 +2810,9 @@ export async function submitResponse(
     persistSession(session, "generating");
 
     await ensureSessionAgent(session, rootDir, session.history, promptOverrides, store);
-    const refineMessage = formatRefineRequestForAgent(session.summary);
+    session.generationPurpose = "question";
+    const focus = typeof responses.focus === "string" ? responses.focus.trim() : undefined;
+    const refineMessage = formatRefineRequestForAgent(session.summary, focus);
     await continueAgentConversation(session, refineMessage);
   } else {
     const currentQuestion = captureOtherCustomText(session.currentQuestion, responses);
@@ -2814,8 +2843,14 @@ export async function submitResponse(
     }
     answeredQuestion = currentQuestion;
 
-    // Answered questions always lead to another question; no answer can validate or complete.
+    /*
+    FNXC:PlanningMode 2026-07-20-15:45:
+    FN-8442 makes answering a plan-update turn. Clear the active question before generation
+    and record its purpose so only an explicit `{ refine: true, focus? }` may surface another
+    question; this keeps the plan-review decision point under operator control.
+    */
     session.currentQuestion = undefined;
+    session.generationPurpose = "plan_update";
     persistSession(session, "generating");
     if (!session.agent) {
       // An edited older answer must be replayed in its original position with every
@@ -2829,8 +2864,8 @@ export async function submitResponse(
       );
     }
     const message = isEditingPriorAnswer
-      ? "An earlier answer was edited. Use the complete preserved interview context above, re-derive the running plan, and ask exactly one new high-impact next question."
-      : formatResponseForAgent(currentQuestion, responses);
+      ? "An earlier answer was edited. Use the complete preserved interview context above and return only the updated plan JSON; do not ask another question."
+      : `${formatResponseForAgent(currentQuestion, responses)}\n\nUpdate the running plan only. Do not ask a next question; the operator may explicitly refine after reviewing the plan.`;
     await continueAgentConversation(session, message);
   }
 
@@ -2851,7 +2886,10 @@ export async function submitResponse(
     return { type: "question", data: answeredQuestion };
   }
 
-  // Should not reach here, but handle gracefully
+  if (session.summary) {
+    return { type: "complete", data: session.summary };
+  }
+
   throw new InvalidSessionStateError("AI agent did not return a question or summary");
 }
 
@@ -3234,6 +3272,78 @@ export function getSummary(sessionId: string): PlanningSummary | undefined {
   return sessions.get(sessionId)?.summary;
 }
 
+/**
+ * Persist planning create-task claim/linkage state. The task row's stable proposalClaimId is
+ * authoritative after a crash; these fields make restore and UI handoff deterministic.
+ */
+export async function updatePlanningCreateClaim(
+  sessionId: string,
+  patch: Pick<Session, "createClaimStatus" | "createdTaskId" | "claimOwnerToken" | "claimStartedAt">,
+): Promise<void> {
+  const session = await getSession(sessionId);
+  if (!session) throw new SessionNotFoundError(`Planning session ${sessionId} not found or expired`);
+  Object.assign(session, patch);
+  session.updatedAt = new Date();
+  await persistSession(session, session.validated ? "complete" : "awaiting_input");
+}
+
+function restoreClaimSession(row: import("./ai-session-store.js").AiSessionRow): Session {
+  const restored = buildSessionFromRow(row);
+  sessions.set(restored.id, restored);
+  return restored;
+}
+
+/** Read durable claim state rather than trusting a process-local session cache. */
+export async function getDurablePlanningSession(sessionId: string): Promise<Session | undefined> {
+  if (!_aiSessionStore) return getSession(sessionId);
+  const row = await _aiSessionStore.get(sessionId);
+  return row?.type === "planning" ? restoreClaimSession(row) : undefined;
+}
+
+/** Atomically claim a validated planning session for its one task creation. */
+export async function claimPlanningTaskCreation(sessionId: string, ownerToken: string, startedAt: string): Promise<Session | undefined> {
+  if (!_aiSessionStore || typeof (_aiSessionStore as unknown as { claimPlanningTaskCreation?: unknown }).claimPlanningTaskCreation !== "function") {
+    const session = await getSession(sessionId);
+    if (!session || session.createClaimStatus === "creating" || session.createClaimStatus === "created") return undefined;
+    Object.assign(session, { createClaimStatus: "creating", claimOwnerToken: ownerToken, claimStartedAt: startedAt });
+    return session;
+  }
+  const row = await _aiSessionStore.claimPlanningTaskCreation(sessionId, ownerToken, startedAt);
+  return row ? restoreClaimSession(row) : undefined;
+}
+
+export async function finalizePlanningTaskCreation(sessionId: string, ownerToken: string, taskId: string): Promise<Session | undefined> {
+  if (!_aiSessionStore || typeof (_aiSessionStore as unknown as { finalizePlanningTaskCreation?: unknown }).finalizePlanningTaskCreation !== "function") {
+    const session = await getSession(sessionId);
+    if (!session || session.claimOwnerToken !== ownerToken) return undefined;
+    Object.assign(session, { createClaimStatus: "created", createdTaskId: taskId, claimOwnerToken: undefined, claimStartedAt: undefined });
+    return session;
+  }
+  const row = await _aiSessionStore.finalizePlanningTaskCreation(sessionId, ownerToken, taskId);
+  return row ? restoreClaimSession(row) : undefined;
+}
+
+export async function reconcilePlanningTaskCreation(sessionId: string, taskId: string): Promise<Session | undefined> {
+  if (!_aiSessionStore || typeof (_aiSessionStore as unknown as { reconcilePlanningTaskCreation?: unknown }).reconcilePlanningTaskCreation !== "function") {
+    const session = await getSession(sessionId);
+    if (session) Object.assign(session, { createClaimStatus: "created", createdTaskId: taskId, claimOwnerToken: undefined, claimStartedAt: undefined });
+    return session;
+  }
+  const row = await _aiSessionStore.reconcilePlanningTaskCreation(sessionId, taskId);
+  return row ? restoreClaimSession(row) : undefined;
+}
+
+export async function releasePlanningTaskCreation(sessionId: string, ownerToken: string): Promise<Session | undefined> {
+  if (!_aiSessionStore || typeof (_aiSessionStore as unknown as { releasePlanningTaskCreation?: unknown }).releasePlanningTaskCreation !== "function") {
+    const session = await getSession(sessionId);
+    if (!session || session.claimOwnerToken !== ownerToken) return undefined;
+    Object.assign(session, { createClaimStatus: "none", claimOwnerToken: undefined, claimStartedAt: undefined });
+    return session;
+  }
+  const row = await _aiSessionStore.releasePlanningTaskCreation(sessionId, ownerToken);
+  return row ? restoreClaimSession(row) : undefined;
+}
+
 /**
  * Generate subtasks from a completed planning summary.
  * Uses the planning session's summary to create a SubtaskItem[] for multi-task creation.
diff --git a/packages/dashboard/src/routes/register-planning-subtask-routes.ts b/packages/dashboard/src/routes/register-planning-subtask-routes.ts
index 0520757d36..e5d71de771 100644
--- a/packages/dashboard/src/routes/register-planning-subtask-routes.ts
+++ b/packages/dashboard/src/routes/register-planning-subtask-routes.ts
@@ -18,9 +18,33 @@ import type { AiSessionStore } from "../ai-session-store.js";
 import type { ApiRoutesContext } from "./types.js";
 import { resolveBranchAssignmentContext, resolveBranchSelection, resolveEntryPointBranchAssignment } from "./branch-selection.js";
 import { requireAsyncLayer } from "../require-async-layer.js";
+import { randomUUID } from "node:crypto";
 
 type SkillPluginRunner = Parameters<typeof import("@fusion/engine").buildSessionSkillContextSync>[3];
 
+const planningCreateLocks = new Map<string, Promise<void>>();
+
+/**
+ * FNXC:PlanningMode 2026-07-20-15:45:
+ * The stable proposalClaimId is the cross-process authority, while this short-lived lock avoids
+ * duplicate local createTask calls before a same-process retry can observe its finalized linkage.
+ * A process death releases this memory only; retry reconciliation still queries the task mapping.
+ */
+async function acquirePlanningCreateLock(sessionId: string): Promise<() => void> {
+  const previous = planningCreateLocks.get(sessionId);
+  let releaseGate!: () => void;
+  const gate = new Promise<void>((resolve) => { releaseGate = resolve; });
+  const tail = previous ? previous.then(() => gate) : gate;
+  planningCreateLocks.set(sessionId, tail);
+  await previous;
+  return () => {
+    releaseGate();
+    void tail.finally(() => {
+      if (planningCreateLocks.get(sessionId) === tail) planningCreateLocks.delete(sessionId);
+    });
+  };
+}
+
 interface PlanningSubtaskRouteDeps {
   store: TaskStore;
   aiSessionStore?: AiSessionStore;
@@ -1103,6 +1127,9 @@ export function registerPlanningSubtaskRoutes(ctx: ApiRoutesContext, deps: Plann
    * Returns: Created Task
    */
   router.post("/planning/create-task", async (req, res) => {
+    let releaseCreateLock: (() => void) | undefined;
+    let claimedOwnerToken: string | undefined;
+    let claimedSessionId: string | undefined;
     try {
       const { sessionId, summary: summaryInput, branch, baseBranch, branchSelection, workflowId } = req.body as {
         sessionId?: unknown;
@@ -1124,9 +1151,18 @@ export function registerPlanningSubtaskRoutes(ctx: ApiRoutesContext, deps: Plann
       const summaryOverride = parsePlanningSummaryOverride(summaryInput);
 
       const { store: scopedStore } = await getProjectContext(req);
-      const { getSession, getSummary, releaseSession } = await import("../planning.js");
+      const {
+        getSession,
+        getSummary,
+        updatePlanningCreateClaim,
+        getDurablePlanningSession,
+        claimPlanningTaskCreation,
+        finalizePlanningTaskCreation,
+        reconcilePlanningTaskCreation,
+        releasePlanningTaskCreation,
+      } = await import("../planning.js");
 
-      const session = await getSession(sessionId);
+      let session = await getSession(sessionId);
       if (session && !session.validated) throw badRequest("Planning session must be validated before creating tasks");
       let summary = summaryOverride ?? getSummary(sessionId);
       let initialPlan = session?.initialPlan;
@@ -1185,6 +1221,70 @@ export function registerPlanningSubtaskRoutes(ctx: ApiRoutesContext, deps: Plann
         throw badRequest("Planning session is not complete");
       }
 
+      releaseCreateLock = await acquirePlanningCreateLock(sessionId);
+      // Re-read after the local single-flight queue: an earlier caller may have finalized while we waited.
+      session = await getSession(sessionId);
+
+      /*
+      FNXC:PlanningMode 2026-07-20-15:45:
+      FN-8442 derives the never-rotated key `planning-session:${sessionId}` at task creation.
+      The task table's partial unique proposalClaimId index, not this process's claim state, is
+      the multi-process and crash-after-insert authority. A session linkage is a durable cache
+      reconciled from that key; a missing linked task fails closed rather than silently forking.
+      */
+      const proposalClaimId = `planning-session:${sessionId}`;
+      const findCreatedTask = async () =>
+        (await scopedStore.listTasks({ includeArchived: true })).find((candidate) => candidate.proposalClaimId === proposalClaimId);
+      const returnLinkedTask = async (candidate = session) => {
+        if (!candidate?.createdTaskId) return false;
+        const linkedTask = await scopedStore.getTask(candidate.createdTaskId).catch(() => null);
+        if (!linkedTask) throw conflict("PLANNING_CREATED_TASK_MISSING");
+        res.status(200).json({ task: linkedTask, alreadyCreated: true });
+        return true;
+      };
+
+      // A task row is the crash-window authority. Reconcile it before trying to claim.
+      const existingTask = await findCreatedTask();
+      if (existingTask) {
+        await reconcilePlanningTaskCreation(sessionId, existingTask.id);
+        res.status(200).json({ task: existingTask, alreadyCreated: true });
+        return;
+      }
+      session = await getDurablePlanningSession(sessionId) ?? session;
+      if (await returnLinkedTask(session)) return;
+
+      const claimOwnerToken = randomUUID();
+      claimedOwnerToken = claimOwnerToken;
+      claimedSessionId = sessionId;
+      const claimStartedAt = new Date().toISOString();
+      const hasDurableClaimStore = typeof (aiSessionStore as unknown as { claimPlanningTaskCreation?: unknown } | undefined)?.claimPlanningTaskCreation === "function";
+      let claimed = hasDurableClaimStore
+        ? await claimPlanningTaskCreation(sessionId, claimOwnerToken, claimStartedAt)
+        : session
+          ? session.createClaimStatus !== "creating" && session.createClaimStatus !== "created"
+            ? (await updatePlanningCreateClaim(sessionId, { createClaimStatus: "creating", claimOwnerToken, claimStartedAt, createdTaskId: undefined }), session)
+            : undefined
+          // Legacy test/session adapters can provide only the route's persisted row. They do
+          // not model a durable claim API, so retain the pre-CAS behavior for that adapter.
+          : ({} as NonNullable<typeof session>);
+      if (!claimed) {
+        // The failed conditional update means another process owns (or completed) this claim.
+        session = await getDurablePlanningSession(sessionId) ?? session;
+        const recoveredTask = await findCreatedTask();
+        if (recoveredTask) {
+          await reconcilePlanningTaskCreation(sessionId, recoveredTask.id);
+          res.status(200).json({ task: recoveredTask, alreadyCreated: true });
+          return;
+        }
+        if (await returnLinkedTask(session)) return;
+        const startedAt = session?.claimStartedAt ? Date.parse(session.claimStartedAt) : Number.NaN;
+        const leaseExpired = session?.createClaimStatus === "creating" && Number.isFinite(startedAt) && Date.now() - startedAt >= 30_000;
+        if (!leaseExpired || !session?.claimOwnerToken) throw conflict("Planning task creation is already in progress");
+        await releasePlanningTaskCreation(sessionId, session.claimOwnerToken);
+        claimed = await claimPlanningTaskCreation(sessionId, claimOwnerToken, new Date().toISOString());
+        if (!claimed) throw conflict("Planning task creation is already in progress");
+      }
+
       const { branch: resolvedBranch, baseBranch: resolvedBaseBranch } =
         resolveBranchSelection(branchSelection, branch, baseBranch);
 
@@ -1220,6 +1320,7 @@ export function registerPlanningSubtaskRoutes(ctx: ApiRoutesContext, deps: Plann
         Planning Mode creates tasks from the board context, so an active workflow lane must be materialized at create time when the client supplies it.
         */
         ...(workflowId !== undefined ? { workflowId: workflowId as string | null } : {}),
+        proposalClaimId,
       });
 
       // Update task with suggested size if provided.
@@ -1251,18 +1352,25 @@ export function registerPlanningSubtaskRoutes(ctx: ApiRoutesContext, deps: Plann
         { taskId: task.id, sessionId },
       );
 
-      // Release any live in-memory planning runtime for this session, but
-      // keep the persisted completed row so planning history can still list
-      // and restore the summary after single-task creation.
-      await runPlanningCreateSideEffect(
-        "Planning create-task session release failed",
-        () => releaseSession(sessionId),
-        { taskId: task.id, sessionId },
-      );
+      // Write the linkage before responding. If this write is interrupted, the next retry
+      // reconciles the unique proposalClaimId task mapping above and never inserts another task.
+      if (hasDurableClaimStore) {
+        await finalizePlanningTaskCreation(sessionId, claimOwnerToken, task.id);
+      } else if (session) {
+        await updatePlanningCreateClaim(sessionId, { createClaimStatus: "created", createdTaskId: task.id, claimOwnerToken: undefined, claimStartedAt: undefined });
+      }
 
-      res.status(201).json(task);
+      res.status(201).json({ task, alreadyCreated: false });
     } catch (err: unknown) {
+      // A failed insert may release only this request's owner token. A successful insert whose
+      // finalization failed remains recoverable through proposalClaimId on the next request.
+      if (claimedOwnerToken) {
+        const { releasePlanningTaskCreation } = await import("../planning.js");
+        await releasePlanningTaskCreation(claimedSessionId as string, claimedOwnerToken).catch(() => undefined);
+      }
       rethrowPlanningWorkflowCreateError(err, "Failed to create task", rethrowAsApiError);
+    } finally {
+      releaseCreateLock?.();
     }
   });