From 6498d028f2d7909296f34840a4ecc877f71c9386 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sat, 4 Jul 2026 16:48:34 -0700
Subject: [PATCH] FN-7517: add task detail oversight quick-controls (level
 change, manual nudge, stop, explain-current-action)

Adds task detail modal controls that let an operator quickly change a task's
oversight level, nudge the planner with a manual instruction, stop oversight
entirely, and request an explanation of the overseer's current action,
backed by new dashboard API routes and engine/core plumbing.

- Add oversight quick-controls UI (level change, manual nudge, stop
  oversight, explain-current-action) to TaskDetailModal with supporting
  styles in TaskDetailModal.css and TaskCard.css
- Add dashboard legacy API + task-workflow routes to handle the new
  oversight actions (register-task-workflow-routes.ts, api/legacy.ts)
- Extend planner-overseer-state and planner-overseer-runtime-snapshot to
  track/report manual nudge and stop-oversight state
- Extend PlannerRecoveryController and project-engine to apply manual
  oversight actions (level change, nudge, stop, explain) end-to-end
- Add tests: TaskDetailModal.oversight-controls.test.tsx,
  tasks-overseer-controls.test.ts,
  planner-recovery-controller-manual-action.test.ts, plus updates to
  planner-overseer-runtime-snapshot.test.ts and test-helpers
- Update docs/dashboard-guide.md and docs/settings-reference.md

Files changed:
 docs/dashboard-guide.md                            |   2 +
 docs/settings-reference.md                         |   2 +-
 packages/core/src/planner-overseer-state.ts        |  18 +
 packages/dashboard/app/api/legacy.ts               |  33 ++
 packages/dashboard/app/components/TaskCard.css     |  13 +
 packages/dashboard/app/components/TaskDetailModal.css   | 122 +++++++
 packages/dashboard/app/components/TaskDetailModal.tsx   | 374 ++++++++++++++++++++-
 packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx | 290 ++++++++++++++++
 packages/dashboard/app/components/__tests__/TaskDetailModal.test-helpers.ts      |  11 +
 packages/dashboard/src/routes/__tests__/tasks-overseer-controls.test.ts      | 191 +++++++++++
 packages/dashboard/src/routes/register-task-workflow-routes.ts    |  68 ++++
 packages/engine/src/__tests__/planner-overseer-runtime-snapshot.test.ts      |  24 +-
 packages/engine/src/__tests__/planner-recovery-controller-manual-action.test.ts |  84 +++++
 packages/engine/src/planner-overseer-runtime-snapshot.ts       |  11 +
 packages/engine/src/planner-recovery-controller.ts |  40 +++
 packages/engine/src/project-engine.ts              | 102 ++++++
 16 files changed, 1380 insertions(+), 5 deletions(-)

Fusion-Task-Id: FN-7517

Fusion-Task-Lineage: eded7ff5-d126-429d-acbb-9f4bfff5ae2a

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 docs/dashboard-guide.md                       |   2 +
 docs/settings-reference.md                    |   2 +-
 packages/core/src/planner-overseer-state.ts   |  18 +
 packages/dashboard/app/api/legacy.ts          |  33 ++
 .../dashboard/app/components/TaskCard.css     |  13 +
 .../app/components/TaskDetailModal.css        | 122 ++++++
 .../app/components/TaskDetailModal.tsx        | 374 +++++++++++++++++-
 ...askDetailModal.oversight-controls.test.tsx | 290 ++++++++++++++
 .../__tests__/TaskDetailModal.test-helpers.ts |  11 +
 .../__tests__/tasks-overseer-controls.test.ts | 191 +++++++++
 .../routes/register-task-workflow-routes.ts   |  68 ++++
 .../planner-overseer-runtime-snapshot.test.ts |  24 +-
 ...-recovery-controller-manual-action.test.ts |  84 ++++
 .../src/planner-overseer-runtime-snapshot.ts  |  11 +
 .../engine/src/planner-recovery-controller.ts |  40 ++
 packages/engine/src/project-engine.ts         | 102 +++++
 16 files changed, 1380 insertions(+), 5 deletions(-)
 create mode 100644 packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx
 create mode 100644 packages/dashboard/src/routes/__tests__/tasks-overseer-controls.test.ts
 create mode 100644 packages/engine/src/__tests__/planner-recovery-controller-manual-action.test.ts

diff --git a/docs/dashboard-guide.md b/docs/dashboard-guide.md
index 025a6cfe84..2d04d7d127 100644
--- a/docs/dashboard-guide.md
+++ b/docs/dashboard-guide.md
@@ -185,6 +185,8 @@ Features:
 <!-- FNXC:PlannerOversight 2026-07-04-16:00: round-2 code-review fix — when a card must fetch the workflow's effective oversight tier (no synchronous per-task override), neither badge below renders until that fetch resolves; the schema default must never render as a guess while the true workflow tier is unknown. -->
 - Task cards show a read-only **oversight-level badge** (`Observe`, `Steer`, or `Auto-recovery`) in the meta-badges cluster reflecting the effective planner-oversight level (a task's explicit override wins and renders immediately; otherwise the card resolves the task's workflow-configured effective `plannerOversightLevel` when the board supplies a `workflowBadge`, falling back to the schema default `Auto-recovery` only when neither tier resolves) (`data-testid="card-oversight-badge"`); the badge is absent (no empty shell) when the effective level is explicitly "off", **and** while an inherited (no per-task-override) workflow tier is still being resolved (in flight or not yet fetched) — it never shows a guessed default during that window.
 - Task cards also show a read-only **active-overseer-state indicator** (`.card-overseer-state-badge`, `data-testid="card-overseer-state-badge"`) — "Executor", "Reviewer", "Merger", "Pull request", or "Workflow gate" — while the task is in a monitorable stage (in-progress/in-review, or paused on a workflow input/approval gate) and the effective oversight level is not "off" (and is known, per the same resolution gate as the oversight badge above). The indicator is suppressed (no empty shell) when the task is user-paused, agent-paused off a workflow gate, `done`, or `archived`.
+<!-- FNXC:PlannerOversight 2026-07-04-17:00: FN-7517 adds interactive task-detail planner-overseer controls (quick level change, manual nudge, stop oversight, explain current action) alongside the FN-7516 read-only card badges above. These controls live ONLY in TaskDetailModal, not TaskCard. -->
+- The task detail modal's inline meta-controls cluster (next to Priority/Execution mode) adds four planner-overseer controls: a **quick oversight-level select** (`data-testid="detail-oversight-level-select"`) that writes the per-task `plannerOversightLevel` override (Off/Observe/Steer/Autonomous recovery) or clears it back to the inherited workflow/project default via an "Inherit" option; a **manual nudge** button (`data-testid="detail-overseer-nudge"`) that asks the overseer to inject one guidance-only steering comment into the currently watched stage right now (never a merge/PR/destructive action), disabled when the overseer is off/inactive or the task is user-paused/done/archived/`autoMerge:false` in-review; a **stop oversight** button (`data-testid="detail-overseer-stop"`) that disables active oversight for the task (confirmation-gated), hidden once oversight is already off; and an **explain current action** button (`data-testid="detail-overseer-explain"`) that toggles a small read-only panel (`data-testid="detail-overseer-explain-panel"`) showing the overseer's watched stage, reason, last action, and attempt count/limit, with a non-empty-shell inactive state when the overseer is not currently watching. All three action controls call the `POST /tasks/:id/overseer/nudge`, `POST /tasks/:id/overseer/stop`, and `GET /tasks/:id/overseer/explain` routes.
 - Task detail surfaces show the selected/effective workflow identity near the task's workflow controls so individual cards remain understandable when Board is in **All workflows** or another aggregate/mixed context.
 - Board task cards support a context menu from right-click, keyboard context menu / Shift+F10, or touch long-press for detail-aligned lifecycle actions without changing normal card clicks. The menu opens as an independent overlay so it stays visible beyond the card or column edge while remaining clamped to the viewport. On mobile, long-press opens that menu without selecting card text or showing native copy/paste callouts. Selecting an action applies that exact action once and dismisses the menu. Completed card context menus include **Refine**, which opens the existing task-detail refinement feedback modal for the same task.
 <!-- FNXC:BoardCardActions 2026-06-29-00:00: Board card context menus are documented as alternate entry points only; normal click still opens task detail, and mobile long-press must not trigger detail behind the menu.
diff --git a/docs/settings-reference.md b/docs/settings-reference.md
index b504685296..32f269fe6d 100644
--- a/docs/settings-reference.md
+++ b/docs/settings-reference.md
@@ -359,7 +359,7 @@ The built-in workflows also declare triage/spec policy settings that were **not*
 | `autoApproveSpec` | `false` | Legacy compatibility setting. Workflow Plan Review now owns optional pre-execution AI plan approval. |
 | `planReviewMaxRevisions` | unset | Workflow-native Plan Review/spec revision cap. Unset/empty means unbounded automatic replans; a non-negative integer caps attempts; `0` disables automatic Plan Review revision. |
 | `codeReviewMaxRevisions` | unset | Workflow-native Code Review remediation cap. Unset/empty means unbounded automatic code-fix passes; a non-negative integer caps attempts; `0` disables automatic Code Review remediation. |
-| `plannerOversightLevel` | `autonomous` | Workflow-native planner oversight mode. `off` disables oversight; `observe` watches only; `steer` injects guidance or suggests revisions; `autonomous` enables bounded retry and targeted-fix recovery — but merge/PR progression and any destructive or external-service side effect ALWAYS require an explicit, recorded human confirmation before they run, even at `autonomous` (FN-7513's confirmation gate; see `docs/architecture.md` → "Planner overseer confirmation gate"). Tasks may set a nullable `Task.plannerOversightLevel` override (same four values) that wins over this workflow value when present; `null`/unset means "inherit the workflow value". `resolveEffectivePlannerOversightLevel` in `@fusion/core` computes the effective level (task override → workflow effective → `autonomous`). The per-task override is exposed in the dashboard as a "Planner oversight" selector (Inherit from workflow / Off / Observe / Steer / Autonomous recovery) in both the New Task dialog and Task Detail edit form, threaded through `createTask`/`updateTask` (FN-7515); the project/global default is set via the **Workflow Editor → Values** tab on the default workflow's `plannerOversightLevel` value, not in Project Settings. Engine read-site behavior beyond the FN-7513 confirmation gate remains follow-up work (FN-7510+). |
+| `plannerOversightLevel` | `autonomous` | Workflow-native planner oversight mode. `off` disables oversight; `observe` watches only; `steer` injects guidance or suggests revisions; `autonomous` enables bounded retry and targeted-fix recovery — but merge/PR progression and any destructive or external-service side effect ALWAYS require an explicit, recorded human confirmation before they run, even at `autonomous` (FN-7513's confirmation gate; see `docs/architecture.md` → "Planner overseer confirmation gate"). Tasks may set a nullable `Task.plannerOversightLevel` override (same four values) that wins over this workflow value when present; `null`/unset means "inherit the workflow value". `resolveEffectivePlannerOversightLevel` in `@fusion/core` computes the effective level (task override → workflow effective → `autonomous`). The per-task override is exposed in the dashboard as a "Planner oversight" selector (Inherit from workflow / Off / Observe / Steer / Autonomous recovery) in both the New Task dialog and Task Detail edit form, threaded through `createTask`/`updateTask` (FN-7515); the project/global default is set via the **Workflow Editor → Values** tab on the default workflow's `plannerOversightLevel` value, not in Project Settings. FN-7517 additionally exposes a quick inline oversight-level select in the Task Detail modal's meta-controls cluster (same `updateTask` override plumbing, no parallel path) plus manual nudge/stop-oversight/explain-current-action controls that call the overseer runtime directly — see `docs/dashboard-guide.md`. Engine read-site behavior beyond the FN-7513 confirmation gate remains follow-up work (FN-7510+). |
 
 When `triageProactiveSubtaskSplittingEnabled` is `true` (the default), triage may proactively replace a large task with 2-5 child tasks when the size, step-count, package breadth, file-scope, or remediation-batch signals justify the coordination overhead. When it is `false`, those automatic oversized-task signals are advisory only for writing a realistic single-task spec; triage must not split solely because the task is large. The per-task `breakIntoSubtasks: true` flag is separate and remains mandatory: if a user explicitly asks for subtask breakdown, triage still evaluates and creates child tasks when the work is meaningfully decomposable.
 
diff --git a/packages/core/src/planner-overseer-state.ts b/packages/core/src/planner-overseer-state.ts
index 3bea80f36e..3076b4adb8 100644
--- a/packages/core/src/planner-overseer-state.ts
+++ b/packages/core/src/planner-overseer-state.ts
@@ -33,6 +33,24 @@ export interface PlannerOverseerRuntimeSnapshot {
   attemptLimit?: number;
   pendingConfirmation?: boolean;
   observedAt?: number;
+  /**
+   * FNXC:PlannerOversight 2026-07-04-17:00:
+   * FN-7517 addition: the human-readable reason for the latest observation
+   * (verbatim from `OverseerStageObservation.reason`), so the task-detail
+   * "explain current action" affordance can render a readable summary
+   * without re-deriving it. Optional/best-effort — absent when there is no
+   * active observation (mirrors `watchedStage`/`signal`).
+   */
+  reason?: string;
+  /**
+   * FNXC:PlannerOversight 2026-07-04-17:00:
+   * FN-7517 addition: a short label for the last dispatched bounded-recovery
+   * action (e.g. `"inject_guidance"`, `"retry_step"`, `"request_targeted_fix"`)
+   * OR a manual operator action recorded via the explain/nudge/stop control
+   * surface (e.g. `"manual_nudge"`, `"manual_stop"`). Absent when no action
+   * has been dispatched/recorded yet for the current watched stage.
+   */
+  lastAction?: string;
 }
 
 /** Pure input the state derivation reads — no engine types, no side effects. */
diff --git a/packages/dashboard/app/api/legacy.ts b/packages/dashboard/app/api/legacy.ts
index bcfe99f6f1..37e385246d 100644
--- a/packages/dashboard/app/api/legacy.ts
+++ b/packages/dashboard/app/api/legacy.ts
@@ -96,6 +96,7 @@ import type {
   CommitAssociationDiffBackfillReport,
 } from "@fusion/core";
 import type { PlanningQuestion, PlanningSummary } from "@fusion/core";
+import type { PlannerOverseerRuntimeSnapshot } from "@fusion/core";
 import type { GithubIssueAction, ScheduledTask, ScheduledTaskCreateInput, ScheduledTaskUpdateInput, AutomationRunResult, Routine, RoutineCreateInput, RoutineUpdateInput, RoutineExecutionResult } from "@fusion/core";
 import type { DiscoveredSkill, CatalogEntry, CatalogFetchResult, ToggleSkillResult, SkillContent, SkillFileEntry, SkillFileContent } from "@fusion/dashboard";
 import type { MilestoneValidationTelemetry, MissionInterviewDraftSummary } from "../components/mission-types";
@@ -818,6 +819,38 @@ export function unpauseTask(id: string, projectId?: string): Promise<Task> {
   return api<Task>(withProjectId(`/tasks/${id}/unpause`, projectId), { method: "POST" });
 }
 
+/*
+FNXC:PlannerOversight 2026-07-04-17:00:
+FN-7517 task-detail planner-overseer controls. `nudgeOverseer` asks the
+engine to inject one steering-guidance comment into the task's currently
+watched stage right now (guidance-only — never a merge/PR/destructive side
+effect); `stopOverseer` disables active oversight for the task (writes the
+per-task `plannerOversightLevel: "off"` override); `explainOverseer` is a
+read of the current overseer runtime state (watched stage, reason, last
+action, attempt count/limit) for the "explain current action" panel. Each
+returns an `applied: false`/`snapshot: null` style result rather than
+throwing when oversight is off/inactive or the engine runtime is
+unavailable — callers should treat that as a normal disabled state, not an
+error toast.
+*/
+export interface OverseerControlResult {
+  applied: boolean;
+  reason: string;
+  task?: Task;
+}
+
+export function nudgeOverseer(id: string, projectId?: string): Promise<OverseerControlResult> {
+  return api<OverseerControlResult>(withProjectId(`/tasks/${id}/overseer/nudge`, projectId), { method: "POST" });
+}
+
+export function stopOverseer(id: string, projectId?: string): Promise<OverseerControlResult> {
+  return api<OverseerControlResult>(withProjectId(`/tasks/${id}/overseer/stop`, projectId), { method: "POST" });
+}
+
+export function explainOverseer(id: string, projectId?: string): Promise<{ snapshot: PlannerOverseerRuntimeSnapshot | null }> {
+  return api<{ snapshot: PlannerOverseerRuntimeSnapshot | null }>(withProjectId(`/tasks/${id}/overseer/explain`, projectId), { method: "GET" });
+}
+
 export function archiveTask(id: string, projectId?: string, options?: ArchiveTaskOptions): Promise<Task> {
   const search = new URLSearchParams();
   if (options?.removeLineageReferences) {
diff --git a/packages/dashboard/app/components/TaskCard.css b/packages/dashboard/app/components/TaskCard.css
index c2e24aa6ac..2d7c94c06a 100644
--- a/packages/dashboard/app/components/TaskCard.css
+++ b/packages/dashboard/app/components/TaskCard.css
@@ -509,6 +509,19 @@ semantic status tokens (info/warning/error family) rather than new hex values.
   color: var(--triage);
 }
 
+/*
+FNXC:PlannerOversight 2026-07-04-17:00:
+FN-7517 addition: the task-detail quick oversight-level-change control (see
+TaskDetailModal.tsx/.css) renders this badge class even for the "off" level
+(unlike the card-surface read-only badge, which never shows for "off") so the
+select control has a neutral, token-based chip background rather than
+falling through to an unstyled transparent shell.
+*/
+.card-oversight-badge--off {
+  background: color-mix(in srgb, var(--text-muted) 12%, transparent);
+  color: var(--text-muted);
+}
+
 /*
 FNXC:PlannerOversight 2026-07-04-00:00:
 `.card-overseer-state-badge` shows the FN-7516 active-overseer-state indicator,
diff --git a/packages/dashboard/app/components/TaskDetailModal.css b/packages/dashboard/app/components/TaskDetailModal.css
index cdd40bd4f0..60f7e7b8c2 100644
--- a/packages/dashboard/app/components/TaskDetailModal.css
+++ b/packages/dashboard/app/components/TaskDetailModal.css
@@ -319,6 +319,16 @@ The task-detail modal metadata must keep priority, execution mode, provenance, P
     gap: var(--space-sm);
   }
 
+  /*
+  FNXC:PlannerOversight 2026-07-04-17:00:
+  FN-7517: the oversight-controls cluster (priority + execution-mode + the
+  new oversight-level/nudge/stop/explain controls) must wrap without
+  overflowing the mobile modal width rather than forcing horizontal scroll.
+  */
+  .detail-meta-inline-controls {
+    flex-wrap: wrap;
+  }
+
   .detail-provenance {
     align-items: center;
   }
@@ -429,6 +439,118 @@ The task-detail modal metadata must keep priority, execution mode, provenance, P
   cursor: wait;
 }
 
+/*
+FNXC:PlannerOversight 2026-07-04-17:00:
+FN-7517 task-detail planner-overseer controls (quick level-change chip,
+manual nudge / stop / explain buttons, explain panel). Reuses the same
+`.card-oversight-badge--*` status-color modifiers FN-7516's TaskCard badge
+already declares (see TaskCard.css) so oversight-level color stays a single
+semantic source, and the same `--detail-priority-control-min-height` chip
+height token as the priority/execution-mode controls above so the cluster
+renders at a uniform height.
+*/
+.detail-oversight-chip {
+  gap: var(--space-xs);
+  min-height: var(--detail-priority-control-min-height);
+  padding-block: var(--space-xs);
+  box-sizing: border-box;
+}
+
+.detail-oversight-chip--saving {
+  opacity: 0.75;
+}
+
+.detail-oversight-select {
+  border: 0;
+  background: transparent;
+  color: inherit;
+  font: inherit;
+  cursor: pointer;
+  padding: 0;
+  min-height: inherit;
+}
+
+.detail-oversight-select:focus-visible {
+  outline: none;
+  box-shadow: var(--focus-ring-strong);
+  border-radius: var(--radius-sm);
+}
+
+.detail-oversight-select:disabled {
+  cursor: wait;
+}
+
+.detail-oversight-select option {
+  color: var(--text);
+  background: var(--surface);
+}
+
+.detail-overseer-nudge,
+.detail-overseer-stop,
+.detail-overseer-explain {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--space-xs);
+  min-height: var(--detail-priority-control-min-height);
+  padding-block: var(--space-xs);
+  box-sizing: border-box;
+}
+
+.detail-overseer-nudge svg,
+.detail-overseer-stop svg,
+.detail-overseer-explain svg {
+  width: 1em;
+  height: 1em;
+}
+
+.detail-overseer-nudge--saving,
+.detail-overseer-stop--saving {
+  opacity: 0.75;
+}
+
+.detail-overseer-nudge:disabled,
+.detail-overseer-stop:disabled,
+.detail-overseer-explain:disabled {
+  cursor: not-allowed;
+  opacity: 0.5;
+}
+
+.detail-overseer-explain-panel {
+  margin-top: var(--space-xs);
+  padding: var(--space-sm);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-md);
+  background: var(--surface-alt, var(--surface));
+  font-size: var(--font-size-sm, 0.875rem);
+}
+
+.detail-overseer-explain-panel__loading {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--space-xs);
+  color: var(--text-muted);
+}
+
+.detail-overseer-explain-panel__grid {
+  display: grid;
+  grid-template-columns: auto 1fr;
+  gap: var(--space-xs) var(--space-sm);
+  margin: 0;
+}
+
+.detail-overseer-explain-panel__grid dt {
+  color: var(--text-muted);
+  font-weight: 600;
+}
+
+.detail-overseer-explain-panel__grid dd {
+  margin: 0;
+}
+
+.detail-overseer-explain-panel__empty {
+  color: var(--text-muted);
+}
+
 
 /* Error alert in task detail modal */
 .detail-error-alert {
diff --git a/packages/dashboard/app/components/TaskDetailModal.tsx b/packages/dashboard/app/components/TaskDetailModal.tsx
index 23a9f5e89e..b7e4c2b291 100644
--- a/packages/dashboard/app/components/TaskDetailModal.tsx
+++ b/packages/dashboard/app/components/TaskDetailModal.tsx
@@ -2,7 +2,7 @@ import "./TaskDetailModal.css";
 import React, { Suspense, lazy, useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { createPortal } from "react-dom";
 import { useTranslation } from "react-i18next";
-import { Pencil, Bot, X, ChevronDown, ChevronRight, GitBranch, ArrowLeft, Zap, Loader2, AlertTriangle, Sparkles, Maximize2, Minimize2 } from "lucide-react";
+import { Pencil, Bot, X, ChevronDown, ChevronRight, GitBranch, ArrowLeft, Zap, Loader2, AlertTriangle, Sparkles, Maximize2, Minimize2, Send, Square, Info } from "lucide-react";
 import { useModalResizePersist } from "../hooks/useModalResizePersist";
 import { useMobileScrollLock } from "../hooks/useMobileScrollLock";
 import { useOverlayDismiss } from "../hooks/useOverlayDismiss";
@@ -11,16 +11,18 @@ import ReactMarkdown from "react-markdown";
 import type { Components } from "react-markdown";
 import remarkGfm from "remark-gfm";
 import { sharedRehypePlugins, createMermaidCodeComponent } from "./markdownPipeline";
-import type { Task, TaskDetail, TaskAttachment, Column, ColumnId, MergeResult, Settings, GlobalSettings, Agent, TaskPriority, TaskSourceIssue, WorkflowStepResult, GithubIssueAction, TaskGitLabTrackedItem } from "@fusion/core";
+import type { Task, TaskDetail, TaskAttachment, Column, ColumnId, MergeResult, Settings, GlobalSettings, Agent, TaskPriority, TaskSourceIssue, WorkflowStepResult, GithubIssueAction, TaskGitLabTrackedItem, PlannerOversightLevel, PlannerOverseerRuntimeSnapshot } from "@fusion/core";
 import {
   DEFAULT_TASK_PRIORITY,
   REPO_OVERRIDE_RE,
   TASK_PRIORITIES,
+  PLANNER_OVERSIGHT_LEVELS,
   getErrorMessage,
 } from "@fusion/core";
+import { resolveEffectivePlannerOversightLevel } from "../../../core/src/workflow-settings-resolver";
 import { isNearDuplicateCanonicalInactive } from "../../../core/src/near-duplicate-canonical";
 import { resolveEffectiveAutoMerge } from "../../../core/src/task-merge";
-import { uploadAttachment, deleteAttachment, updateTask, repairOverlapBlocker, pauseTask, unpauseTask, fetchTaskDetail, fetchSettings, fetchTaskEffectiveSettings, fetchGlobalSettings, requestSpecRevision, rebuildTaskSpec, approvePlan, rejectPlan, refineTask, fetchWorkflowResults, assignTask, fetchAgents, fetchAgent, refreshPrStatus, fetchBoardWorkflows, updateTaskCustomFields, summarizeTitle, api } from "../api";
+import { uploadAttachment, deleteAttachment, updateTask, repairOverlapBlocker, pauseTask, unpauseTask, fetchTaskDetail, fetchSettings, fetchTaskEffectiveSettings, fetchGlobalSettings, requestSpecRevision, rebuildTaskSpec, approvePlan, rejectPlan, refineTask, fetchWorkflowResults, assignTask, fetchAgents, fetchAgent, refreshPrStatus, fetchBoardWorkflows, updateTaskCustomFields, summarizeTitle, fetchWorkflowSettingValues, nudgeOverseer, stopOverseer, explainOverseer, api } from "../api";
 import type { BoardWorkflowsPayload, WorkflowFieldDefinition, CustomFieldRejection } from "../api";
 import { WorkflowIcon } from "./WorkflowIcon";
 import { ApiRequestError } from "../api";
@@ -410,6 +412,59 @@ function normalizeSourceIssueUrl(value: string): string | undefined {
   return trimmed.length > 0 ? trimmed : undefined;
 }
 
+/*
+FNXC:PlannerOversight 2026-07-04-17:00:
+FN-7517 quick oversight-level-change control needs the workflow's effective
+`plannerOversightLevel` setting to show/reset-to the TRUE effective level
+for tasks with no per-task override — the same gap FN-7516's TaskCard badge
+hit (Task carries no `workflowId` field; the setting is not on the task
+payload). Mirrors TaskCard's module-level `(workflowId, projectId)` cache +
+in-flight de-dup exactly (see packages/dashboard/app/components/TaskCard.tsx)
+rather than re-deriving precedence locally — `resolveEffectivePlannerOversightLevel`
+remains the single resolver both surfaces call.
+*/
+const modalWorkflowOversightEffectiveCache = new Map<string, PlannerOversightLevel | undefined>();
+const modalWorkflowOversightInflight = new Map<string, Promise<void>>();
+
+function getModalWorkflowOversightCacheKey(workflowId: string, projectId?: string): string {
+  return `${projectId ?? "default"}::${workflowId}`;
+}
+
+function isPlannerOversightLevelValue(value: unknown): value is PlannerOversightLevel {
+  return typeof value === "string" && (PLANNER_OVERSIGHT_LEVELS as readonly string[]).includes(value);
+}
+
+async function loadModalWorkflowOversightEffectiveLevel(workflowId: string, projectId: string | undefined): Promise<PlannerOversightLevel | undefined> {
+  const key = getModalWorkflowOversightCacheKey(workflowId, projectId);
+  if (modalWorkflowOversightEffectiveCache.has(key)) {
+    return modalWorkflowOversightEffectiveCache.get(key);
+  }
+  let inflight = modalWorkflowOversightInflight.get(key);
+  if (!inflight) {
+    inflight = fetchWorkflowSettingValues(workflowId, projectId)
+      .then((payload) => {
+        const raw = payload.effective?.plannerOversightLevel;
+        modalWorkflowOversightEffectiveCache.set(key, isPlannerOversightLevelValue(raw) ? raw : undefined);
+      })
+      .catch(() => {
+        modalWorkflowOversightEffectiveCache.set(key, undefined);
+      })
+      .finally(() => {
+        modalWorkflowOversightInflight.delete(key);
+      });
+    modalWorkflowOversightInflight.set(key, inflight);
+  }
+  await inflight;
+  return modalWorkflowOversightEffectiveCache.get(key);
+}
+
+const OVERSIGHT_LEVEL_LABEL: Record<PlannerOversightLevel, string> = {
+  off: "Off",
+  observe: "Observe",
+  steer: "Steer",
+  autonomous: "Autonomous recovery",
+};
+
 function normalizeTaskPriorityValue(priority: Task["priority"]): TaskPriority {
   return isStringValue(priority) && (TASK_PRIORITIES as readonly string[]).includes(priority)
     ? (priority as TaskPriority)
@@ -857,6 +912,46 @@ export function TaskDetailContent({
     };
   }, [task.id, projectId, workflowFieldDefsProp]);
 
+  /*
+  FNXC:PlannerOversight 2026-07-04-17:00:
+  FN-7517: resolve the WORKFLOW's effective plannerOversightLevel (via the
+  same cache/fetch pattern as TaskCard's card-oversight-badge, see the FNXC
+  block above `modalWorkflowOversightEffectiveCache`) so the quick
+  level-change control shows the TRUE effective level — not a guessed
+  schema default — for tasks with no per-task override. Gated on
+  `taskWorkflowBadge.id` resolving first (from the board-workflows payload
+  fetch above); a known per-task override renders synchronously regardless.
+  */
+  const workflowIdForOversight = taskWorkflowBadge?.id;
+  const [workflowOversightState, setWorkflowOversightState] = useState<{ level: PlannerOversightLevel | undefined; resolved: boolean }>({ level: undefined, resolved: false });
+  useEffect(() => {
+    if (!workflowIdForOversight) {
+      setWorkflowOversightState({ level: undefined, resolved: true });
+      return;
+    }
+    const workflowId = workflowIdForOversight;
+    const key = getModalWorkflowOversightCacheKey(workflowId, projectId);
+    if (modalWorkflowOversightEffectiveCache.has(key)) {
+      setWorkflowOversightState({ level: modalWorkflowOversightEffectiveCache.get(key), resolved: true });
+      return;
+    }
+    setWorkflowOversightState({ level: undefined, resolved: false });
+    let cancelled = false;
+    void loadModalWorkflowOversightEffectiveLevel(workflowId, projectId).then((level) => {
+      if (!cancelled) setWorkflowOversightState({ level, resolved: true });
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [workflowIdForOversight, projectId]);
+  const workflowOversightEffectiveLevel = workflowOversightState.level;
+  const workflowOversightResolved = workflowOversightState.resolved;
+  const hasTaskOversightOverride = isPlannerOversightLevelValue(task.plannerOversightLevel);
+  const effectiveOversightLevel: PlannerOversightLevel = resolveEffectivePlannerOversightLevel(
+    task.plannerOversightLevel,
+    workflowOversightEffectiveLevel,
+  );
+
   const handleSaveCustomFields = useCallback(
     async (patch: Record<string, unknown>) => {
       setCustomFieldError(null);
@@ -941,6 +1036,13 @@ export function TaskDetailContent({
   const [isSavingInlineExecutionMode, setIsSavingInlineExecutionMode] = useState(false);
   const [inlineNoCommitsExpected, setInlineNoCommitsExpected] = useState<boolean>(task.noCommitsExpected === true);
   const [isSavingInlineNoCommitsExpected, setIsSavingInlineNoCommitsExpected] = useState(false);
+  // FNXC:PlannerOversight 2026-07-04-17:00: FN-7517 quick oversight-level-change + nudge/stop/explain control state.
+  const [isSavingOversightLevel, setIsSavingOversightLevel] = useState(false);
+  const [isNudgingOverseer, setIsNudgingOverseer] = useState(false);
+  const [isStoppingOverseer, setIsStoppingOverseer] = useState(false);
+  const [overseerExplainOpen, setOverseerExplainOpen] = useState(false);
+  const [isLoadingOverseerExplain, setIsLoadingOverseerExplain] = useState(false);
+  const [overseerExplainSnapshot, setOverseerExplainSnapshot] = useState<PlannerOverseerRuntimeSnapshot | null>(null);
   const { confirm, confirmWithChoice, confirmWithCheckbox } = useConfirm();
   const requestClose = useCallback(() => {
     onRequestClose?.();
@@ -1882,6 +1984,124 @@ export function TaskDetailContent({
     }
   }, [task.id, projectId, inlineNoCommitsExpected, onTaskUpdated, addToast]);
 
+  /*
+  FNXC:PlannerOversight 2026-07-04-17:00:
+  FN-7517 quick oversight-level-change control. Writes the per-task override
+  via the SAME `updateTask` scalar-override plumbing FN-7509/FN-7515 already
+  wired (no parallel override path). `nextValue === "__inherit__"` clears the
+  override back to the inherited workflow/project default (null-clear,
+  mirroring the other scalar overrides' clear semantics).
+  */
+  const handleOversightLevelChange = useCallback(async (nextValue: string) => {
+    const isClear = nextValue === "__inherit__";
+    const nextOverride: PlannerOversightLevel | null = isClear ? null : (nextValue as PlannerOversightLevel);
+
+    setIsSavingOversightLevel(true);
+    try {
+      const updatedTask = await updateTask(task.id, { plannerOversightLevel: nextOverride }, projectId);
+      onTaskUpdated?.(updatedTask);
+      addToast(
+        isClear
+          ? t("taskDetail.oversight.reset", "Oversight level reset to workflow default")
+          : t("taskDetail.oversight.updated", "Oversight level set to {{level}}", { level: OVERSIGHT_LEVEL_LABEL[nextOverride as PlannerOversightLevel] }),
+        "success",
+      );
+    } catch (err) {
+      addToast(t("taskDetail.updateFailed", "Failed to update {{id}}: {{error}}", { id: task.id, error: getErrorMessage(err) }), "error");
+    } finally {
+      if (mountedRef.current) {
+        setIsSavingOversightLevel(false);
+      }
+    }
+  }, [task.id, projectId, onTaskUpdated, addToast, t]);
+
+  /*
+  FNXC:PlannerOversight 2026-07-04-17:00:
+  FN-7517 manual nudge control. Guidance-only — never a merge/PR/destructive
+  side effect (enforced server-side by `ProjectEngine.nudgeOverseerTask`,
+  reusing the FN-7512 guidance channel). `applied: false` is a normal,
+  non-error outcome (oversight off/inactive, or withheld by the human-control
+  guard) surfaced as an info toast, not an error toast.
+  */
+  const handleNudgeOverseer = useCallback(async () => {
+    setIsNudgingOverseer(true);
+    try {
+      const result = await nudgeOverseer(task.id, projectId);
+      if (result.applied) {
+        if (result.task) {
+          onTaskUpdated?.(result.task);
+        }
+        addToast(t("taskDetail.oversight.nudged", "Manual nudge sent to the overseer"), "success");
+      } else {
+        addToast(t("taskDetail.oversight.nudgeNotApplicable", "Nudge not applicable ({{reason}})", { reason: result.reason }), "info");
+      }
+    } catch (err) {
+      addToast(t("taskDetail.updateFailed", "Failed to update {{id}}: {{error}}", { id: task.id, error: getErrorMessage(err) }), "error");
+    } finally {
+      if (mountedRef.current) {
+        setIsNudgingOverseer(false);
+      }
+    }
+  }, [task.id, projectId, onTaskUpdated, addToast, t]);
+
+  /*
+  FNXC:PlannerOversight 2026-07-04-17:00:
+  FN-7517 stop-oversight control. Disables active oversight for this task
+  (per-task override -> "off") — a lightweight `confirm(...)` guards it since
+  it's a disabling action, matching the PROMPT's guidance for this control.
+  */
+  const handleStopOverseer = useCallback(async () => {
+    const shouldStop = await confirm({
+      title: t("taskDetail.oversight.stopTitle", "Stop planner oversight?"),
+      message: t("taskDetail.oversight.stopMessage", "This disables active planner oversight for this task (sets oversight level to Off)."),
+    });
+    if (!shouldStop) return;
+
+    setIsStoppingOverseer(true);
+    try {
+      const result = await stopOverseer(task.id, projectId);
+      if (result.task) {
+        onTaskUpdated?.(result.task);
+      }
+      addToast(t("taskDetail.oversight.stopped", "Planner oversight stopped for this task"), "success");
+    } catch (err) {
+      addToast(t("taskDetail.updateFailed", "Failed to update {{id}}: {{error}}", { id: task.id, error: getErrorMessage(err) }), "error");
+    } finally {
+      if (mountedRef.current) {
+        setIsStoppingOverseer(false);
+      }
+    }
+  }, [task.id, projectId, onTaskUpdated, addToast, confirm, t]);
+
+  /*
+  FNXC:PlannerOversight 2026-07-04-17:00:
+  FN-7517 explain-current-action control: toggles a small read-only panel and
+  fetches the current overseer runtime state (watched stage, reason, last
+  action, attempt count/limit). Never mutates anything.
+  */
+  const handleExplainOverseer = useCallback(async () => {
+    if (overseerExplainOpen) {
+      setOverseerExplainOpen(false);
+      return;
+    }
+    setOverseerExplainOpen(true);
+    setIsLoadingOverseerExplain(true);
+    try {
+      const result = await explainOverseer(task.id, projectId);
+      if (mountedRef.current) {
+        setOverseerExplainSnapshot(result.snapshot);
+      }
+    } catch {
+      if (mountedRef.current) {
+        setOverseerExplainSnapshot(null);
+      }
+    } finally {
+      if (mountedRef.current) {
+        setIsLoadingOverseerExplain(false);
+      }
+    }
+  }, [task.id, projectId, overseerExplainOpen]);
+
   // Handle keyboard shortcuts for edit mode
   const handleEditKeyDown = useCallback((e: KeyboardEvent) => {
     if (!isEditing) return;
@@ -2790,6 +3010,30 @@ export function TaskDetailContent({
   const autoMergeEnabled = autoMergeEnabledProp ?? (settings?.autoMerge ?? false);
   const effectiveAutoMerge = resolveEffectiveAutoMerge({ autoMerge: task.autoMerge }, { autoMerge: autoMergeEnabled });
   const isManualPrFlow = mergeStrategy === "pull-request" && !effectiveAutoMerge;
+  /*
+  FNXC:PlannerOversight 2026-07-04-17:00:
+  FN-7517 enablement rules for the nudge/stop/explain controls. Nudge and
+  explain require the overseer to actively be watching this task (mirrors
+  `PlannerOverseerMonitor.observeTask`, which records nothing for an idle/off
+  task) — approximated client-side via presence of `task.plannerOverseerState`
+  (FN-7531; only ever populated while there is a live observation). Nudge
+  additionally respects the human-control safeguards this task must NOT
+  re-implement (FN-7513/FN-7514): user-pause (`isTaskPaused`), done/archived
+  terminal columns, and the `autoMerge:false` in-review human-review terminal
+  (approximated here via `effectiveAutoMerge`, the same resolver the merge UI
+  already uses — the server-side `evaluateOverseerHumanControl` guard is the
+  real enforcement; this is a client-side disable heuristic only). Stop is
+  hidden once oversight is already off — there is nothing left to stop.
+  */
+  const overseerSnapshot = task.plannerOverseerState ?? null;
+  const overseerActive = Boolean(overseerSnapshot);
+  const isDoneOrArchivedColumn = task.column === "done" || task.column === "archived";
+  const isOverseerHumanReviewTerminal = task.column === "in-review" && !effectiveAutoMerge;
+  const overseerHumanControlSuppressed = Boolean(isTaskPaused) || isDoneOrArchivedColumn || isOverseerHumanReviewTerminal;
+  const oversightIsOff = effectiveOversightLevel === "off";
+  const canNudgeOverseer = overseerActive && !oversightIsOff && !overseerHumanControlSuppressed;
+  const canExplainOverseer = overseerActive && !oversightIsOff;
+  const showStopOverseer = !oversightIsOff;
   const isActivityExpanded = activityExpanded && activeTab === "chat" && !isEditing;
   const isPlannerChatExpanded = plannerChatExpanded && activeTab === "planner-chat" && !isEditing;
   /*
@@ -3473,7 +3717,131 @@ export function TaskDetailContent({
                     <Zap aria-hidden="true" />
                     <span>{inlineExecutionMode === "fast" ? t("taskDetail.executionMode.fast", "Fast") : t("taskDetail.executionMode.standard", "Standard")}</span>
                   </button>
+                  {/*
+                  FNXC:PlannerOversight 2026-07-04-17:00:
+                  FN-7517 quick oversight-level-change control. Shows the current
+                  EFFECTIVE level (resolved via the single `resolveEffectivePlannerOversightLevel`
+                  resolver, not re-derived locally) and distinguishes an explicit
+                  per-task override from an inherited workflow/project default via
+                  the "Inherit workflow default" option. Withheld entirely until the
+                  workflow tier resolves (or a per-task override renders it
+                  synchronously), mirroring FN-7516's TaskCard badge gating so this
+                  never shows a guessed schema-default value for a beat.
+                  */}
+                  {(hasTaskOversightOverride || workflowOversightResolved) && (
+                    <label
+                      className={`card-oversight-badge card-oversight-badge--${effectiveOversightLevel} detail-oversight-chip ${isSavingOversightLevel ? "detail-oversight-chip--saving" : ""}`}
+                    >
+                      <span>{t("taskDetail.oversight.label", "Oversight:")}</span>
+                      <select
+                        className="detail-oversight-select"
+                        data-testid="detail-oversight-level-select"
+                        value={hasTaskOversightOverride ? (task.plannerOversightLevel as string) : "__inherit__"}
+                        onChange={(event) => {
+                          void handleOversightLevelChange(event.target.value);
+                        }}
+                        disabled={isSavingOversightLevel}
+                        aria-label={t("taskDetail.oversight.ariaLabel", "Planner oversight level")}
+                      >
+                        <option value="__inherit__">
+                          {t("taskDetail.oversight.inherit", "Inherit ({{level}})", { level: OVERSIGHT_LEVEL_LABEL[effectiveOversightLevel] })}
+                        </option>
+                        {PLANNER_OVERSIGHT_LEVELS.map((levelOption) => (
+                          <option key={levelOption} value={levelOption}>
+                            {OVERSIGHT_LEVEL_LABEL[levelOption]}
+                          </option>
+                        ))}
+                      </select>
+                    </label>
+                  )}
+                  {/*
+                  FNXC:PlannerOversight 2026-07-04-17:00:
+                  FN-7517 manual nudge / stop oversight / explain current action
+                  controls. Disabled (with an accessible aria-label reason) rather
+                  than hidden for nudge/explain when the overseer is off/inactive
+                  so operators understand WHY the control is inert instead of it
+                  silently vanishing; stop is hidden once oversight is already off
+                  (nothing left to stop) per the PROMPT's enablement rule, avoiding
+                  an always-on empty shell for the common oversight-off default.
+                  */}
+                  {(hasTaskOversightOverride || workflowOversightResolved) && !oversightIsOff && (
+                    <button
+                      type="button"
+                      className={`btn btn-sm detail-overseer-nudge ${isNudgingOverseer ? "detail-overseer-nudge--saving" : ""}`}
+                      data-testid="detail-overseer-nudge"
+                      onClick={() => {
+                        void handleNudgeOverseer();
+                      }}
+                      disabled={!canNudgeOverseer || isNudgingOverseer}
+                      title={canNudgeOverseer ? t("taskDetail.oversight.nudgeTitle", "Inject steering guidance into the current stage now") : t("taskDetail.oversight.nudgeDisabledTitle", "Nudge unavailable: overseer is not actively watching this task")}
+                      aria-label={t("taskDetail.oversight.nudgeAriaLabel", "Manual nudge")}
+                    >
+                      {isNudgingOverseer ? <Loader2 className="spin" aria-hidden="true" /> : <Send aria-hidden="true" />}
+                      <span>{t("taskDetail.oversight.nudge", "Nudge")}</span>
+                    </button>
+                  )}
+                  {(hasTaskOversightOverride || workflowOversightResolved) && showStopOverseer && (
+                    <button
+                      type="button"
+                      className={`btn btn-sm detail-overseer-stop ${isStoppingOverseer ? "detail-overseer-stop--saving" : ""}`}
+                      data-testid="detail-overseer-stop"
+                      onClick={() => {
+                        void handleStopOverseer();
+                      }}
+                      disabled={isStoppingOverseer}
+                      aria-label={t("taskDetail.oversight.stopAriaLabel", "Stop oversight")}
+                    >
+                      {isStoppingOverseer ? <Loader2 className="spin" aria-hidden="true" /> : <Square aria-hidden="true" />}
+                      <span>{t("taskDetail.oversight.stop", "Stop")}</span>
+                    </button>
+                  )}
+                  {(hasTaskOversightOverride || workflowOversightResolved) && !oversightIsOff && (
+                    <button
+                      type="button"
+                      className="btn btn-sm detail-overseer-explain"
+                      data-testid="detail-overseer-explain"
+                      onClick={() => {
+                        void handleExplainOverseer();
+                      }}
+                      disabled={!canExplainOverseer && !overseerExplainOpen}
+                      title={canExplainOverseer ? t("taskDetail.oversight.explainTitle", "Explain the overseer's current action") : t("taskDetail.oversight.explainDisabledTitle", "Explain unavailable: overseer is not actively watching this task")}
+                      aria-label={t("taskDetail.oversight.explainAriaLabel", "Explain current action")}
+                      aria-expanded={overseerExplainOpen}
+                    >
+                      <Info aria-hidden="true" />
+                      <span>{t("taskDetail.oversight.explain", "Explain")}</span>
+                    </button>
+                  )}
                 </div>
+                {overseerExplainOpen && (
+                  <div className="detail-overseer-explain-panel" data-testid="detail-overseer-explain-panel" role="region" aria-live="polite">
+                    {isLoadingOverseerExplain ? (
+                      <span className="detail-overseer-explain-panel__loading">
+                        <Loader2 className="spin" aria-hidden="true" />
+                        {t("taskDetail.oversight.explainLoading", "Loading overseer state…")}
+                      </span>
+                    ) : overseerExplainSnapshot ? (
+                      <dl className="detail-overseer-explain-panel__grid">
+                        <dt>{t("taskDetail.oversight.explainStage", "Watched stage")}</dt>
+                        <dd>{overseerExplainSnapshot.watchedStage ?? t("taskDetail.oversight.explainUnknown", "Unknown")}</dd>
+                        <dt>{t("taskDetail.oversight.explainReason", "Reason")}</dt>
+                        <dd>{overseerExplainSnapshot.reason ?? t("taskDetail.oversight.explainUnknown", "Unknown")}</dd>
+                        <dt>{t("taskDetail.oversight.explainLastAction", "Last action")}</dt>
+                        <dd>{overseerExplainSnapshot.lastAction ?? t("taskDetail.oversight.explainNone", "None yet")}</dd>
+                        <dt>{t("taskDetail.oversight.explainAttempts", "Attempts")}</dt>
+                        <dd>
+                          {overseerExplainSnapshot.attemptCount ?? 0}
+                          {" / "}
+                          {overseerExplainSnapshot.attemptLimit ?? "—"}
+                        </dd>
+                      </dl>
+                    ) : (
+                      <span className="detail-overseer-explain-panel__empty">
+                        {t("taskDetail.oversight.explainEmpty", "The overseer is not currently watching this task.")}
+                      </span>
+                    )}
+                  </div>
+                )}
                 {provenanceDisplay && (
                   <div className="detail-provenance">
                     <GitBranch aria-hidden="true" />
diff --git a/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx b/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx
new file mode 100644
index 0000000000..6ccca037fc
--- /dev/null
+++ b/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx
@@ -0,0 +1,290 @@
+/*
+FNXC:PlannerOversight 2026-07-04-17:00:
+FN-7517 coverage for the task-detail planner-overseer controls: the quick
+oversight-level-change select, the manual nudge/stop/explain buttons, and
+their enablement/leftover-shell rules (Surface Enumeration).
+*/
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen, fireEvent, waitFor } from "@testing-library/react";
+import type { PlannerOverseerRuntimeSnapshot } from "@fusion/core";
+import {
+  makeTask,
+  noop,
+  noopDelete,
+  noopMerge,
+  noopMove,
+  noopOpenDetail,
+  mockConfirm,
+  setupTaskDetailModalHooks,
+} from "./TaskDetailModal.test-helpers";
+import { TaskDetailModal } from "../TaskDetailModal";
+
+setupTaskDetailModalHooks();
+
+const activeSnapshot: PlannerOverseerRuntimeSnapshot = {
+  state: "watching",
+  oversightLevel: "autonomous",
+  watchedStage: "executor",
+  signal: "progressing",
+  attemptCount: 1,
+  attemptLimit: 3,
+  pendingConfirmation: false,
+  observedAt: 1_700_000_000_000,
+  reason: "Task is actively executing in-progress work",
+  lastAction: "inject_guidance",
+};
+
+describe("TaskDetailModal oversight controls", () => {
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    mockConfirm.mockResolvedValue(true);
+    const api = await import("../../api");
+    vi.mocked(api.fetchBoardWorkflows).mockResolvedValue({ flagEnabled: false, defaultWorkflowId: "", workflows: [], taskWorkflowIds: {} });
+    vi.mocked(api.fetchWorkflowSettingValues).mockResolvedValue({ stored: {}, effective: {}, defaults: {} });
+    vi.mocked(api.nudgeOverseer).mockResolvedValue({ applied: false, reason: "oversight-off" });
+    vi.mocked(api.stopOverseer).mockResolvedValue({ applied: true, reason: "stopped" });
+    vi.mocked(api.explainOverseer).mockResolvedValue({ snapshot: null });
+  });
+
+  it("quick level select reflects a per-task override and writes the override on change", async () => {
+    const api = await import("../../api");
+    const mockUpdate = vi.mocked(api.updateTask);
+    mockUpdate.mockResolvedValueOnce(makeTask({ id: "FN-100", plannerOversightLevel: "steer" }) as any);
+
+    render(
+      <TaskDetailModal
+        task={makeTask({ id: "FN-100", column: "in-progress", plannerOversightLevel: "observe" })}
+        onClose={noop}
+        onMoveTask={noopMove}
+        onDeleteTask={noopDelete}
+        onMergeTask={noopMerge}
+        onOpenDetail={noopOpenDetail}
+        addToast={noop}
+      />,
+    );
+
+    const select = await screen.findByTestId("detail-oversight-level-select");
+    expect((select as HTMLSelectElement).value).toBe("observe");
+
+    fireEvent.change(select, { target: { value: "steer" } });
+
+    await waitFor(() => {
+      expect(mockUpdate).toHaveBeenCalledWith("FN-100", { plannerOversightLevel: "steer" }, undefined);
+    });
+  });
+
+  it("clearing the override writes a null-clear back to the inherited default", async () => {
+    const api = await import("../../api");
+    const mockUpdate = vi.mocked(api.updateTask);
+    mockUpdate.mockResolvedValueOnce(makeTask({ id: "FN-101" }) as any);
+
+    render(
+      <TaskDetailModal
+        task={makeTask({ id: "FN-101", column: "in-progress", plannerOversightLevel: "steer" })}
+        onClose={noop}
+        onMoveTask={noopMove}
+        onDeleteTask={noopDelete}
+        onMergeTask={noopMerge}
+        onOpenDetail={noopOpenDetail}
+        addToast={noop}
+      />,
+    );
+
+    const select = await screen.findByTestId("detail-oversight-level-select");
+    fireEvent.change(select, { target: { value: "__inherit__" } });
+
+    await waitFor(() => {
+      expect(mockUpdate).toHaveBeenCalledWith("FN-101", { plannerOversightLevel: null }, undefined);
+    });
+  });
+
+  it("nudge is enabled and calls nudgeOverseer when the overseer is actively watching", async () => {
+    const api = await import("../../api");
+    vi.mocked(api.nudgeOverseer).mockResolvedValueOnce({ applied: true, reason: "nudged", task: makeTask({ id: "FN-102" }) as any });
+
+    render(
+      <TaskDetailModal
+        task={makeTask({ id: "FN-102", column: "in-progress", plannerOversightLevel: "autonomous", plannerOverseerState: activeSnapshot })}
+        onClose={noop}
+        onMoveTask={noopMove}
+        onDeleteTask={noopDelete}
+        onMergeTask={noopMerge}
+        onOpenDetail={noopOpenDetail}
+        addToast={noop}
+      />,
+    );
+
+    const nudgeBtn = await screen.findByTestId("detail-overseer-nudge");
+    expect(nudgeBtn).not.toBeDisabled();
+    fireEvent.click(nudgeBtn);
+
+    await waitFor(() => {
+      expect(api.nudgeOverseer).toHaveBeenCalledWith("FN-102", undefined);
+    });
+  });
+
+  it("nudge is disabled when the overseer has no active observation", async () => {
+    render(
+      <TaskDetailModal
+        task={makeTask({ id: "FN-103", column: "todo", plannerOversightLevel: "autonomous" })}
+        onClose={noop}
+        onMoveTask={noopMove}
+        onDeleteTask={noopDelete}
+        onMergeTask={noopMerge}
+        onOpenDetail={noopOpenDetail}
+        addToast={noop}
+      />,
+    );
+
+    const nudgeBtn = await screen.findByTestId("detail-overseer-nudge");
+    expect(nudgeBtn).toBeDisabled();
+  });
+
+  it("nudge is disabled while the task is user-paused", async () => {
+    render(
+      <TaskDetailModal
+        task={makeTask({ id: "FN-104", column: "in-progress", plannerOversightLevel: "autonomous", plannerOverseerState: activeSnapshot, userPaused: true })}
+        onClose={noop}
+        onMoveTask={noopMove}
+        onDeleteTask={noopDelete}
+        onMergeTask={noopMerge}
+        onOpenDetail={noopOpenDetail}
+        addToast={noop}
+      />,
+    );
+
+    const nudgeBtn = await screen.findByTestId("detail-overseer-nudge");
+    expect(nudgeBtn).toBeDisabled();
+  });
+
+  it("nudge is disabled when the task is done", async () => {
+    render(
+      <TaskDetailModal
+        task={makeTask({ id: "FN-105", column: "done", plannerOversightLevel: "autonomous", plannerOverseerState: activeSnapshot })}
+        onClose={noop}
+        onMoveTask={noopMove}
+        onDeleteTask={noopDelete}
+        onMergeTask={noopMerge}
+        onOpenDetail={noopOpenDetail}
+        addToast={noop}
+      />,
+    );
+
+    const nudgeBtn = await screen.findByTestId("detail-overseer-nudge");
+    expect(nudgeBtn).toBeDisabled();
+  });
+
+  it("stop calls stopOverseer after confirmation", async () => {
+    const api = await import("../../api");
+    vi.mocked(api.stopOverseer).mockResolvedValueOnce({ applied: true, reason: "stopped", task: makeTask({ id: "FN-106", plannerOversightLevel: "off" }) as any });
+
+    render(
+      <TaskDetailModal
+        task={makeTask({ id: "FN-106", column: "in-progress", plannerOversightLevel: "steer" })}
+        onClose={noop}
+        onMoveTask={noopMove}
+        onDeleteTask={noopDelete}
+        onMergeTask={noopMerge}
+        onOpenDetail={noopOpenDetail}
+        addToast={noop}
+      />,
+    );
+
+    const stopBtn = await screen.findByTestId("detail-overseer-stop");
+    fireEvent.click(stopBtn);
+
+    await waitFor(() => {
+      expect(mockConfirm).toHaveBeenCalled();
+      expect(api.stopOverseer).toHaveBeenCalledWith("FN-106", undefined);
+    });
+  });
+
+  it("stop is hidden when oversight is already off", async () => {
+    render(
+      <TaskDetailModal
+        task={makeTask({ id: "FN-107", column: "in-progress", plannerOversightLevel: "off" })}
+        onClose={noop}
+        onMoveTask={noopMove}
+        onDeleteTask={noopDelete}
+        onMergeTask={noopMerge}
+        onOpenDetail={noopOpenDetail}
+        addToast={noop}
+      />,
+    );
+
+    await screen.findByTestId("detail-oversight-level-select");
+    expect(screen.queryByTestId("detail-overseer-stop")).not.toBeInTheDocument();
+  });
+
+  it("explain renders watched stage/reason/action/attempt-count from overseer state", async () => {
+    const api = await import("../../api");
+    vi.mocked(api.explainOverseer).mockResolvedValueOnce({ snapshot: activeSnapshot });
+
+    render(
+      <TaskDetailModal
+        task={makeTask({ id: "FN-108", column: "in-progress", plannerOversightLevel: "autonomous", plannerOverseerState: activeSnapshot })}
+        onClose={noop}
+        onMoveTask={noopMove}
+        onDeleteTask={noopDelete}
+        onMergeTask={noopMerge}
+        onOpenDetail={noopOpenDetail}
+        addToast={noop}
+      />,
+    );
+
+    const explainBtn = await screen.findByTestId("detail-overseer-explain");
+    fireEvent.click(explainBtn);
+
+    const panel = await screen.findByTestId("detail-overseer-explain-panel");
+    expect(panel).toHaveTextContent("executor");
+    expect(panel).toHaveTextContent("Task is actively executing in-progress work");
+    expect(panel).toHaveTextContent("inject_guidance");
+    expect(panel).toHaveTextContent("1");
+    expect(panel).toHaveTextContent("3");
+  });
+
+  it("explain shows the inactive empty-state (no empty shell) when the overseer is inactive", async () => {
+    const api = await import("../../api");
+    vi.mocked(api.explainOverseer).mockResolvedValueOnce({ snapshot: null });
+
+    render(
+      <TaskDetailModal
+        task={makeTask({ id: "FN-109", column: "in-progress", plannerOversightLevel: "observe", plannerOverseerState: activeSnapshot })}
+        onClose={noop}
+        onMoveTask={noopMove}
+        onDeleteTask={noopDelete}
+        onMergeTask={noopMerge}
+        onOpenDetail={noopOpenDetail}
+        addToast={noop}
+      />,
+    );
+
+    const explainBtn = await screen.findByTestId("detail-overseer-explain");
+    fireEvent.click(explainBtn);
+
+    const panel = await screen.findByTestId("detail-overseer-explain-panel");
+    expect(panel).toHaveTextContent("not currently watching");
+  });
+
+  it("renders no oversight-control leftover shell when oversight is off and the overseer is inactive (default case)", async () => {
+    render(
+      <TaskDetailModal
+        task={makeTask({ id: "FN-110", column: "todo", plannerOversightLevel: "off" })}
+        onClose={noop}
+        onMoveTask={noopMove}
+        onDeleteTask={noopDelete}
+        onMergeTask={noopMerge}
+        onOpenDetail={noopOpenDetail}
+        addToast={noop}
+      />,
+    );
+
+    // The quick level-change select still renders (it's always editable so an
+    // operator can opt IN to oversight), but nudge/stop/explain must not
+    // render an always-on empty shell for the common off+inactive default.
+    await screen.findByTestId("detail-oversight-level-select");
+    expect(screen.queryByTestId("detail-overseer-nudge")).not.toBeInTheDocument();
+    expect(screen.queryByTestId("detail-overseer-stop")).not.toBeInTheDocument();
+    expect(screen.queryByTestId("detail-overseer-explain")).not.toBeInTheDocument();
+  });
+});
diff --git a/packages/dashboard/app/components/__tests__/TaskDetailModal.test-helpers.ts b/packages/dashboard/app/components/__tests__/TaskDetailModal.test-helpers.ts
index fd2a91cb13..60be2dc0a5 100644
--- a/packages/dashboard/app/components/__tests__/TaskDetailModal.test-helpers.ts
+++ b/packages/dashboard/app/components/__tests__/TaskDetailModal.test-helpers.ts
@@ -68,6 +68,15 @@ vi.mock("../../api", async (importOriginal) => {
     ensureTaskPlannerChatSession: vi.fn().mockResolvedValue({ session: { id: "chat-task-planner", agentId: "task-planner:FN-099", title: "FN-099 planner chat", status: "active", projectId: null, modelProvider: null, modelId: null, createdAt: "2026-01-01T00:00:00.000Z", updatedAt: "2026-01-01T00:00:00.000Z", cliSessionFile: null, cliExecutorAdapterId: null, inFlightGeneration: null } }),
     fetchChatMessages: vi.fn().mockResolvedValue({ messages: [] }),
     streamChatResponse: vi.fn(),
+    // FNXC:PlannerOversight 2026-07-04-17:00: FN-7517 default overseer-control
+    // mocks so every existing TaskDetailModal suite gets deterministic
+    // no-op behavior for the new quick oversight-level-change resolution
+    // fetch and the nudge/stop/explain controls, rather than falling through
+    // to the auto-synthesized `undefined`-resolving fallback.
+    fetchWorkflowSettingValues: vi.fn().mockResolvedValue({ stored: {}, effective: {}, defaults: {} }),
+    nudgeOverseer: vi.fn().mockResolvedValue({ applied: false, reason: "oversight-off" }),
+    stopOverseer: vi.fn().mockResolvedValue({ applied: true, reason: "stopped" }),
+    explainOverseer: vi.fn().mockResolvedValue({ snapshot: null }),
   });
 });
 
@@ -92,6 +101,8 @@ vi.mock("lucide-react", () => ({
   Minimize2: () => null,
   Loader2: (props: any) => React.createElement("svg", { "data-testid": "loader2-icon", ...props }),
   Send: (props: any) => React.createElement("svg", { "data-testid": "send-icon", ...props }),
+  Square: (props: any) => React.createElement("svg", { "data-testid": "square-icon", ...props }),
+  Info: (props: any) => React.createElement("svg", { "data-testid": "info-icon", ...props }),
   Bot: () => null,
   CircleDot: () => null,
   XCircle: () => null,
diff --git a/packages/dashboard/src/routes/__tests__/tasks-overseer-controls.test.ts b/packages/dashboard/src/routes/__tests__/tasks-overseer-controls.test.ts
new file mode 100644
index 0000000000..2f2fed3646
--- /dev/null
+++ b/packages/dashboard/src/routes/__tests__/tasks-overseer-controls.test.ts
@@ -0,0 +1,191 @@
+// @vitest-environment node
+//
+// FN-7517: HTTP-level coverage for the task-detail planner-overseer control
+// endpoints (nudge/stop/explain). Mirrors the FN-7531 plannerOverseerState
+// enrichment test's engine-stub pattern. Asserts: success path returns the
+// expected payload; nudge never triggers a merge/PR/destructive side effect
+// (it only ever calls the engine's guidance-only control method); and
+// engine-unavailable degrades to a 200 "not applicable" payload rather than
+// a 5xx.
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import express from "express";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { TaskStore } from "@fusion/core";
+import type { ProjectEngine } from "@fusion/engine";
+import { createApiRoutes } from "../../routes.js";
+import { request as REQUEST } from "../../test-request.js";
+
+describe("task-detail planner-overseer control routes", () => {
+  let store: TaskStore;
+  let rootDir: string;
+  let globalDir: string;
+
+  beforeEach(async () => {
+    rootDir = mkdtempSync(join(tmpdir(), "overseer-controls-root-"));
+    globalDir = mkdtempSync(join(tmpdir(), "overseer-controls-global-"));
+    store = new TaskStore(rootDir, globalDir, { inMemoryDb: true });
+    await store.init();
+  });
+
+  afterEach(() => {
+    store.close();
+    rmSync(rootDir, { recursive: true, force: true });
+    rmSync(globalDir, { recursive: true, force: true });
+  });
+
+  function buildApp(engine: Partial<ProjectEngine> | undefined): express.Express {
+    const app = express();
+    app.use(express.json());
+    app.use("/api", createApiRoutes(store, engine ? { engine: engine as unknown as ProjectEngine } : undefined));
+    return app;
+  }
+
+  describe("POST /tasks/:id/overseer/nudge", () => {
+    it("returns the engine's applied result on the success path", async () => {
+      const task = await store.createTask({ description: "watched task" });
+      let calledWith: string | undefined;
+      const engineStub: Partial<ProjectEngine> = {
+        getTaskStore: () => store,
+        nudgeOverseerTask: async (taskId: string) => {
+          calledWith = taskId;
+          return { applied: true, reason: "nudged", task };
+        },
+      };
+
+      const app = buildApp(engineStub);
+      const res = await REQUEST(app, "POST", `/api/tasks/${task.id}/overseer/nudge`);
+      expect(res.status).toBe(200);
+      expect(res.body).toMatchObject({ applied: true, reason: "nudged" });
+      expect(calledWith).toBe(task.id);
+    });
+
+    it("never invokes a merge/PR/destructive method — only the guidance-only nudge control", async () => {
+      const task = await store.createTask({ description: "watched task" });
+      const mergeSpy = { called: false };
+      const engineStub: Partial<ProjectEngine> & { mergeTask?: () => void } = {
+        getTaskStore: () => store,
+        nudgeOverseerTask: async () => ({ applied: true, reason: "nudged", task }),
+        mergeTask: () => {
+          mergeSpy.called = true;
+        },
+      };
+
+      const app = buildApp(engineStub);
+      await REQUEST(app, "POST", `/api/tasks/${task.id}/overseer/nudge`);
+      expect(mergeSpy.called).toBe(false);
+    });
+
+    it("surfaces a not-applicable result (still 200) when oversight is off/inactive", async () => {
+      const task = await store.createTask({ description: "idle task" });
+      const engineStub: Partial<ProjectEngine> = {
+        getTaskStore: () => store,
+        nudgeOverseerTask: async () => ({ applied: false, reason: "oversight-off" }),
+      };
+
+      const app = buildApp(engineStub);
+      const res = await REQUEST(app, "POST", `/api/tasks/${task.id}/overseer/nudge`);
+      expect(res.status).toBe(200);
+      expect(res.body).toMatchObject({ applied: false, reason: "oversight-off" });
+    });
+
+    it("respects user-paused tasks — the engine control itself withholds action", async () => {
+      const task = await store.createTask({ description: "paused task" });
+      const engineStub: Partial<ProjectEngine> = {
+        getTaskStore: () => store,
+        nudgeOverseerTask: async () => ({ applied: false, reason: "withheld:user-paused" }),
+      };
+
+      const app = buildApp(engineStub);
+      const res = await REQUEST(app, "POST", `/api/tasks/${task.id}/overseer/nudge`);
+      expect(res.status).toBe(200);
+      expect(res.body).toMatchObject({ applied: false, reason: "withheld:user-paused" });
+    });
+
+    it("degrades to a 200 not-applicable payload when no engine is present", async () => {
+      const task = await store.createTask({ description: "no engine task" });
+      const app = buildApp(undefined);
+      const res = await REQUEST(app, "POST", `/api/tasks/${task.id}/overseer/nudge`);
+      expect(res.status).toBe(200);
+      expect(res.body).toMatchObject({ applied: false, reason: "engine-unavailable" });
+    });
+  });
+
+  describe("POST /tasks/:id/overseer/stop", () => {
+    it("returns the updated task on the success path", async () => {
+      const task = await store.createTask({ description: "watched task" });
+      const engineStub: Partial<ProjectEngine> = {
+        getTaskStore: () => store,
+        stopOverseerTask: async () => ({ applied: true, reason: "stopped", task: { ...task, plannerOversightLevel: "off" } }),
+      };
+
+      const app = buildApp(engineStub);
+      const res = await REQUEST(app, "POST", `/api/tasks/${task.id}/overseer/stop`);
+      expect(res.status).toBe(200);
+      expect(res.body).toMatchObject({ applied: true, reason: "stopped" });
+      expect((res.body as { task?: { plannerOversightLevel?: string } }).task?.plannerOversightLevel).toBe("off");
+    });
+
+    it("respects autoMerge:false human-review terminal tasks — the engine control itself withholds", async () => {
+      const task = await store.createTask({ description: "human review task", autoMerge: false });
+      const engineStub: Partial<ProjectEngine> = {
+        getTaskStore: () => store,
+        stopOverseerTask: async () => ({ applied: false, reason: "withheld:auto-merge-off-human-review" }),
+      };
+
+      const app = buildApp(engineStub);
+      const res = await REQUEST(app, "POST", `/api/tasks/${task.id}/overseer/stop`);
+      expect(res.status).toBe(200);
+      expect(res.body).toMatchObject({ applied: false, reason: "withheld:auto-merge-off-human-review" });
+    });
+  });
+
+  describe("GET /tasks/:id/overseer/explain", () => {
+    it("returns the current overseer runtime snapshot", async () => {
+      const task = await store.createTask({ description: "watched task" });
+      const snapshot = {
+        state: "watching" as const,
+        oversightLevel: "autonomous" as const,
+        watchedStage: "executor",
+        signal: "progressing",
+        attemptCount: 0,
+        attemptLimit: 3,
+        pendingConfirmation: false,
+        observedAt: 1700000000000,
+        reason: "Task is actively executing in-progress work",
+      };
+      const engineStub: Partial<ProjectEngine> = {
+        getTaskStore: () => store,
+        explainOverseerTask: () => snapshot,
+      };
+
+      const app = buildApp(engineStub);
+      const res = await REQUEST(app, "GET", `/api/tasks/${task.id}/overseer/explain`);
+      expect(res.status).toBe(200);
+      expect(res.body).toEqual({ snapshot });
+    });
+
+    it("returns a null snapshot (not an error) when there is no active observation", async () => {
+      const task = await store.createTask({ description: "idle task" });
+      const engineStub: Partial<ProjectEngine> = {
+        getTaskStore: () => store,
+        explainOverseerTask: () => null,
+      };
+
+      const app = buildApp(engineStub);
+      const res = await REQUEST(app, "GET", `/api/tasks/${task.id}/overseer/explain`);
+      expect(res.status).toBe(200);
+      expect(res.body).toEqual({ snapshot: null });
+    });
+
+    it("degrades to a null snapshot when no engine is present", async () => {
+      const task = await store.createTask({ description: "no engine task" });
+      const app = buildApp(undefined);
+      const res = await REQUEST(app, "GET", `/api/tasks/${task.id}/overseer/explain`);
+      expect(res.status).toBe(200);
+      expect(res.body).toEqual({ snapshot: null });
+    });
+  });
+});
diff --git a/packages/dashboard/src/routes/register-task-workflow-routes.ts b/packages/dashboard/src/routes/register-task-workflow-routes.ts
index 4ee2a3847a..7b14dd9f7b 100644
--- a/packages/dashboard/src/routes/register-task-workflow-routes.ts
+++ b/packages/dashboard/src/routes/register-task-workflow-routes.ts
@@ -2405,6 +2405,74 @@ export function registerTaskWorkflowRoutes(ctx: ApiRoutesContext, deps: TaskWork
     }
   });
 
+  /*
+  FNXC:PlannerOversight 2026-07-04-17:00:
+  FN-7517 task-detail planner-overseer control endpoints. Nudge is
+  guidance-only — it must NOT trigger merge/PR/destructive side effects; it
+  reuses ProjectEngine.nudgeOverseerTask, which itself only ever posts a
+  steering comment through the existing FN-7512 guidance channel and is
+  gated by the FN-7514 human-control guard (user-paused / autoMerge:false
+  human-review) plus the effective oversight level. Stop disables active
+  oversight for this task (per-task override -> "off") via
+  ProjectEngine.stopOverseerTask. Explain is a pure READ of the current
+  overseer runtime state (watched stage, reason, last action, attempt
+  count/limit) via ProjectEngine.explainOverseerTask — never mutates
+  anything. All three degrade to a 200 "not applicable" style payload
+  (rather than a 5xx) when the engine/overseer runtime is unavailable for
+  this project, since a missing in-memory runtime is an expected
+  (non-error) state, e.g. right after an engine restart.
+  */
+  router.post("/tasks/:id/overseer/nudge", async (req, res) => {
+    try {
+      const { store: scopedStore, engine } = await getProjectContext(req);
+      await scopedStore.getTask(req.params.id);
+      if (!engine) {
+        return res.json({ applied: false, reason: "engine-unavailable" });
+      }
+      const result = await engine.nudgeOverseerTask(req.params.id);
+      res.json(result);
+    } catch (err: unknown) {
+      if (err instanceof ApiError) {
+        throw err;
+      }
+      rethrowAsApiError(err);
+    }
+  });
+
+  router.post("/tasks/:id/overseer/stop", async (req, res) => {
+    try {
+      const { store: scopedStore, engine } = await getProjectContext(req);
+      await scopedStore.getTask(req.params.id);
+      if (!engine) {
+        return res.json({ applied: false, reason: "engine-unavailable" });
+      }
+      const result = await engine.stopOverseerTask(req.params.id);
+      res.json(result);
+    } catch (err: unknown) {
+      if (err instanceof ApiError) {
+        throw err;
+      }
+      rethrowAsApiError(err);
+    }
+  });
+
+  router.get("/tasks/:id/overseer/explain", async (req, res) => {
+    try {
+      const { store: scopedStore, engine } = await getProjectContext(req);
+      await scopedStore.getTask(req.params.id);
+      if (!engine) {
+        return res.json({ snapshot: null });
+      }
+      const snapshot = engine.explainOverseerTask(req.params.id);
+      res.json({ snapshot });
+    } catch (err: unknown) {
+      if (err instanceof ApiError) {
+        throw err;
+      }
+      rethrowAsApiError(err);
+    }
+  });
+
   router.post("/tasks/:id/recover-branch-binding", async (req, res) => {
     try {
       const { store: scopedStore } = await getProjectContext(req);
diff --git a/packages/engine/src/__tests__/planner-overseer-runtime-snapshot.test.ts b/packages/engine/src/__tests__/planner-overseer-runtime-snapshot.test.ts
index 6d6e82a3f1..bd294243fb 100644
--- a/packages/engine/src/__tests__/planner-overseer-runtime-snapshot.test.ts
+++ b/packages/engine/src/__tests__/planner-overseer-runtime-snapshot.test.ts
@@ -21,10 +21,13 @@ function fakeMonitor(observations: OverseerStageObservation[]) {
   };
 }
 
-function fakeController(opts: { pending?: { status?: string }[]; attempts?: Record<string, number> } = {}) {
+function fakeController(
+  opts: { pending?: { status?: string }[]; attempts?: Record<string, number>; lastActions?: Record<string, string> } = {},
+) {
   return {
     getPendingConfirmations: () => opts.pending ?? [],
     getAttemptCount: (_taskId: string, stage: string) => opts.attempts?.[stage] ?? 0,
+    getLastAction: (_taskId: string, stage: string) => opts.lastActions?.[stage],
   };
 }
 
@@ -83,6 +86,25 @@ describe("assemblePlannerOverseerRuntimeSnapshot", () => {
     expect(snapshot?.observedAt).toBe(2);
   });
 
+  it("passes through the observation's `reason` verbatim (FN-7517)", () => {
+    const obs = observation({ reason: "Executor stage paused: waiting on human input" });
+    const snapshot = assemblePlannerOverseerRuntimeSnapshot("FN-1", fakeMonitor([obs]), fakeController());
+    expect(snapshot?.reason).toBe("Executor stage paused: waiting on human input");
+  });
+
+  it("includes lastAction from the recovery controller when present (FN-7517)", () => {
+    const obs = observation({ stage: "executor" as OverseerWatchedStage });
+    const controller = fakeController({ lastActions: { executor: "manual_nudge" } });
+    const snapshot = assemblePlannerOverseerRuntimeSnapshot("FN-1", fakeMonitor([obs]), controller);
+    expect(snapshot?.lastAction).toBe("manual_nudge");
+  });
+
+  it("omits lastAction entirely when the controller has no recorded action (FN-7517)", () => {
+    const obs = observation({ stage: "executor" as OverseerWatchedStage });
+    const snapshot = assemblePlannerOverseerRuntimeSnapshot("FN-1", fakeMonitor([obs]), fakeController());
+    expect(snapshot && "lastAction" in snapshot).toBe(false);
+  });
+
   it("never throws — a throwing monitor/controller degrades to null", () => {
     const throwingMonitor = {
       getObservations: () => {
diff --git a/packages/engine/src/__tests__/planner-recovery-controller-manual-action.test.ts b/packages/engine/src/__tests__/planner-recovery-controller-manual-action.test.ts
new file mode 100644
index 0000000000..5cb1485198
--- /dev/null
+++ b/packages/engine/src/__tests__/planner-recovery-controller-manual-action.test.ts
@@ -0,0 +1,84 @@
+/*
+FNXC:PlannerOversight 2026-07-04-17:00:
+FN-7517 focused coverage for the `PlannerRecoveryController` last-action
+inspection seam: `getLastAction` reflects a dispatched bounded-recovery
+action, `recordManualAction` records an operator-driven action (nudge/stop)
+without consuming the autonomous attempt budget, and `clear` releases both.
+*/
+import { describe, expect, it, vi } from "vitest";
+import type { Task } from "@fusion/core";
+import { PlannerRecoveryController, type PlannerRecoveryHandlers } from "../planner-recovery-controller.js";
+import type { OverseerStageObservation, OverseerWatchedStage } from "../planner-overseer.js";
+
+function task(overrides: Partial<Task> = {}): Task {
+  return {
+    id: "FN-1",
+    title: "t",
+    description: "",
+    column: "in-progress",
+    ...overrides,
+  } as Task;
+}
+
+function observation(overrides: Partial<OverseerStageObservation> = {}): OverseerStageObservation {
+  return {
+    taskId: "FN-1",
+    stage: "executor" as OverseerWatchedStage,
+    signal: "failed",
+    oversightLevel: "autonomous",
+    observedAt: Date.now(),
+    reason: "test",
+    sources: [],
+    ...overrides,
+  };
+}
+
+function makeController(
+  obs: OverseerStageObservation | null,
+  handlers: PlannerRecoveryHandlers = {},
+): PlannerRecoveryController {
+  return new PlannerRecoveryController({
+    snapshotProvider: { getSnapshot: () => obs },
+    handlers,
+  });
+}
+
+describe("PlannerRecoveryController manual-action tracking (FN-7517)", () => {
+  it("getLastAction reflects the last dispatched bounded-recovery action", async () => {
+    const retryStep = vi.fn().mockResolvedValue(undefined);
+    const controller = makeController(observation(), { retryStep });
+
+    expect(controller.getLastAction("FN-1", "executor")).toBeUndefined();
+    await controller.tick(task());
+    expect(controller.getLastAction("FN-1", "executor")).toBe("retry_step");
+  });
+
+  it("recordManualAction records an operator action without consuming the attempt budget", () => {
+    const controller = makeController(null);
+
+    expect(controller.getAttemptCount("FN-1", "executor")).toBe(0);
+    controller.recordManualAction("FN-1", "executor", "manual_nudge");
+    expect(controller.getLastAction("FN-1", "executor")).toBe("manual_nudge");
+    expect(controller.getAttemptCount("FN-1", "executor")).toBe(0);
+  });
+
+  it("recordManualAction for stop overwrites a prior autonomous last-action label", async () => {
+    const retryStep = vi.fn().mockResolvedValue(undefined);
+    const controller = makeController(observation(), { retryStep });
+    await controller.tick(task());
+    expect(controller.getLastAction("FN-1", "executor")).toBe("retry_step");
+
+    controller.recordManualAction("FN-1", "executor", "manual_stop");
+    expect(controller.getLastAction("FN-1", "executor")).toBe("manual_stop");
+  });
+
+  it("clear releases the last-action registry for a task", async () => {
+    const retryStep = vi.fn().mockResolvedValue(undefined);
+    const controller = makeController(observation(), { retryStep });
+    await controller.tick(task());
+    expect(controller.getLastAction("FN-1", "executor")).toBe("retry_step");
+
+    controller.clear("FN-1");
+    expect(controller.getLastAction("FN-1", "executor")).toBeUndefined();
+  });
+});
diff --git a/packages/engine/src/planner-overseer-runtime-snapshot.ts b/packages/engine/src/planner-overseer-runtime-snapshot.ts
index 43b9fa103a..f226ee795d 100644
--- a/packages/engine/src/planner-overseer-runtime-snapshot.ts
+++ b/packages/engine/src/planner-overseer-runtime-snapshot.ts
@@ -16,6 +16,14 @@ export interface PlannerOverseerObservationSource {
 export interface PlannerRecoveryRegistrySource {
   getPendingConfirmations(taskId: string): { status?: string }[];
   getAttemptCount(taskId: string, stage: string): number;
+  /**
+   * FNXC:PlannerOversight 2026-07-04-17:00:
+   * FN-7517 addition: last dispatched/recorded action label for a
+   * `(taskId, stage)` pair, consumed by the "explain current action"
+   * control. Optional on the source interface so pre-FN-7517 fakes in
+   * existing tests keep compiling without a stub.
+   */
+  getLastAction?(taskId: string, stage: string): string | undefined;
 }
 
 /**
@@ -43,6 +51,7 @@ export function assemblePlannerOverseerRuntimeSnapshot(
 
     const pendingConfirmationCount = recoveryController?.getPendingConfirmations(taskId).length ?? 0;
     const attemptCount = recoveryController?.getAttemptCount(taskId, observation.stage) ?? 0;
+    const lastAction = recoveryController?.getLastAction?.(taskId, observation.stage);
 
     const state = derivePlannerOverseerState({
       oversightLevel: observation.oversightLevel,
@@ -60,6 +69,8 @@ export function assemblePlannerOverseerRuntimeSnapshot(
       attemptLimit: PLANNER_RECOVERY_MAX_ATTEMPTS,
       pendingConfirmation: pendingConfirmationCount > 0,
       observedAt: observation.observedAt,
+      reason: observation.reason,
+      ...(lastAction ? { lastAction } : {}),
     };
   } catch {
     return null;
diff --git a/packages/engine/src/planner-recovery-controller.ts b/packages/engine/src/planner-recovery-controller.ts
index 403e197efd..58077310db 100644
--- a/packages/engine/src/planner-recovery-controller.ts
+++ b/packages/engine/src/planner-recovery-controller.ts
@@ -174,6 +174,15 @@ export class PlannerRecoveryController {
    * on every subsequent poll while it remains withheld for the same reason.
    */
   private readonly lastWithheldReason = new Map<string, OverseerHumanControlWithholdReason>();
+  /**
+   * FNXC:PlannerOversight 2026-07-04-17:00:
+   * FN-7517 addition: last dispatched bounded-recovery action OR manually
+   * recorded operator action (see `recordManualAction`) per
+   * `(taskId, watchedStage)`, surfaced via `getLastAction` for the
+   * task-detail "explain current action" control. Purely additive
+   * inspection state — never read by `tick()`'s decision logic.
+   */
+  private readonly lastActions = new Map<string, { action: string; at: number }>();
 
   constructor(options: PlannerRecoveryControllerOptions) {
     this.snapshotProvider = normalizeProvider(options.snapshotProvider);
@@ -253,6 +262,7 @@ export class PlannerRecoveryController {
       const dispatched = await this.dispatch(decision, task, ctx);
       if (dispatched) {
         this.attempts.set(key, attemptCount + 1);
+        this.lastActions.set(key, { action: decision.action, at: ctx.now?.() ?? Date.now() });
       }
       return decision;
     } catch (err) {
@@ -489,10 +499,40 @@ export class PlannerRecoveryController {
       }
     }
     this.lastWithheldReason.delete(taskId);
+    for (const key of [...this.lastActions.keys()]) {
+      if (key.startsWith(prefix)) {
+        this.lastActions.delete(key);
+      }
+    }
   }
 
   /** Test/inspection seam: current attempt count for a `(taskId, watchedStage)` pair. */
   getAttemptCount(taskId: string, stage: string): number {
     return this.attempts.get(this.attemptKey(taskId, stage)) ?? 0;
   }
+
+  /**
+   * FNXC:PlannerOversight 2026-07-04-17:00:
+   * FN-7517: the last dispatched bounded-recovery action label, or a
+   * manually recorded operator action (see `recordManualAction`), for a
+   * `(taskId, watchedStage)` pair. Read by the task-detail "explain current
+   * action" control via `ProjectEngine.explainOverseerTask`.
+   */
+  getLastAction(taskId: string, stage: string): string | undefined {
+    return this.lastActions.get(this.attemptKey(taskId, stage))?.action;
+  }
+
+  /**
+   * FNXC:PlannerOversight 2026-07-04-17:00:
+   * FN-7517: records a manual operator action (e.g. "manual_nudge" from the
+   * task-detail nudge button, "manual_stop" from the stop-oversight button)
+   * against a `(taskId, watchedStage)` pair so `getLastAction`/`explain`
+   * reflects operator-driven actions, not only autonomous bounded-recovery
+   * dispatches. Never mutates the attempt-budget registry — manual actions
+   * are guidance-only and do not consume/gate the autonomous recovery
+   * attempt budget.
+   */
+  recordManualAction(taskId: string, stage: string, action: string, now: () => number = Date.now): void {
+    this.lastActions.set(this.attemptKey(taskId, stage), { action, at: now() });
+  }
 }
diff --git a/packages/engine/src/project-engine.ts b/packages/engine/src/project-engine.ts
index aaa2138307..88310ae4e8 100644
--- a/packages/engine/src/project-engine.ts
+++ b/packages/engine/src/project-engine.ts
@@ -24,6 +24,7 @@ import type { ProjectRuntimeConfig } from "./project-runtime.js";
 import { PrMonitor } from "./pr-monitor.js";
 import { PlannerOverseerMonitor } from "./planner-overseer.js";
 import { PlannerRecoveryController, type PlannerRecoveryHandlers } from "./planner-recovery-controller.js";
+import { evaluateOverseerHumanControl } from "./overseer-human-control-policy.js";
 import type { PrNodeGithubOps } from "./pr-nodes.js";
 import { PrReconciler, type PrReconcileGithubOps } from "./pr-reconcile.js";
 import { PrCommentHandler } from "./pr-comment-handler.js";
@@ -1043,6 +1044,107 @@ export class ProjectEngine {
     return assemblePlannerOverseerRuntimeSnapshot(taskId, this.plannerOverseer, this.plannerRecoveryController);
   }
 
+  /**
+   * FNXC:PlannerOversight 2026-07-04-17:00:
+   * FN-7517 manual nudge control: injects one planner-authored steering
+   * comment into the task's currently watched stage RIGHT NOW, via the same
+   * `store.addSteeringComment` guidance channel FN-7512's `injectGuidance`
+   * handler already uses — guidance-only, never a merge/PR/destructive side
+   * effect (those remain FN-7513's confirmation-gated executeMergePrAction/
+   * executeDestructiveExternalAction, never invoked here). Returns
+   * `{applied:false, reason:...}` without mutating anything when: the task
+   * does not exist, the human-control guard withholds oversight (user-paused
+   * or autoMerge:false/human-review), the effective oversight level is
+   * "off", or there is no currently monitorable watched stage.
+   */
+  async nudgeOverseerTask(taskId: string): Promise<{ applied: boolean; reason: string; task?: Task }> {
+    try {
+      const store = this.runtime.getTaskStore();
+      const task = await store.getTask(taskId).catch(() => undefined);
+      if (!task) {
+        return { applied: false, reason: "task-not-found" };
+      }
+
+      const settings = await store.getSettings().catch(() => undefined);
+      const humanControl = evaluateOverseerHumanControl(task, settings);
+      if (humanControl.withhold) {
+        return { applied: false, reason: `withheld:${humanControl.reason}`, task };
+      }
+
+      const workflowEffective = await resolveEffectiveSettings(store, { id: task.id }).catch(() => ({}) as Record<string, unknown>);
+      const level = resolveEffectivePlannerOversightLevel(task.plannerOversightLevel, workflowEffective.plannerOversightLevel as string | undefined);
+      if (level === "off") {
+        return { applied: false, reason: "oversight-off", task };
+      }
+
+      let observation = this.plannerOverseer ? this.plannerOverseer.getObservations(taskId).slice(-1)[0] : undefined;
+      if (!observation && this.plannerOverseer) {
+        observation = (await this.plannerOverseer.observeTask(task, level)) ?? undefined;
+      }
+      if (!observation) {
+        return { applied: false, reason: "no-active-stage", task };
+      }
+
+      const text = `[planner-oversight] manual nudge (${observation.stage}): ${observation.reason}`;
+      await store.addSteeringComment(taskId, text, "user");
+      this.plannerRecoveryController?.recordManualAction(taskId, observation.stage, "manual_nudge");
+
+      const updatedTask = await store.getTask(taskId).catch(() => undefined);
+      return { applied: true, reason: "nudged", task: updatedTask ?? task };
+    } catch (err) {
+      void err;
+      return { applied: false, reason: "error" };
+    }
+  }
+
+  /**
+   * FNXC:PlannerOversight 2026-07-04-17:00:
+   * FN-7517 stop-oversight control: disables active planner oversight for
+   * this task by writing the per-task override `plannerOversightLevel:
+   * "off"` (the same FN-7509 scalar-override field/plumbing the quick
+   * level-change control writes) and releasing the in-memory monitor/
+   * recovery-controller ring buffers for this task (mirrors the poll's
+   * leave-in-flight cleanup). This is a user action; it never mutates task
+   * lifecycle/column and never performs a merge/PR/destructive side effect.
+   */
+  async stopOverseerTask(taskId: string): Promise<{ applied: boolean; reason: string; task?: Task }> {
+    try {
+      const store = this.runtime.getTaskStore();
+      const task = await store.getTask(taskId).catch(() => undefined);
+      if (!task) {
+        return { applied: false, reason: "task-not-found" };
+      }
+
+      const observation = this.plannerOverseer ? this.plannerOverseer.getObservations(taskId).slice(-1)[0] : undefined;
+      if (observation) {
+        this.plannerRecoveryController?.recordManualAction(taskId, observation.stage, "manual_stop");
+      }
+
+      const updatedTask = await store.updateTask(taskId, { plannerOversightLevel: "off" });
+      this.plannerOverseer?.clear(taskId);
+      this.plannerRecoveryController?.clear(taskId);
+
+      return { applied: true, reason: "stopped", task: updatedTask };
+    } catch (err) {
+      void err;
+      return { applied: false, reason: "error" };
+    }
+  }
+
+  /**
+   * FNXC:PlannerOversight 2026-07-04-17:00:
+   * FN-7517 explain-current-action control: a READ of the current overseer
+   * runtime state — watched stage, reason, last action taken, and attempt
+   * count/limit — assembled from the exact same FN-7511/FN-7512/FN-7531
+   * sources as `getPlannerOverseerRuntimeSnapshot`, plus the human-readable
+   * `reason`/`lastAction` fields FN-7517 added to `PlannerOverseerRuntimeSnapshot`.
+   * Never mutates anything. Returns `null` when there is no active
+   * observation for the task (nothing to explain).
+   */
+  explainOverseerTask(taskId: string): PlannerOverseerRuntimeSnapshot | null {
+    return this.getPlannerOverseerRuntimeSnapshot(taskId);
+  }
+
   /**
    * FNXC:PlannerOversight 2026-07-04-12:00:
    * Concrete FN-7512 handler wiring — ONLY reuses existing mechanisms: